fleshed out top-level pydantic config

Author: jsl12

appdaemon/__main__.py

@@ -31,6 +31,8 @@
 from appdaemon.logging import Logging
 from appdaemon.models.config import AppDaemonConfig
 
+from .models.config.yaml import MainConfig
+
 try:
     import pid
 except ImportError:
@@ -107,16 +109,13 @@ def stop(self):
             self.http_object.stop()
 
     # noinspection PyBroadException,PyBroadException
-    def run(self, ad_config_model: AppDaemonConfig, hadashboard, admin, aui, api, http):
+    def run(self, ad_config_model: AppDaemonConfig, *args, http):
         """Start AppDaemon up after initial argument parsing.
 
         Args:
             ad_config_model: Config for AppDaemon Object.
-            hadashboard: Config for HADashboard Object.
-            admin: Config for admin Object.
-            aui: Config for aui Object.
-            api: Config for API Object
-            http: Config for HTTP Object
+            *args: Gets used to create the HTTP object.
+            http: Main HTTP config
         """
 
         try:
@@ -142,16 +141,9 @@ def run(self, ad_config_model: AppDaemonConfig, hadashboard, admin, aui, api, ht
 
             # Initialize Dashboard/API/admin
 
-            if http is not None and (hadashboard is not None or admin is not None or aui is not None or api is not False):
+            if http is not None and any(arg is not None for arg in args):
                 self.logger.info("Initializing HTTP")
-                self.http_object = HTTP(
-                    self.AD,
-                    hadashboard,
-                    admin,
-                    aui,
-                    api,
-                    http,
-                )
+                self.http_object = HTTP(self.AD, *args, http)
                 self.AD.register_http(self.http_object)
             else:
                 if http is not None:
@@ -314,11 +306,17 @@ def main(self):  # noqa: C901
             else:
                 ad_kwargs["module_debug"] = module_debug_cli
 
-            # Validate the AppDaemon configuration
-            ad_config_model = AppDaemonConfig.model_validate(ad_kwargs)
+            if hadashboard := config.get("hadashboard"):
+                hadashboard["config_dir"] = config_dir
+                hadashboard["config_file"] = config_file
+                hadashboard["dashboard"] = True
+                hadashboard["profile_dashboard"] = args.profiledash
+
+            model = MainConfig.model_validate(config)
+            dump_kwargs = dict(mode='json', by_alias=True, exclude_unset=True)
 
             if args.debug.upper() == "DEBUG":
-                model_json = ad_config_model.model_dump(by_alias=True, exclude_unset=True)
+                model_json = model.model_dump(**dump_kwargs)
                 print(json.dumps(model_json, indent=4, default=str, sort_keys=True))
         except ValidationError as e:
             print(f"Configuration error in: {config_file}")
@@ -332,59 +330,7 @@ def main(self):  # noqa: C901
             print(e)
             sys.exit(1)
 
-        hadashboard = None
-        if "hadashboard" in config:
-            if config["hadashboard"] is None:
-                hadashboard = {}
-            else:
-                hadashboard = config["hadashboard"]
-
-            hadashboard["profile_dashboard"] = args.profiledash
-            hadashboard["config_dir"] = config_dir
-            hadashboard["config_file"] = config_file
-            if args.profiledash:
-                hadashboard["profile_dashboard"] = True
-
-            if "dashboard" not in hadashboard:
-                hadashboard["dashboard"] = True
-
-        old_admin = None
-        if "old_admin" in config:
-            if config["old_admin"] is None:
-                old_admin = {}
-            else:
-                old_admin = config["old_admin"]
-        admin = None
-        if "admin" in config:
-            if config["admin"] is None:
-                admin = {}
-            else:
-                admin = config["admin"]
-        api = None
-        if "api" in config:
-            if config["api"] is None:
-                api = {}
-            else:
-                api = config["api"]
-
-        http = None
-        if "http" in config:
-            http = config["http"]
-
-        # Setup _logging
-
-        if "log" in config:
-            print(
-                "ERROR",
-                "'log' directive deprecated, please convert to new 'logs' syntax",
-            )
-            sys.exit(1)
-        if "logs" in config:
-            logs = config["logs"]
-        else:
-            logs = {}
-
-        self.logging = Logging(logs, args.debug)
+        self.logging = Logging(model.logs.model_dump(**dump_kwargs), args.debug)
         self.logger = self.logging.get_logger()
 
         if "time_zone" in config["appdaemon"]:
@@ -407,23 +353,33 @@ def main(self):  # noqa: C901
         )
         self.logger.info("Configuration read from: %s", config_file)
 
-        utils.deprecation_warnings(ad_config_model, self.logger)
+        utils.deprecation_warnings(model.appdaemon, self.logger)
 
         self.logging.dump_log_config()
         self.logger.debug("AppDaemon Section: %s", config.get("appdaemon"))
         self.logger.debug("HADashboard Section: %s", config.get("hadashboard"))
 
+        run = functools.partial(
+            self.run,
+            model.appdaemon,
+            model.hadashboard.model_dump(**dump_kwargs),
+            model.old_admin,
+            model.admin,
+            model.api,
+            http=model.http.model_dump(**dump_kwargs),
+        )
+
         if pidfile is not None:
             self.logger.info("Using pidfile: %s", pidfile)
             dir = os.path.dirname(pidfile)
             name = os.path.basename(pidfile)
             try:
                 with pid.PidFile(name, dir):
-                    self.run(ad_config_model, hadashboard, old_admin, admin, api, http)
+                    run()
             except pid.PidFileError:
                 self.logger.error("Unable to acquire pidfile - terminating")
         else:
-            self.run(ad_config_model, hadashboard, old_admin, admin, api, http)
+            run()
 
 
 def main():

appdaemon/models/config/__init__.py

@@ -1,6 +1,14 @@
 """This sub-package contains all the pydantic models for the appdaemon.yaml file.
 
-The top-level model can be found in ``yaml.py``
+Modules:
+    app: Pydantic models for the app configuration files
+    appdaemon: Pydantic models for the appdaemon section of the appdaemon.yaml file
+    common: Common types used in multiple places
+    http: Pydantic models for the http section of the appdaemon.yaml file
+    log: Pydantic models for the log section of the appdaemon.yaml file
+    plugin: Pydantic models for the plugin section of the appdaemon.yaml file
+    sequence: Pydantic models for the sequences defined in app configuration files
+    yaml: Top-level pydantic model for the appdaemon.yaml file
 """
 
 from .app import AllAppConfig, AppConfig, GlobalModule

appdaemon/models/config/api.py

@@ -1,10 +1,10 @@
 import logging
 import sys
 from abc import ABC
+from collections.abc import Iterable, Iterator
 from copy import deepcopy
 from pathlib import Path
 from typing import Annotated, Any, Literal
-from collections.abc import Iterable, Iterator
 
 from pydantic import BaseModel, Discriminator, Field, RootModel, Tag, ValidationError, field_validator
 from pydantic_core import PydanticUndefinedType
@@ -21,6 +21,7 @@ class GlobalModules(RootModel):
 
 class BaseApp(BaseModel, ABC):
     """Abstract class to contain logic that's common to both apps and global modules"""
+
     name: str
     config_path: Path | None = None  # Needs to remain optional because it gets set later
     module_name: str = Field(alias="module")
@@ -113,7 +114,7 @@ def __iter__(self) -> Iterator[Path]:
 
     @classmethod
     def from_config_file(cls, path: Path):
-        return cls.model_validate(read_config_file(path))
+        return cls.model_validate(read_config_file(path, app_config=True))
 
     @classmethod
     def from_config_files(cls, paths: Iterable[Path], app_dir: Path | None = None):
@@ -126,7 +127,7 @@ def from_config_files(cls, paths: Iterable[Path], app_dir: Path | None = None):
         cfg = {}
         for p in paths:
             try:
-                for new, new_cfg in read_config_file(p).items():
+                for new, new_cfg in read_config_file(p, app_config=True).items():
                     try:
                         cls.model_validate({new: new_cfg})
                     except ValidationError:
@@ -145,7 +146,7 @@ def from_config_files(cls, paths: Iterable[Path], app_dir: Path | None = None):
                     else:
                         cfg[new] = new_cfg
             except ade.ConfigReadFailure as e:
-                logging.getLogger('AppDaemon').warning(f'Failed to read file: {e}')
+                logging.getLogger("AppDaemon").warning(f"Failed to read file: {e}")
                 continue
         else:
             return cls.model_validate(cfg)
@@ -156,7 +157,7 @@ def depedency_graph(self) -> dict[str, set[str]]:
             app_name: cfg.dependencies
             for app_name, cfg in self.root.items()
             if isinstance(cfg, (AppConfig, GlobalModule))
-        }
+        } # fmt: skip
 
     def reversed_dependency_graph(self) -> dict[str, set[str]]:
         """Maps each app to the other apps that depend on it"""
@@ -168,13 +169,13 @@ def app_definitions(self):
             (app_name, cfg)
             for app_name, cfg in self.root.items()
             if isinstance(cfg, (BaseApp, SequenceConfig))
-        )
+        ) # fmt: skip
 
     def global_modules(self) -> list[GlobalModule]:
         return [
             cfg for cfg in self.root.values()
             if isinstance(cfg, GlobalModule)
-        ]
+        ] # fmt: skip
 
     def app_names(self) -> set[str]:
         """Returns all the app names for regular user apps and global module apps"""
@@ -189,7 +190,7 @@ def apps_from_file(self, paths: Iterable[Path]):
             for app_name, cfg in self.root.items()
             if isinstance(cfg, BaseApp) and
             cfg.config_path in paths
-        )
+        ) # fmt: skip
 
     @property
     def active_app_count(self) -> int:

appdaemon/models/config/app.py

@@ -1,14 +1,16 @@
 import logging
+from collections.abc import Callable
 from datetime import datetime, timedelta
 from pathlib import Path
 from typing import Annotated, Any, Literal
-from collections.abc import Callable
 
 import pytz
-from pydantic import BaseModel, BeforeValidator, ConfigDict, Discriminator, Field, RootModel, Tag, field_validator, model_validator
+from pydantic import BaseModel, BeforeValidator, ConfigDict, Discriminator, Field, RootModel, SecretStr, Tag, field_validator, model_validator
 from pytz.tzinfo import BaseTzInfo
 from typing_extensions import deprecated
 
+from appdaemon.models.config.http import CoercedPath
+
 from ...models.config.plugin import HASSConfig, MQTTConfig
 from ...version import __version__
 from .misc import FilterConfig, NamespaceConfig
@@ -45,7 +47,7 @@ class AppDaemonConfig(BaseModel, extra="allow"):
     write_toml: bool = False
     ext: Literal[".yaml", ".toml"] = ".yaml"
 
-    filters: list[FilterConfig] = []
+    filters: list[FilterConfig] = Field(default_factory=list)
 
     starttime: datetime | None = None
     endtime: datetime | None = None
@@ -56,6 +58,9 @@ class AppDaemonConfig(BaseModel, extra="allow"):
     module_debug: ModuleLoggingLevels = Field(default_factory=dict)
 
     api_port: int | None = None
+    api_key: SecretStr | None = None
+    api_ssl_certificate: CoercedPath | None = None
+    api_ssl_key: CoercedPath | None = None
     stop_function: Callable | None = None
 
     utility_delay: int = 1

appdaemon/models/config/appdaemon.py

@@ -0,0 +1,35 @@
+from datetime import timedelta
+from pathlib import Path
+from typing import Annotated, Any, Literal
+
+from pydantic import BeforeValidator, PlainSerializer, ValidationError
+
+LogLevel = Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
+
+
+CoercedPath = Annotated[Path, BeforeValidator(lambda v: Path(v).resolve())]
+
+
+def validate_timedelta(v: Any):
+    match v:
+        case str():
+            parts = tuple(map(float, v.split(":")))
+            match len(parts):
+                case 1:
+                    return timedelta(seconds=parts[0])
+                case 2:
+                    return timedelta(minutes=parts[0], seconds=parts[1])
+                case 3:
+                    return timedelta(hours=parts[0], minutes=parts[1], seconds=parts[2])
+                case _:
+                    raise ValidationError(f"Invalid timedelta format: {v}")
+        case int() | float():
+            return timedelta(seconds=v)
+        case _:
+            raise ValidationError(f"Invalid type for timedelta: {v}")
+
+
+TimeType = Annotated[timedelta, BeforeValidator(validate_timedelta), PlainSerializer(lambda td: td.total_seconds())]
+
+
+BoolNum = Annotated[bool, BeforeValidator(lambda v: False if int(v) == 0 else True)]

appdaemon/models/config/common.py

@@ -0,0 +1,14 @@
+from pydantic import BaseModel
+
+from .common import BoolNum, CoercedPath
+
+
+class DashboardConfig(BaseModel):
+    config_dir: CoercedPath | None = None
+    config_file: CoercedPath | None = None
+
+    dashboard_dir: CoercedPath | None = None
+    force_compile: BoolNum = False
+    compile_on_start: BoolNum = False
+    profile_dashboard: bool = False
+    dashboard: bool

appdaemon/models/config/dashboard.py

@@ -0,0 +1,15 @@
+from typing import Literal
+
+from pydantic import BaseModel, HttpUrl, SecretStr
+
+from .common import CoercedPath
+
+
+class HTTPConfig(BaseModel, extra="allow"):
+    url: HttpUrl | None = None
+    password: SecretStr | None = None
+    transport: Literal["ws", "socketio"] = "ws"
+    ssl_certificate: CoercedPath | None = None
+    ssl_key: CoercedPath | None = None
+    static_dirs: dict[str, CoercedPath] | None = None
+    headers: dict[str, str] | None = None