apexcodexpy 0.7.2__tar.gz → 0.7.4__tar.gz

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

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

{apexcodexpy-0.7.2 → apexcodexpy-0.7.4}/codex/infra/program.py

@@ -1,12 +1,14 @@
 from __future__ import annotations
 
 import subprocess
-from collections.abc import Callable, Iterable, Iterator, MutableSequence
 from dataclasses import dataclass, field, replace
-from typing import Any, Protocol
+from typing import TYPE_CHECKING, Any, Protocol
 
 from codex.infra.result import ComboResult, ProgramResult, TaskResult
 
+if TYPE_CHECKING:
+    from collections.abc import Callable, Iterable, Iterator, MutableSequence
+
 
 @dataclass(frozen=True)
 class Program:
@@ -22,6 +24,7 @@ class Program:
                     text=True,
                     encoding="utf-8",
                     capture_output=True,
+                    check=False,
                 )
             ),
         )

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.2 → apexcodexpy-0.7.4}/codex/infra/reporters.py

@@ -1,11 +1,13 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
-from typing import Protocol
+from typing import TYPE_CHECKING, Protocol
 
-from codex.infra.result import Reporter
 from codex.infra.typer.device import TyperDevice
 
+if TYPE_CHECKING:
+    from codex.infra.result import Reporter
+
 
 @dataclass(frozen=True)
 class SimpleReporter:

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

@@ -1,8 +1,10 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
-from subprocess import CompletedProcess
-from typing import Any, Protocol
+from typing import TYPE_CHECKING, Any, Protocol
+
+if TYPE_CHECKING:
+    from subprocess import CompletedProcess
 
 
 class TaskResult(Protocol):
@@ -59,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.2 → apexcodexpy-0.7.4}/codex/infra/service.py

@@ -1,8 +1,8 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from pathlib import Path
 from time import time
+from typing import TYPE_CHECKING
 
 from codex.infra.program import Command, Executable, MultiProgram, Program
 from codex.infra.pyproject import PyProjectToml
@@ -22,7 +22,9 @@ from codex.infra.workflows import (
     CheckCodeWorkflow,
     DependabotWorkflow,
 )
-from codex.infra.workflows.lock import CodexLockWorkflow
+
+if TYPE_CHECKING:
+    from pathlib import Path
 
 
 @dataclass(frozen=True)
@@ -134,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:
@@ -204,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.2 → apexcodexpy-0.7.4}/codex/infra/tools.py

@@ -4,6 +4,7 @@ import sys
 from dataclasses import dataclass, field
 from importlib import metadata
 from pathlib import Path
+from typing import TYPE_CHECKING
 
 from codex.infra.program import (
     BoundedProgram,
@@ -11,7 +12,9 @@ from codex.infra.program import (
     MultiProgram,
     Program,
 )
-from codex.infra.result import TaskResult
+
+if TYPE_CHECKING:
+    from codex.infra.result import TaskResult
 
 
 @dataclass(frozen=True, kw_only=True)

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.2 → 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.2 → apexcodexpy-0.7.4}/codex/infra/workflows/base.py

@@ -3,13 +3,16 @@ from __future__ import annotations
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
 from datetime import UTC, datetime
-from pathlib import Path
+from typing import TYPE_CHECKING
 
 from codex.infra.program import Executable, LazyExecutable
 from codex.infra.result import ProgramResult
 from codex.infra.tools import Version
 from codex.infra.yamler import Yamler
 
+if TYPE_CHECKING:
+    from pathlib import Path
+
 
 @dataclass(frozen=True, kw_only=True)
 class YamlWorkflow(ABC):
@@ -43,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.2 → apexcodexpy-0.7.4}/codex/infra/workflows/ci.py

@@ -1,10 +1,13 @@
 from __future__ import annotations
 
-from collections.abc import MutableMapping, MutableSequence
 from dataclasses import dataclass, field, replace
+from typing import TYPE_CHECKING
 
 from codex.infra.yamler import Yamler
 
+if TYPE_CHECKING:
+    from collections.abc import MutableMapping, MutableSequence
+
 
 @dataclass(frozen=True)
 class CiWorkflow:

{apexcodexpy-0.7.2 → apexcodexpy-0.7.4}/codex/infra/yamler.py

@@ -1,14 +1,16 @@
 from __future__ import annotations
 
-from collections.abc import Iterable, Mapping
 from dataclasses import dataclass
-from pathlib import Path
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from ruamel.yaml import YAML
 from ruamel.yaml.comments import CommentedMap
 from ruamel.yaml.scalarstring import FoldedScalarString
 
+if TYPE_CHECKING:
+    from collections.abc import Iterable, Mapping
+    from pathlib import Path
+
 
 @dataclass(frozen=True, kw_only=True)
 class Yamler:

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

@@ -1,6 +1,6 @@
 [project]
 name = "apexcodexpy"
-version = "0.7.2"
+version = "0.7.4"
 description = "The Non-Destructive Configuration Steward for Python Projects."
 readme = "README.md"
 authors = [
@@ -54,6 +54,23 @@ select = [
     "I",
     "N",
     "UP",
+    "RUF",
+    "FURB",
+    "PERF",
+    "LOG",
+    "PIE",
+    "SLF",
+    "DTZ",
+    "PTH",
+    "TRY",
+    "PL",
+    "TCH",
+]
+ignore = [
+    "TRY003",
+    "PLR0913",
+    "PLR0917",
+    "PLR2004",
 ]
 
 [tool.ruff.lint.mccabe]

apexcodexpy-0.7.2/codex/infra/pyproject.py

@@ -1,112 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from pathlib import Path
-from typing import Any
-
-import tomlkit
-
-from codex.infra.program import Executable
-from codex.infra.result import ProgramResult
-
-
-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",
-            ],
-            "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 = tomlkit.parse(pyproject.read_text(encoding="utf-8"))
-        original = tomlkit.dumps(document)
-        deep_merge(STANDARDS, document)
-        modified = tomlkit.dumps(document)
-
-        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
-
-
-def deep_merge(source: dict[str, Any], destination: dict[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.2/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.2/codex/infra/workflows/lock.py

@@ -1,33 +0,0 @@
-from __future__ import annotations
-
-import hashlib
-from dataclasses import dataclass
-from pathlib import Path
-
-from codex.infra.yamler import Yamler
-
-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": hash_of(Path("pyproject.toml")),
-                },
-            }
-        )
-
-    def verify(self) -> bool:
-        return self.path.exists() and self.standards == Yamler.read(self.path)

{apexcodexpy-0.7.2 → apexcodexpy-0.7.4}/codex/infra/workflows/__init__.py

@@ -3,7 +3,7 @@ from .dependabot import DependabotWorkflow
 from .validate import CheckCodeWorkflow
 
 __all__ = [
-    "DependabotWorkflow",
     "BuildCodeWorkflow",
     "CheckCodeWorkflow",
+    "DependabotWorkflow",
 ]