PyDIET 0.9.3__py3-none-any.whl

pydiet/server/config/config.py

@@ -0,0 +1,330 @@
+"""
+Configure application.
+"""
+# Copyright CEA/CFHT/CNRS/UParisSaclay
+# Licensed under the MIT licence
+
+from argparse import ArgumentParser, SUPPRESS
+from configparser import ConfigParser
+from os import environ, makedirs, path
+from pathlib import Path
+from pprint import pprint
+from sys import exit, modules
+from time import localtime, strftime
+from typing import Tuple
+
+from astropy import units as u  #type: ignore[import-untyped]
+from pydantic import ValidationError
+
+from ... import package
+from ..types import str_to_quantity_array
+from .settings import AppSettings
+
+
+class Config(object):
+    """
+    Manage application settings in groups.
+
+    Settings are stored as Pydantic fields.
+    """
+    def __init__(
+            self,
+            settings: AppSettings,
+            args: bool=True,
+            config_file: str=package.config_file):
+
+        self.settings = settings
+        self.groups = tuple(self.settings.dict().keys())
+        self.image_filename = None
+        self.config_filename = config_file
+
+        # Skip argument parsing if Sphinx or pytest are involved
+        if "PYTEST_CURRENT_TEST" in environ or \
+            "COVERAGE_RUN" in environ or \
+            "COVERAGE_PROCESS_START" in environ or \
+            environ.get("IN_SPHINX_BUILD") == "1":
+              args = False
+        if args:
+            args_dict = self.parse_args()
+            if args_dict['version']:
+                print(f"{package.title} {package.version}")
+                exit(0)
+            # Save configuration file if requested
+            if args_dict['save_config']:
+                # Create config dir if it does not exist
+                makedirs(path.dirname(self.config_filename), exist_ok=True)
+                self.save_config(self.config_filename)
+                exit(0)
+            self.config_filename = args_dict['config']
+
+        # Parse configuration file
+        if Path(self.config_filename).exists():
+            config_dict = self.parse_config(self.config_filename)
+            # Update settings from the config file
+            self.update_from_dict(config_dict) 
+
+        # Update settings from the command line (overriding config file values)
+        if args:
+            self.update_from_dict(args_dict)
+            if args_dict['show_config']:
+                pprint(self.flat_dict())
+ 
+ 
+    def grouped_dict(self) -> dict:
+        """
+        Return a dictionary of all settings, organized in groups.
+
+        Returns
+        -------
+        gdict: dict
+            Dictionary of settings.
+        """
+        return self.settings.dict()
+
+
+    def flat_dict(self) -> dict:
+        """
+        Return a flattened dictionary of all settings.
+
+        Returns
+        -------
+        fdict: dict
+            Dictionary of settings.
+        """
+        fdict = {}
+        for group in self.groups:
+            settings = getattr(self.settings, group).dict()
+            for setting in settings:
+                fdict[setting] = settings[setting]
+        return fdict
+
+
+    def schema(self) -> dict:
+        """
+        Return a schema of the settings as a dictionary.
+
+        Returns
+        -------
+        schema: dict
+            Schema of the settings, as a dictionary.
+        """
+        return self.settings.schema()
+
+
+    def schema_json(self, indent=2) -> str:
+        """
+        Return a schema of the settings as a JSON string.
+
+        Parameters
+        ----------
+        indent: int
+            Number of indentation spaces.
+
+        Returns
+        -------
+        schema: str
+            JSON schema of the settings.
+        """
+        return self.settings.schema_json(indent=indent)
+
+
+    def parse_args(self) -> dict:
+        """
+        Return a dictionary of all settings, with values updated from the
+        command line.
+
+        Extra settings are ignored.
+
+        Returns
+        -------
+        gdict: dict
+            Dictionary of all settings, organized in groups.
+        """
+        parser = ArgumentParser(
+            description=f"{package.title} v{package.version} : {package.summary}"
+        )
+        # Add options not relevant to configuration itself
+        parser.add_argument(
+            "-V", "--version",
+            default=False,
+            help="Return the version of the package and exit", 
+            action='store_true'
+        )
+        parser.add_argument(
+            "-c", "--config",
+            type=str, default=package.config_file,
+            help=f"Configuration filename (default={package.config_file})", 
+            metavar="FILE"
+        )
+        parser.add_argument(
+            "-s", "--save_config",
+            default=False,
+            help=f"Save a default {package.title} configuration file and exit",
+            action='store_true'
+        )
+        parser.add_argument(
+            "-S", "--show_config",
+            default=False,
+            help=f"Print the actual {package.title} configuration settings",
+            action='store_true'
+        )
+
+        for group in self.groups:
+            args_group = parser.add_argument_group(group.title())
+            groupsettings = getattr(self.settings, group)
+            settings = groupsettings.schema()['properties']
+            defaults = groupsettings.dict()
+            for setting in settings:
+                props = settings[setting]
+                arg = ["-" + props['short'], "--" + setting] \
+                    if props.get('short') else ["--" + setting]
+                default = defaults[setting]
+                # Booleans don't have units
+                help = props.get('description', "")
+                if props.get('type', 'unit')=='boolean':
+                    args_group.add_argument(
+                        *arg,
+                        default=SUPPRESS,
+                        help=props.get('description', ""), 
+                        action='store_true'
+                    )
+                elif props.get('type', 'unit')=='array':
+                    deftype = type(default[0])
+                    args_group.add_argument(
+                        *arg,
+                        default=SUPPRESS,
+                        type=(lambda s: tuple([int(val) for val in s.split(',')]))
+                            if deftype==int
+                            else (lambda s: tuple([float(val) for val in s.split(',')])),
+                        help=f"{help} (default={default})"
+                    )
+                elif isinstance(default, u.Quantity):
+                    args_group.add_argument(
+                        *arg,
+                        default=SUPPRESS,
+                        type=u.Quantity if default.isscalar else str_to_quantity_array,
+                        help=f"{help} (default={default})"
+                    )  
+                else:
+                    args_group.add_argument(
+                        *arg,
+                        default=SUPPRESS,
+                        type=type(default),
+                        help=f"{help} (default={default})"
+                    )  
+        # Generate dictionary of args grouped by section
+        fdict = vars(parser.parse_args())
+        gdict = {}
+        # Command-line specific arguments
+        gdict['version'] = fdict['version']
+        gdict['config'] = fdict['config']
+        gdict['save_config'] = fdict['save_config']
+        gdict['show_config'] = fdict['show_config']
+        for group in self.groups:
+            gdict[group] = {}
+            gdictg = gdict[group]
+            settings = getattr(self.settings, group).dict()
+            for setting in settings:
+                if setting in fdict:
+                    gdictg[setting] = fdict[setting]
+        return gdict
+
+
+    def parse_config(self, filename: str) -> dict:
+        """
+        Return a dictionary of all settings, with values updated from a
+        configuration file in INI format.
+
+        Extra settings are ignored.
+
+        Parameters
+        ----------
+        filename: str | ~pathlib.Path
+            Configuration filename.
+
+        Returns
+        -------
+        gdict: dict
+            Dictionary of all settings, organized in groups.
+        """
+        config = ConfigParser(converters={})
+        config.read(filename)
+        gdict: dict = {}
+        for group in self.groups:
+            gdict[group] = {}
+            gdictg = gdict[group]
+            settings = getattr(self.settings, group).dict()
+            for setting in settings:
+                if (value := config.get(group, setting, fallback=None)) is not None:
+                    default = settings[setting]
+                    stype = type(default)
+                    gdictg[setting] = tuple(
+                        type(settings[setting][i])(val.strip()) \
+                            for i, val in enumerate(value[1:-1].split(','))
+                    )  if stype == tuple \
+                        else value.lower() in ("yes", "true", "t", "1") if stype == bool \
+                        else str_to_quantity_array(value) if \
+                            isinstance(default, u.Quantity) and not default.isscalar \
+                        else stype(value)
+        return gdict
+
+
+    def save_config(self, filename) -> None:
+        """
+        Save all settings as a configuration file in INI format.
+
+        Extra settings are ignored.
+
+        Parameters
+        ----------
+        filename: str | ~pathlib.Path
+            Configuration filename.
+        """
+        config = ConfigParser()
+        for group in self.groups:
+            config[group] = {}
+            settings = getattr(self.settings, group).dict()
+            for setting in settings:
+                props = f"{settings[setting]}"
+                config[group][setting] = props
+
+        # Ask confirmation if file already exists
+        if Path(filename).exists():
+            user_input = input(
+                f"This will overwrite {filename}! Continue? [y/N]"
+            )
+            if user_input.lower() not in ('y', 'yes'):
+                return
+
+        with open(filename, 'w') as config_file:
+            config_file.write(f"; Default {package.title} configuration file\n")
+            nowstr = strftime("%a, %d %b %Y %H:%M:%S %z", localtime())
+            config_file.write(f"; {nowstr}\n")
+            config.write(config_file)
+
+
+    def update_from_dict(self, settings_dict) -> None:
+        """
+        Update internal settings based on a dictionary (in groups)
+
+        Parameters
+        ----------
+        settings_dict: dict
+            Input dictionary.
+        """
+        for group in self.groups:
+            groupsettings = getattr(self.settings, group)
+            groupsettings_dict = groupsettings.dict()
+            settings = settings_dict[group]
+            for setting in settings:
+                vars(groupsettings).update({setting: settings_dict[group][setting]})
+            try:
+                groupsettings.model_validate(groupsettings.dict())
+            except ValidationError as valid_exception:
+                print(valid_exception)
+                exit(1)
+            except Exception as other_exception:
+                print(other_exception)
+                exit(1)
+
+

pydiet/server/config/fields.py

@@ -0,0 +1,49 @@
+"""
+Group and define Pydantic-compatible fields.
+"""
+# Copyright UParisSaclay/CEA/CFHT/CNRS
+# Licensed under the MIT licence
+
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import Field
+
+
+
+def SField(short: str | None = None, **kwargs) -> Any:
+    """
+    Return Pydantic field with augmented JSON schema including a command-line
+    "shortcut" keyword.
+
+    Examples
+    --------
+    >>> from pydantic_settings import BaseSettings
+
+    >>> class Settings(BaseSettings):
+    ...     parameter: float = SField(
+    ...         short='p',
+    ...         description="an arbitrary parameter",
+    ...         default=10.,
+    ...     )
+    
+    >>> s = Settings(parameter=3.)
+    
+    >>> s.model_json_schema()
+    {'additionalProperties': False, 'properties': {'parameter': {'default': 10.0,
+    'description': 'an arbitrary parameter', 'short': 'p', 'title': 'Parameter',
+    'type': 'number'}}, 'title': 'Settings', 'type': 'object'}
+    
+    Parameters
+    ----------
+    short: str, optional
+        Shortcut for keyword
+    **kwargs:
+        Additional Field arguments.
+    Returns
+    -------
+        Pydantic Field with augmented JSON schema.
+    """
+    return Field(**kwargs, json_schema_extra={'short': short})
+

pydiet/server/config/settings.py

@@ -0,0 +1,166 @@
+"""
+Configuration settings for the application.
+"""
+# Copyright CEA/CFHT/CNRS/UParisSaclay
+# Licensed under the MIT licence
+
+from __future__ import annotations
+
+from os import cpu_count, path
+from typing import Any, Literal, Tuple
+
+from astropy import units as u #type: ignore[import-untyped]
+import numpy as np
+from pydantic import Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+from ... import package
+from ..types import AnnotatedQuantity
+from .fields import SField
+
+# Enable imperial units such as inches
+u.imperial.enable()
+
+
+class HostSettings(BaseSettings):
+    host: str = SField(
+        short='H',
+        default="localhost",
+        description="Host name or IP address"
+        )
+    port: int = SField(
+        short='p',
+        default=8010,
+        ge=1,
+        le=65535,
+        description="Port"
+        )
+    root_path: str = SField(
+        short='R',
+        default="",
+        description="ASGI root_path"
+        )
+    access_log: bool = SField(
+        short='a',
+        default=False,
+        description="Display access log"
+        )
+    reload: bool = SField(
+        short='r',
+        default=False,
+        description="Enable auto-reload (turns off multiple workers)"
+        )
+    workers: int = SField(
+        short='w',
+        default=4 if package.isonlinux else 1,
+        ge=1,
+        description="Number of workers"
+        )
+
+    model_config = SettingsConfigDict(
+        env_prefix = f"{package.name}_",
+        extra = 'ignore',
+    )
+
+
+class ServerSettings(BaseSettings):
+    api_path : str = SField(
+        default="/api",
+        description="Endpoint URL for the webservice API"
+        )
+    banner_template: str = SField(
+        default="common/banner.html",
+        description="Name of the HTML template file for the service banner"
+        )
+    base_template: str = SField(
+        default="common/base.html",
+        description="Name of the HTML template file for the web client"
+        )
+    browser: bool = SField(
+        short='b',
+        default=False,
+        description="Start browser when launching the server"
+        )
+    client_dir: str = SField(
+        default=path.join(package.src_dir, "web_client"),
+        description="Directory containing the web client code, style and media"
+        )
+    data_config: str = SField(
+        default=path.join(package.root_dir, "data", "data_config.toml"),
+        description="Data configuration filename"
+        )
+    data_dir: str = SField(
+        default=path.join(package.root_dir, "data"),
+        description="Data root directory"
+        )
+    doc_dir: str = SField(
+        default=path.join(package.root_dir, "doc/html"),
+        description="HTML documentation root directory (after build)"
+        )
+    doc_path: str = SField(
+        default="/manual",
+        description="Endpoint URL for the root of the HTML documentation"
+        )
+    extra_dir: str = SField(
+        default=".",
+        description="Extra data root directory"
+        )
+    template_dir: str = SField(
+        default=path.join(package.src_dir, "templates"),
+        description="Directory containing templates"
+        )
+    userdoc_url: str = SField(
+        default = doc_path.default + "/index.html", #type: ignore
+        description="Endpoint URL for the user's HTML documentation"
+        )
+
+    model_config = SettingsConfigDict(
+        env_prefix = f"{package.name}_",
+        extra = 'ignore',
+    )
+
+
+
+ncpu = cpu_count()
+
+
+
+class EngineSettings(BaseSettings):
+    thread_count: int = SField(
+        short='t',
+        default = ncpu // 2 if ncpu is not None else 4,
+        ge=0,
+        le=1024,
+        description="Number of engine threads"
+        )
+
+    model_config = SettingsConfigDict(
+        env_prefix = f"{package.name}_",
+        extra = 'ignore',
+    )
+
+
+
+class MiscSettings(BaseSettings):
+    """
+    Miscellaneous settings.
+    """
+    verbose: bool = SField(
+        short='v',
+        default=True,
+        description="Verbose output"
+        )
+
+    model_config = SettingsConfigDict(
+        env_prefix = f"{package.name}_",
+        extra = 'ignore',
+        arbitrary_types_allowed = True
+    )
+
+
+class AppSettings(BaseSettings):
+    host: BaseSettings = HostSettings()
+    server: BaseSettings = ServerSettings()
+    engine: BaseSettings = EngineSettings()
+    misc: BaseSettings = MiscSettings()
+

pydiet/server/data.py

@@ -0,0 +1,31 @@
+"""
+Gather data and prepare assets.
+"""
+# Copyright CFHT/CNRS/CEA/UParisSaclay
+# Licensed under the MIT licence
+from astropy import units as u #type: ignore[import-untyped]
+from synphot import ConstFlux1D, SourceSpectrum #type: ignore[import-untyped]
+
+from .datafiles import (
+    get_data_config,
+    get_default,
+    get_instruments,
+    get_webapi_instruments,
+)
+
+data_config = get_data_config()
+
+instruments = get_instruments(data_config)
+
+default_instrument = get_default(instruments)
+winstruments = get_webapi_instruments(instruments)
+
+filters = {k:v for key,val in instruments.items() for k,v in val.filters.transmissions.items()}
+default_filter = get_default(default_instrument.filters.transmissions)
+
+# Load reference spectra
+ab_spectrum = SourceSpectrum(ConstFlux1D, amplitude = 0.*u.ABmag)
+st_spectrum = SourceSpectrum(ConstFlux1D, amplitude = 0.*u.STmag)
+vega_spectrum = SourceSpectrum.from_vega()
+
+