wema.py

"""
WER 20210624

First attempt at having a parallel dedicated agent for weather and enclosure.
This code should be as simple and reliable as possible, no hanging variables,
etc.

This would be a good place to log the weather data and any enclosure history,
once this code is stable enough to run as a service.

"""


import os
import signal
import json
import shelve
import time
import socket
from pathlib import Path
import math
import requests
import traceback
import ephem
import ptr_config
from api_calls import API_calls
import wema_events
from devices.observing_conditions import ObservingConditions
from devices.enclosure import Enclosure
from global_yard import g_dev
import logging
from wema_utility import plog
from pyowm import OWM
from pyowm.utils import config
from pyowm.utils import timestamps
from pyowm.utils.config import get_default_config
from pyowm.commons.databoxes import SubscriptionType
#from requests.adapters import HTTPAdapter, Retry
from dotenv import load_dotenv
load_dotenv(".env")
from wema_config import get_enc_status_custom
from wema_config import get_ocn_status_custom
import csv

from astropy.coordinates import EarthLocation, AltAz, SkyCoord
from astropy.time import Time
import astropy.units as u

from func_timeout import func_timeout, FunctionTimedOut
import numpy as np
#import http.client
#http.client.HTTPConnection.debuglevel = 1
#logging.getLogger("urllib3").setLevel(logging.DEBUG)


import matplotlib.pyplot as plt
import pandas as pd
import sys
from scipy.fft import fft, ifft, fftfreq
import numpy as np
from scipy.signal import correlate
import seaborn as sns
from sklearn.model_selection import train_test_split,cross_val_predict, KFold
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.metrics import mean_squared_error, r2_score
from sklearn.preprocessing import PolynomialFeatures



close_headers = {
    "Connection": "close"  # Forces the server to close the connection after the response
}

import pytz
import datetime

#import requests


# Reload the function from the canvas
def fit_cloud_prediction_model(df, directory):
    
    directory=directory+'/weatherfits'
    if not os.path.exists(directory):
        os.makedirs(directory)
    
    file_date_string=str(datetime.datetime.now()).replace(' ','_').split('.')[0].replace(':','-')
    
    # Drop irrelevant columns
    df_clean = df.drop(columns=['date', 'time', 'Local_clouds', 'time_in_days', 'time_in_years'], errors='ignore')

    # Check the range of 'phase_of_year'
    if 'phase_of_year' in df_clean.columns:
        phase_of_year_range = df_clean['phase_of_year'].max() - df_clean['phase_of_year'].min()
    else:
        phase_of_year_range = 0

    # Select features based on the range check
    if phase_of_year_range > 0.9:
        features = ['Humidity', 'sky-ambient', 'dew_point_depression', 'phase_of_day', 'phase_of_year']
        
    else:
        features = ['Humidity', 'sky-ambient', 'dew_point_depression', 'phase_of_day']

    # Prepare data with PolynomialFeatures
    poly = PolynomialFeatures(degree=2, include_bias=False)
    X = poly.fit_transform(df_clean[features])
    y = df_clean['OWM_clouds']

    # First pass: Fit Gradient Boosting model
    gb_model = GradientBoostingRegressor(n_estimators=100, learning_rate=0.1, random_state=42)
    gb_model.fit(X, y)
    y_pred = gb_model.predict(X)

    # Outlier rejection based on straight cut of ±30 units
    residuals = y - y_pred
    mask = np.abs(residuals) <= 30
    X = X[mask]
    y = y[mask]

    # Second pass: Refit the model without outliers
    gb_model.fit(X, y)
    y_pred = gb_model.predict(X)

    # Plot predicted vs actual values
    plt.figure(figsize=(8, 6))
    plt.scatter(y, y_pred, alpha=0.7, color='black', marker='o')
    plt.plot([y.min(), y.max()], [y.min(), y.max()], '--', color='red')
    plt.xlabel('Actual OWM_clouds')
    plt.ylabel('Predicted OWM_clouds')
    plt.title('Predicted vs Actual OWM_clouds with Black Markers')
    
    #breakpoint()
    plt.savefig(directory+'/ActualVSPredicted_' + str(file_date_string)+'.png', dpi=300, bbox_inches='tight')
    #breakpoint()
    #plt.show()

    # # Interaction plot between 'sky-ambient' and 'phase_of_day'
    # plt.figure(figsize=(8, 6))
    # scatter = plt.scatter(X[:, 3], X[:, 1], c=y, cmap='viridis', alpha=0.6)  # Adjusting for expanded features
    # plt.colorbar(scatter, label='Actual OWM_clouds')
    # plt.xlabel('phase_of_day')
    # plt.ylabel('sky-ambient')
    # plt.title('Interaction Between phase_of_day and sky-ambient')
    # plt.show()

    # Heatmap of correlation between factors
    plt.figure(figsize=(8, 6))
    sns.heatmap(pd.DataFrame(X).join(pd.Series(y, name='OWM_clouds')).corr(), annot=True, cmap='coolwarm', fmt='.2f', linewidths=0.5)
    plt.title('Correlation Heatmap')
    plt.savefig(directory+'/Correlation_' + str(file_date_string)+'.png', dpi=300, bbox_inches='tight')
   
    #plt.show()

    # Evaluate performance
    mse = mean_squared_error(y, y_pred)
    r2 = r2_score(y, y_pred)

    # Print performance metrics
    print(f"Phase of Year Range: {phase_of_year_range:.3f}")
    print(f"Mean Squared Error: {mse:.2f}")
    print(f"R² Score: {r2:.2f}")

    df_clean.loc[mask.index, 'predicted_clouds'] = y_pred
    
    
    df_clean.to_csv(directory+'/WeatherData_' + str(file_date_string)+'.csv', index=False)
    
    
    return gb_model, df_clean




# Default headers to force closing connections
# close_headers = {"Connection": "close"}

# def global_request(method, url, **kwargs):
#     """ Wrapper around requests to enforce default options and ensure response is closed """
#     kwargs.setdefault("allow_redirects", False)
#     kwargs.setdefault("headers", close_headers)
#     kwargs.setdefault("stream", False)
#     kwargs.setdefault("timeout", 5)  # Optional: Set a global timeout
    
#     # Send the request
#     response = requests.request(method, url, **kwargs)


#     # Read the response content (to ensure the connection can be closed)
#     content = response.content  # Ensure the body is downloaded before closing
#     status_code = response.status_code
#     headers = response.headers

#     # Close the response immediately
#     response.close()

#     # Return relevant response data (since original response object is closed)
#     return {
#         "status_code": status_code,
#         "content": content,
#         "headers": headers
#     }


def correct_dome_azimuth(telescope_az, telescope_alt, side_of_pier, dome_radius, telescope_offset):#, dome_slit_offset=0):
    """
    Corrects the dome azimuth based on telescope pointing and side of the pier.

    Parameters:
        telescope_az (float): Telescope azimuth in degrees (0-360).
        telescope_alt (float): Telescope altitude in degrees (0-90).
        side_of_pier (str): 'E' for East, 'W' for West.
        dome_radius (float): Radius of the dome in meters.
        telescope_offset (float): Lateral offset of the telescope from the dome center in meters.
        dome_slit_offset (float, optional): Empirical offset to keep the telescope centered in the dome slit (default 0).

    Returns:
        float: Corrected dome azimuth in degrees (0-360).
    """

    # Convert to radians for calculations
    #az_rad = np.radians(telescope_az)
    alt_rad = np.radians(telescope_alt)

    # Compute the small offset angle due to the telescope offset inside the dome
    if dome_radius > 0:
        offset_angle = np.degrees(np.arctan2(telescope_offset * np.cos(alt_rad), dome_radius))
    else:
        offset_angle = 0  # Avoid division by zero

    # Adjust azimuth based on the side of the pier
    if side_of_pier.upper() == 'E':
        dome_az = (telescope_az + offset_angle) % 360
    elif side_of_pier.upper() == 'W':
        dome_az = (telescope_az - offset_angle) % 360
    else:
        raise ValueError("side_of_pier must be 'E' or 'W'")

    # # Apply an empirical dome slit offset
    # dome_az = (dome_az + dome_slit_offset) % 360

    return dome_az


# FIXME: This needs attention once we figure out the restart_obs script.
def terminate_restart_observer(site_path, no_restart=False):
    """Terminates obs-platform code if running and restarts obs."""
    if no_restart is False:
        return

    camShelf = shelve.open(site_path + "ptr_night_shelf/" + "pid_obs")
    pid = camShelf["pid_obs"]  # a 9 character string
    camShelf.close()
    try:
        print("Terminating:  ", pid)
        os.kill(pid, signal.SIGTERM)
    except:
        print("No observer process was found, starting a new one.")
    # The above routine does not return but does start a process.
    parentPath = Path.cwd()
    os.system("cmd /c " + str(parentPath) + "\restart_obs.bat")

    return


def send_status(obsy, column, status_to_send):
    """Sends a status update to AWS."""
    
    uri_status = f"https://status.photonranch.org/status/{obsy}/status/"
    # NB None of the strings can be empty. Otherwise this put faults.
    payload = {"statusType": str(column), "status": status_to_send}\

    data = json.dumps(payload)
    try:
        
        response = requests.post(uri_status, data=data, timeout=20, allow_redirects=False, headers=close_headers)

        if response.ok:
           # pass
           print("~")
    except:
        print(
            'self.api.authenticated_request("PUT", uri, status):  Failed! ',
            response.status_code,
        )

class WxEncAgent:
    """A class for weather enclosure functionality."""
    
    """
    Re-working ARO Weather 20231226 WER.  Currently the Wema-attached external 
    SkyAlert is failing so we are picking up Weather from the ARO-0m30 Skyalert 
    provided by a reflection from AWS -- and we have an inside skyalert which
    measures the underside roof temp during the day!  Unfortunately the AWS
    style reflection gets stale so I am putting in a redis based way to pass
    the ARO-0m30 weather information over to the Wema.  No Weather decisions
    are made at ARO-0m30 except to convert to metric and compute the 15 minute 
    wind-gust value.
    
    In the event the redis data is stale -- we may use the AWS supplied data if
    we can figure out how to verify it is not stale.
    
    NOTE  ARO-0m30 passes its weather line through skyalert\weatherdata_nw.txt
    
    Status as sent to GUI does go through AWS however.
    
    The whole Weather Hold system has been bypassed and semi-replaced with the OWM
    rework.  I plan to revisit this once I am satsified it serves a useful purpose.
    for ARO late afternoon winds are common but they tend to abate.  Some wind-
    shake during eve skyflats causes no harm so we can be more tolerant.
    """

    def __init__(self, name, config):

        self.name=name        

        self.api = API_calls()
        self.command_interval = 30
        self.status_interval = 30
        self.config = config
        g_dev["wema"] = self

        # Initialise location
        self.latitude=self.config["latitude"]
        self.longitude=self.config["longitude"]
        self.height=0        
        self.observer_location = EarthLocation(lat=self.latitude*u.deg, lon=self.longitude*u.deg, height=self.height*u.m)

        self.cloud_model=None
        self.ocn_status=None
        self.enc_status=None

        self.current_owm_humidity=-1
        self.current_owm_ambient_temperature=0
        self.current_owm_dewpoint=0

        self.cloud_tracker=[]
        self.median_cloud_estimate=0

        # Initialise this variable
        self.open_and_enabled_to_observe=False

        self.debug_flag = self.config['debug_mode']
        self.admin_only_flag = self.config['admin_owner_commands_only']
        if self.debug_flag:
            self.debug_lapse_time = time.time() + self.config['debug_duration_sec']
            g_dev['debug'] = True
        else:
            self.debug_lapse_time = 0.0
            g_dev['debug'] = False

        self.hostname = socket.gethostname()
        if self.hostname in self.config["wema_hostname"]:
            self.is_wema = True
        else:
            # This host is a client.   What does this mean??  This IS wema code.
            self.is_wema = False  # This is a client.
        self.wema_path = config["wema_path"]
        g_dev["wema_write_share_path"] = self.wema_path
        #self.site_path = self.wema_path  #  No longer used


        # THIS IS JUST THE FIRST OF SOME DOMES
        # NEED TO MAKE THIS A CONFIG ITEM
        try:
            self.dome_offset = self.config['enclosure']['enclosure1']['dome_offset_in_degrees'] ### THIS IS PURELY FOR LCS
        except:
            plog ("Couldn't load dome offset. mayhaps not a dome")


        self.last_request = None
        self.stopped = False
        self.site_message = "-"
        #self.site_mode = config['site_enclosures_default_mode']
        self.device_types = config["wema_types"]
        self.astro_events = wema_events.Events(self.config)
        self.astro_events.compute_day_directory()
        self.astro_events.calculate_events()
        self.astro_events.display_events()

        self.dome_check_timer=time.time()
        self.dome_check_timer_period=5

        self.wema_pid = os.getpid()
        print("Fresh WEMA_PID:  ", self.wema_pid)
        
        self.update_config()
        self.create_devices(config)
        self.time_last_status = time.time() - 60  #forces early status on startup.
        self.loud_status = False
        self.blocks = None
        self.projects = None
        self.events_new = None
        immed_time = time.time()
        self.obs_time = immed_time
        self.wema_start_time = immed_time
        self.cool_down_latch = False

        obs_win_begin, sunZ88Op, sunZ88Cl, ephem_now = self.astro_events.getSunEvents()
        self.nightly_weather_report_complete = False
        self.weather_report_run_timer=time.time()-3600
        self.local_pytz_timezone=pytz.timezone(self.config['TZ_database_name'])
        

        self.owm_active=config['OWM_active']
        self.local_weather_active=config['local_weather_active']
        
        self.enclosure_status_check_period=config['enclosure_status_check_period']
        self.weather_status_check_period = config['weather_status_check_period']
        self.safety_status_check_period = config['safety_status_check_period']
        self.scan_requests_check_period = 4
        self.wema_settings_upload_period = 10
        self.error_fault_clear_timer=time.time()

        # Timers rather than time.sleeps
        self.enclosure_status_check_timer=time.time() - 2*self.enclosure_status_check_period
        self.weather_status_check_timer = time.time() - 2*self.weather_status_check_period
        self.safety_check_timer=time.time() - 2*self.safety_status_check_period
        self.scan_requests_timer=time.time() -2 * self.scan_requests_check_period
        self.wema_settings_upload_timer=time.time() -2 * self.wema_settings_upload_period

        # This is a flag that enables or disables observing for all OBS in the WEMA.
        self.observing_mode = 'active'
        self.rain_limit_quiet=False
        self.cloud_limit_quiet=False
        self.humidity_limit_quiet=False
        self.windspeed_limit_quiet=False
        self.lightning_limit_quiet=False
        self.temp_minus_dew_quiet=False
        self.skytemp_limit_quiet=False
        self.hightemp_limit_quiet=False
        self.lowtemp_limit_quiet=False

        if self.config['observing_conditions']['observing_conditions1']['driver'] == None:
            self.ocn_exists=False
        else:
            self.ocn_exists=True

        # This variable prevents the roof being called to open every loop...        
        self.enclosure_next_open_time = time.time()
        # This keeps a track of how many times the roof has been open this evening
        # Which is really a measure of how many times the enclosure has
        # attempted to observe but been shut on....
        # If it is too many, then it shuts down for the whole evening. 
        self.opens_this_evening = 0
        self.local_weather_ok = None
        self.weather_text_report = []       
        self.times_to_open = []
        self.times_to_close = []
        self.hourly_report_holder=[]
        self.weather_report_open_at_start = False
        self.nightly_reset_complete = False  
        self.keep_open_all_night = False
        self.keep_closed_all_night   = False          
        self.open_at_specific_utc = False
        self.specific_utc_when_to_open = -1.0  
        self.manual_weather_hold_set = False
        self.manual_weather_hold_duration = -1.0    
        self.wema_has_roof_control=config['wema_has_control_of_roof']
        
        # Obs under WEMA guidance
        self.obs_ids=self.config['obsp_ids']
        self.morning_flats_finished=False

        # This prevents commands from previous nights/runs suddenly running
        # when wema.py is booted (has happened a bit!)
        url_job = "https://jobs.photonranch.org/jobs/getnewjobs"
        body = {"site": self.config['wema_name']}
        
        try:

            requests.request("POST", url_job, data=json.dumps(body), timeout=30, allow_redirects=False, headers=close_headers, stream=False).json()
        except:
            plog ("Connection glitch in getnewjobs")
            plog(traceback.format_exc())
            

        
        if not os.path.exists(self.wema_path):
            os.makedirs(self.wema_path)
        if not os.path.exists(self.wema_path + "ptr_night_shelf"):
            os.makedirs(self.wema_path + "ptr_night_shelf")
        
        self.wema_settings_shelf_filename = self.wema_path + "ptr_night_shelf/" + str(self.config['wema_name'])+"_wema_stored_settings"
    
        #######################
        # THIS AREA JUST GETS DELETED ONCE WE HAVE AN ONLINE ADJUSTABLE WEMA SETTINGS
        # UNTIL THEN IT WILL LOAD THE VALUES FROM THE CONFIG
        #######################
        
        plog ("Loading limits from config: TO BE DEPRECATED ONCE WE HAVE AN ONLINE LIMIT SYSTEM")
        try:
            wema_settings_shelf = shelve.open(self.wema_settings_shelf_filename)
            
            self.rain_limit_setting = self.config['rain_limit']
            self.humidity_limit_setting = self.config['humidity_limit']
            self.windspeed_limit_setting = self.config['windspeed_limit']
            self.lightning_limit_setting = self.config['lightning_limit']
            self.temp_minus_dew_setting = self.config['temperature_minus_dewpoint_limit']
            self.sky_temp_limit_setting = self.config['sky_temperature_limit']
            self.cloud_cover_limit_setting = self.config['cloud_cover_limit']
            self.lowest_temperature_setting = self.config['lowest_ambient_temperature']
            self.highest_temperature_setting = self.config['highest_ambient_temperature']

            self.warning_rain_limit_setting = self.config['warning_rain_limit']
            self.warning_humidity_limit_setting = self.config['warning_humidity_limit']
            self.warning_windspeed_limit_setting = self.config['warning_windspeed_limit']
            self.warning_lightning_limit_setting = self.config['warning_lightning_limit']
            self.warning_temp_minus_dew_setting = self.config['warning_temperature_minus_dewpoint_limit']
            self.warning_sky_temp_limit_setting = self.config['warning_sky_temperature_limit']
            self.warning_cloud_cover_limit_setting = self.config['warning_cloud_cover_limit']
            self.warning_lowest_temperature_setting = self.config['warning_lowest_ambient_temperature']
            self.warning_highest_temperature_setting = self.config['warning_highest_ambient_temperature']

            self.rain_limit_on = self.config['rain_limit_on']
            self.humidity_limit_on = self.config['humidity_limit_on']
            self.windspeed_limit_on = self.config['windspeed_limit_on']
            self.lightning_limit_on = self.config['lightning_limit_on']
            self.temp_minus_dew_on = self.config['temperature_minus_dewpoint_limit_on']
            self.sky_temperature_limit_on = self.config['sky_temperature_limit_on']
            self.cloud_cover_limit_on = self.config['cloud_cover_limit_on']
            self.lowest_temperature_on = self.config['lowest_ambient_temperature_on']
            self.highest_temperature_on = self.config['highest_ambient_temperature_on']
                    
            wema_settings_shelf['rain_limit_on'] = self.rain_limit_on
            wema_settings_shelf['warning_rain_limit_setting'] = self.warning_rain_limit_setting
            wema_settings_shelf['rain_limit_setting'] = self.rain_limit_setting
            
            wema_settings_shelf['cloud_cover_limit_on'] = self.cloud_cover_limit_on
            wema_settings_shelf['warning_cloud_cover_limit_setting'] = self.warning_cloud_cover_limit_setting
            wema_settings_shelf['cloud_cover_limit_setting'] = self.cloud_cover_limit_setting
            
            wema_settings_shelf['humidity_limit_on'] = self.humidity_limit_on
            wema_settings_shelf['warning_humidity_limit_setting'] = self.warning_humidity_limit_setting
            wema_settings_shelf['humidity_limit_setting'] = self.humidity_limit_setting
            
            wema_settings_shelf['windspeed_limit_on'] = self.windspeed_limit_on
            wema_settings_shelf['warning_windspeed_limit_setting'] = self.warning_windspeed_limit_setting
            wema_settings_shelf['windspeed_limit_setting'] = self.windspeed_limit_setting
            
            wema_settings_shelf['lightning_limit_on'] = self.lightning_limit_on
            wema_settings_shelf['warning_lightning_limit_setting'] = self.warning_lightning_limit_setting
            wema_settings_shelf['lightning_limit_setting'] = self.lightning_limit_setting
            
            wema_settings_shelf['temp_minus_dew_on'] = self.temp_minus_dew_on
            wema_settings_shelf['warning_temp_minus_dew_setting'] = self.warning_temp_minus_dew_setting
            wema_settings_shelf['temp_minus_dew_setting'] = self.temp_minus_dew_setting
            
            wema_settings_shelf['sky_temperature_limit_on'] = self.sky_temperature_limit_on
            wema_settings_shelf['warning_sky_temp_limit_setting'] = self.warning_sky_temp_limit_setting
            wema_settings_shelf['sky_temp_limit_setting'] = self.sky_temp_limit_setting
            
            wema_settings_shelf['lowest_ambient_temperature'] = self.lowest_temperature_setting
            wema_settings_shelf['highest_ambient_temperature'] = self.highest_temperature_setting

            wema_settings_shelf['lowest_ambient_temperature_on'] = self.lowest_temperature_on
            wema_settings_shelf['highest_ambient_temperature_on']= self.highest_temperature_on
            
            wema_settings_shelf['hightemperature_limit_warning_level'] = self.warning_highest_temperature_setting
            #status['wema_settings']['hightemperature_limit_danger_level'] = self.highest_temperature_setting
            
            # status['wema_settings']['lowtemperature_limit_on']  = self.lowest_temperature_on
            # status['wema_settings']['lowtemperature_limit_quiet'] = self.lowtemp_limit_quiet
            wema_settings_shelf['lowtemperature_limit_warning_level'] = self.warning_lowest_temperature_setting
            
            #pid = camShelf["pid_obs"]  # a 9 character string
            wema_settings_shelf.close()
        except:
            plog ("Startup shelf load failed.")
            plog(traceback.format_exc())
        
        plog ("passed startup shelf load")
        #######################
        # ^^^^^^^^^^^^^^ THIS AREA JUST GETS DELETED ONCE WE HAVE AN ONLINE ADJUSTABLE WEMA SETTINGS
        # UNTIL THEN IT WILL LOAD THE VALUES FROM THE CONFIG
        #######################
    
    
    
    
        
        if os.path.exists(self.wema_settings_shelf_filename + '.dat'):       
        
            wema_settings_shelf = shelve.open(self.wema_settings_shelf_filename)
            
            #print ("woo")
            
            #print (wema_settings_shelf['local_weather_active'])
            
            g_dev['enc'].mode =wema_settings_shelf['mode']
            self.observing_mode=wema_settings_shelf['observing_mode']
            self.local_weather_active=wema_settings_shelf['local_weather_active']
            self.owm_active=wema_settings_shelf['owm_active']
            self.keep_open_all_night=wema_settings_shelf['keep_open_all_night']
            self.keep_closed_all_night=wema_settings_shelf['keep_closed_all_night']
            if self.ocn_exists:
                try:
                    self.rain_limit_on=wema_settings_shelf['rain_limit_on']
                    self.warning_rain_limit_setting=wema_settings_shelf['warning_rain_limit_setting']
                    self.rain_limit_setting=wema_settings_shelf['rain_limit_setting']
                    
                    self.cloud_cover_limit_on=wema_settings_shelf['cloud_cover_limit_on']
                    self.warning_cloud_cover_limit_setting=wema_settings_shelf['warning_cloud_cover_limit_setting']
                    self.cloud_cover_limit_setting=wema_settings_shelf['cloud_cover_limit_setting']
                    
                    self.humidity_limit_on=wema_settings_shelf['humidity_limit_on']
                    self.warning_humidity_limit_setting=wema_settings_shelf['warning_humidity_limit_setting']
                    self.humidity_limit_setting=wema_settings_shelf['humidity_limit_setting']
                    
                    self.windspeed_limit_on=wema_settings_shelf['windspeed_limit_on']
                    self.warning_windspeed_limit_setting=wema_settings_shelf['warning_windspeed_limit_setting']
                    self.windspeed_limit_setting=wema_settings_shelf['windspeed_limit_setting']
                    
                    self.lightning_limit_on=wema_settings_shelf['lightning_limit_on']
                    self.warning_lightning_limit_setting=wema_settings_shelf['warning_lightning_limit_setting']
                    self.lightning_limit_setting=wema_settings_shelf['lightning_limit_setting']
                    
                    self.temp_minus_dew_on=wema_settings_shelf['temp_minus_dew_on']
                    self.warning_temp_minus_dew_setting=wema_settings_shelf['warning_temp_minus_dew_setting']
                    self.temp_minus_dew_setting=wema_settings_shelf['temp_minus_dew_setting']
                    
                    self.sky_temperature_limit_on=wema_settings_shelf['sky_temperature_limit_on']
                    self.warning_sky_temp_limit_setting=wema_settings_shelf['warning_sky_temp_limit_setting']
                    self.sky_temp_limit_setting=wema_settings_shelf['sky_temp_limit_setting']
                    
                    self.lowest_temperature_setting =  wema_settings_shelf['lowest_ambient_temperature']
                    self.highest_temperature_setting =  wema_settings_shelf['highest_ambient_temperature']
                    self.lowest_temperature_on =  wema_settings_shelf['lowest_ambient_temperature_on']
                    self.highest_temperature_on =  wema_settings_shelf['highest_ambient_temperature_on']
                    
                    self.warning_highest_temperature_setting=wema_settings_shelf['highest_ambient_temperature_on']
                    #status['wema_settings']['hightemperature_limit_danger_level'] = self.highest_temperature_setting
                    
                    # status['wema_settings']['lowtemperature_limit_on']  = self.lowest_temperature_on
                    # status['wema_settings']['lowtemperature_limit_quiet'] = self.lowtemp_limit_quiet
                    self.warning_lowest_temperature_setting=wema_settings_shelf['lowest_ambient_temperature_on']
                    
                    
                    
                except:
                    plog ("Probably has not formed a shelf yet, forming a shelf from the config.")
                    plog(traceback.format_exc())
                    
                    
                    
                    self.rain_limit_setting = self.config['rain_limit']
                    self.humidity_limit_setting = self.config['humidity_limit']
                    self.windspeed_limit_setting = self.config['windspeed_limit']
                    self.lightning_limit_setting = self.config['lightning_limit']
                    self.temp_minus_dew_setting = self.config['temperature_minus_dewpoint_limit']
                    self.sky_temp_limit_setting = self.config['sky_temperature_limit']
                    self.cloud_cover_limit_setting = self.config['cloud_cover_limit']
                    self.lowest_temperature_setting = self.config['lowest_ambient_temperature']
                    self.highest_temperature_setting = self.config['highest_ambient_temperature']

                    self.warning_rain_limit_setting = self.config['warning_rain_limit']
                    self.warning_humidity_limit_setting = self.config['warning_humidity_limit']
                    self.warning_windspeed_limit_setting = self.config['warning_windspeed_limit']
                    self.warning_lightning_limit_setting = self.config['warning_lightning_limit']
                    self.warning_temp_minus_dew_setting = self.config['warning_temperature_minus_dewpoint_limit']
                    self.warning_sky_temp_limit_setting = self.config['warning_sky_temperature_limit']
                    self.warning_cloud_cover_limit_setting = self.config['warning_cloud_cover_limit']
                    self.warning_lowest_temperature_setting = self.config['warning_lowest_ambient_temperature']
                    self.warning_highest_temperature_setting = self.config['warning_highest_ambient_temperature']

                    self.rain_limit_on = self.config['rain_limit_on']
                    self.humidity_limit_on = self.config['humidity_limit_on']
                    self.windspeed_limit_on = self.config['windspeed_limit_on']
                    self.lightning_limit_on = self.config['lightning_limit_on']
                    self.temp_minus_dew_on = self.config['temperature_minus_dewpoint_limit_on']
                    self.sky_temperature_limit_on = self.config['sky_temperature_limit_on']
                    self.cloud_cover_limit_on = self.config['cloud_cover_limit_on']
                    self.lowest_temperature_on = self.config['lowest_ambient_temperature_on']
                    self.highest_temperature_on = self.config['highest_ambient_temperature_on']
                    
                    # self.rain_limit_on=True
                    # self.warning_rain_limit_setting=1
                    # self.rain_limit_setting=3
                    
                    # self.cloud_cover_limit_on=True
                    # self.warning_cloud_cover_limit_setting=25
                    # self.cloud_cover_limit_setting=50
                    
                    # self.humidity_limit_on=True
                    # self.warning_humidity_limit_setting=75
                    # self.humidity_limit_setting=88
                    
                    # self.windspeed_limit_on=True
                    # self.warning_windspeed_limit_setting=10
                    # self.windspeed_limit_setting=15
                    
                    # self.lightning_limit_on=False
                    # self.warning_lightning_limit_setting=10
                    # self.lightning_limit_setting=15
                    
                    # self.temp_minus_dew_on=False
                    # self.warning_temp_minus_dew_setting=2
                    # self.temp_minus_dew_setting=3
                    
                    # self.sky_temperature_limit_on=False
                    # self.warning_sky_temp_limit_setting=-17
                    # self.sky_temp_limit_setting=-1           
                    
                    
                    wema_settings_shelf['rain_limit_on'] = self.rain_limit_on
                    wema_settings_shelf['warning_rain_limit_setting'] = self.warning_rain_limit_setting
                    wema_settings_shelf['rain_limit_setting'] = self.rain_limit_setting
                    
                    wema_settings_shelf['cloud_cover_limit_on'] = self.cloud_cover_limit_on
                    wema_settings_shelf['warning_cloud_cover_limit_setting'] = self.warning_cloud_cover_limit_setting
                    wema_settings_shelf['cloud_cover_limit_setting'] = self.cloud_cover_limit_setting
                    
                    wema_settings_shelf['humidity_limit_on'] = self.humidity_limit_on
                    wema_settings_shelf['warning_humidity_limit_setting'] = self.warning_humidity_limit_setting
                    wema_settings_shelf['humidity_limit_setting'] = self.humidity_limit_setting
                    
                    wema_settings_shelf['windspeed_limit_on'] = self.windspeed_limit_on
                    wema_settings_shelf['warning_windspeed_limit_setting'] = self.warning_windspeed_limit_setting
                    wema_settings_shelf['windspeed_limit_setting'] = self.windspeed_limit_setting
                    
                    wema_settings_shelf['lightning_limit_on'] = self.lightning_limit_on
                    wema_settings_shelf['warning_lightning_limit_setting'] = self.warning_lightning_limit_setting
                    wema_settings_shelf['lightning_limit_setting'] = self.lightning_limit_setting
                    
                    wema_settings_shelf['temp_minus_dew_on'] = self.temp_minus_dew_on
                    wema_settings_shelf['warning_temp_minus_dew_setting'] = self.warning_temp_minus_dew_setting
                    wema_settings_shelf['temp_minus_dew_setting'] = self.temp_minus_dew_setting
                    
                    wema_settings_shelf['sky_temperature_limit_on'] = self.sky_temperature_limit_on
                    wema_settings_shelf['warning_sky_temp_limit_setting'] = self.warning_sky_temp_limit_setting
                    wema_settings_shelf['sky_temp_limit_setting'] = self.sky_temp_limit_setting
                    
                    wema_settings_shelf['lowest_ambient_temperature'] = self.lowest_temperature_setting
                    wema_settings_shelf['highest_ambient_temperature'] = self.highest_temperature_setting

                    wema_settings_shelf['lowest_ambient_temperature_on'] = self.lowest_temperature_on
                    wema_settings_shelf['highest_ambient_temperature_on']= self.highest_temperature_on
                    
                    wema_settings_shelf['hightemperature_limit_warning_level'] = self.warning_highest_temperature_setting
                    #status['wema_settings']['hightemperature_limit_danger_level'] = self.highest_temperature_setting
                    
                    # status['wema_settings']['lowtemperature_limit_on']  = self.lowest_temperature_on
                    # status['wema_settings']['lowtemperature_limit_quiet'] = self.lowtemp_limit_quiet
                    wema_settings_shelf['lowtemperature_limit_warning_level'] = self.warning_lowest_temperature_setting
                    
            #pid = camShelf["pid_obs"]  # a 9 character string
            wema_settings_shelf.close()
            
            self.update_status()
        
        plog ("booted up and got status from ocn device")

        # The LCS dome loses it's position if the wema code gets restarted.
        # If the WEMA code is restarted while the shutter is open, it needs to rehome
        # to figure out where it is. 
        
        
        
        if 'MaxDome' in g_dev['enc'].config['enclosure']['enclosure1']['driver']:
            home_on_boot=True
            
            enc_status=g_dev['enc'].get_status()
            
            if enc_status is not None:
                #breakpoint()
                if enc_status['shutter_status'] in ['Open', 'Sim Open']:
                    if home_on_boot:
                        try:
                            g_dev['enc'].enclosure.FindHome()
                            enc_status = g_dev['enc'].get_status()
                            self.send_enclosure_status(enc_status, [])
                            
                            home_wait_timeout=time.time()
                            while not g_dev['enc'].enclosure.AtHome  and (time.time()-home_wait_timeout < 300):
                                plog ("Waiting for Home")
                                time.sleep(5)
                                
                            g_dev['enc'].enclosure.SyncToAzimuth(self.config['enclosure']['enclosure1']['dome_home_azimuth']) # If shutter home at 194, then park at 100.
                            
                            enc_status = g_dev['enc'].get_status()
                            self.send_enclosure_status(enc_status, [])
                            
                            plog ("Successfully found Home. Ready to observe")
                        except:
                            plog(traceback.format_exc())
                            plog ("DOME COMMAND GLITCHED OUT.")
                        
        
            
        
        



    def create_devices(self, config: dict):
        self.all_devices = {}
        for (
            dev_type
        ) in self.device_types:  # This has been set up for wema to be ocn and enc.
            self.all_devices[dev_type] = {}
            devices_of_type = config.get(dev_type, {})
            device_names = devices_of_type.keys()
            if dev_type == "camera":
                pass
            for name in device_names:
                driver = devices_of_type[name]["driver"]
 
                if dev_type == "observing_conditions" and not self.config['observing_conditions']['observing_conditions1']['ocn_is_custom']:

                    device = ObservingConditions(
                        driver, name, self.config, self.astro_events
                    )
                    self.ocn_status_custom=False
                elif dev_type == "observing_conditions" and self.config['observing_conditions']['observing_conditions1']['ocn_is_custom']:
                    
                    device=None
                    self.ocn_status_custom=True
                    
                
                
                elif dev_type == "enclosure" and not self.config['enclosure']['enclosure1']['encl_is_custom']:
                    device = Enclosure(driver, name, self.config, self.astro_events)
                    self.enc_status_custom=False
                elif dev_type == "enclosure" and self.config['enclosure']['enclosure1']['encl_is_custom']:
                    
                    device=None
                    self.enc_status_custom=True
                   
                else:
                    print(f"Unknown device: {name}")
                self.all_devices[dev_type][name] = device
        print("Finished creating devices.")

    def update_config(self):
        """Sends the config to AWS."""

        uri = f"{self.config['wema_name']}/config/"
        self.config["events"] = g_dev["events"]
        response = self.api.authenticated_request("PUT", uri, self.config)
        if response:
            print("\n\nConfig uploaded successfully.")

    def scan_requests(self):
        """
        
        This can pick up owner/admin Shutdown and Automatic request but it 
        would need to be a custom api endpoint.
        
        Not too many useful commands: Shutdown, Automatic, Immediate close,
        BadWxSimulate event (ie a 15 min shutdown)

        For a wema this can be used to capture commands to the wema once the
        AWS side knows how to redirect from any mount/telescope to the common
        Wema.
        This should be changed to look into the site command queue to pick up
        any commands directed at the Wx station, or if the agent is going to
        always exist lets develop a seperate command queue for it.
        
        NB NB NB should this be on some sort of timeout so that if AWS
        connection goes away the code can deal with that case?
        """


        url_job = "https://jobs.photonranch.org/jobs/getnewjobs"
        body = {"site": self.config['wema_name']}
        cmd = {}
        # Get a list of new jobs to complete (this request
        # marks the commands as "RECEIVED")
        #plog ("scanning requests")
        try:
            unread_commands = requests.request(
                "POST", url_job, data=json.dumps(body), timeout=20, allow_redirects=False, headers=close_headers, stream=False
            ).json()
        except:
            plog(traceback.format_exc())
            plog("problem gathering scan requests. Likely just a connection glitch.")
            unread_commands = []
        # Make sure the list is sorted in the order the jobs were issued
        # Note: the ulid for a job is a unique lexicographically-sortable id.
        if len(unread_commands) > 0:
            try:
                unread_commands.sort(key=lambda x: x["timestamp_ms"])
                # Process each job one at a time
                for cmd in unread_commands:
                    if 'action' in cmd:
                        plog(cmd)
                        if cmd['action']=='open':
                            plog ("open enclosure command received")
                 
                            self.open_enclosure({}, {})     #WER added missing dicts 10142023 WER

                            self.enclosure_status_check_timer=time.time() - 2*self.enclosure_status_check_period
                            self.update_status()
                            
                        if cmd['action']=='close':
                            plog ("command enclosure command received")
                           
                            self.park_enclosure_and_close()
                            self.enclosure_status_check_timer=time.time() - 2*self.enclosure_status_check_period
                            self.update_status()
                        
                        
                        if cmd['action']=='simulate_weather_hold':
                            plog("simulate weather hold button doesn't do anything yet")
                        
                        if cmd['action']=='open_no_earlier_than_owm_plan':
                            plog("open no earlier than owm button doesn't do anything yet")
                        
                        # Change in Enclosure mode
                        if cmd['action']=='set_enclosure_mode':
                            plog ("set enclosure mode command received")
                            g_dev['enc'].mode = cmd['required_params']['enclosure_mode']
                            self.enclosure_status_check_timer =time.time() - 2* self.enclosure_status_check_period
                            self.update_status()
                            
                        
                        if cmd['action']=='set_observing_mode':
                            plog ("set observing mode command received")
                            self.observing_mode=cmd['required_params']['observing_mode']
                            self.enclosure_status_check_timer =time.time() - 2* self.enclosure_status_check_period
                            self.update_status()
                            
                        if cmd['action']=='configure_active_weather_report':
                            plog ("configure weather settings command received")
                            if cmd['required_params']["weather_type"] == 'local':
                                if cmd['required_params']["weather_type_value"] == 'on':
                                    self.local_weather_active=True
                                if cmd['required_params']["weather_type_value"] == 'off':
                                    self.local_weather_active=False
                             
                            if cmd['required_params']["weather_type"] == 'owm':
                                if cmd['required_params']["weather_type_value"] == 'on':
                                    self.owm_active=True
                                if cmd['required_params']["weather_type_value"] == 'off':
                                    self.owm_active=False
                            
                            self.wema_settings_upload_timer=time.time() -2 * self.wema_settings_upload_period
                            self.update_status()
                            
                            
                        if cmd['action']=='force_roof_state':
                            if cmd['required_params']["force_roof_state"] == 'open':
                                plog ("keep roof open all night command received")
                                self.keep_open_all_night = True
                                self.keep_closed_all_night = False
                            
                            if cmd['required_params']["force_roof_state"] == 'closed':
                                
                                plog ("keep roof closed all night command received")
                                self.keep_closed_all_night= True
                                self.keep_open_all_night = False
                            
                            if cmd['required_params']["force_roof_state"] == 'auto':
                                
                                plog ("Remove roof force command received")
                                self.keep_closed_all_night= False
                                self.keep_open_all_night = False
                            
                            self.wema_settings_upload_timer=time.time() -2 * self.wema_settings_upload_period
                            self.update_status()
                            
                        if cmd['action']=='set_weather_values': 
                            tempval=cmd['required_params']['weather_values']
                            
                            self.rain_limit_on='on' in tempval['rain']['status']
                            self.warning_rain_limit_setting=tempval['rain']['warning_level']
                            self.rain_limit_setting=tempval['rain']['danger_level']
                            
                            self.cloud_cover_limit_on='on' in tempval['clouds']['status']
                            self.warning_cloud_cover_limit_setting=tempval['clouds']['warning_level']
                            self.cloud_cover_limit_setting=tempval['clouds']['danger_level']
                            
                            self.humidity_limit_on='on' in tempval['humidity']['status']
                            self.warning_humidity_limit_setting=tempval['humidity']['warning_level']
                            self.humidity_limit_setting=tempval['humidity']['danger_level']
                            
                            self.windspeed_limit_on='on' in tempval['windspeed']['status']
                            self.warning_windspeed_limit_setting=tempval['windspeed']['warning_level']
                            self.windspeed_limit_setting=tempval['windspeed']['danger_level']
                            
                            self.lightning_limit_on='on' in tempval['lightning']['status']
                            self.warning_lightning_limit_setting=tempval['lightning']['warning_level']
                            self.lightning_limit_setting=tempval['lightning']['danger_level']
                            
                            self.temp_minus_dew_on='on' in tempval['tempDew']['status']
                            self.warning_temp_minus_dew_setting=tempval['tempDew']['warning_level']
                            self.temp_minus_dew_setting=tempval['tempDew']['danger_level']
                            
                            self.sky_temperature_limit_on='on' in tempval['skyTempLimit']['status']
                            self.warning_sky_temp_limit_setting=tempval['skyTempLimit']['warning_level']
                            self.sky_temp_limit_setting=tempval['skyTempLimit']['danger_level']
                            
                            self.wema_settings_upload_timer=time.time() -2 * self.wema_settings_upload_period
                            self.update_status()
                            
                    else:
                        plog ("orphanned command?")
                        plog(cmd)
                
                # Open and store the settings in the wema settings shelf
                wema_settings_shelf = shelve.open(self.wema_settings_shelf_filename)
                
                
                wema_settings_shelf['mode']=g_dev['enc'].mode 
                wema_settings_shelf['observing_mode']=self.observing_mode
                wema_settings_shelf['local_weather_active']=self.local_weather_active
                wema_settings_shelf['owm_active']=self.owm_active
                wema_settings_shelf['keep_open_all_night']=self.keep_open_all_night
                wema_settings_shelf['keep_closed_all_night']=self.keep_closed_all_night
                if self.ocn_exists:
                    wema_settings_shelf['rain_limit_on']=self.rain_limit_on
                    wema_settings_shelf['warning_rain_limit_setting']=self.warning_rain_limit_setting
                    wema_settings_shelf['rain_limit_setting']=self.rain_limit_setting
                    
                    wema_settings_shelf['cloud_cover_limit_on']=self.cloud_cover_limit_on
                    wema_settings_shelf['warning_cloud_cover_limit_setting']=self.warning_cloud_cover_limit_setting
                    wema_settings_shelf['cloud_cover_limit_setting']=self.cloud_cover_limit_setting
                    
                    wema_settings_shelf['humidity_limit_on']=self.humidity_limit_on
                    wema_settings_shelf['warning_humidity_limit_setting']=self.warning_humidity_limit_setting
                    wema_settings_shelf['humidity_limit_setting']=self.humidity_limit_setting
                    
                    wema_settings_shelf['windspeed_limit_on']=self.windspeed_limit_on
                    wema_settings_shelf['warning_windspeed_limit_setting']=self.warning_windspeed_limit_setting
                    wema_settings_shelf['windspeed_limit_setting']=self.windspeed_limit_setting
                    
                    wema_settings_shelf['lightning_limit_on']=self.lightning_limit_on
                    wema_settings_shelf['warning_lightning_limit_setting']=self.warning_lightning_limit_setting
                    wema_settings_shelf['lightning_limit_setting']=self.lightning_limit_setting
                    
                    wema_settings_shelf['temp_minus_dew_on']=self.temp_minus_dew_on
                    wema_settings_shelf['warning_temp_minus_dew_setting']=self.warning_temp_minus_dew_setting
                    wema_settings_shelf['temp_minus_dew_setting']=self.temp_minus_dew_setting
                    
                    wema_settings_shelf['sky_temperature_limit_on']=self.sky_temperature_limit_on
                    wema_settings_shelf['warning_sky_temp_limit_setting']=self.warning_sky_temp_limit_setting
                    wema_settings_shelf['sky_temp_limit_setting']=self.sky_temp_limit_setting
              
                    wema_settings_shelf['lowest_ambient_temperature'] = self.lowest_temperature_setting
                    wema_settings_shelf['highest_ambient_temperature'] = self.highest_temperature_setting

                    wema_settings_shelf['lowest_temperature_on'] = self.lowest_temperature_on
                    wema_settings_shelf['highest_temperature_on']= self.highest_temperature_on  
                    
                    
                    wema_settings_shelf['hightemperature_limit_warning_level'] = self.warning_highest_temperature_setting
                    #status['wema_settings']['hightemperature_limit_danger_level'] = self.highest_temperature_setting
                    
                    # status['wema_settings']['lowtemperature_limit_on']  = self.lowest_temperature_on
                    # status['wema_settings']['lowtemperature_limit_quiet'] = self.lowtemp_limit_quiet
                    wema_settings_shelf['lowtemperature_limit_warning_level'] = self.warning_lowest_temperature_setting
                    # status['wema_settings']['lowtemperature_limit_danger_level'] = self.lowest_temperature_setting

              
                #pid = camShelf["pid_obs"]  # a 9 character string
                wema_settings_shelf.close()
                

            except:
                if 'Internal server error' in str(unread_commands):
                    plog("AWS server glitch reading unread_commands")
                else:
                    plog(traceback.format_exc())
                    plog("unread commands")
                    plog(unread_commands)
                    plog("MF trying to find whats happening with this relatively rare bug!")

        return



    def update_status(self):
        """
        Collect status from weather and enclosure devices and sends an
        update to AWS. Each device class is responsible for implementing the
        method 'get_status()', which returns a dictionary.
        """


        enc_status = None
        ocn_status = None
        wema = self.config['wema_name']  
        sync_obs= self.config['obsp_ids'][0]

        # For those domes not synced by ascom, check in with telescope      
        
        # pointing and rotate dome accordingly
        # This needs a config item at some stage
        # Only bother checking if the shutter is open
        enc_status=g_dev['enc'].get_status()
        
        if enc_status is not None:
            #breakpoint()
            if enc_status['shutter_status'] in ['Open', 'Sim Open']:
            #if True:
                if 'MaxDome' in g_dev['enc'].config['enclosure']['enclosure1']['driver']:
                    
                    if time.time() > (self.dome_check_timer + self.dome_check_timer_period):
                        #print (time.time() - self.dome_check_timer)
                        self.dome_check_timer=time.time()
                        
                        dome_at_scope=False
                        
                        while not dome_at_scope:
                            
                            #breakpoint()
                            report_timer=time.time() - 31
                            try:
                                slew_timeout_timer=time.time()
                                while g_dev['enc'].enclosure.Slewing and time.time()-slew_timeout_timer < 300:
                                    if time.time() - report_timer > 10:
                                        plog("Waiting for dome to stop slewing")
                                        report_timer=time.time()
                                    #self.send_enclosure_status(self.enc_status, self.ocn_status)
                                    time.sleep(0.25)
                            except:
                                plog(traceback.format_exc())
                                plog ("DOME COMMAND GLITCHED OUT.")
                            
                            enc_status = g_dev['enc'].get_status()
                            self.send_enclosure_status(enc_status, [])
                            
                            
                            # Call out to aws to get current main scope pointing and ra and dec
                            
                            uri_status = f"https://status.photonranch.org/status/{sync_obs}/device"
                            try:
                                #print ("Grabbing obs status")


                                main_obs_status=requests.get(uri_status, timeout=20, allow_redirects=False, headers=close_headers, stream=False)
                                #try:
                                #main_obs_status = func_timeout(10, requests.get, args=(uri_status,), kwargs={"timeout": 20, "allow_redirects": False, "headers": close_headers, "stream": False})
                                #except:
                                
                                #print ("Got obs status")
                            
                                    
                                obs_mount_name=list(main_obs_status.json()['status']['mount'].keys())[0]
                                
                                obs_mount_status=main_obs_status.json()['status']['mount'][obs_mount_name]
                                
                                
                                # Where is scope currently pointing?
                                obs_mount_ra=obs_mount_status['right_ascension']['val']
                                obs_mount_dec=obs_mount_status['declination']['val']
                                
                                
                                # Figure out the implied azimuth for that ra and dec at this location                      
                                observation_time=Time.now()
                                
                                sky_coord=SkyCoord(ra=obs_mount_ra*15*u.deg, dec=obs_mount_dec*u.deg)
                                # Convert to AltAz frame
                                altaz_frame = AltAz(obstime=observation_time, location=self.observer_location)
                                altaz_coords = sky_coord.transform_to(altaz_frame)
                                
                                obs_current_altitude = altaz_coords.alt.deg
                                obs_current_azimuth = altaz_coords.az.deg
                                
                                
                                
                                
                                
                                slave_directly_to_telescope_pointing=False
                                if slave_directly_to_telescope_pointing:
                                    obs_mount_ra=obs_mount_status['right_ascension']['val']
                                    obs_mount_dec=obs_mount_status['declination']['val']
                                    
                                    
                                    # Figure out the implied azimuth for that ra and dec at this location                      
                                    observation_time=Time.now()
                                    
                                    sky_coord=SkyCoord(ra=obs_mount_ra*15*u.deg, dec=obs_mount_dec*u.deg)
                                    # Convert to AltAz frame
                                    altaz_frame = AltAz(obstime=observation_time, location=self.observer_location)
                                    altaz_coords = sky_coord.transform_to(altaz_frame)
                                    
                                    # Extract altitude and azimuth
                                    #obs_altitude = altaz_coords.alt.deg
                                    obs_target_azimuth = altaz_coords.az.deg
                                    obs_target_altitude = altaz_coords.alt.deg
                                
                                else:
                                    obs_target_azimuth=obs_mount_dec=obs_mount_status['target_az']['val']
                                    obs_target_altitude=obs_mount_dec=obs_mount_status['target_alt']['val']
                                
                                #### At this stage, we actually want to adjust the requested azimuth
                                #### To move the dome slightly west or east depending on the 
                                #### pierside of the telescope
                                
                                
                                
                                #breakpoint()
                                
                                if obs_target_azimuth == -500:
                                    #plog ("Target Azimuth for Scope not an actual skytarget, so not moving dome")
                                    #plog(f"Actual Azimuth: {obs_current_azimuth:.2f} degrees")
                                    dome_at_scope=True
                                    pass
                                else:
                                    
                                    print ("Requested Azmituh: " + str(obs_target_azimuth))
                                    
                                    
                                    
                                    correct_dome_for_pier_effect=True
                                    if correct_dome_for_pier_effect:
                                        # Example usage
                                        telescope_azimuth = obs_target_azimuth  # Example telescope azimuth
                                        telescope_altitude = obs_target_altitude   # Example telescope altitude
                                        if obs_mount_status['pier_side']['val'] == 1:
                                            side_of_pier = 'W'        # 'E' or 'W'
                                        else:
                                            side_of_pier = 'E'        # 'E' or 'W'
                                        dome_radius = g_dev['enc'].config['enclosure']['enclosure1']['dome_radius']           # Example dome radius in meters
                                        telescope_offset = g_dev['enc'].config['enclosure']['enclosure1']['offset_from_ota_to_axis']     # Telescope offset from the center in meters
                                        #dome_slit_offset =       # Small additional offset in degrees
                                        
                                        target_dome_azimuth = correct_dome_azimuth(telescope_azimuth, telescope_altitude, side_of_pier, dome_radius, telescope_offset)#, dome_slit_offset)
    
                                        #print ("Corrected Azmituh: " + str(corrected_dome_az))
                                    else:
                                        target_dome_azimuth=obs_target_azimuth
                                    
                                    
                                    #print(f"Time: {observation_time.iso}")
                                    plog ("Primary Obs Pointing")
                                    #plog(f"Altitude: {obs_altitude:.2f} degrees")
                                    
                                    plog(f"Target Telescope Azimuth: {obs_target_azimuth:.2f} degrees")
                                    
                                    plog(f"Actual Telescope Azimuth: {obs_current_azimuth:.2f} degrees")
                                    
                                    plog(f"Target Dome Azimuth: {target_dome_azimuth:.2f} degrees")
                                                                    
                                    # Temporary hack - 
                                    target_azimuth = obs_target_azimuth + self.dome_offset
                                    if target_azimuth > 360:
                                        target_azimuth=target_azimuth - 360
                                    if target_azimuth < 0:
                                        target_azimuth=target_azimuth + 360
                                    
                                    try:
                                        current_dome_azimuth= g_dev['enc'].enclosure.Azimuth
                                    except:
                                        plog(traceback.format_exc())
                                        plog ("DOME COMMAND GLITCHED OUT.")
                                    
                                    plog(f"Current Dome Azimuth: {current_dome_azimuth:.2f} degrees")
                                    
                                    dome_out_by=abs (current_dome_azimuth-target_dome_azimuth)
                                    if dome_out_by > 180:
                                        dome_out_by=abs(dome_out_by-360)                                   
                                    
                                    plog ("Dome out by: " + str (dome_out_by))
                                    if abs (dome_out_by) > 1:                       
                                        plog ("Moving Dome")
                                    
                                        try:                                            
                                            g_dev['enc'].enclosure.SlewToAzimuth(target_dome_azimuth)
                                            enc_status = g_dev['enc'].get_status()
                                            self.send_enclosure_status(enc_status, [])
                                            
                                            dome_at_scope=False
                                            #time.sleep(10)
                                        except:
                                            plog(traceback.format_exc())
                                            plog ("DOME COMMAND GLITCHED OUT.")
                                            
                                    else:
                                        plog ("Leaving Dome as it is")
                                        dome_at_scope=True
                            except:
                                plog(traceback.format_exc())
                                plog ("failed getting the obs status probably, but also might be a dome thing in the dome position area")
                                

        loud = False
        while time.time() < self.time_last_status + self.status_interval:
            return        

        # Hourly Weather Report
        if time.time() > (self.weather_report_run_timer + 3600):
            self.weather_report_run_timer=time.time()
            if self.enc_status_custom:
                enc_status={}
                enc_status['enclosure']={}

                enc_status['enclosure']['enclosure1']= get_enc_status_custom()
                self.run_nightly_weather_report(enc_status=enc_status['enclosure']['enclosure1'], ocn_status=g_dev['ocn'].get_status())
            else:
                self.run_nightly_weather_report(enc_status=g_dev['enc'].get_status(), ocn_status=g_dev['ocn'].get_status())
        
        
        # Enclosure and Weather Status
        if time.time() > self.enclosure_status_check_timer + self.enclosure_status_check_period:
            #breakpoint()
            self.enclosure_status_check_timer = time.time()
            status = {}
            status["timestamp"] = round(time.time(), 1)
            status['enclosure']={}

            if self.enc_status_custom==False:
                device=self.all_devices.get('enclosure', {})['enclosure1']
                status['enclosure']['enclosure1'] = device.get_status()
                enc_status = {"enclosure": status.pop("enclosure")}
            else:
                #This is SRO mode
                enc_status={}
                enc_status['enclosure']={}

                enc_status['enclosure']['enclosure1']= get_enc_status_custom()
            
            self.send_enclosure_status(enc_status, ocn_status)

    

        if time.time() > self.weather_status_check_timer + self.weather_status_check_period:
            self.weather_status_check_timer=time.time()
            status = {}
            status["timestamp"] = round(time.time(), 1)
            status['observing_conditions'] = {}
            if self.ocn_status_custom==False:
                device = self.all_devices.get('observing_conditions', {})['observing_conditions1']
                if device == None:
                    status['observing_conditions']['observing_conditions1'] = None
                else:
                    status['observing_conditions']['observing_conditions1'] = device.get_status()
                    ocn_status = {"observing_conditions": status.pop("observing_conditions")}
            else:
                ocn_status={}
                ocn_status['observing_conditions']={}
                ocn_status['observing_conditions']['observing_conditions1'] = get_ocn_status_custom()

            if ocn_status is None or ocn_status['observing_conditions']['observing_conditions1']  == None:   #20230709 Changed from not None
                ocn_status = {}
                ocn_status['observing_conditions'] = {}
                ocn_status['observing_conditions']['observing_conditions1'] = dict(wx_ok='Unknown',
                                                                                       wx_hold='no',
                                                                                       hold_duration=0)


            ocn_status['observing_conditions']['observing_conditions1']['weather_report_good'] = self.weather_report_open_at_start
            try:
                ocn_status['observing_conditions']['observing_conditions1']['fitzgerald_number'] = self.night_fitzgerald_number  # uninit Variable
            except:
                pass

            
            #breakpoint()

            
            
            # Here is where we actually make the decision about the weather
            # Independantly of the actual observing conditions device        
            # THE WAYNE ROSING BRAND WEATHER DECISION DESK!!! Made from the status, not in the device
            
            quick_status=ocn_status['observing_conditions']['observing_conditions1']
            
            if quick_status['humidity_%'] == -1:
                plog ("local weather station not reporting humidity, using last owm report")
                ocn_status['observing_conditions']['observing_conditions1']['humidity_%']=self.current_owm_humidity
                quick_status['humidity_%'] = self.current_owm_humidity
                #breakpoint()
                print ("OWM Humidity: " + str(self.current_owm_humidity))
            
            
            
            # Simply override cloud_cover for the moment
            quick_status['cloud_cover_%']=self.median_cloud_estimate
            
            
            wx_reasons = []
            #breakpoint()
            
            
            
            #self.lightning_limit_on = self.config['lightning_limit_on']
            
            
            
            if self.rain_limit_on:
                rain_limit = quick_status['rain_rate'] > self.rain_limit_setting
                if rain_limit:
                    plog("Reported rain rate in mm/hr:  ", quick_status['rain_rate'])
                    wx_reasons.append('Rain > ' + str(self.rain_limit_setting))
                    # Also here move the next allowed open time to much later
                    # Like until 45 minutes later. If there is rain around
                    # We have to be safe. This should continually update as the status
                    # is updated such that the enclosure won't be able to open until
                    # at least 45 minutes after the last reported rain fall
                    self.enclosure_next_open_time = time.time() + 2700
            else:
                rain_limit=False
            
            if self.humidity_limit_on:
                humidity_limit = quick_status['humidity_%'] < self.humidity_limit_setting
                if not humidity_limit:
                    wx_reasons.append('Humidity >= ' + str(self.humidity_limit_setting) + '%')
            else:
                humidity_limit=True
            
            if self.windspeed_limit_on:
                wind_limit = (
                        quick_status['wind_m/s']*0.2778 < self.windspeed_limit_setting
                )  # sky_monitor reports km/h, Clarity may report in MPH
                if not wind_limit:
                    wx_reasons.append('Wind > ' + str(self.windspeed_limit_setting) + ' km/h')
            else:
                wind_limit=True
            
            if self.temp_minus_dew_on:
                dewpoint_gap = (
                    not (quick_status['temperature_C']- quick_status['dewpoint_C']) < self.temp_minus_dew_setting
                )
                if not dewpoint_gap:
                    wx_reasons.append('Ambient - Dewpoint < ' + str(self.temp_minus_dew_setting) + 'C')
            else:
                dewpoint_gap=True
            
            if self.sky_temperature_limit_on:
                sky_amb_limit = (
                                        quick_status['sky_temp_C']- quick_status['temperature_C']
                                ) < self.sky_temp_limit_setting  # NB THIS NEEDS ATTENTION, Sky alert defaults to -17
                if not sky_amb_limit:
                    wx_reasons.append('(sky - amb) > ' + str(self.sky_temp_limit_setting) + 'C')
            else:
                sky_amb_limit=True
            
            if self.cloud_cover_limit_on:
                try:
                    cloud_cover_value = float(quick_status['cloud_cover_%'])
                    #status['cloud_cover_%'] = round(cloud_cover_value, 0)
                    if cloud_cover_value <= self.cloud_cover_limit_setting:
                        cloud_cover = False
                        #wx_reasons.append('>=' + str(self.cloud_cover_limit_setting) + '% Cloudy')
                
                    else:
                        cloud_cover = True
                        wx_reasons.append('>=' + str(self.cloud_cover_limit_setting) + '% Cloudy')
                except:
                    #status['cloud_cover_%'] = "no report"
                    cloud_cover = True  # We cannot use this signal to force a wX hold or close
            else:
                cloud_cover = False
            
            
            if self.lowest_temperature_on:
                low_temp_bound=not quick_status['temperature_C'] < self.lowest_temperature_setting
            else: 
                low_temp_bound=True
            
            if self.highest_temperature_on:
                high_temp_bound=not quick_status['temperature_C'] > self.highest_temperature_setting
            else:
                high_temp_bound=True
                
            temp_bounds=True
            if not low_temp_bound or not high_temp_bound:
                temp_bounds=False
                wx_reasons.append('amb temp out of range')
    
            # self.local_weather_ok = (
            #         (dewpoint_gap and self.temp_minus_dew_on)
            #         and (temp_bounds and (self.lowest_temperature_on or self.highest_temperature_on))
            #         and (wind_limit and self.windspeed_limit_on)
            #         and (sky_amb_limit and self.sky_temperature_limit_on)
            #         and (humidity_limit and self.humidity_limit_on)
            #         and not (rain_limit and self.rain_limit_on)
            #         and not (cloud_cover and self.cloud_cover_limit_on)
            # )
            #breakpoint()
            self.local_weather_ok = dewpoint_gap and temp_bounds and wind_limit and sky_amb_limit and humidity_limit and not rain_limit and not cloud_cover  
            
            #  NB wx_is_ok does not include ambient light or altitude of the Sun
            # the notion of Obs OK should bring in Sun Elevation and or ambient light.
            
            #breakpoint()
    
            if quick_status['rain_rate']> 0.0:
                #plog("%$%^%#^$%#*!$^#%$*@#^$%*@#^$%*#%$^&@#$*@&")
                #plog("Rain Rate is 1.0")
                # plog('Rain > ' + str(rain_limit_setting))
                plog("For SkyAlerts: Rain Flag is 1: This is usually a glitch so ignoring.")
                plog("May be unevaporated rain, ice, or a bird dropping.")
                #plog("%$%^%#^$%#*!$^#%$*@#^$%*@#^$%*#%$^&@#$*@&")
    
            if self.local_weather_ok:
                #wx_str = "Yes"
                ocn_status['observing_conditions']['observing_conditions1']["local_weather_ok"] = "Yes"
                # plog('Wx Ok?  ', status["wx_ok"])
            else:
                #wx_str = "No"  # Ideally we add the dominant reason in priority order.
                ocn_status['observing_conditions']['observing_conditions1']["local_weather_ok"] = "No"
                #plog('Wx Ok: ', status["wx_ok"], wx_reasons)
    
    
            ocn_status['observing_conditions']['observing_conditions1']["OWM_weather_ok"] = self.weather_report_open_at_start
            
            if self.owm_active and not self.weather_report_open_at_start:
                wx_reasons.append("OWM Report negative.")
    
            if self.local_weather_active and self.owm_active:
                combined_weather_ok = self.local_weather_ok and self.weather_report_open_at_start
            elif  self.owm_active:
                combined_weather_ok = self.weather_report_open_at_start
            elif self.local_weather_active:
                combined_weather_ok = self.local_weather_ok
            else:
                combined_weather_ok = 'Not considered'
                
            
            ocn_status['observing_conditions']['observing_conditions1']["wx_ok"] = combined_weather_ok
    
            #breakpoint()
    
            plog('Wx Ok: ', combined_weather_ok, wx_reasons)
    
            #g_dev["wx_ok"] = self.wx_is_ok
            
            #breakpoint()
            
            
            
            #######
            # ONCE WE HAVE FIGURED ALL THAT OUT, THEN SEND THE STATUS
            ################
            
            #breakpoint()
            if self.enclosure_next_open_time - time.time() > 0:
                ocn_status['observing_conditions']['observing_conditions1']['hold_duration'] = round(self.enclosure_next_open_time - time.time(), 1)
            else:
                ocn_status['observing_conditions']['observing_conditions1']['hold_duration'] = 0
            

            ocn_status['observing_conditions']['observing_conditions1']["wx_hold"] = not combined_weather_ok
    
            if ocn_status is not None:
                lane = "weather"
                try:
                    send_status(wema, lane, ocn_status)
                except:
                    plog('could not send weather status')                  

            loud = False
            if loud:
                print("\n\n > Status Sent:  \n", ocn_status)
            
            self.ocn_status=ocn_status
            
            
            

        # WEMA Settings
        if time.time() > self.wema_settings_upload_timer + self.wema_settings_upload_period:
            self.wema_settings_upload_timer = time.time()

            status = {}
            status['wema_settings']={}
            status['wema_settings']['OWM_active']=self.owm_active
            status['wema_settings']['local_weather_active']=self.local_weather_active
            status['wema_settings']['keep_roof_open_all_night'] = self.keep_open_all_night
            status['wema_settings']['keep_roof_closed_all_night']  = self.keep_closed_all_night
            
            status['wema_settings']['open_at_specific_utc'] = self.open_at_specific_utc
            status['wema_settings']['specific_utc_when_to_open'] = self.specific_utc_when_to_open
            
            status['wema_settings']['manual_weather_hold_set'] = self.manual_weather_hold_set
            status['wema_settings']['manual_weather_hold_duration'] = self.manual_weather_hold_duration
            status['wema_settings']['observing_mode'] =self.observing_mode
                    
            if self.ocn_exists:
                # Local Weather Limits
                status['wema_settings']['rain_limit_on'] = self.rain_limit_on
                status['wema_settings']['rain_limit_quiet'] = self.rain_limit_quiet
                status['wema_settings']['rain_limit_warning_level'] = self.warning_rain_limit_setting
                status['wema_settings']['rain_limit_danger_level'] = self.rain_limit_setting
                
                status['wema_settings']['cloud_limit_on'] = self.cloud_cover_limit_on
                status['wema_settings']['cloud_limit_quiet'] = self.cloud_limit_quiet
                status['wema_settings']['cloud_limit_warning_level'] = self.warning_cloud_cover_limit_setting
                status['wema_settings']['cloud_limit_danger_level'] = self.cloud_cover_limit_setting
                
                status['wema_settings']['humidity_limit_on']  = self.humidity_limit_on
                status['wema_settings']['humidity_limit_quiet'] = self.humidity_limit_quiet
                status['wema_settings']['humidity_limit_warning_level'] = self.warning_humidity_limit_setting
                status['wema_settings']['humidity_limit_danger_level'] = self.humidity_limit_setting
                
                status['wema_settings']['windspeed_limit_on']  = self.windspeed_limit_on
                status['wema_settings']['windspeed_limit_quiet'] = self.windspeed_limit_quiet
                status['wema_settings']['windspeed_limit_warning_level'] = self.warning_windspeed_limit_setting
                status['wema_settings']['windspeed_limit_danger_level'] = self.windspeed_limit_setting
                
                status['wema_settings']['lightning_limit_on']  = self.lightning_limit_on
                status['wema_settings']['lightning_limit_quiet'] = self.lightning_limit_quiet
                status['wema_settings']['lightning_limit_warning_level'] = self.warning_lightning_limit_setting
                status['wema_settings']['lightning_limit_danger_level'] =  self.lightning_limit_setting
                
                status['wema_settings']['tempminusdew_limit_on']  = self.temp_minus_dew_on
                status['wema_settings']['tempminusdew_limit_quiet'] = self.temp_minus_dew_quiet
                status['wema_settings']['tempminusdew_limit_warning_level'] = self.warning_temp_minus_dew_setting
                status['wema_settings']['tempminusdew_limit_danger_level'] = self.temp_minus_dew_setting
                
                status['wema_settings']['skytemp_limit_on']  = self.sky_temperature_limit_on
                status['wema_settings']['skytemp_limit_quiet'] = self.skytemp_limit_quiet
                status['wema_settings']['skytemp_limit_warning_level'] = self.warning_sky_temp_limit_setting
                status['wema_settings']['skytemp_limit_danger_level'] = self.sky_temp_limit_setting
                
                status['wema_settings']['hightemperature_limit_on']  = self.highest_temperature_on
                status['wema_settings']['hightemperature_limit_quiet'] = self.hightemp_limit_quiet
                status['wema_settings']['hightemperature_limit_warning_level'] = self.warning_highest_temperature_setting
                status['wema_settings']['hightemperature_limit_danger_level'] = self.highest_temperature_setting
                
                status['wema_settings']['lowtemperature_limit_on']  = self.lowest_temperature_on
                status['wema_settings']['lowtemperature_limit_quiet'] = self.lowtemp_limit_quiet
                status['wema_settings']['lowtemperature_limit_warning_level'] = self.warning_lowest_temperature_setting
                status['wema_settings']['lowtemperature_limit_danger_level'] = self.lowest_temperature_setting

            lane = "wema_settings"
            try:                
                send_status(wema, lane, status)
            except:
                plog('could not send wema_settings status') 
                
        
                            
            
                    #breakpoint()
                    
    def send_enclosure_status(self, enc_status, ocn_status):

        if enc_status is not None:
            
            #breakpoint()
            
            
            # Reformulate a short enclosure status - bit of a hack for the moment.
            try: 
                print (enc_status['enclosure']['enclosure1']['shutter_status'] )
                print ("good")
            except:
                enc_status_extended={}

                enc_status_extended['enclosure'] ={}

                enc_status_extended['enclosure']['enclosure1'] ={}
                
                enc_status_extended['enclosure']['enclosure1'] = enc_status
                
                enc_status=enc_status_extended
                print ("bad")
            
            # New Tim Entries
            if enc_status['enclosure']['enclosure1']['shutter_status']  is not None:
                if enc_status['enclosure']['enclosure1']['shutter_status'] in ['Open', 'Sim Open']:
                    enc_status['enclosure']['enclosure1']['enclosure_is_open'] = True
                    enc_status['enclosure']['enclosure1']['shut_reason_bad_weather'] = False
                    enc_status['enclosure']['enclosure1']['shut_reason_daytime'] = False
                    enc_status['enclosure']['enclosure1']['shut_reason_manual_mode'] = False
            else:
                enc_status['enclosure']['enclosure1']['enclosure_is_open'] = False
                if not enc_status['enclosure']['enclosure1']['enclosure_mode'] == 'Automatic':
                    enc_status['enclosure']['enclosure1']['shut_reason_manual_mode'] = True
                else:
                    enc_status['enclosure']['enclosure1']['shut_reason_manual_mode'] = False
                if ocn_status is not None:  #NB NB ocn status has never been established first time this is envoked after startup -WER
                    if ocn_status['observing_conditions']['observing_conditions1']['wx_ok'] == 'Unknown':
                        enc_status['enclosure']['enclosure1']['shut_reason_bad_weather'] = False
                    elif ocn_status['observing_conditions']['observing_conditions1']['wx_ok'] == 'No' or not self.weather_report_open_at_start:
                        enc_status['enclosure']['enclosure1']['shut_reason_bad_weather'] = True
                elif not self.weather_report_open_at_start:
                    enc_status['enclosure']['enclosure1']['shut_reason_bad_weather'] = True
                else:
                    enc_status['enclosure']['enclosure1']['shut_reason_bad_weather'] = False

                    # NEED TO INCLUDE WEATHER REPORT AND FITZ NUMBER HERE

                if g_dev['events']['Cool Down, Open'] < ephem.now() or ephem.now() < g_dev['events'][
                    'Close and Park'] > ephem.now():
                    enc_status['enclosure']['enclosure1']['shut_reason_daytime'] = True
                else:
                    enc_status['enclosure']['enclosure1']['shut_reason_daytime'] = False
                    
            if 'MaxDome' in g_dev['enc'].config['enclosure']['enclosure1']['driver']:   
                # Remove the dome_offset
                try:
                    actual_azimuth = g_dev['enc'].enclosure.Azimuth - self.dome_offset
                    if actual_azimuth > 360:
                        actual_azimuth=actual_azimuth - 360
                    if actual_azimuth < 0:
                        actual_azimuth=actual_azimuth + 360
                    
                    enc_status['enclosure']['enclosure1']['dome_azimuth'] = actual_azimuth
                    plog ("reported dome az: " + str(actual_azimuth))
                except:
                    plog(traceback.format_exc())
                    plog ("DOME COMMAND GLITCHED OUT.")
                
            else:
                enc_status['enclosure']['enclosure1']['dome_azimuth'] = 0
            
            
            # If the observing mode is set to off, append a noobs to prevent the obs from observing   #Why have this in the WEMA?  
            #  There is a more intersting thing to deal with -- opening into a night with no observations scheduled, or having
            #  a long blank spot ofter an early night of observing.
            if self.observing_mode == 'inactive':
                enc_status['enclosure']['enclosure1']['shutter_status'] += '/NoObs'

            if enc_status is not None:
                lane = "enclosure"
                wema = self.config['wema_name']  
                try:                        
                    send_status(wema, lane, enc_status)
                except:
                    plog('could not send enclosure status')   
                    plog(traceback.format_exc())
                    #breakpoint()

    # def update_enclosure_immediately(self, enc_status):
        
    #     lane = "enclosure"
    #     print ("updating enclosure immediately")
    #     wema = self.config['wema_name']  
    #     try:                        
    #         send_status(wema, lane, enc_status)
    #     except:
    #         plog('could not send enclosure status')   
    #         plog(traceback.format_exc())

    def update(self):     ## NB NB NB This is essentially the Manager/Sequencer for the
        #breakpoint()                 ## enclosures managed by the WEMA
        try:
            self.update_status()
        except:
            
            plog(traceback.format_exc())
            plog ("failed to update status")

        if time.time() > self.scan_requests_timer + self.scan_requests_check_period:
            self.scan_requests_timer=time.time()
            self.scan_requests()


        if time.time() > self.safety_check_timer + self.safety_status_check_period:
            self.safety_check_timer=time.time()

            # Here it runs through the various checks and decides whether to open or close the roof or not.
            # Check for delayed opening of the enclosure and act accordingly.
            
            

            # If the enclosure is simply delayed until opening, then wait until then, then attempt to start up the enclosure
            obs_win_begin, sunZ88Op, sunZ88Cl, ephem_now = self.astro_events.getSunEvents()
            
            if (g_dev['events']['Cool Down, Open'] <= ephem_now) or \
                (g_dev['events']['Close and Park'] <= ephem_now):
                self.nightly_reset_complete = False

            #This is used to access SRO weather and Enclosure shares.

            if self.ocn_status_custom==False:                            
                ocn_status = g_dev['ocn'].get_status()
            else:
                ocn_status = get_ocn_status_custom()
            if self.enc_status_custom==False:                
                enc_status = g_dev['enc'].get_status()
            else:
                enc_status = get_enc_status_custom()
            #breakpoint()
            # if ocn_status==None:
            #     self.local_weather_ok = None
            # else:
               
            #     if 'wx_ok' in ocn_status:
            #         if ocn_status['wx_ok'] == 'Yes':
            #             self.local_weather_ok = True
            #         elif ocn_status['wx_ok'] == 'No':
            #             self.local_weather_ok = False
            #         else:
            #             self.local_weather_ok = None
            #     else:
            #         self.local_weather_ok = None

            plog("***************************************************************")
            plog("Current time             : " + str(time.asctime()))
            plog("Enclosure Mode           : " + str(enc_status['enclosure_mode']))
            plog("Shutter Status           : " + str(enc_status['shutter_status']))
            
            if ocn_status == None:
                plog("This WEMA does not report observing conditions")
            else:
                plog("Observing Conditions      : " +str(ocn_status))
                
            if self.local_weather_ok == None:
                plog("No information on local weather available.")
            else:
                plog("Local Weather Ok to Observe  : " + str(self.local_weather_ok))
                if not self.local_weather_active:
                    plog ("However, Local Weather control is set off")
            
            if g_dev['enc'].mode == 'Manual':
                plog ("Weather Considerations overriden due to being in Manual or debug mode: ")
            
            plog("OWM Weather Report Good to Observe: " + str(self.weather_report_open_at_start))
            plog("Time until Cool and Open      : " + str(round(( g_dev['events']['Cool Down, Open'] - ephem_now) * 24,2)) + " hours")
            plog("Time until Close and Park     : "+ str(round(( g_dev['events']['Close and Park'] - ephem_now) * 24,2)) + " hours")
            plog("Time until Nightly Reset      : " + str(round((g_dev['events']['Nightly Reset'] - ephem_now) * 24, 2)) + " hours")
            plog("Nightly Reset Complete        : " + str(self.nightly_reset_complete))
            plog("\n")

            if len(self.weather_text_report) >0:
                for line in self.weather_text_report:
                    plog (line)
        
            if not self.owm_active:
                plog("OWM is off. OWM information is advisory only, it is currently inactive.")

            if self.owm_active:
                plog("OWM is on. OWM predicts it will set to open/close the roof at these times.")

            if not self.local_weather_active:
                plog("Reacting to local weather is *OFF*. Not reacting to local weather signals.")

            if self.local_weather_active:
                plog("Reacting to local weather is *ON*. Reacting to local weather signals.")

            if self.keep_open_all_night:
                plog("Roof is being forced to stay OPEN ALL NIGHT")

            if self.keep_closed_all_night:                
                plog("Roof is being forced to stay CLOSED ALL NIGHT")

            # Predicy clouds from model
            #breakpoint()
            
            if ocn_status['humidity_%'] == -1:
                model_humidity=self.current_owm_humidity
            else:
                model_humidity=ocn_status['humidity_%']
            
            
            #breakpoint()
            model_skyambient=ocn_status['sky_temp_C']-self.current_owm_ambient_temperature
            
            if ocn_status['dewpoint_C'] >99:
                model_dewpoint=self.current_owm_dewpoint
            else:
                model_dewpoint=ocn_status['dewpoint_C']
            
            model_dewpointdepression=self.current_owm_ambient_temperature-model_dewpoint
            
           
            model_phaseofday=((time.time() - 1735689600.0) /86400) % 1
            
            new_data = pd.DataFrame({
                'Humidity': [model_humidity],
                'sky-ambient': [model_skyambient],
                'dew_point_depression': [model_dewpointdepression],
                'phase_of_day': [model_phaseofday]
            })
            print (new_data)
            try:
                # Apply the exact polynomial transformation used in training
                poly = PolynomialFeatures(degree=2, include_bias=False)
                X_new_poly = poly.fit_transform(new_data)
    
                # Predict clouds using trained gb_model
                predicted_clouds = self.cloud_model.predict(X_new_poly)
                
                self.cloud_tracker.append(predicted_clouds)
                if len(self.cloud_tracker) > 10:
                    self.cloud_tracker.pop(0)
                #breakpoint()
                
                self.median_cloud_estimate=round(np.median(self.cloud_tracker),2)
            
                plog(f"Predicted clouds: {predicted_clouds[0]:.2f}")
                plog ("Past clouds: " + str(self.cloud_tracker))
                plog ("Median of last ten observations: " + str(round(np.median(self.cloud_tracker),2)) + " std " + str(round(np.std(self.cloud_tracker),2)))

            except:
                plog ("failed model? Perhaps can happen if we haven't built up enough points yet.")
                self.median_cloud_estimate=100
                plog(traceback.format_exc())

            plog("**************************************************************")

            if (g_dev['events']['Nightly Reset'] <= ephem.now() < g_dev['events']['End Nightly Reset']):
                if self.nightly_reset_complete == False:
                    self.nightly_reset_complete = True
                    self.nightly_reset_script(enc_status)
            
            # Safety checks here
            if not g_dev['debug'] and self.open_and_enabled_to_observe:
                #breakpoint()
                if enc_status is not None:
                    if enc_status['shutter_status'] == 'Software Fault':
                        plog("Software Fault Detected. Will alert the authorities!")
                        self.open_and_enabled_to_observe = False
                        self.park_enclosure_and_close()
                        
                    if enc_status['shutter_status'] == 'Closing':
                        plog("Detected Roof Closing.")
                        self.open_and_enabled_to_observe = False
                        self.enclosure_next_open_time = time.time(
                         ) + self.config['roof_open_safety_base_time'] * self.opens_this_evening

                    if enc_status['shutter_status'] == 'Error':
                        plog("Detected an Error in the Roof Status. Packing up for safety.")
                        self.open_and_enabled_to_observe = False
                        self.park_enclosure_and_close()
                        self.enclosure_next_open_time = time.time(
                        ) + self.config['roof_open_safety_base_time'] * self.opens_this_evening
                            
                else:
                    plog("Enclosure roof status probably not reporting correctly. WEMA down?")

            # Error / Fault Clear timer.
            # If the ASCOM status is in Error of Software Fault,
            # It generally needs a close command to clear it out.
            # This periodically checks for that and sends a close
            # every now and then to try and clear it. 
            if self.error_fault_clear_timer-time.time() > 120:
                self.error_fault_clear_timer=time.time()
                if enc_status['shutter_status'] == 'Software Fault':
                    
                    plog("Software Fault Detected. Will alert the authorities!")
                    self.open_and_enabled_to_observe = False
                    self.park_enclosure_and_close()
                    self.enclosure_next_open_time = time.time(
                    ) + self.config['roof_open_safety_base_time'] * self.opens_this_evening
                     
                
                if enc_status['shutter_status'] == 'Error':
                    
                    plog("Detected an Error in the Roof Status. Packing up for safety.")
                    self.open_and_enabled_to_observe = False
                    self.park_enclosure_and_close()
                    self.enclosure_next_open_time = time.time(
                    ) + self.config['roof_open_safety_base_time'] * self.opens_this_evening
                     


            roof_should_be_shut = False

            if g_dev['enc'].mode in ['Shutdown']:
                roof_should_be_shut = True
                self.open_and_enabled_to_observe = False

            if not (g_dev['events']['Cool Down, Open'] < ephem_now < g_dev['events']['Close and Park']):
                roof_should_be_shut = True
                self.open_and_enabled_to_observe = False
                
            if self.keep_closed_all_night:
                roof_should_be_shut = True
                self.open_and_enabled_to_observe = False
            
            
                
            if enc_status['shutter_status'] == 'Open':
                if roof_should_be_shut == True and not g_dev['enc'].mode == 'Manual':
                    plog("Safety check notices that the roof was open outside of the normal observing period")
                    self.park_enclosure_and_close()
                
                if not (self.local_weather_ok == None) and g_dev['enc'].mode == 'Automatic':
                    if (not self.local_weather_ok and self.local_weather_active):
                        plog("Safety check notices that the local weather is not ok. Shutting the roof.")
                        self.park_enclosure_and_close()
                
                if g_dev['enc'].mode == 'Automatic':
                    if (not self.weather_report_open_at_start) and self.owm_active:
                        plog("Safety check notices that the weather report is not ok. Shutting the roof.")
                        self.park_enclosure_and_close()
                

            if enc_status['shutter_status'] == 'Closed' and self.keep_open_all_night and g_dev['enc'].mode in ['Automatic']:

                if time.time() > self.enclosure_next_open_time and self.opens_this_evening < self.config[
                    'maximum_roof_opens_per_evening']:
                    self.nightly_reset_complete = False
                    self.open_enclosure(enc_status, ocn_status)

            if (self.enclosure_next_open_time - time.time()) > 0:
                plog("opens this eve: " + str(self.opens_this_evening))

                plog("minutes until next open attempt ALLOWED: " +
                     str((self.enclosure_next_open_time - time.time()) / 60))

            #breakpoint()
            if (not self.keep_closed_all_night) and ((g_dev['events']['Cool Down, Open'] <= ephem_now < g_dev['events']['Observing Ends']) and (self.keep_open_all_night or self.weather_report_open_at_start==True or not self.owm_active) and \
                g_dev['enc'].mode == 'Automatic') and (not self.cool_down_latch) and (self.keep_open_all_night or self.local_weather_ok  or (not self.ocn_exists) or (not self.local_weather_active)) and \
                (not enc_status['shutter_status'] in ['Software Fault', 'Opening', 'Closing', 'Error']):

                self.cool_down_latch = True

                if not self.open_and_enabled_to_observe and (self.weather_report_open_at_start or not self.owm_active): # and (self.weather_report_open_during_evening == False or self.local_weather_always_overrides_OWM):

                    if time.time() > self.enclosure_next_open_time and self.opens_this_evening < self.config['maximum_roof_opens_per_evening']:
                        self.nightly_reset_complete = False
                        self.open_enclosure(enc_status, ocn_status)

                self.cool_down_latch = False

            # If in post-close and park era of the night, check those two things have happened!
            if (g_dev['events']['Close and Park'] <= ephem_now < g_dev['events']['Nightly Reset']) \
                    and g_dev['enc'].mode == 'Automatic':

                if not any(status in enc_status['shutter_status'].lower() for status in ('closed', 'closing')):
                    plog("Found shutter open after Close and Park, shutting up the shutter")
                    self.park_enclosure_and_close()

        
            if (g_dev['events']['Observing Ends'] <= ephem_now < g_dev['events']['Nightly Reset']) \
                    and g_dev['enc'].mode == 'Automatic' and enc_status['shutter_status'] in ['Open', 'open', 'Opening', 'opening']:
                        
                # Checking roof shouldn't be shut due to local clock hour
                current_local_time=datetime.datetime.now(self.local_pytz_timezone)
                current_local_decimal_hour=current_local_time.hour + (current_local_time.minute/60)
                if current_local_decimal_hour > self.config['absolute_latest_shutting_hour']:
                    plog ("Shutting roof as it is after the absolute latest shutting hour")
                    self.park_enclosure_and_close()            

            # If it is in the morning, check whether obs have finished morning flats
            # If finished, close the shutter            
            if ephem_now > g_dev['events']['Naut Dawn']: # Start checking towards Dawn                
                plog ("Morning Flats Done: " + str(self.morning_flats_finished))
                if not self.morning_flats_finished:
                    completed=[]
                    for obsid in self.obs_ids:
                        uri_status = f"https://status.photonranch.org/status/{obsid}/obs_settings/"

                        
                        try:
                            #print ("Grabbing obs settings")                            
                            obs_settings=requests.get(uri_status, timeout=20, allow_redirects=False, headers=close_headers, stream=False)
                            #print ("Grabbed obs settings")
                        except:
                            plog ("Some error in getting the obs_settings")
                            plog(traceback.format_exc())
                            obs_settings='nope'

                        if '[200]' in str(obs_settings): # If reading successful
                            obs_settings=obs_settings.json()['status']['obs_settings']
                            if 'morning_flats_done' in obs_settings:
                            #breakpoint()
                                flats_done=obs_settings['morning_flats_done']
                                plog (str(obsid) + " Flats Done: " + str(flats_done))
                                last_communication=time.time()-obs_settings['timedottime_of_last_upload']
                                plog (str(obsid) + " Last Communication: " + str(last_communication))
                                # If last communication with obs was more than 10 minutes ago
                                # OR it is reporting flats_done, then it is ready to close
                                if last_communication > 600 or flats_done:
                                    completed.append(True)
                                else:
                                    completed.append(False)
                            else:
                                plog (str(obsid) + " isn't reporting flats done status yet")
                                completed.append(False)
                        else:
                            # If fail to get status, assume it isn't done.
                            completed.append(False)
                    # If there is a False in completed then it is still waiting, otherwise close up
                    if False in completed:
                        plog ("Still waiting for flats to finish")
                    else:
                        plog ("Flats all done, closing up the shutter")
                        self.park_enclosure_and_close()
                        self.morning_flats_finished=True

                
                      

    def nightly_reset_script(self, enc_status):
        
        if g_dev['enc'].mode == 'Automatic':
            self.park_enclosure_and_close()
        
        # Set weather report to false because it is daytime anyways.
        self.weather_report_open_at_start=False
        
        #events = g_dev['events']
        obs_win_begin, sunZ88Op, sunZ88Cl, ephem_now = self.astro_events.getSunEvents()

        # Reopening config and resetting all the things.
        self.astro_events.compute_day_directory()
        self.astro_events.calculate_events()
        self.astro_events.display_events()
        
        # sending this up to AWS
        '''
        Send the config to aws.
        '''
        uri = f"{self.config['wema_name']}/config/"
        # self.config['events'] = g_dev['events']
        response = self.api.authenticated_request("PUT", uri, self.config)
        if response:
            plog("Config uploaded successfully.")

        self.cool_down_latch = False
        self.nightly_reset_complete = True
        self.opens_this_evening=0
        
        self.keep_open_all_night = False
        self.keep_closed_all_night   = False          
        self.open_at_specific_utc = False
        self.specific_utc_when_to_open = -1.0  
        self.manual_weather_hold_set = False
        self.manual_weather_hold_duration = -1.0
        
        self.morning_flats_finished=False
        
        return



    def run(self):  # run is a poor name for this function.
        """Runs the continuous WEMA process.

        Loop ends with keyboard interrupt."""
        try:
            while True:
                self.update()  # `Ctrl-C` will exit the program.
                time.sleep(0.5)
        except KeyboardInterrupt:
            print("Finishing loops and exiting...")
            self.stopped = True
            return

    def send_to_user(self, p_log, p_level="INFO"):
        """ """
        url_log = "https://logs.photonranch.org/logs/newlog"
        body = json.dumps(
            {
                "site": self.config["obsp_ids"][0],
                "log_message": str(p_log),
                "log_level": str(p_level),
                "timestamp": time.time(),
            }
        )
        try:
            response = requests.post(url_log, body, timeout=20, allow_redirects=False, headers=close_headers, stream=False)
        except Exception:
            print("Log did not send, usually not fatal.")

    def park_enclosure_and_close(self):

        self.open_and_enabled_to_observe = False
        if not g_dev['enc'].dummy:
            g_dev['enc'].close_roof_directly({}, {})
        else:
            g_dev['enc'].dummy_status='Closed'
        
        # If it is a dome, then we need to get the dome parked as well
        # This currently does this. 
        if 'MaxDome' in g_dev['enc'].config['enclosure']['enclosure1']['driver']:
            plog ("Detected Dome. Now waiting for official close command and then Parking the Dome.")
            
            
            closing_timeout_timer=time.time()
            while True:
                enc_status = g_dev['enc'].get_status()
                self.send_enclosure_status(enc_status, [])
                if enc_status['shutter_status'] in ['Closed', 'closed']:
                    break
                elif time.time()-closing_timeout_timer > 300:
                    plog ("Never reported fully Closed! Parking the dome anyway assuming it is mostly shut")
                    break
                else:
                    time.sleep(10)
                    plog ("still waiting for official closed report")
                    
            if self.config['enclosure']['enclosure1']['home_dome_before_parking']:
            
                plog ("Homing Dome")
                try:
                    g_dev['enc'].enclosure.FindHome()
                    enc_status = g_dev['enc'].get_status()
                    self.send_enclosure_status(enc_status, [])
                    home_wait_timeout=time.time()
                    while not g_dev['enc'].enclosure.AtHome and (time.time()-home_wait_timeout < 300):
                        plog ("Waiting for Home")
                        time.sleep(5)
                
                    if g_dev['enc'].enclosure.AtHome:
                        g_dev['enc'].enclosure.SyncToAzimuth(self.config['enclosure']['enclosure1']['dome_home_azimuth']) # If shutter home at 194, then park at 100.
                        plog ("Successfully found Home. Ready to observe")
                    else:
                        plog ("Could not find Home reliably.")
                    
                    enc_status = g_dev['enc'].get_status()
                    self.send_enclosure_status(enc_status, [])
                
                    
                except:
                    plog(traceback.format_exc())
                    plog ("DOME COMMAND GLITCHED OUT.")
                    
            if self.config['enclosure']['enclosure1']['use_park_command_rather_than_slew_to_park']:
                plog ("Parking Dome")
                #breakpoint()
                try:
                    g_dev['enc'].enclosure.Park()
                    enc_status = g_dev['enc'].get_status()
                    self.send_enclosure_status(enc_status, [])
                    park_timeout_timer=time.time()
                    while not g_dev['enc'].enclosure.AtPark and time.time()-park_timeout_timer < 300:
                        plog ("Waiting for Park")
                        time.sleep(5)
                    enc_status = g_dev['enc'].get_status()
                    self.send_enclosure_status(enc_status, [])
                except:
                    plog(traceback.format_exc())
                    plog ("DOME COMMAND GLITCHED OUT.")
            else:
                plog ("Parking Dome")
                try:
                    g_dev['enc'].enclosure.SlewToAzimuth(self.config['enclosure']['enclosure1']['slew_park_azimuth'])
                    enc_status = g_dev['enc'].get_status()
                    self.send_enclosure_status(enc_status, [])
                    park_timeout_timer=time.time()
                    while g_dev['enc'].enclosure.Slewing and time.time()-park_timeout_timer < 300:
                        plog("Waiting for Park")
                        #self.send_enclosure_status(self.enc_status, self.ocn_status)
                        time.sleep(5)
                    enc_status = g_dev['enc'].get_status()
                    self.send_enclosure_status(enc_status, [])
                except:
                    plog(traceback.format_exc())
                    plog ("DOME COMMAND GLITCHED OUT.")
                
            
            plog ("Successfully parked. Ready to go to bed.")
        
        
        return

    def open_enclosure(self, enc_status, ocn_status):   # Unused 10142023 wer, no_sky=False):

        enc_status = g_dev['enc'].get_status()
        ocn_status = g_dev['ocn'].get_status()   #The call to get-status causes s spurious pringout of two Boltood lines, Status is the average
        flat_spot, flat_alt = g_dev['evnt'].flat_spot_now()
        obs_win_begin, sunZ88Op, sunZ88Cl, ephem_now = self.astro_events.getSunEvents()

        if g_dev['enc'].mode in ['Shutdown']:
            plog ("Not OPENING the enclosure. Site in Shutdown mode.")
            return

        if self.keep_closed_all_night and not g_dev['enc'].mode in ['Manual']:
            plog ("Observatory set to be closed all night. Not opening enclosure.")
            return
        
        # Checking roof shouldn't be shut due to local clock hour
        current_local_time=datetime.datetime.now(self.local_pytz_timezone)
        #plog('*******WER MOD At line 1138 in wema*******')
        current_local_decimal_hour=current_local_time.hour + (current_local_time.minute/60)
        if  current_local_decimal_hour < self.config['absolute_earliest_opening_hour']  and not g_dev['enc'].mode in ['Manual'] and ephem_now < g_dev['events']['Naut Dusk']:
            plog ("Not opening roof as it is before the absolute earliest opening hour.")
            return

        # Only send an enclosure open command if the weather
        if (self.weather_report_open_at_start or not self.owm_active or g_dev['enc'].mode == "Manual"):
            #plog('WER debug line 1146 in wema')
            if not g_dev['debug'] and not g_dev['enc'].mode in ['Manual'] and (
                    ephem_now < g_dev['events']['Cool Down, Open']) or \
                    (g_dev['events']['Close and Park'] < ephem_now < g_dev['events']['Nightly Reset']):
                plog("NOT OPENING THE enclosure -- IT IS THE DAYTIME!!")
                return
            else:

                try:

                    plog("Attempting to open the roof.")
                    

                    if ocn_status == None:
                        if not enc_status['shutter_status'] in ['Open', 'open','Opening','opening'] and \
                                g_dev['enc'].mode == 'Automatic' or g_dev['enc'].mode == 'Manual':
                            self.opens_this_evening = self.opens_this_evening + 1

                            if not g_dev['enc'].dummy:
                                g_dev['enc'].open_roof_directly({}, {})
                            else:
                                g_dev['enc'].dummy_status='Open'

                    elif  not enc_status['shutter_status'] in ['Open', 'open','Opening','opening'] and \
                            g_dev['enc'].mode == 'Automatic' \
                            and time.time() > self.enclosure_next_open_time and self.weather_report_open_at_start:#  and self.weather_report_is_acceptable_to_observe:  # NB

                        self.opens_this_evening = self.opens_this_evening + 1

                        if not g_dev['enc'].dummy:
                            g_dev['enc'].open_roof_directly({}, {})
                        else:
                            g_dev['enc'].dummy_status='Open'

                    elif not enc_status['shutter_status'] in ['Open', 'open', 'Opening', 'opening'] and \
                            g_dev['enc'].mode == 'Manual':
                        self.opens_this_evening = self.opens_this_evening + 1

                        if not g_dev['enc'].dummy:
                            g_dev['enc'].open_roof_directly({}, {})
                        else:
                            g_dev['enc'].dummy_status='Open'

                        
                    plog("Attempting to Open Shutter. Waiting until shutter opens")
                    #while True:
                    enc_status = g_dev['enc'].get_status()
                    if not enc_status['shutter_status'] in ['Open', 'open']:
# =============================================================================
                        if not g_dev['enc'].dummy:
                            g_dev['enc'].open_roof_directly({}, {})
                        else:
                            g_dev['enc'].dummy_status='Open'
# =============================================================================
                        time.sleep(self.config['period_of_time_to_wait_for_roof_to_open'])
                   
                    #This is where successive opens get stretched out.
                    self.enclosure_next_open_time = time.time() + (self.config['roof_open_safety_base_time'] * 60) * self.opens_this_evening

                    enc_status = g_dev['enc'].get_status()

                    # If it is a dome, then we need to get the dome setup as well
                    # This currently does this. 
                    if 'MaxDome' in g_dev['enc'].config['enclosure']['enclosure1']['driver']:
                        plog ("Detected Dome. Now waiting for official open command and then Homing the Dome.")
                        
                        
                        
                        open_dome_timer=time.time()
                        while True:
                            enc_status = g_dev['enc'].get_status()
                            if enc_status['shutter_status'] in ['Open', 'open']:
                                break
                            elif (time.time() - open_dome_timer) > 300:
                                plog ("dome open report timed out")
                                plog ("moving on")
                                break
                            else:
                                time.sleep(2)
                                plog ("still waiting for official open report")
                                
                        
                        
                        
                        if self.config['enclosure']['enclosure1']['home_dome_after_opening']:
                        
                            plog ("Homing Dome")
                            try:
                                g_dev['enc'].enclosure.FindHome()
                                enc_status = g_dev['enc'].get_status()
                                self.send_enclosure_status(enc_status, [])
                                home_wait_timeout=time.time()
                                while not g_dev['enc'].enclosure.AtHome  and (time.time()-home_wait_timeout < 300):
                                    plog ("Waiting for Home")
                                    time.sleep(5)
                                enc_status = g_dev['enc'].get_status()
                                self.send_enclosure_status(enc_status, [])
                                
                                g_dev['enc'].enclosure.SyncToAzimuth(self.config['enclosure']['enclosure1']['dome_home_azimuth']) # If shutter home at 194, then park at 100.
                                plog ("Successfully found Home. Ready to observe")
                            except:
                                plog(traceback.format_exc())
                                plog ("DOME COMMAND GLITCHED OUT.")
                            
                            
                        #breakpoint()
                    
                    time.sleep(5)
                    
                    enc_status = g_dev['enc'].get_status()
                    
                    print ("Post dome shutter status:")
                    print (enc_status)
                        
                    if enc_status['shutter_status'] in ['Open', 'open']:
                        self.open_and_enabled_to_observe = True

                        # try:
                        #     plog("Synchronising dome.")
                        #     g_dev['enc'].sync_mount_command({}, {})
                        # except:
                        #     pass
                        # Prior to skyflats no dome following.
                        # self.dome_homed = False

                        return

                    elif not 'MaxDome' in g_dev['enc'].config['enclosure']['enclosure1']['driver']:
                        plog("Failed to open roof. Sending the close command to the roof.")
                        plog("opens this eve: " + str(self.opens_this_evening))
                        plog("minutes until next open attempt ALLOWED: " + str(
                            (self.enclosure_next_open_time - time.time()) / 60))
                        if not g_dev['enc'].dummy:
                            g_dev['enc'].close_roof_directly({}, {})
                        else:
                            g_dev['enc'].dummy_status='Closed'

                        return
                    else:
                        plog ("Skipping dome failure mode.... it was going to say failed to open .... but it usually isn't... need to find out what that is.")
                        return
                    
                except Exception as e:
                    plog("Enclosure opening glitched out: ", e)
                    plog(traceback.format_exc())

        else:
            plog("An enclosure command was rejected because the weather report was not acceptable.")

        return

    def run_nightly_weather_report(self,enc_status=None, ocn_status=None):
       
        events = g_dev['events']

        obs_win_begin, sunset, sunrise, ephem_now = self.astro_events.getSunEvents()
        
        #self.update_status()
        # First thing to do at the Cool Down, Open time is to calculate the quality of the evening
        # using the broad weather report.
        try: 
            plog("Appraising quality of evening from Open Weather Map.")
            
            config_dict = get_default_config()
            
            config_dict["subscription_type"] = SubscriptionType(name="professional", subdomain="pro", is_paid=False)            

            owm = OWM('d5c3eae1b48bf7df3f240b8474af3ed0', config_dict)
            mgr = owm.weather_manager()
            
            #breakpoint()
            try:
                one_call = mgr.one_call(lat=self.config["latitude"], lon=self.config["longitude"],exclude=["alerts", "minutely" ,"daily"])
            except:
                plog ("Connection glitch probably. Bailing out, will try again soon")
                plog(traceback.format_exc())
                time.sleep(10)
                
                return
            
            #breakpoint()
            
            self.weather_report_run_timer = time.time()
            
            # Keep this for weather stations that do not have current humidity
            self.current_owm_humidity=one_call.current.humidity
            self.current_owm_ambient_temperature=one_call.current.temp['temp']- 273.15
            self.current_owm_dewpoint=one_call.current.dewpoint - 273.15
            
        
            # Collect relevant info for fitzgerald weather number calculation
            hourcounter=0
            fitzgerald_weather_number_grid=[]
            hours_until_end_of_observing= math.ceil((events['Close and Park'] - ephem_now) * 24)
            hours_until_start_of_observing= math.ceil((events['Cool Down, Open'] - ephem_now) * 24)
            if hours_until_start_of_observing < 0:
                hours_until_start_of_observing = 0
            plog("Hours until end of observing: " + str(hours_until_end_of_observing))
            
            OWM_status_json={}
            OWM_status_json["timestamp"] = round(time.time(), 1)
            for hourly_report in one_call.forecast_hourly:
                
                
                clock_hour=int(hourly_report.reference_time('iso').split(' ')[1].split(':')[0])

                # Calculate Fitzgerald number for this hour
                tempFn=0
                # Add humidity score up
                if 80 < hourly_report.humidity <= 85:
                    tempFn=tempFn+4
                elif 85 < hourly_report.humidity <= 90:
                    tempFn=tempFn+20
                elif 90 < hourly_report.humidity <= 100:
                    tempFn=tempFn+101

                # Add cloud score up
                if 20 < hourly_report.clouds <= 40:
                    tempFn=tempFn+10
                elif 40 < hourly_report.clouds <= 60:
                    tempFn=tempFn+40
                elif 60 < hourly_report.clouds <= 80:
                    tempFn=tempFn+60
                elif 80 < hourly_report.clouds <= 100:
                    tempFn=tempFn+101

                # Add wind score up
                if 8 < hourly_report.wind()['speed'] <=12:
                    tempFn=tempFn+1
                elif 12 < hourly_report.wind()['speed'] <= 15:
                    tempFn=tempFn+4
                elif 15 < hourly_report.wind()['speed'] <= 20:
                    tempFn=tempFn+40
                elif 20 < hourly_report.wind()['speed'] :
                    tempFn=tempFn+101

                if 'rain'  in hourly_report.detailed_status or 'storm'  in hourly_report.detailed_status or hourly_report.rain != {}:
                    tempFn=tempFn+101

                weatherline=[hourly_report.humidity,hourly_report.clouds,hourly_report.wind()['speed'],hourly_report.status, hourly_report.detailed_status, clock_hour, tempFn, hourly_report.reference_time('iso'), hourly_report.temperature()['temp'] - 273.15, hourly_report.rain]
                fitzgerald_weather_number_grid.append(weatherline)

                hourcounter=hourcounter + 1


            forecast_status=[]
            for weatherline in fitzgerald_weather_number_grid:

                status_line={}
                status_line['humidity']=weatherline[0]
                status_line['cloud_cover'] = weatherline[1]
                status_line['wind_speed'] = weatherline[2]
                status_line['short_text'] = weatherline[3]
                status_line['long_text'] = weatherline[4]
                status_line['utc_clock_hour'] = weatherline[5]
                status_line['fitz_number'] = weatherline[6]
                status_line['utc_long_form'] = weatherline[7].replace(' ','T').split('+')[0]+'Z'
                status_line['temperature'] = weatherline[8]
                status_line['rain'] = weatherline[9]

                if float(weatherline[6]) < 11:
                    status_line['weather_quality_number'] = 1
                elif float (weatherline[6]) < 21:
                    status_line['weather_quality_number'] = 2
                elif float (weatherline[6]) < 41:
                    status_line['weather_quality_number'] = 3
                elif float (weatherline[6]) < 101:
                    status_line['weather_quality_number'] = 4
                else:
                    status_line['weather_quality_number'] = 5

                forecast_status.append(status_line)
                

            if forecast_status is not None:
                lane = "forecast"
                obsy = self.config['wema_name']
                url = f"https://status.photonranch.org/status/{obsy}/status"

                payload = json.dumps({
                    "statusType": "forecast",
                    "status": { "forecast": forecast_status }
                })
                try:
                    response = requests.request("POST", url, data=payload, allow_redirects=False, headers=close_headers, stream=False)
                except:
                    plog ("Connection glitch on the forecast request")

            
            # Fitzgerald weather number calculation.
            hourly_fitzgerald_number=[]
            hourly_fitzgerald_number_by_hour=[]
            hourcounter = 0
            self.hourly_report_holder=[]
            for entry in fitzgerald_weather_number_grid:
                if hourcounter >= hours_until_start_of_observing and hourcounter <= hours_until_end_of_observing:
                    
                    textdescription= entry[4]+ '   Cloud:   ' + str(entry[1]) + '%     Hum:    ' + str(entry[0]) +   '%    Wind:  ' +str(entry[2])+' m/s      rain: ' + str(entry[9])  # WER changed to make more readable.

                    hourly_fitzgerald_number.append(entry[6])
                    hourly_fitzgerald_number_by_hour.append([entry[5],entry[6],textdescription])
                hourcounter=hourcounter+1
            
            plog ("Hourly Fitzgerald number report")
            self.hourly_report_holder.append("Hourly Fitzgerald number report")
            
            plog ("For Evening of " +str(g_dev['dayhyphened']) )
            self.hourly_report_holder.append("For LOCAL Evening of " +str(g_dev['dayhyphened']) )
            
            plog("Time of Weather Report: " + str(time.asctime()))
            self.hourly_report_holder.append("Time of Weather Report (UTC): " + str(time.asctime()))
            
            plog ("*******************************")
            self.hourly_report_holder.append("*******************************")
            plog ("Hour(UTC) |  FNumber |  Text    ")
            self.hourly_report_holder.append("Hour(UTC) |  FNumber |  Text    ")
            for line in hourly_fitzgerald_number_by_hour:
                plog (str(line[0]) + '         | '+ str(line[1]) + '        | ' + str(line[2]))
                self.hourly_report_holder.append(str(line[0]) + '         | '+ str(line[1]) + '        | ' + str(line[2]))
            
            plog ("Night's total fitzgerald number: " + str(sum(hourly_fitzgerald_number)))
            

            self.night_fitzgerald_number = sum(hourly_fitzgerald_number)
            if len(hourly_fitzgerald_number) >= 1:
                average_fitzn_for_rest_of_night = sum(hourly_fitzgerald_number) / len(hourly_fitzgerald_number)
            else:
                average_fitzn_for_rest_of_night = 100
            
            plog("Night's average fitzgerald number: " + str(average_fitzn_for_rest_of_night))
            
            # Simplified decision array
            hours_bad_or_good=[]
            for entry in hourly_fitzgerald_number_by_hour:
                if entry[1] > 41:
                    hours_bad_or_good.append([entry[0],0])
                else:
                    hours_bad_or_good.append([entry[0],1])

           
            # If the first three hours are good, then open from the start
            self.weather_report_open_at_start = False
            try:
                if (hours_bad_or_good[0][1] + hours_bad_or_good[1][1] +hours_bad_or_good[2][1] ) == 3:
                    plog("Looks like it is clear enough to open the observatory from the beginning.")
                    self.weather_report_open_at_start = True
                elif (hours_bad_or_good[0][1]) == 0 and g_dev['enc'].mode == 'Automatic' and not \
                'closed' in enc_status['shutter_status'].lower() and self.owm_active:
                    plog("Looks like the weather gets rough in the first hour, shutting up observatory.")
                    self.park_enclosure_and_close()
            except:
                plog (plog(traceback.format_exc()))
                plog (hours_bad_or_good)
                plog ("Probably that there isn't actually three elements in the list?")
                plog (len(hours_bad_or_good))

            # Look for three hour gaps in the weather throughout the night
            self.times_to_open=[]
            self.times_to_close=[]
            for counter in range(len(hours_bad_or_good)):
                
                # A three hour gap after a bad hour is a good time to open.
                
                if (counter - len(hours_bad_or_good)) == -1:                   
                    pass
                elif (counter - len(hours_bad_or_good)) == -2:
                    sum_of_next_three_hours=int((hours_bad_or_good[counter][1]+hours_bad_or_good[counter+1][1])*1.5)
                else:
                    sum_of_next_three_hours = hours_bad_or_good[counter][1] + hours_bad_or_good[counter + 1][1] + \
                                          hours_bad_or_good[counter + 2][1]

                if sum_of_next_three_hours == 3 and hours_bad_or_good[counter-1][1] == 0:
                    plog ("good time to open")
                    self.times_to_open.append([hours_bad_or_good[counter][0]])

                # Simply a bad hour is a good time to close.
                if len(hours_bad_or_good) == counter + 1:                    
                    pass
                elif hours_bad_or_good[counter][1] == 1 and hours_bad_or_good[counter+1][1] == 0:
                    plog ("good time to close")
                    self.times_to_close.append([hours_bad_or_good[counter][0]])


            self.weather_text_report=[]
            # Construct the text!

            if len(self.hourly_report_holder) > 0:
                pasttitle = False
                firstentry = True
                for line in self.hourly_report_holder:
                    self.weather_text_report.append(str(line))

                    if pasttitle == True:
                        current_utc_hour = float(line.split(' ')[0])

                        if len(self.times_to_open) > 0:
                            for entry in self.times_to_open:

                                if int(current_utc_hour) == int(entry[0]) and not firstentry:
                                    self.weather_text_report.append("OWM would plan to open the roof")
                            
                        if len(self.times_to_close) > 0:
                            for entry in self.times_to_close:
                                
                                if int(current_utc_hour) == int(entry[0]):
                                    self.weather_text_report.append("OWM would plan to close the roof")
                        firstentry = False
                        
                    if 'Hour(UTC)' in line:
                        pasttitle = True
                        self.weather_text_report.append("-----------------------------")
                        if g_dev['events']['Cool Down, Open'] > ephem_now:
                            self.weather_text_report.append("Cool Down Open")
                        if self.weather_report_open_at_start:
                            self.weather_text_report.append("OWM would plan to open at this point.")
                        else:
                            self.weather_text_report.append("OWM would keep the roof shut at this point.")
                if g_dev['events']['Close and Park'] > ephem_now:
                    self.weather_text_report.append("Close and Park")
                self.weather_text_report.append("-----------------------------")

           
            # Output to the log the various interesting things about the weather
            # Which will be used at some stage to calibrate the weather station
            
            line_of_weather_info=[]
            line_of_weather_info.append(str(datetime.datetime.now()))
            line_of_weather_info.append(time.time())
            # Current cloud % from weather forecast
            line_of_weather_info.append(one_call.current.clouds)
            
            # Reported cloud_cover
            line_of_weather_info.append(ocn_status['cloud_cover_%'])
            
            # Current humidity
            if ocn_status['humidity_%'] == -1:
                line_of_weather_info.append(one_call.current.humidity)
            else:
                line_of_weather_info.append(ocn_status['humidity_%'])
                        
            # Measured sky_temp
            line_of_weather_info.append(ocn_status['sky_temp_C'])
        
            # Measured temp
            line_of_weather_info.append(ocn_status['temperature_C'])
                        
            # Dewpoint
            if ocn_status['dewpoint_C'] == 100:
                line_of_weather_info.append(one_call.current.dewpoint - 273.15)
            else:
                line_of_weather_info.append(ocn_status['dewpoint_C'])
            
           
            
            # Rain Rate
            line_of_weather_info.append(ocn_status['rain_rate'])
            
            # Wind Speed
            line_of_weather_info.append(ocn_status['wind_m/s'])                        
            
            # OWM temperature - can be more reliable than weather station
            line_of_weather_info.append(one_call.current.temp['temp']-273.15)
            
                
            # Open the file in append mode and write the line
            try:
                with open(self.wema_path+self.name + '_weatherlog.csv', mode='a', newline='') as file:
                    writer = csv.writer(file)
                    writer.writerow(line_of_weather_info)
                    print(f"Data written at {datetime.datetime.now().isoformat()}")  # For logging
            except:
                plog ("failed to write weatherlog")
                plog(traceback.format_exc())
            #breakpoint()


            ######## We also need to update our cloud prediction model.
            # So lets open the weatherlog
            # Assign column names manually
            column_names = ['date','time','OWM_clouds','Local_clouds','Humidity','sky_temp_C','local_temperature_C', 'dewpoint', 'rain_rate','wind_m/s', 'OWM_temperature']
            
            # Read CSV without a header and assign column names
            df = pd.read_csv(self.wema_path+self.name + '_weatherlog.csv', header=None, names=column_names)
            
            # Need to remove some rows with nan values
            df = df.dropna()
            
            # Convert to years as main value
            # Arbitrary reference point is the 1st of janurary 2025
            # time.time() then is 1735689600.0
            df['time_in_days']= df['time'] - 1735689600.0
            df['time_in_days']= df['time_in_days'] / 86400 
            df['phase_of_day']= df['time_in_days'] % 1
            
            df['time_in_years']= df['time'] - 1735689600.0
            df['time_in_years']= df['time_in_years'] / 31536000
            df['phase_of_year']= df['time_in_years'] % 1
            
            df['sky-ambient'] = df['sky_temp_C'] - df['OWM_temperature']
            
            # dew point depression
            df['dew_point_depression'] =  df['OWM_temperature'] - df['dewpoint']

            directory=self.wema_path+self.name
            
            try:
                # Trim the extreme values off... realistically MOST of the time it can be clear or cloudy
                # and we even aren't too particularly interested in the extremes... more the range
                df = df[~((df['OWM_clouds'] > 95) | (df['OWM_clouds'] < 5))]
                #breakpoint()
                
                # Run the updated model with polynomial features included
                self.cloud_model, updated_df = fit_cloud_prediction_model(df, directory)
            
            except:
                plog ("failed model?")
                plog(traceback.format_exc())



            status = {}
            status['owm_report'] = json.dumps(self.weather_text_report)
            lane = "owm_report"


            try:
                send_status(self.config['wema_name'], lane, status)
            except:
                plog('could not send owm_report status')
                plog(traceback.format_exc())
                
        except Exception as e:
            plog ("OWN failed", e)
            plog ("Usually a connection glitch")
            plog(traceback.format_exc())
            
        # However, if the enclosure is under manual control, leave this switch on.
        if self.enc_status_custom==False:
            enc_status = g_dev['enc'].status
        else:
            enc_status = get_enc_status_custom()        
                    
        return
        
if __name__ == "__main__":
    wema = WxEncAgent(ptr_config.wema_name, ptr_config.wema_config)
    wema.run()