apexcodexpy 0.7.3__tar.gz → 0.7.4__tar.gz

{apexcodexpy-0.7.3 → apexcodexpy-0.7.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: apexcodexpy
-Version: 0.7.3
+Version: 0.7.4
 Summary: The Non-Destructive Configuration Steward for Python Projects.
 License-File: LICENSE
 Author: Apex Dev

apexcodexpy-0.7.4/codex/infra/pyproject.py

@@ -0,0 +1,190 @@
+from __future__ import annotations
+
+import copy
+import hashlib
+from dataclasses import dataclass, field
+from functools import cached_property
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+import tomlkit
+
+from codex.infra.result import ProgramResult
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping
+
+    from codex.infra.program import Executable
+
+
+@dataclass(frozen=True)
+class PyProjectToml:
+    name: str = "PyProject"
+    path: Path = Path("pyproject.toml")
+
+    def sync(self, target: Path) -> Executable:
+        pyproject = PyProjectFile(target / self.path, standards=self.standards)
+
+        if not pyproject.exists():
+            return ProgramResult(name=self.name).fail(message=f"{self.name} not found.")
+
+        if not pyproject.is_outdated():
+            return ProgramResult(name=self.name).no_changes()
+
+        pyproject.sync()
+
+        return ProgramResult(name=self.name).workflow_success()
+
+    @property
+    def standards(self) -> Mapping[str, Any]:
+        return {
+            "tool": {
+                "mypy": self._mypy,
+                "ruff": self._ruff,
+                "coverage": self._coveragepy,
+            }
+        }
+
+    @property
+    def _mypy(self) -> dict[str, Any]:
+        return {
+            "strict": True,
+            "ignore_missing_imports": True,
+            "show_error_codes": True,
+            "pretty": True,
+        }
+
+    @property
+    def _ruff(self) -> dict[str, Any]:
+        return {
+            "lint": {
+                "select": [
+                    "A",
+                    "ARG",
+                    "B",
+                    "C4",
+                    "PT",
+                    "RSE",
+                    "RET",
+                    "SIM",
+                    "T20",
+                    "E",
+                    "W",
+                    "F",
+                    "I",
+                    "N",
+                    "UP",
+                    "RUF",
+                    "FURB",
+                    "PERF",
+                    "LOG",
+                    "PIE",
+                    "SLF",
+                    "DTZ",
+                    "PTH",
+                    "TRY",
+                    "PL",
+                    "TCH",
+                ],
+                "mccabe": {
+                    "max-complexity": 10,
+                },
+            }
+        }
+
+    @property
+    def _coveragepy(self) -> dict[str, Any]:
+        return {
+            "run": {
+                "branch": True,
+            },
+            "report": {
+                "skip_empty": True,
+                "skip_covered": True,
+                "show_missing": True,
+            },
+        }
+
+
+@dataclass(frozen=True)
+class PyProjectFile:
+    path: Path
+
+    standards: Mapping[str, Any] = field(default_factory=dict)
+
+    @cached_property
+    def current(self) -> Tomler:
+        return Tomler.read(self.path)
+
+    @cached_property
+    def latest(self) -> Tomler:
+        return self.current.update_with(self.standards)
+
+    def exists(self) -> bool:
+        return self.path.exists()
+
+    def is_outdated(self) -> bool:
+        return self.current != self.latest
+
+    def sync(self) -> None:
+        self.path.write_text(self.latest.dumps(), encoding="utf-8", newline="\n")
+
+
+@dataclass(frozen=True)
+class Tomler:
+    document: Mapping[str, Any]
+
+    @classmethod
+    def read(cls, path: Path) -> Tomler:
+        return cls(tomlkit.parse(path.read_text(encoding="utf-8")))
+
+    def dumps(self) -> str:
+        return tomlkit.dumps(self.document)
+
+    def update_with(self, source: Mapping[str, Any]) -> Tomler:
+        return Tomler(deep_merge(source, self.document))
+
+    def hashed(self) -> str:
+        return hashlib.sha256(self.dumps().encode()).hexdigest()
+
+
+def deep_merge(
+    source: Mapping[str, Any],
+    destination: Mapping[str, Any],
+) -> Mapping[str, Any]:
+    """
+    Recursively merges two mappings, taking the source and merging it into
+    the destination. Performs a deep merge such that nested dictionaries or
+    arrays are combined intelligently.
+
+    The function identifies the type of each key-value pair in the `source`
+    and `destination` mappings and determines how to merge them based on
+    their data types, supporting nested dictionaries and TOML data
+    structures.
+
+    :param source: The source mapping to merge into the destination.
+    :param destination: The destination mapping that will be updated with the
+        data from `source`.
+    :return: A new mapping that represents the merged result of `source`
+        and `destination`.
+    """
+    result = {**destination}
+
+    for key, value in source.items():
+        match (result.get(key), value):
+            case (dict(destination_value), dict(source_value)):
+                # Both exist and are dicts -> recursively merge
+                result[key] = deep_merge(source_value, destination_value)
+            case (_, dict(source_value)):
+                # Only source is a dict -> convert to TOML table
+                result[key] = deep_merge(source_value, {})
+            case (_, list(src_list)):
+                # Formatted TOML array
+                new_array = tomlkit.array()
+                new_array.extend(copy.deepcopy(src_list))
+                new_array.multiline(True)
+                result[key] = new_array
+            case _:
+                result[key] = copy.deepcopy(value)
+
+    return result

{apexcodexpy-0.7.3 → apexcodexpy-0.7.4}/codex/infra/result.py

@@ -61,6 +61,9 @@ class ProgramResult:
     def no_changes(self) -> ProgramResult:
         return self.success(message="Already up to date.\n")
 
+    def workflow_success(self) -> ProgramResult:
+        return self.success(message="Workflow succeeded!\n")
+
     def success(self, *, message: str = "") -> ProgramResult:
         return ProgramResult(
             name=self.name,

{apexcodexpy-0.7.3 → apexcodexpy-0.7.4}/codex/infra/service.py

@@ -22,7 +22,6 @@ from codex.infra.workflows import (
     CheckCodeWorkflow,
     DependabotWorkflow,
 )
-from codex.infra.workflows.lock import CodexLockWorkflow
 
 if TYPE_CHECKING:
     from pathlib import Path
@@ -137,14 +136,12 @@ class CodexTools:
     def sync(self, force: bool) -> Executable:
         return (
             MultiProgram()
-            .attach(PyProjectToml().sync(self.target))
             .attach(DependabotWorkflow().sync(self.target, force=force))
             .attach(CheckCodeWorkflow().sync(self.target, force=force))
             .attach(
                 BuildCodeWorkflow(disclaimer=False).sync(self.target, force=force),
                 when=self.target.joinpath("Dockerfile").exists(),
             )
-            .attach(CodexLockWorkflow().sync(self.target, force=force))
         )
 
     def lock(self) -> Executable:
@@ -207,23 +204,27 @@ class CodexTools:
 
     def fix(self, unsafe: bool = False) -> Executable:
         return (
-            PoetryRun()
+            MultiProgram()
+            .attach(PyProjectToml().sync(self.target))
             .attach(
-                Program(
-                    name="black",
-                    command=Ruff(on=self.target).format(),
+                PoetryRun()
+                .attach(
+                    Program(
+                        name="black",
+                        command=Ruff(on=self.target).format(),
+                    )
                 )
-            )
-            .attach(
-                Program(
-                    name="ruff",
-                    command=(
-                        Ruff(on=self.target)
-                        .lint()
-                        .flag(fix=True)
-                        .flag(unsafe_fixes=unsafe)
+                .attach(
+                    Program(
+                        name="ruff",
+                        command=(
+                            Ruff(on=self.target)
+                            .lint()
+                            .flag(fix=True)
+                            .flag(unsafe_fixes=unsafe)
+                        ),
                     ),
-                ),
+                )
             )
         )
 

apexcodexpy-0.7.4/codex/infra/typer/device.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from textwrap import dedent
+from typing import TYPE_CHECKING
+
+import typer
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+
+@dataclass(frozen=True)
+class TyperDevice:
+    color: str = typer.colors.RESET
+
+    def with_green(self) -> TyperDevice:
+        return TyperDevice(typer.colors.GREEN)
+
+    def with_red(self) -> TyperDevice:
+        return TyperDevice(typer.colors.RED)
+
+    def with_white(self) -> TyperDevice:
+        return TyperDevice(typer.colors.WHITE)
+
+    def with_yellow(self) -> TyperDevice:
+        return TyperDevice(typer.colors.YELLOW)
+
+    def echo(self, message: str) -> TyperDevice:
+        _Message.parse(message).display(using=lambda m: typer.secho(m, fg=self.color))
+
+        return self
+
+
+@dataclass(frozen=True)
+class _Message:
+    raw: str
+
+    @staticmethod
+    def parse(raw: str) -> _Message | _NoMessage:
+        message = dedent(raw)
+
+        return _Message(message) if message.strip() else _NoMessage()
+
+    def display(self, using: Callable[[str], None]) -> None:
+        using(self.raw)
+
+
+@dataclass(frozen=True)
+class _NoMessage:
+    def display(self, using: Callable[[str], None]) -> None:
+        _ = using

{apexcodexpy-0.7.3 → apexcodexpy-0.7.4}/codex/infra/typer/root.py

@@ -4,25 +4,10 @@ import typer
 
 from codex.infra.reporters import DefaultReporter, SimpleReporter
 from codex.infra.service import Codex, Git
-from codex.infra.workflows.lock import CodexLockWorkflow
 
 cli = typer.Typer(no_args_is_help=True)
 
 
-@cli.callback()
-def verify_codex_lock(ctx: typer.Context) -> None:
-    if ctx.invoked_subcommand == "sync":
-        return
-
-    if CodexLockWorkflow().verify():
-        return
-
-    typer.echo("Codex is out of sync!")
-    typer.echo("Run `codex sync` to bring configuration up to date")
-
-    raise typer.Exit(1)
-
-
 @cli.command(
     name="version",
     help="Show the codex version and exit.",

{apexcodexpy-0.7.3 → apexcodexpy-0.7.4}/codex/infra/workflows/base.py

@@ -46,14 +46,9 @@ class YamlWorkflow(ABC):
 
             standards.dump_to(path)
 
-            return self.success()
+            return ProgramResult(name=self.name).workflow_success()
 
         return LazyExecutable(_)
 
     def _utcnow(self) -> str:
         return datetime.now(tz=UTC).replace(microsecond=0).isoformat(sep=" ")
-
-    def success(self) -> ProgramResult:
-        return ProgramResult(name=self.name).success(
-            message=f"{self.name} workflow succeeded.\n"
-        )

{apexcodexpy-0.7.3 → apexcodexpy-0.7.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "apexcodexpy"
-version = "0.7.3"
+version = "0.7.4"
 description = "The Non-Destructive Configuration Steward for Python Projects."
 readme = "README.md"
 authors = [
@@ -66,7 +66,6 @@ select = [
     "PL",
     "TCH",
 ]
-
 ignore = [
     "TRY003",
     "PLR0913",

apexcodexpy-0.7.3/codex/infra/pyproject.py

@@ -1,157 +0,0 @@
-from __future__ import annotations
-
-import hashlib
-from dataclasses import dataclass, field
-from pathlib import Path
-from typing import TYPE_CHECKING, Any, Self
-
-import tomlkit
-from tomlkit import TOMLDocument
-
-from codex.infra.result import ProgramResult
-
-if TYPE_CHECKING:
-    from collections.abc import Mapping, MutableMapping
-
-    from codex.infra.program import Executable
-
-
-def _mypy_config() -> dict[str, Any]:
-    return {
-        "strict": True,
-        "ignore_missing_imports": True,
-        "show_error_codes": True,
-        "pretty": True,
-    }
-
-
-def _ruff_config() -> dict[str, Any]:
-    return {
-        "lint": {
-            "select": [
-                "A",
-                "ARG",
-                "B",
-                "C4",
-                "PT",
-                "RSE",
-                "RET",
-                "SIM",
-                "T20",
-                "E",
-                "W",
-                "F",
-                "I",
-                "N",
-                "UP",
-                "RUF",
-                "FURB",
-                "PERF",
-                "LOG",
-                "PIE",
-                "SLF",
-                "DTZ",
-                "PTH",
-                "TRY",
-                "PL",
-                "TCH",
-            ],
-            "mccabe": {
-                "max-complexity": 10,
-            },
-        }
-    }
-
-
-def _coverage_config() -> dict[str, Any]:
-    return {
-        "run": {
-            "branch": True,
-        },
-        "report": {
-            "skip_empty": True,
-            "skip_covered": True,
-            "show_missing": True,
-        },
-    }
-
-
-STANDARDS = {
-    "tool": {
-        "mypy": _mypy_config(),
-        "ruff": _ruff_config(),
-        "coverage": _coverage_config(),
-    }
-}
-
-
-@dataclass(frozen=True)
-class PyProjectToml:
-    _result: ProgramResult = field(init=False, default=ProgramResult(name="PyProject"))
-
-    NAME = "pyproject.toml"
-
-    def sync(self, target: Path) -> Executable:
-        return self._sync(self.toml_on(target))
-
-    def _sync(self, pyproject: Path) -> Executable:
-        if not pyproject.exists():
-            return self._result.fail(message=f"{self.NAME} not found.")
-
-        document = Tomler.read(pyproject)
-        original = document.dumps()
-        modified = document.update_with(STANDARDS).dumps()
-
-        if original == modified:
-            return self._result.no_changes()
-
-        pyproject.write_text(modified, encoding="utf-8", newline="\n")
-
-        return self._result.success(message=f"{self.NAME} synchronized successfully.\n")
-
-    def toml_on(self, path: Path) -> Path:
-        return path / self.NAME
-
-    @staticmethod
-    def latest() -> Tomler:
-        return Tomler.read(Path("pyproject.toml")).update_with(STANDARDS)
-
-
-@dataclass(frozen=True)
-class Tomler:
-    document: TOMLDocument
-
-    @classmethod
-    def read(cls, path: Path) -> Tomler:
-        return cls(tomlkit.parse(path.read_text(encoding="utf-8")))
-
-    def dumps(self) -> str:
-        return tomlkit.dumps(self.document)
-
-    def update_with(self, source: Mapping[str, Any]) -> Self:
-        deep_merge(source, self.document)
-
-        return self
-
-    def hashed(self) -> str:
-        return hashlib.sha256(self.dumps().encode()).hexdigest()
-
-
-def deep_merge(
-    source: Mapping[str, Any],
-    destination: MutableMapping[str, Any],
-) -> None:
-    """Recursively merges the source into destination with TOML formatting."""
-    for key, value in source.items():
-        match value:
-            case dict():
-                if key not in destination:
-                    destination[key] = tomlkit.table()
-                deep_merge(value, destination[key])
-            case list():
-                new_array = tomlkit.array()
-                new_array.extend(value)
-                new_array.multiline(True)
-                destination[key] = new_array
-            case _:
-                destination[key] = value

apexcodexpy-0.7.3/codex/infra/typer/device.py

@@ -1,28 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-
-import typer
-
-
-@dataclass(frozen=True)
-class TyperDevice:
-    color: str = typer.colors.RESET
-
-    def with_green(self) -> TyperDevice:
-        return TyperDevice(typer.colors.GREEN)
-
-    def with_red(self) -> TyperDevice:
-        return TyperDevice(typer.colors.RED)
-
-    def with_white(self) -> TyperDevice:
-        return TyperDevice(typer.colors.WHITE)
-
-    def with_yellow(self) -> TyperDevice:
-        return TyperDevice(typer.colors.YELLOW)
-
-    def echo(self, message: str) -> TyperDevice:
-        if message.strip():
-            typer.secho(message, fg=self.color)
-
-        return self

apexcodexpy-0.7.3/codex/infra/workflows/lock.py

@@ -1,34 +0,0 @@
-from __future__ import annotations
-
-import hashlib
-from dataclasses import dataclass
-from pathlib import Path
-
-from codex.infra.yamler import Yamler
-
-from ..pyproject import PyProjectToml
-from .base import YamlWorkflow
-
-
-def hash_of(path: Path) -> str:
-    with path.open("rb") as f:
-        return hashlib.file_digest(f, hashlib.sha256).hexdigest()
-
-
-@dataclass(frozen=True, kw_only=True)
-class CodexLockWorkflow(YamlWorkflow):
-    name: str = "CodexLock"
-    path: Path = Path("codex.lock")
-
-    @property
-    def standards(self) -> Yamler:
-        return Yamler.parse(
-            {
-                "hashes": {
-                    "pyproject": PyProjectToml.latest().hashed(),
-                },
-            }
-        )
-
-    def verify(self) -> bool:
-        return not self.path.exists() or self.standards == Yamler.read(self.path)