citrascope 0.1.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

citrascope/hardware/nina_adv_http_survey_template.json

@@ -0,0 +1,328 @@
+{
+  "$id": "1",
+  "$type": "NINA.Sequencer.Container.SequenceRootContainer, NINA.Sequencer",
+  "Strategy": {
+    "$type": "NINA.Sequencer.Container.ExecutionStrategy.SequentialStrategy, NINA.Sequencer"
+  },
+  "Name": "{{SEQUENCE_NAME}}",
+  "Conditions": {
+    "$id": "2",
+    "$type": "System.Collections.ObjectModel.ObservableCollection`1[[NINA.Sequencer.Conditions.ISequenceCondition, NINA.Sequencer]], System.ObjectModel",
+    "$values": []
+  },
+  "IsExpanded": true,
+  "Items": {
+    "$id": "3",
+    "$type": "System.Collections.ObjectModel.ObservableCollection`1[[NINA.Sequencer.SequenceItem.ISequenceItem, NINA.Sequencer]], System.ObjectModel",
+    "$values": [
+      {
+        "$id": "4",
+        "$type": "NINA.Sequencer.Container.StartAreaContainer, NINA.Sequencer",
+        "Strategy": {
+          "$type": "NINA.Sequencer.Container.ExecutionStrategy.SequentialStrategy, NINA.Sequencer"
+        },
+        "Name": "Start",
+        "Conditions": {
+          "$id": "5",
+          "$type": "System.Collections.ObjectModel.ObservableCollection`1[[NINA.Sequencer.Conditions.ISequenceCondition, NINA.Sequencer]], System.ObjectModel",
+          "$values": []
+        },
+        "IsExpanded": true,
+        "Items": {
+          "$id": "6",
+          "$type": "System.Collections.ObjectModel.ObservableCollection`1[[NINA.Sequencer.SequenceItem.ISequenceItem, NINA.Sequencer]], System.ObjectModel",
+          "$values": []
+        },
+        "Triggers": {
+          "$id": "7",
+          "$type": "System.Collections.ObjectModel.ObservableCollection`1[[NINA.Sequencer.Trigger.ISequenceTrigger, NINA.Sequencer]], System.ObjectModel",
+          "$values": []
+        },
+        "Parent": {
+          "$ref": "1"
+        },
+        "ErrorBehavior": 0,
+        "Attempts": 1
+      },
+      {
+        "$id": "8",
+        "$type": "NINA.Sequencer.Container.TargetAreaContainer, NINA.Sequencer",
+        "Strategy": {
+          "$type": "NINA.Sequencer.Container.ExecutionStrategy.SequentialStrategy, NINA.Sequencer"
+        },
+        "Name": "Targets",
+        "Conditions": {
+          "$id": "9",
+          "$type": "System.Collections.ObjectModel.ObservableCollection`1[[NINA.Sequencer.Conditions.ISequenceCondition, NINA.Sequencer]], System.ObjectModel",
+          "$values": []
+        },
+        "IsExpanded": true,
+        "Items": {
+          "$id": "10",
+          "$type": "System.Collections.ObjectModel.ObservableCollection`1[[NINA.Sequencer.SequenceItem.ISequenceItem, NINA.Sequencer]], System.ObjectModel",
+          "$values": [
+            {
+              "$id": "11",
+              "$type": "NINA.Sequencer.Container.SequentialContainer, NINA.Sequencer",
+              "Strategy": {
+                "$type": "NINA.Sequencer.Container.ExecutionStrategy.SequentialStrategy, NINA.Sequencer"
+              },
+              "Name": "Sequential Instruction Set",
+              "Conditions": {
+                "$id": "12",
+                "$type": "System.Collections.ObjectModel.ObservableCollection`1[[NINA.Sequencer.Conditions.ISequenceCondition, NINA.Sequencer]], System.ObjectModel",
+                "$values": []
+              },
+              "IsExpanded": true,
+              "Items": {
+                "$id": "15",
+                "$type": "System.Collections.ObjectModel.ObservableCollection`1[[NINA.Sequencer.SequenceItem.ISequenceItem, NINA.Sequencer]], System.ObjectModel",
+                "$values": [
+                  {
+                    "$id": "20",
+                    "$type": "NINA.Joko.Plugin.Orbitals.SequenceItems.ManualTLEContainer, NINA.Joko.Plugin.Orbitals",
+                    "TLEData": "{{TLE_DATA}}",
+                    "OffsetExpanded": false,
+                    "OffsetCoordinates": {
+                      "$id": "21",
+                      "$type": "NINA.Joko.Plugin.Orbitals.Utility.InputCoordinatesEx, NINA.Joko.Plugin.Orbitals",
+                      "RAHours": 0,
+                      "RAMinutes": 0,
+                      "RASeconds": 0.0,
+                      "NegativeDec": false,
+                      "NegativeRA": false,
+                      "DecDegrees": 0,
+                      "DecMinutes": 0,
+                      "DecSeconds": 0.0
+                    },
+                    "Target": {
+                      "$id": "22",
+                      "$type": "NINA.Astrometry.InputTarget, NINA.Astrometry",
+                      "Expanded": true,
+                      "TargetName": "{{SATELLITE_NAME}}",
+                      "PositionAngle": 0.0,
+                      "InputCoordinates": {
+                        "$id": "23",
+                        "$type": "NINA.Astrometry.InputCoordinates, NINA.Astrometry",
+                        "RAHours": 3,
+                        "RAMinutes": 33,
+                        "RASeconds": 12.92135,
+                        "NegativeDec": true,
+                        "DecDegrees": -6,
+                        "DecMinutes": 0,
+                        "DecSeconds": 9.52085
+                      }
+                    },
+                    "Strategy": {
+                      "$type": "NINA.Sequencer.Container.ExecutionStrategy.SequentialStrategy, NINA.Sequencer"
+                    },
+                    "Name": "{{SATELLITE_NAME}}",
+                    "Conditions": {
+                      "$id": "24",
+                      "$type": "System.Collections.ObjectModel.ObservableCollection`1[[NINA.Sequencer.Conditions.ISequenceCondition, NINA.Sequencer]], System.ObjectModel",
+                      "$values": []
+                    },
+                    "IsExpanded": true,
+                    "Items": {
+                      "$id": "25",
+                      "$type": "System.Collections.ObjectModel.ObservableCollection`1[[NINA.Sequencer.SequenceItem.ISequenceItem, NINA.Sequencer]], System.ObjectModel",
+                      "$values": [
+                        {
+                          "$id": "26",
+                          "$type": "DaleGhent.NINA.PlaneWaveTools.TLE.TLEControl, PlaneWave Tools",
+                          "Line1": "{{TLE_LINE1}}",
+                          "Line2": "{{TLE_LINE2}}",
+                          "Axis0Distance": -0.14,
+                          "Axis1Distance": -0.01,
+                          "Parent": {
+                            "$ref": "20"
+                          },
+                          "ErrorBehavior": 0,
+                          "Attempts": 1
+                        },
+
+                        {
+                          "$id": "27",
+                          "$type": "NINA.Sequencer.SequenceItem.FilterWheel.SwitchFilter, NINA.Sequencer",
+                          "Filter": {
+                            "$id": "28",
+                            "$type": "NINA.Core.Model.Equipment.FilterInfo, NINA.Core",
+                            "_name": "Clear",
+                            "_focusOffset": 0,
+                            "_position": 0,
+                            "_autoFocusExposureTime": -1.0,
+                            "_autoFocusFilter": true,
+                            "FlatWizardFilterSettings": {
+                              "$id": "29",
+                              "$type": "NINA.Core.Model.Equipment.FlatWizardFilterSettings, NINA.Core",
+                              "FlatWizardMode": 0,
+                              "HistogramMeanTarget": 0.5,
+                              "HistogramTolerance": 0.1,
+                              "MaxFlatExposureTime": 30.0,
+                              "MinFlatExposureTime": 0.01,
+                              "MaxAbsoluteFlatDeviceBrightness": 32767,
+                              "MinAbsoluteFlatDeviceBrightness": 0,
+                              "Gain": -1,
+                              "Offset": -1,
+                              "Binning": {
+                                "$id": "30",
+                                "$type": "NINA.Core.Model.Equipment.BinningMode, NINA.Core",
+                                "X": 1,
+                                "Y": 1
+                              }
+                            },
+                            "_autoFocusBinning": {
+                              "$id": "31",
+                              "$type": "NINA.Core.Model.Equipment.BinningMode, NINA.Core",
+                              "X": 1,
+                              "Y": 1
+                            },
+                            "_autoFocusGain": -1,
+                            "_autoFocusOffset": -1
+                          },
+                          "Parent": {
+                            "$ref": "20"
+                          },
+                          "ErrorBehavior": 0,
+                          "Attempts": 1
+                        },
+                        {
+                          "$id": "32",
+                          "$type": "NINA.Sequencer.SequenceItem.Focuser.MoveFocuserAbsolute, NINA.Sequencer",
+                          "Position": 9000,
+                          "Parent": {
+                            "$ref": "20"
+                          },
+                          "ErrorBehavior": 0,
+                          "Attempts": 1
+                        },
+                        {
+                          "$id": "33",
+                          "$type": "NINA.Sequencer.SequenceItem.Imaging.TakeExposure, NINA.Sequencer",
+                          "ExposureTime": 1.0,
+                          "Gain": -1,
+                          "Offset": -1,
+                          "Binning": {
+                            "$id": "34",
+                            "$type": "NINA.Core.Model.Equipment.BinningMode, NINA.Core",
+                            "X": 4,
+                            "Y": 4
+                          },
+                          "ImageType": "LIGHT",
+                          "ExposureCount": 130,
+                          "Parent": {
+                            "$ref": "20"
+                          },
+                          "ErrorBehavior": 0,
+                          "Attempts": 1
+                        }
+
+                      ]
+                    },
+                    "Triggers": {
+                      "$id": "63",
+                      "$type": "System.Collections.ObjectModel.ObservableCollection`1[[NINA.Sequencer.Trigger.ISequenceTrigger, NINA.Sequencer]], System.ObjectModel",
+                      "$values": []
+                    },
+                    "Parent": {
+                      "$ref": "11"
+                    },
+                    "ErrorBehavior": 0,
+                    "Attempts": 1
+                  }
+                ]
+              },
+              "Triggers": {
+                "$id": "112",
+                "$type": "System.Collections.ObjectModel.ObservableCollection`1[[NINA.Sequencer.Trigger.ISequenceTrigger, NINA.Sequencer]], System.ObjectModel",
+                "$values": []
+              },
+              "Parent": {
+                "$ref": "8"
+              },
+              "ErrorBehavior": 0,
+              "Attempts": 1
+            }
+          ]
+        },
+        "Triggers": {
+          "$id": "113",
+          "$type": "System.Collections.ObjectModel.ObservableCollection`1[[NINA.Sequencer.Trigger.ISequenceTrigger, NINA.Sequencer]], System.ObjectModel",
+          "$values": []
+        },
+        "Parent": {
+          "$ref": "1"
+        },
+        "ErrorBehavior": 0,
+        "Attempts": 1
+      },
+      {
+        "$id": "114",
+        "$type": "NINA.Sequencer.Container.EndAreaContainer, NINA.Sequencer",
+        "Strategy": {
+          "$type": "NINA.Sequencer.Container.ExecutionStrategy.SequentialStrategy, NINA.Sequencer"
+        },
+        "Name": "End",
+        "Conditions": {
+          "$id": "115",
+          "$type": "System.Collections.ObjectModel.ObservableCollection`1[[NINA.Sequencer.Conditions.ISequenceCondition, NINA.Sequencer]], System.ObjectModel",
+          "$values": []
+        },
+        "IsExpanded": true,
+        "Items": {
+          "$id": "116",
+          "$type": "System.Collections.ObjectModel.ObservableCollection`1[[NINA.Sequencer.SequenceItem.ISequenceItem, NINA.Sequencer]], System.ObjectModel",
+          "$values": [
+            {
+              "$id": "117",
+              "$type": "NINA.Sequencer.Container.SequentialContainer, NINA.Sequencer",
+              "Strategy": {
+                "$type": "NINA.Sequencer.Container.ExecutionStrategy.SequentialStrategy, NINA.Sequencer"
+              },
+              "Name": "Sequential Instruction Set",
+              "Conditions": {
+                "$id": "118",
+                "$type": "System.Collections.ObjectModel.ObservableCollection`1[[NINA.Sequencer.Conditions.ISequenceCondition, NINA.Sequencer]], System.ObjectModel",
+                "$values": []
+              },
+              "IsExpanded": true,
+              "Items": {
+                "$id": "119",
+                "$type": "System.Collections.ObjectModel.ObservableCollection`1[[NINA.Sequencer.SequenceItem.ISequenceItem, NINA.Sequencer]], System.ObjectModel",
+                "$values": []
+              },
+              "Triggers": {
+                "$id": "123",
+                "$type": "System.Collections.ObjectModel.ObservableCollection`1[[NINA.Sequencer.Trigger.ISequenceTrigger, NINA.Sequencer]], System.ObjectModel",
+                "$values": []
+              },
+              "Parent": {
+                "$ref": "114"
+              },
+              "ErrorBehavior": 0,
+              "Attempts": 1
+            }
+          ]
+        },
+        "Triggers": {
+          "$id": "124",
+          "$type": "System.Collections.ObjectModel.ObservableCollection`1[[NINA.Sequencer.Trigger.ISequenceTrigger, NINA.Sequencer]], System.ObjectModel",
+          "$values": []
+        },
+        "Parent": {
+          "$ref": "1"
+        },
+        "ErrorBehavior": 0,
+        "Attempts": 1
+      }
+    ]
+  },
+  "Triggers": {
+    "$id": "125",
+    "$type": "System.Collections.ObjectModel.ObservableCollection`1[[NINA.Sequencer.Trigger.ISequenceTrigger, NINA.Sequencer]], System.ObjectModel",
+    "$values": []
+  },
+  "Parent": null,
+  "ErrorBehavior": 0,
+  "Attempts": 1
+}

citrascope/logging/__init__.py

@@ -1,3 +1,4 @@
 from citrascope.logging._citrascope_logger import CITRASCOPE_LOGGER
+from citrascope.logging.web_log_handler import WebLogHandler
 
-__all__ = ["CITRASCOPE_LOGGER"]
+__all__ = ["CITRASCOPE_LOGGER", "WebLogHandler"]

citrascope/logging/_citrascope_logger.py

@@ -1,4 +1,7 @@
 import logging
+from logging.handlers import TimedRotatingFileHandler
+from pathlib import Path
+from typing import Optional
 
 
 class ExcludeHttpRequestFilter(logging.Filter):
@@ -6,6 +9,22 @@ class ExcludeHttpRequestFilter(logging.Filter):
         return "HTTP Request:" not in record.getMessage()
 
 
+class ExcludeWebLogsFilter(logging.Filter):
+    """Filter out web-related logs (uvicorn, HTTP requests) from file logging."""
+
+    def filter(self, record):
+        # Exclude uvicorn loggers
+        if record.name.startswith("uvicorn"):
+            return False
+        # Exclude HTTP request messages
+        if "HTTP Request:" in record.getMessage():
+            return False
+        # Exclude WebSocket messages
+        if "WebSocket" in record.getMessage():
+            return False
+        return True
+
+
 class ColoredFormatter(logging.Formatter):
     COLORS = {
         "DEBUG": "\033[94m",  # Blue
@@ -17,14 +36,26 @@ class ColoredFormatter(logging.Formatter):
     RESET = "\033[0m"
 
     def format(self, record):
+        # Save original levelname
+        original_levelname = record.levelname
+
+        # Temporarily add color codes
         color = self.COLORS.get(record.levelname, self.RESET)
         record.levelname = f"{color}{record.levelname}{self.RESET}"
-        return super().format(record)
+
+        # Format the record
+        result = super().format(record)
+
+        # Restore original levelname so other handlers don't get colored version
+        record.levelname = original_levelname
+
+        return result
 
 
 CITRASCOPE_LOGGER = logging.getLogger()
 CITRASCOPE_LOGGER.setLevel(logging.INFO)
 
+# Console handler with colors
 handler = logging.StreamHandler()
 handler.addFilter(ExcludeHttpRequestFilter())
 log_format = "%(asctime)s %(levelname)s %(message)s"
@@ -33,3 +64,51 @@ formatter = ColoredFormatter(fmt=log_format, datefmt=date_format)
 handler.setFormatter(formatter)
 CITRASCOPE_LOGGER.handlers.clear()
 CITRASCOPE_LOGGER.addHandler(handler)
+
+# File handler will be added by setup_file_logging()
+_file_handler: Optional[TimedRotatingFileHandler] = None
+
+
+def setup_file_logging(log_file_path: Path, backup_count: int = 30) -> None:
+    """Setup file-based logging with daily rotation.
+
+    Args:
+        log_file_path: Path to the log file (should include date in filename).
+        backup_count: Number of daily log files to keep (default 30 days).
+    """
+    global _file_handler
+
+    # Remove existing file handler if present
+    if _file_handler is not None:
+        CITRASCOPE_LOGGER.removeHandler(_file_handler)
+        _file_handler.close()
+        _file_handler = None
+
+    # Create new file handler with daily rotation
+    _file_handler = TimedRotatingFileHandler(
+        filename=str(log_file_path),
+        when="midnight",
+        interval=1,
+        backupCount=backup_count,
+        encoding="utf-8",
+    )
+
+    # Add filter to exclude web logs
+    _file_handler.addFilter(ExcludeWebLogsFilter())
+
+    # Use plain formatter (no ANSI colors for files)
+    plain_formatter = logging.Formatter(fmt=log_format, datefmt=date_format)
+    _file_handler.setFormatter(plain_formatter)
+    _file_handler.setLevel(logging.INFO)
+
+    # Add to logger
+    CITRASCOPE_LOGGER.addHandler(_file_handler)
+
+
+def get_file_handler() -> Optional[TimedRotatingFileHandler]:
+    """Get the current file handler.
+
+    Returns:
+        The file handler if file logging is set up, None otherwise.
+    """
+    return _file_handler

citrascope/logging/web_log_handler.py

@@ -0,0 +1,74 @@
+"""Log handler that streams logs to web clients via WebSocket."""
+
+import asyncio
+import logging
+from collections import deque
+from typing import Optional
+
+
+class WebLogHandler(logging.Handler):
+    """Custom log handler that buffers logs and makes them available to web clients."""
+
+    def __init__(self, max_logs: int = 1000):
+        super().__init__()
+        self.log_buffer = deque(maxlen=max_logs)
+        self.web_app = None
+        self.loop = None
+
+    def set_web_app(self, web_app, loop=None):
+        """Set the web app instance for broadcasting logs."""
+        self.web_app = web_app
+        self.loop = loop
+
+    def emit(self, record):
+        """Emit a log record."""
+        try:
+            # Filter out web-related logs from the web UI
+            # (uvicorn.access, WebSocket messages, HTTP Request logs, etc.)
+            if (
+                record.name.startswith("uvicorn")
+                or "WebSocket" in record.getMessage()
+                or "HTTP Request:" in record.getMessage()
+            ):
+                return
+
+            # Get the original levelname without color codes
+            # Record.levelname might have ANSI codes from ColoredFormatter
+            level = record.levelname
+            # Strip ANSI codes from level if present
+            import re
+
+            level = re.sub(r"\x1b\[\d+m", "", level)
+
+            log_entry = {
+                "timestamp": self.format_time(record),
+                "level": level,
+                "message": record.getMessage(),  # Use raw message, not formatted
+                "module": record.module,
+            }
+            self.log_buffer.append(log_entry)
+
+            # Broadcast to web clients if available
+            if self.web_app and hasattr(self.web_app, "broadcast_log") and self.loop:
+                # Schedule the broadcast in the web server's event loop
+                try:
+                    if self.loop.is_running():
+                        asyncio.run_coroutine_threadsafe(self.web_app.broadcast_log(log_entry), self.loop)
+                except Exception:
+                    # Silently fail if we can't broadcast
+                    pass
+
+        except Exception:
+            self.handleError(record)
+
+    def format_time(self, record):
+        """Format the timestamp."""
+        from datetime import datetime
+
+        return datetime.fromtimestamp(record.created).isoformat()
+
+    def get_recent_logs(self, limit: Optional[int] = None):
+        """Get recent log entries."""
+        if limit:
+            return list(self.log_buffer)[-limit:]
+        return list(self.log_buffer)

citrascope/settings/citrascope_settings.py

@@ -0,0 +1,145 @@
+"""CitraScope settings class using JSON-based configuration."""
+
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+import platformdirs
+
+# Application constants for platformdirs
+# Defined before imports to avoid circular dependency
+APP_NAME = "citrascope"
+APP_AUTHOR = "citra-space"
+
+from citrascope.logging import CITRASCOPE_LOGGER
+from citrascope.settings.settings_file_manager import SettingsFileManager
+
+
+class CitraScopeSettings:
+    """Settings for CitraScope loaded from JSON configuration file."""
+
+    def __init__(
+        self,
+        dev: bool = False,
+        log_level: str = "INFO",
+        keep_images: bool = False,
+    ):
+        """Initialize settings from JSON config file.
+
+        Args:
+            dev: If True, use development API endpoint
+            log_level: Logging level (DEBUG, INFO, WARNING, ERROR)
+            keep_images: If True, preserve captured images
+        """
+        self.config_manager = SettingsFileManager()
+
+        # Load configuration from file
+        config = self.config_manager.load_config()
+
+        # Application data directories
+        self._images_dir = Path(platformdirs.user_data_dir(APP_NAME, appauthor=APP_AUTHOR)) / "images"
+
+        # API Settings
+        self.host: str = config.get("host", "dev.api.citra.space" if dev else "api.citra.space")
+        self.port: int = config.get("port", 443)
+        self.use_ssl: bool = config.get("use_ssl", True)
+        self.personal_access_token: str = config.get("personal_access_token", "")
+        self.telescope_id: str = config.get("telescope_id", "")
+
+        # Hardware adapter selection
+        self.hardware_adapter: str = config.get("hardware_adapter", "")
+
+        # Hardware adapter-specific settings stored as dict
+        self.adapter_settings: Dict[str, Any] = config.get("adapter_settings", {})
+
+        # Runtime settings (can be overridden by CLI flags)
+        self.log_level: str = log_level if log_level != "INFO" else config.get("log_level", "INFO")
+        self.keep_images: bool = keep_images if keep_images else config.get("keep_images", False)
+
+        # Task retry configuration
+        self.max_task_retries: int = config.get("max_task_retries", 3)
+        self.initial_retry_delay_seconds: int = config.get("initial_retry_delay_seconds", 30)
+        self.max_retry_delay_seconds: int = config.get("max_retry_delay_seconds", 300)
+
+        # Log file configuration
+        self.file_logging_enabled: bool = config.get("file_logging_enabled", True)
+        self.log_retention_days: int = config.get("log_retention_days", 30)
+
+        if dev:
+            self.host = "dev.api.citra.space"
+            CITRASCOPE_LOGGER.info("Using development API endpoint.")
+
+    def get_images_dir(self) -> Path:
+        """Get the path to the images directory.
+
+        Returns:
+            Path object pointing to the images directory.
+        """
+        return self._images_dir
+
+    def ensure_images_directory(self) -> None:
+        """Create images directory if it doesn't exist."""
+        if not self._images_dir.exists():
+            self._images_dir.mkdir(parents=True)
+
+    def is_configured(self) -> bool:
+        """Check if minimum required configuration is present.
+
+        Returns:
+            True if personal_access_token, telescope_id, and hardware_adapter are set.
+        """
+        return bool(self.personal_access_token and self.telescope_id and self.hardware_adapter)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert settings to dictionary for serialization.
+
+        Returns:
+            Dictionary of all settings.
+        """
+        return {
+            "host": self.host,
+            "port": self.port,
+            "use_ssl": self.use_ssl,
+            "personal_access_token": self.personal_access_token,
+            "telescope_id": self.telescope_id,
+            "hardware_adapter": self.hardware_adapter,
+            "adapter_settings": self.adapter_settings,
+            "log_level": self.log_level,
+            "keep_images": self.keep_images,
+            "max_task_retries": self.max_task_retries,
+            "initial_retry_delay_seconds": self.initial_retry_delay_seconds,
+            "max_retry_delay_seconds": self.max_retry_delay_seconds,
+            "file_logging_enabled": self.file_logging_enabled,
+            "log_retention_days": self.log_retention_days,
+        }
+
+    def save(self) -> None:
+        """Save current settings to JSON config file."""
+        self.config_manager.save_config(self.to_dict())
+        CITRASCOPE_LOGGER.info(f"Configuration saved to {self.config_manager.get_config_path()}")
+
+    @classmethod
+    def from_dict(cls, config: Dict[str, Any]) -> "CitraScopeSettings":
+        """Create settings instance from dictionary.
+
+        Args:
+            config: Dictionary of configuration values.
+
+        Returns:
+            New CitraScopeSettings instance.
+        """
+        settings = cls()
+        settings.host = config.get("host", settings.host)
+        settings.port = config.get("port", settings.port)
+        settings.use_ssl = config.get("use_ssl", settings.use_ssl)
+        settings.personal_access_token = config.get("personal_access_token", "")
+        settings.telescope_id = config.get("telescope_id", "")
+        settings.hardware_adapter = config.get("hardware_adapter", "")
+        settings.adapter_settings = config.get("adapter_settings", {})
+        settings.log_level = config.get("log_level", "INFO")
+        settings.keep_images = config.get("keep_images", False)
+        settings.max_task_retries = config.get("max_task_retries", 3)
+        settings.initial_retry_delay_seconds = config.get("initial_retry_delay_seconds", 30)
+        settings.max_retry_delay_seconds = config.get("max_retry_delay_seconds", 300)
+        settings.file_logging_enabled = config.get("file_logging_enabled", True)
+        settings.log_retention_days = config.get("log_retention_days", 30)
+        return settings