apexcodexpy 0.2.3__tar.gz → 0.3.2__tar.gz

{apexcodexpy-0.2.3 → apexcodexpy-0.3.2}/PKG-INFO

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

{apexcodexpy-0.2.3/codex/tasks → apexcodexpy-0.3.2/codex/infra}/dependabot.py

@@ -1,13 +1,14 @@
 from __future__ import annotations
 
 import json
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any
 
 import yaml
 
-from codex.tasks.result import ProgramResult, TaskResult
+from codex.infra.program import Executable
+from codex.infra.result import ProgramResult
 
 
 def _pip_config() -> dict[str, Any]:
@@ -55,19 +56,20 @@ STANDARDS = {
 class DependabotYaml:
     dry_run: bool = False
 
+    _result: ProgramResult = field(init=False, default=ProgramResult(name="DependaBot"))
+
     NAME = "dependabot.yml"
 
-    def sync(self, target: Path) -> TaskResult:
+    def sync(self, target: Path) -> Executable:
         dependabot = self.yaml_on(target)
         dependabot.parent.mkdir(parents=True, exist_ok=True)
 
         return self._sync(dependabot)
 
-    def _sync(self, dependabot: Path) -> ProgramResult:
+    def _sync(self, dependabot: Path) -> Executable:
         if self.dry_run:
-            return ProgramResult.success(
-                stdout=f"Changes would be applied:\n{json.dumps(STANDARDS, indent=2)}"
-            )
+            dumped = json.dumps(STANDARDS, indent=2)
+            return self._result.success(message=f"Changes to apply:\n{dumped}")
 
         with dependabot.open(mode="w", encoding="utf-8", newline="\n") as stream:
             yaml.dump(
@@ -78,7 +80,7 @@ class DependabotYaml:
                 default_flow_style=False,
             )
 
-        return ProgramResult.success(stdout="Configuration synchronized successfully.")
+        return self._result.success(message=f"{self.NAME} synchronized successfully.\n")
 
     def yaml_on(self, path: Path) -> Path:
         return path / ".github" / self.NAME

apexcodexpy-0.3.2/codex/infra/program.py

@@ -0,0 +1,126 @@
+from __future__ import annotations
+
+import subprocess
+from collections.abc import Iterable, Iterator, MutableSequence
+from dataclasses import dataclass, field, replace
+from typing import Any, Protocol
+
+from codex.infra.result import ComboResult, ProgramResult, TaskResult
+
+
+@dataclass(frozen=True)
+class Program:
+    command: Command
+
+    name: str = "unknown"
+
+    def execute(self) -> ProgramResult:
+        return replace(
+            ProgramResult(name=self.name.capitalize()).parse(
+                subprocess.run(
+                    list(self.command),
+                    text=True,
+                    encoding="utf-8",
+                    capture_output=True,
+                )
+            ),
+        )
+
+
+@dataclass(frozen=True)
+class Command:
+    name: str
+
+    _arguments: list[str] = field(init=False, default_factory=list)
+
+    def with_a(self, **kwargs: Any) -> Command:
+        return self.and_a(**kwargs)
+
+    def and_a(self, **kwargs: Any) -> Command:
+        assert len(kwargs) == 1, "with_a/and_a supports one argument at a time."
+
+        name, value = kwargs.popitem()
+
+        return self.append(f"--{name}={value}")
+
+    def flag(self, **kwargs: bool | None) -> Command:
+        for name, value in kwargs.items():
+            flag = self.dashify(name)
+
+            if value is not None:
+                self.append(f"--{flag}" if value else f"--no-{flag}")
+
+        return self
+
+    def dashify(self, name: str) -> str:
+        return name.replace("_", "-")
+
+    def extend(self, arguments: Iterable[Any]) -> Command:
+        for argument in arguments:
+            self.append(argument)
+
+        return self
+
+    def append(self, argument: Any) -> Command:
+        if argument is not None:
+            self._arguments.extend(str(argument).split())
+
+        return self
+
+    def __str__(self) -> str:
+        return " ".join(self)
+
+    def __iter__(self) -> Iterator[str]:
+        yield from self.name.split()
+
+        for argument in self._arguments:
+            yield from str(argument).split()
+
+
+class Executable(Protocol):
+    def execute(self) -> TaskResult:
+        pass
+
+
+@dataclass(frozen=True)
+class MultiProgram:
+    sub_programs: MutableSequence[Executable] = field(default_factory=list)
+
+    def attach(self, program: Executable) -> MultiProgram:
+        self.sub_programs.append(program)
+
+        return self
+
+    def execute(self) -> TaskResult:
+        return ComboResult([program.execute() for program in self.sub_programs])
+
+
+@dataclass(frozen=True)
+class BoundedProgram:
+    before: MultiProgram = field(init=False, default_factory=MultiProgram)
+    action: MultiProgram = field(init=False, default_factory=MultiProgram)
+    after: MultiProgram = field(init=False, default_factory=MultiProgram)
+
+    def setup(self, program: Executable) -> BoundedProgram:
+        self.before.attach(program)
+
+        return self
+
+    def teardown(self, program: Executable) -> BoundedProgram:
+        self.after.attach(program)
+
+        return self
+
+    def attach(self, program: Executable) -> BoundedProgram:
+        self.action.attach(program)
+
+        return self
+
+    def execute(self) -> TaskResult:
+        return (
+            MultiProgram()
+            .attach(self.before)
+            .attach(self.action)
+            .attach(self.after)
+            .execute()
+        )

apexcodexpy-0.2.3/codex/tasks/update.py → apexcodexpy-0.3.2/codex/infra/pyproject.py

@@ -1,12 +1,13 @@
 from __future__ import annotations
 
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any
 
 import tomlkit
 
-from codex.tasks import ProgramResult, TaskResult
+from codex.infra.program import Executable
+from codex.infra.result import ProgramResult
 
 
 def _mypy_config() -> dict[str, Any]:
@@ -69,14 +70,16 @@ STANDARDS = {
 class PyProjectToml:
     dry_run: bool = False
 
+    _result: ProgramResult = field(init=False, default=ProgramResult(name="PyProject"))
+
     NAME = "pyproject.toml"
 
-    def sync(self, target: Path) -> TaskResult:
+    def sync(self, target: Path) -> Executable:
         return self._sync(self.toml_on(target))
 
-    def _sync(self, pyproject: Path) -> TaskResult:
+    def _sync(self, pyproject: Path) -> Executable:
         if not pyproject.exists():
-            return ProgramResult.fail(stderr=f"{self.NAME} not found.")
+            return self._result.fail(message=f"{self.NAME} not found.")
 
         document = tomlkit.parse(pyproject.read_text(encoding="utf-8"))
 
@@ -86,16 +89,14 @@ class PyProjectToml:
         modified = tomlkit.dumps(document)
 
         if original == modified:
-            return ProgramResult.success(stdout="Configuration is already up to date.")
+            return self._result.success(message=f"{self.NAME} is already up to date.\n")
 
         if self.dry_run:
-            return ProgramResult.success(
-                stdout=f"Changes would be applied:\n{modified}"
-            )
+            return self._result.success(message=f"Changes to apply:\n{modified}")
 
         pyproject.write_text(modified, encoding="utf-8", newline="\n")
 
-        return ProgramResult.success(stdout="Configuration synchronized successfully.")
+        return self._result.success(message=f"{self.NAME} synchronized successfully.\n")
 
     def toml_on(self, path: Path) -> Path:
         return path / self.NAME

{apexcodexpy-0.2.3/codex → apexcodexpy-0.3.2/codex/infra}/reporters.py

@@ -3,12 +3,19 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from typing import Protocol
 
-import typer
+from codex.infra.result import Reporter
+from codex.infra.typer.device import TyperDevice
 
 
 @dataclass(frozen=True)
 class DefaultReporter:
-    device: _Device = field(default_factory=lambda: TyperDevice())
+    device: _Device = field(default_factory=TyperDevice)
+
+    def silenced(self, *, when: bool) -> Reporter:
+        if when:
+            return DefaultReporter(SilentDevice())
+
+        return self
 
     def success_of(self, name: str) -> None:
         self.device.with_green().echo(f"✅ {name} passed!")
@@ -40,24 +47,20 @@ class _Device(Protocol):
         pass
 
 
-@dataclass(frozen=True)
-class TyperDevice:
-    color: str = typer.colors.RESET
-
-    def with_green(self) -> TyperDevice:
-        return TyperDevice(typer.colors.GREEN)
+class SilentDevice:  # pragma: no cover
+    def with_green(self) -> _Device:
+        return self
 
-    def with_red(self) -> TyperDevice:
-        return TyperDevice(typer.colors.RED)
+    def with_red(self) -> _Device:
+        return self
 
-    def with_white(self) -> TyperDevice:
-        return TyperDevice(typer.colors.WHITE)
+    def with_white(self) -> _Device:
+        return self
 
-    def with_yellow(self) -> TyperDevice:
-        return TyperDevice(typer.colors.YELLOW)
+    def with_yellow(self) -> _Device:
+        return self
 
-    def echo(self, message: str) -> TyperDevice:
-        if message.strip():
-            typer.secho(message, fg=self.color)
+    def echo(self, message: str) -> _Device:
+        _ = message
 
         return self

apexcodexpy-0.3.2/codex/infra/result.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from subprocess import CompletedProcess
+from typing import Any, Protocol
+
+
+class TaskResult(Protocol):
+    def report(self, using: Reporter) -> TaskResult:
+        pass
+
+    def exit(self, using: type[Exception] | None = None) -> int:
+        pass
+
+
+@dataclass(frozen=True)
+class ComboResult:
+    results: list[TaskResult] = field(default_factory=list)
+
+    @property
+    def _exit_code(self) -> int:
+        return sum(result.exit() for result in self.results)
+
+    def report(self, using: Reporter) -> ComboResult:
+        for result in self.results:
+            result.report(using)
+
+        return self
+
+    def exit(self, using: type[Exception] | None = None) -> int:
+        if using is None:
+            return self._exit_code
+
+        raise using(self._exit_code)
+
+
+@dataclass(frozen=True, kw_only=True)
+class ProgramResult:
+    name: str
+
+    stdout: str = ""
+    stderr: str = ""
+    exit_code: int = 0
+
+    def __int__(self) -> int:
+        return self.exit_code
+
+    def __bool__(self) -> bool:
+        return self.exit_code == 0
+
+    def parse(self, result: CompletedProcess[Any]) -> ProgramResult:
+        return ProgramResult(
+            name=self.name,
+            stdout=result.stdout or "",
+            stderr=result.stderr or "",
+            exit_code=result.returncode,
+        )
+
+    def success(self, *, message: str = "") -> ProgramResult:
+        return ProgramResult(
+            name=self.name,
+            stdout=message or self.stdout,
+            stderr=self.stderr,
+            exit_code=0,
+        )
+
+    def fail(self, *, message: str = "") -> ProgramResult:
+        return ProgramResult(
+            name=self.name,
+            stdout=self.stdout,
+            stderr=message or self.stderr,
+            exit_code=1,
+        )
+
+    def execute(self) -> ProgramResult:
+        return self
+
+    def report(self, using: Reporter) -> ProgramResult:
+        if self.exit_code == 0:
+            using.success_of(self.name)
+        else:
+            using.failure_of(self.name)
+
+        using.out(self.stdout)
+        using.error(self.stderr)
+
+        return self
+
+    def exit(self, using: type[Exception] | None = None) -> int:
+        if using is None:
+            return self.exit_code
+
+        raise using(self.exit_code)
+
+
+class Reporter(Protocol):
+    def success_of(self, name: str) -> None:
+        pass
+
+    def failure_of(self, name: str) -> None:
+        pass
+
+    def out(self, message: str) -> None:
+        pass
+
+    def error(self, message: str) -> None:
+        pass

apexcodexpy-0.3.2/codex/infra/service.py

@@ -0,0 +1,262 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from time import time
+
+from codex.infra.dependabot import DependabotYaml
+from codex.infra.program import (
+    Command,
+    Executable,
+    MultiProgram,
+    Program,
+)
+from codex.infra.pyproject import PyProjectToml
+from codex.infra.result import TaskResult
+from codex.infra.tools import MyPy, Pip, Poetry, PoetryRun, Pytest, Ruff
+
+
+@dataclass(frozen=True)
+class Codex:
+    tools: CodexTools
+
+    @classmethod
+    def target(cls, target: Path) -> Codex:
+        return cls(CodexTools(target))
+
+    def ci(self, on: bool) -> Codex | CiCodex:
+        if on:
+            return CiCodex(tools=self.tools)
+
+        return self
+
+    def sync(self, dry_run: bool = False) -> TaskResult:
+        return self.tools.sync(dry_run=dry_run).execute()
+
+    def lock(self) -> TaskResult:
+        return self.tools.lock().execute()
+
+    def update(self) -> TaskResult:
+        return self.tools.update().execute()
+
+    def install(self) -> TaskResult:
+        return self.tools.install().execute()
+
+    def lint(self) -> TaskResult:
+        return self.tools.lint().execute()
+
+    def fix(self, unsafe: bool = False) -> TaskResult:
+        return self.tools.fix(unsafe=unsafe).execute()
+
+    def unit(self) -> TaskResult:
+        return self.tools.unit().execute()
+
+    def integration(self) -> TaskResult:
+        return self.tools.integration().execute()
+
+    def behaviour(self) -> TaskResult:
+        return self.tools.behaviour().execute()
+
+    def build(self, tag: str) -> TaskResult:
+        return self.tools.build(tag).execute()
+
+
+@dataclass(frozen=True)
+class CiCodex:
+    tools: CodexTools
+
+    def lint(self) -> TaskResult:
+        return (
+            MultiProgram()
+            .attach(self.tools.install())
+            .attach(self.tools.lint())
+            .execute()
+        )
+
+    def unit(self) -> TaskResult:
+        return (
+            MultiProgram()
+            .attach(self.tools.install())
+            .attach(self.tools.unit(in_ci=True))
+            .execute()
+        )
+
+    def integration(self) -> TaskResult:
+        return (
+            MultiProgram()
+            .attach(self.tools.install())
+            .attach(self.tools.integration())
+            .execute()
+        )
+
+    def behaviour(self) -> TaskResult:
+        return (
+            MultiProgram()
+            .attach(self.tools.install())
+            .attach(self.tools.behaviour(in_ci=True))
+            .execute()
+        )
+
+
+@dataclass(frozen=True)
+class CodexTools:
+    target: Path
+
+    def sync(self, dry_run: bool = False) -> Executable:
+        return (
+            MultiProgram()
+            .attach(PyProjectToml(dry_run=dry_run).sync(self.target))
+            .attach(DependabotYaml(dry_run=dry_run).sync(self.target))
+        )
+
+    def lock(self) -> Executable:
+        return Program(name="lock", command=Poetry().lock())
+
+    def update(self) -> Executable:
+        return Program(name="update", command=Poetry().update())
+
+    def install(self) -> Executable:
+        return (
+            MultiProgram()
+            .attach(
+                Program(
+                    name="tools",
+                    command=Pip().install("pip", "poetry"),
+                )
+            )
+            .attach(
+                Program(
+                    name="dependencies",
+                    command=Poetry().install(),
+                )
+            )
+        )
+
+    def lint(self) -> Executable:
+        return (
+            PoetryRun()
+            .attach(
+                Program(
+                    name="poetry",
+                    command=Poetry().lint(self.target),
+                )
+            )
+            .attach(
+                Program(
+                    name="black",
+                    command=Ruff(on=self.target).format().flag(check=True),
+                )
+            )
+            .attach(
+                Program(
+                    name="ruff",
+                    command=Ruff(on=self.target).lint(),
+                )
+            )
+            .attach(
+                Program(
+                    name="mypy",
+                    command=MyPy(on=self.target).check(),
+                )
+            )
+        )
+
+    def fix(self, unsafe: bool = False) -> Executable:
+        return (
+            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)
+                    ),
+                ),
+            )
+        )
+
+    def unit(self, in_ci: bool = False) -> Executable:
+        return PoetryRun().attach(
+            Program(
+                name="test",
+                command=(
+                    Pytest.on(self.target)
+                    .run()
+                    .flag(cov=not in_ci or None)
+                    .flag(last_failed=not in_ci or None)
+                ),
+            )
+        )
+
+    def behaviour(self, in_ci: bool = False) -> Executable:
+        return PoetryRun().attach(
+            Program(
+                name="behave",
+                command=(
+                    Command("behave")
+                    .append(self.target / "tests" / "features")
+                    .with_a(format="progress" if in_ci else "pretty")
+                    .flag(summary=not in_ci)
+                ),
+            )
+        )
+
+    def integration(self) -> Executable:
+        return (
+            Poetry()
+            .export(self.target)
+            .attach(
+                PoetryRun().attach(
+                    Program(
+                        name="test",
+                        command=Pytest.on(self.target / "tests" / "integration").run(),
+                    )
+                )
+            )
+        )
+
+    def build(self, tag: str) -> Executable:
+        return (
+            Poetry()
+            .export(self.target)
+            .attach(
+                Program(
+                    name="build",
+                    command=(
+                        Command("docker build")
+                        .flag(tag=True)
+                        .append(tag)
+                        .flag(build_arg=True)
+                        .with_a(RELEASE=Git().revision() or str(int(time())))
+                        .append(self.target)
+                    ),
+                )
+            )
+        )
+
+
+@dataclass(frozen=True)
+class Git:
+    def revision(self, of: str = "HEAD", short: bool = True) -> str:
+        return (
+            Program(Command("git rev-parse").flag(short=short).append(of))
+            .execute()
+            .stdout
+        )
+
+    def amend(self) -> TaskResult:
+        return Program(
+            name="amend",
+            command=Command("git commit")
+            .flag(all=True)
+            .flag(amend=True)
+            .flag(edit=False),
+        ).execute()