hadalized 0.4.0__py3-none-any.whl

hadalized/__init__.py

@@ -0,0 +1 @@
+"""CLI app for generating color themes for specific applications."""

hadalized/__main__.py

@@ -0,0 +1,6 @@
+"""Allow running hadalized cli via `python -m hadalized`."""
+
+from hadalized.cli.main import app
+
+if __name__ == "__main__":
+    app()

hadalized/base.py

@@ -0,0 +1,137 @@
+"""Base container for all model classes."""
+
+from typing import ClassVar, Self
+
+from pydantic import PrivateAttr
+from pydantic_settings import (
+    BaseSettings,
+    PydanticBaseSettingsSource,
+    SettingsConfigDict,
+    # TomlConfigSettingsSource,
+)
+
+from hadalized.const import APP_NAME, APP_VERSION
+
+
+class BaseNode(BaseSettings):
+    """An extension of BaseSettings that all model classes inherit.
+
+    Unless overriden, by default only initialization settings are respected.
+
+    Full setting sources are exposed in the ``UserConfig`` subclass.
+    """
+
+    model_config: ClassVar[SettingsConfigDict] = SettingsConfigDict(
+        frozen=True,
+        extra="forbid",
+    )
+
+    _hash: int | None = PrivateAttr(default=None)
+    """Cached hash computation so that instances can be passed to cached
+    functions and used in dicts."""
+
+    @classmethod
+    def settings_customise_sources(
+        cls,
+        settings_cls: type[BaseSettings],
+        init_settings: PydanticBaseSettingsSource,
+        env_settings: PydanticBaseSettingsSource,
+        dotenv_settings: PydanticBaseSettingsSource,
+        file_secret_settings: PydanticBaseSettingsSource,
+    ) -> tuple[PydanticBaseSettingsSource, ...]:
+        """Set source loading priority.
+
+        Returns:
+            Priority order in which config settings are loaded.
+
+        """
+        return (init_settings,)
+
+    @property
+    def app_info(self) -> str:
+        """App name and version."""
+        return f"{APP_NAME} v{APP_VERSION}"
+
+    def model_dump_lua(self) -> str:
+        """Dump the model as a lua table.
+
+        Returns:
+            A human readable lua table string.
+
+        """
+        import luadata
+
+        # TODO: Unclear if we want to import luadata just for this
+        return luadata.serialize(self.model_dump(mode="json"), indent="  ")
+
+    def replace(self, **kwargs) -> Self:
+        """Create a new instance with input arguments merged in.
+
+        Returns:
+            A new instance.
+
+        """
+        return self.model_validate(self.model_dump() | kwargs)
+
+    def __getitem__(self, key: str):
+        """Provide dict-like lookup for all models.
+
+        Returns:
+            The field specified by the input key.
+
+        """
+        return getattr(self, key)
+
+    def __hash__(self) -> int:
+        """Make an instance hashable for use in cache and dict lookups.
+
+        Defined for type checking purposes. Frozen models are hashable.
+
+        Returns:
+            The BaseModel hash.
+
+        """
+        if self._hash is None:
+            self._hash = hash(self.model_dump_json())
+        return self._hash
+
+    def __len__(self) -> int:
+        """Report the number of model fields.
+
+        Returns:
+            The length of the set of model fields.
+
+        """
+        return len(self.__class__.model_fields)
+
+    def __or__(self, other: BaseNode) -> Self:
+        """Shallow merge explicitly set fields.
+
+        Only the explicitly set fields of ``other`` are merged in.
+
+        Args:
+            other: An instance of the same type or parent type to ``self``.
+
+        Returns:
+            A new instance with the set fields of `other` merged in.
+
+        """
+        merged = self.model_dump(exclude_unset=True) | other.model_dump(
+            exclude_unset=True
+        )
+        return self.model_validate(merged)
+
+    # def merge(self, parent: BaseNode) -> Self:
+    #     """Shallow merge a parent instance.
+    #
+    #     Args:
+    #         parent: A model with a subset of the fields defined in the
+    #             instance.
+    #
+    #     Returns:
+    #         A new instance of the same type as the instance with the set
+    #         parent fields.
+    #
+    #     """
+    #     merged = self.model_dump() | parent.model_dump(exclude_unset=True)
+    #     return self.model_validate(merged)

hadalized/cache.py

@@ -0,0 +1,121 @@
+"""Application cache layer."""
+
+import sqlite3
+from typing import TYPE_CHECKING, Self
+
+from loguru import logger
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+from hadalized.options import Options
+
+
+class Cache:
+    """Caching layer."""
+
+    def __init__(self, opts: Options | None = None):
+        """Create a new instance.
+
+        Args:
+            opts: Runtime options controlling location of cache, whether to
+               use it, etc.
+
+        """
+        self.opt = opts or Options()
+        self.cache_dir: Path = self.opt.cache_dir
+        self._db_file: Path = self.cache_dir / "builds.db"
+        if not self.opt.cache_in_memory:
+            self.cache_dir.mkdir(parents=True, exist_ok=True)
+        self._conn: sqlite3.Connection
+
+    def _setup(self):
+        with self._conn:
+            self._conn.execute("""
+                CREATE TABLE IF NOT EXISTS
+                digests(path TEXT PRIMARY KEY, digest TEXT)""")
+            # self._conn.execute("""
+            #     CREATE TABLE IF NOT EXISTS
+            #     palettes(name TEXT PRIMARY KEY, data TEXT)""")
+
+    def connect(self) -> Self:
+        """Connect to the underlying sqlite database.
+
+        Returns:
+            The connected instance.
+
+        """
+        file = ":memory:" if self.opt.cache_in_memory else self._db_file
+        self._conn = sqlite3.connect(file)
+        self._setup()
+        return self
+
+    def close(self):
+        """Close the database connection."""
+        self._conn.close()
+
+    def add(self, path: str | Path, digest: str):
+        """Add a (path, hash hexdigest) to the database.
+
+        Used after a file is successfully generated to store a proxy for
+        the contents of the generated file.
+        """
+        with self._conn:
+            self._conn.execute(
+                """INSERT INTO digests VALUES(:path, :digest)
+                ON CONFLICT(path) DO UPDATE SET digest=:digest""",
+                {
+                    "path": str(path),
+                    "digest": digest,
+                },
+            )
+
+    def delete(self, path: str | Path):
+        """Remove a cache entry."""
+        with self._conn:
+            self._conn.execute(
+                """DELETE FROM digests WHERE path == ?""",
+                [str(path)],
+            )
+
+    def get(self, path: str | Path) -> str | None:
+        """Get a build digest for the input path.
+
+        Returns:
+            A hash (proxy) of the previously generated file or None if no
+            record is found.
+
+        """
+        with self._conn:
+            cur = self._conn.execute(
+                """SELECT digest FROM digests WHERE path == ? LIMIT 1""",
+                [str(path)],
+            )
+            data = cur.fetchone()
+        return data[0] if isinstance(data, tuple) else None
+
+    def get_digests(self) -> dict[str, str]:
+        """Obtain the contents of all cache build digests as a mapping.
+
+        Returns:
+            Mapping of path -> hash digest for all paths in the cache.
+
+        """
+        with self._conn:
+            return dict(self._conn.execute("SELECT * from digests"))
+
+    def __enter__(self) -> Self:
+        """Connect to the database.
+
+        Returns:
+            The connected instance.
+
+        """
+        self.connect()
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        """Close the database connection."""
+        if exc_type is not None:
+            logger.error((exc_type, exc_value, traceback))
+        self.close()

hadalized/cli/__init__.py

@@ -0,0 +1 @@
+"""Command line interface for hadalized theme builder."""

hadalized/cli/main.py

@@ -0,0 +1,221 @@
+"""Application commands."""
+
+from contextlib import suppress
+from pathlib import Path  # noqa
+from shutil import rmtree
+
+from cyclopts import App
+
+from hadalized import homedirs
+from hadalized.cache import Cache
+from hadalized.config import Config, Options, load_config
+from hadalized.writer import ThemeWriter
+
+app = App()
+cache_app = app.command(App(name="cache", help="Interact with the application cache."))
+config_app = app.command(
+    App(name="config", help="Interact with the application config.")
+)
+palette_app = app.command(App(name="palette", help="Interact with palettes."))
+state_app = app.command(
+    App(name="state", help="Interact with the application state, e.g., built files.")
+)
+
+
+@app.command
+def build(name: str | None = None, opt: Options | None = None):
+    """Build application color themes files.
+
+    When no applications or palette is specified, themes will be built for all
+    application and palette pairs.
+
+    Args:
+        name: Target application to build. Use ``--app`` to include multiple.
+        opt: Options.
+
+    """
+    opt = opt or Options()
+    if name is not None:
+        opt |= Options(include_builds=[*opt.include_builds, name])
+    config = load_config(opt)
+    if config.dry_run:
+        print("DRY-RUN. No theme files will be generated or copied.")
+    with ThemeWriter(config) as writer:
+        writer.run()
+
+
+# @config_app.command(name="info")
+# def config_info(opt: Options | None = None):
+#     """Dispaly configuration info."""
+#     from rich import print_json
+#
+#     config = load_config(opt)
+#     print_json(config.model_dump_json())
+
+
+@config_app.command(name="schema")
+def config_schema():
+    """Display configuration schema."""
+    import json
+
+    from rich import print_json
+
+    print_json(json.dumps(Config.model_json_schema()))
+
+
+@config_app.command(name="init")
+def config_init(opts: Options | None = None):
+    """Populate application configuration toml file.
+
+    When `--output=stdout` the toml contents will be printed.
+    """
+    import tomli_w as toml
+
+    config = load_config(opts)
+    if str(config.output_dir) == "stdout":
+        print(toml.dumps(config.model_dump(mode="json", exclude_none=True)))
+        return
+    output = config.output_dir or homedirs.config()
+    if output.suffix != ".toml":
+        output /= "config.toml"
+
+    output_exists = output.exists()
+    if output_exists and not config.quiet:
+        print(f"{output} already exists.")
+    if output_exists and not config.force:
+        return
+
+    output.parent.mkdir(parents=True, exist_ok=True)
+    with output.open("wb") as fp:
+        if not config.quiet:
+            print(f"Creating {output}")
+        data = config.model_dump(mode="json", exclude_none=True)
+        if not config.dry_run:
+            toml.dump(data, fp)
+    # except TypeError as exc:
+    #     print(f"Unable to write config file: {exc}")
+    #     output.unlink()
+
+
+@palette_app.command(name="parse")
+def palette_parse(
+    name: str = "hadalized",
+    *,
+    gamut: str | None = None,
+    opt: Options | None = None,
+):
+    """Show information about a particular palette.
+
+    Args:
+        name: Palette name or alias, e.g., "hadalized".
+        gamut: A specifed gamut to parse against. If not provided, the
+            gamut defined by the palette is used.
+        opt: Options
+
+    """
+    # TODO: Respect user config.
+    from rich import print_json
+
+    opt = opt or Options()
+    config = load_config(opt)
+    for item in [name, *config.include_palettes]:
+        palette = config.get_palette(item)
+        if gamut is not None:
+            palette = palette.replace(gamut=gamut)
+        print_json(palette.parse().model_dump_json())
+
+
+@cache_app.command(name="clean")
+def cache_clean(opt: Options | None = None):
+    """Clear the application cache."""
+    config = load_config(opt)
+    if config.dry_run and not config.quiet:
+        print("DRY-RUN: Cache files will not be deleted.")
+    if not config.quiet:
+        print(f"Clearing {config.cache_dir}")
+    if config.verbose:
+        files = "\n".join(str(x) for x in config.cache_dir.glob("**/*") if x.is_file())
+        print(files)
+    if not config.dry_run:
+        with suppress(FileNotFoundError):
+            rmtree(config.cache_dir)
+
+
+@cache_app.command(name="dir")
+def cache_dir(opt: Options | None = None):
+    """Show the cache directory."""
+    config = load_config(opt)
+    print(config.cache_dir)
+
+
+@cache_app.command(name="list", alias=["ls"])
+def cache_list(opt: Options | None = None):
+    """List the contents of the application cache."""
+    import json
+
+    from rich import print_json
+
+    config = load_config(opt)
+
+    with Cache(config.opt) as cache:
+        print_json(json.dumps(cache.get_digests()))
+
+
+@state_app.command(name="dir")
+def state_dir(opt: Options | None = None):
+    """Show the applicate state directory."""
+    config = load_config(opt)
+    print(config.opt.state_dir)
+
+
+@state_app.command(name="clean")
+def state_clean(opt: Options | None = None):
+    """Clear application state files such as built themes."""
+    config = load_config(opt)
+    if config.dry_run and not config.quiet:
+        print("DRY-RUN. No state files will be deleted.")
+    if not config.quiet:
+        # import json
+        #
+        # from rich import print_json
+
+        print(f"Clearing {config.state_dir}")
+        files = "\n".join(str(x) for x in config.state_dir.glob("**/*") if x.is_file())
+        if files:
+            print(files)
+        # print_json(json.dumps(files))
+    if not config.dry_run:
+        with suppress(FileNotFoundError):
+            rmtree(config.state_dir)
+
+
+@state_app.command(name="list", alias=["ls"])
+def state_list(opt: Options | None = None):
+    """List application state files."""
+    config = load_config(opt)
+    files = "\n".join(str(x) for x in config.state_dir.glob("**/*") if x.is_file())
+    print(files)
+
+
+@app.command
+def clean(opt: Options | None = None):
+    """Clean cache and state files."""
+    cache_clean(opt)
+    state_clean(opt)
+
+
+# @app.command
+# def debug(opt: Options | None = None):
+#     """Debug things."""
+#     from rich import print_json
+#
+#     config = load_config(opt)
+#     print(f"{config.cache_dir=}")
+#     print(f"{config.dry_run=}")
+#     print(f"{opt=}")
+#     if opt is not None:
+#         print(f"{opt.model_fields_set=}")
+#     print("config.opt")
+#     print_json(config.opt.model_dump_json())
+#     print(f"{config.model_fields_set=}")
+#     print(f"{config.opt.model_fields_set=}")