apexdevkit 1.27.2__tar.gz → 1.28.1__tar.gz

{apexdevkit-1.27.2 → apexdevkit-1.28.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: apexdevkit
-Version: 1.27.2
+Version: 1.28.1
 Summary: Apex Development Tools for python.
 License-File: LICENSE
 Author: Apex Dev
@@ -13,7 +13,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: fastapi
 Requires-Dist: httpx
-Requires-Dist: pymssql (==2.3.2)
+Requires-Dist: pymssql (==2.*)
 Requires-Dist: python-dotenv
 Requires-Dist: sentry-sdk[fastapi]
 Requires-Dist: tomlkit

{apexdevkit-1.27.2 → apexdevkit-1.28.1}/apexdevkit/repository/connector.py

@@ -7,8 +7,6 @@ from functools import cached_property
 from typing import Any
 
 import pymssql
-from pymssql import Connection as _Connection
-from pymssql import Cursor
 
 from apexdevkit.repository import Connection
 
@@ -46,26 +44,23 @@ class MsSqlConnector:
     db_password: str
     db_name: str
     db_tds_version = "7.0"
-    db_port: str | None = None
+    db_port: str = "1433"
 
     def connect(self) -> AbstractContextManager[Connection]:
         return ConnectionContextManager(self._connection())
 
     def _connection(self) -> Connection:
-        connection_params = {
-            "tds_version": self.db_tds_version,
-            "server": self.db_host,
-            "user": self.db_user,
-            "password": self.db_password,
-            "database": self.db_name,
-            "as_dict": True,
-            "autocommit": True,
-        }
-
-        if self.db_port is not None:
-            connection_params["port"] = self.db_port
-
-        return MsSqlConnectionAdapter(pymssql.connect(**connection_params))
+        return MsSqlConnectionAdapter(
+            pymssql.connect(
+                server=self.db_host,
+                user=self.db_user,
+                password=self.db_password,
+                database=self.db_name,
+                tds_version=self.db_tds_version,
+                as_dict=True,
+                autocommit=True,
+            )
+        )
 
 
 class ConnectionContextManager(AbstractContextManager[Connection]):
@@ -82,7 +77,7 @@ class ConnectionContextManager(AbstractContextManager[Connection]):
 
 @dataclass
 class MsSqlConnectionAdapter:
-    connection: _Connection
+    connection: pymssql.Connection[pymssql.DictRow]
 
     def cursor(self) -> MsSqlCursorAdapter:
         return MsSqlCursorAdapter(self.connection.cursor())
@@ -93,7 +88,7 @@ class MsSqlConnectionAdapter:
 
 @dataclass
 class MsSqlCursorAdapter:
-    cursor: Cursor
+    cursor: pymssql.Cursor[pymssql.DictRow]
 
     def execute(self, *args: Any, **kwargs: Any) -> Any:
         self.cursor.execute(*args, **kwargs)

{apexdevkit-1.27.2 → apexdevkit-1.28.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "apexdevkit"
-version = "1.27.2"
+version = "1.28.1"
 description = "Apex Development Tools for python."
 readme = "README.md"
 authors = [
@@ -9,22 +9,13 @@ authors = [
 dynamic = ["dependencies"]
 requires-python = ">=3.11"
 
-[project.scripts]
-codex = "pycodex.cli:cli"
-
-[tool.poetry]
-packages = [
-    { include = "apexdevkit" },
-    { include = "pycodex" }
-]
-
 [tool.poetry.dependencies]
 httpx = "*"
 fastapi = "*"
 uvicorn = "*"
 sentry-sdk = { extras = ["fastapi"], version = "*" }
 python-dotenv = "*"
-pymssql = "2.3.2"
+pymssql = "2.*"
 typer = "*"
 tomlkit = "*"
 
@@ -37,9 +28,9 @@ pytest-recording = "*"
 coverage = "*"
 faker = "*"
 
+
 [tool.poetry.group.lint.dependencies]
-mypy = "*"
-ruff = "*"
+apexcodexpy = "*"
 
 [tool.mypy]
 ignore_missing_imports = true

apexdevkit-1.27.2/pycodex/cli.py

@@ -1,120 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from pathlib import Path
-
-import typer
-
-from pycodex.reporters import DefaultReporter
-from pycodex.service import PyCodex
-
-cli = typer.Typer(add_completion=False)
-
-
-@cli.command(
-    name="lint",
-    help="Run linting (Ruff) and type checking (MyPy).",
-)
-def _(
-    path: str = typer.Option(
-        ".",
-        "--path",
-        "-p",
-        help="Target directory.",
-    ),
-    silent: bool = typer.Option(
-        False,
-        "--silent",
-        "-s",
-        help="Suppress output.",
-    ),
-) -> None:
-    raise typer.Exit(
-        PyCodex(
-            target=Path(path),
-            reporter=DefaultReporter.using(TyperDevice()).silenced().when(silent),
-        ).lint()
-    )
-
-
-@cli.command(
-    name="fix",
-    help="Automatically fix Ruff linting errors.",
-)
-def _(
-    path: str = typer.Option(
-        ".",
-        "--path",
-        "-p",
-        help="Target directory.",
-    ),
-    silent: bool = typer.Option(
-        False,
-        "--silent",
-        "-s",
-        help="Suppress output.",
-    ),
-    unsafe: bool = typer.Option(
-        False,
-        "--unsafe",
-        help="Run unsafe Ruff fixes.",
-    ),
-) -> None:
-    raise typer.Exit(
-        PyCodex(
-            target=Path(path),
-            reporter=DefaultReporter.using(TyperDevice()).silenced().when(silent),
-        ).fix(unsafe=unsafe)
-    )
-
-
-@cli.command(
-    name="sync",
-    help="Inject pycodex standards into pyproject TOML file.",
-)
-def _(
-    path: str = typer.Option(
-        ".",
-        "--path",
-        "-p",
-        help="Target directory.",
-    ),
-    dry_run: bool = typer.Option(
-        False,
-        "--dry-run",
-        help="Show changes without applying them.",
-    ),
-) -> None:
-    raise typer.Exit(
-        PyCodex(
-            target=Path(path),
-            reporter=DefaultReporter.using(TyperDevice()),
-        ).sync(dry_run=dry_run)
-    )
-
-
-@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
-
-
-if __name__ == "__main__":
-    cli()

apexdevkit-1.27.2/pycodex/reporters.py

@@ -1,85 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import Protocol
-
-from pycodex.tasks import TaskResult
-
-
-class Reporter(Protocol):
-    def report(self, **results: TaskResult) -> int:
-        pass
-
-
-@dataclass(frozen=True)
-class DefaultReporter:
-    device: _Device
-
-    @classmethod
-    def using(cls, device: _Device) -> DefaultReporter:
-        return cls(device)
-
-    def silenced(self) -> _Silenced:
-        return _Silenced(self)
-
-    def report(self, **results: TaskResult) -> int:
-        return sum(
-            self.report_one(name.capitalize(), result)
-            for name, result in results.items()
-        )
-
-    def report_one(self, name: str, result: TaskResult) -> int:
-        if result:
-            self.device.with_green().echo(f"✅ {name} passed!")
-        else:
-            self.device.with_red().echo(f"❌ {name} failed!")
-
-        self.device.with_white().echo(result.stdout)
-        self.device.with_yellow().echo(result.stderr)
-
-        return result.exit_code
-
-
-class _Device(Protocol):
-    def with_green(self) -> _Device:
-        pass
-
-    def with_red(self) -> _Device:
-        pass
-
-    def with_white(self) -> _Device:
-        pass
-
-    def with_yellow(self) -> _Device:
-        pass
-
-    def echo(self, message: str) -> _Device:
-        pass
-
-
-@dataclass(frozen=True)
-class _Silenced:
-    reporter: Reporter
-
-    def when(self, silenced: bool) -> Reporter:
-        return self.reporter if not silenced else DefaultReporter.using(_NoDevice())
-
-
-@dataclass(frozen=True)
-class _NoDevice:
-    def with_green(self) -> _Device:
-        return self
-
-    def with_red(self) -> _Device:
-        return self
-
-    def with_white(self) -> _Device:
-        return self
-
-    def with_yellow(self) -> _Device:
-        return self
-
-    def echo(self, message: str) -> _Device:
-        _ = message  # suppresses IDE warning for unused argument
-
-        return self

apexdevkit-1.27.2/pycodex/service.py

@@ -1,31 +0,0 @@
-from dataclasses import dataclass
-from pathlib import Path
-
-from pycodex.reporters import Reporter
-from pycodex.tasks import RunMypy, RunRuffCheck, SyncToml
-from pycodex.tasks.shell import RunPoetryCheck, RunRuffFormat
-
-
-@dataclass(frozen=True)
-class PyCodex:
-    target: Path
-    reporter: Reporter
-
-    def sync(self, dry_run: bool = False) -> int:
-        return self.reporter.report(
-            sync=SyncToml(of=self.target, dry_run=dry_run).run()
-        )
-
-    def lint(self) -> int:
-        return self.reporter.report(
-            poetry=RunPoetryCheck(on=self.target).run(),
-            black=RunRuffFormat(on=self.target, check=True).run(),
-            ruff=RunRuffCheck(on=self.target).run(),
-            mypy=RunMypy(on=self.target).run(),
-        )
-
-    def fix(self, unsafe: bool = False) -> int:
-        return self.reporter.report(
-            black=RunRuffFormat(on=self.target).run(),
-            ruff=RunRuffCheck(on=self.target, fix=True, unsafe=unsafe).run(),
-        )

apexdevkit-1.27.2/pycodex/tasks/__init__.py

@@ -1,10 +0,0 @@
-from pycodex.tasks.result import TaskResult
-from pycodex.tasks.shell import RunMypy, RunRuffCheck
-from pycodex.tasks.update import SyncToml
-
-__all__ = [
-    "TaskResult",
-    "RunMypy",
-    "RunRuffCheck",
-    "SyncToml",
-]

apexdevkit-1.27.2/pycodex/tasks/result.py

@@ -1,31 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from subprocess import CompletedProcess
-from typing import Any
-
-
-@dataclass(frozen=True, kw_only=True)
-class TaskResult:
-    stdout: str
-    stderr: str
-    exit_code: int
-
-    def __bool__(self) -> bool:
-        return self.exit_code == 0
-
-    @classmethod
-    def parse(cls, result: CompletedProcess[Any]) -> TaskResult:
-        return cls(
-            stdout=result.stdout,
-            stderr=result.stderr,
-            exit_code=result.returncode,
-        )
-
-    @classmethod
-    def success(cls, *, stdout: str = "", stderr: str = "") -> TaskResult:
-        return cls(stdout=stdout, stderr=stderr, exit_code=0)
-
-    @classmethod
-    def fail(cls, *, stdout: str = "", stderr: str = "") -> TaskResult:
-        return cls(stdout=stdout, stderr=stderr, exit_code=1)

apexdevkit-1.27.2/pycodex/tasks/shell.py

@@ -1,86 +0,0 @@
-from __future__ import annotations
-
-import subprocess
-from abc import ABC, abstractmethod
-from collections.abc import Iterable
-from dataclasses import dataclass
-from pathlib import Path
-from subprocess import CompletedProcess
-
-from pycodex.tasks.result import TaskResult
-
-
-class ShellTask(ABC):
-    def run(self) -> TaskResult:
-        return TaskResult.parse(self._execute())
-
-    def _execute(self) -> CompletedProcess[str]:
-        return subprocess.run(
-            list(self._command),
-            text=True,
-            encoding="utf-8",
-            capture_output=True,
-        )
-
-    @property
-    @abstractmethod
-    def _command(self) -> Iterable[str]:
-        pass
-
-
-@dataclass(frozen=True)
-class RunRuffCheck(ShellTask):
-    on: Path
-
-    fix: bool = False
-    unsafe: bool = False
-
-    @property
-    def _command(self) -> Iterable[str]:
-        yield "ruff"
-        yield "check"
-        yield str(self.on)
-
-        if self.fix:
-            yield "--fix"
-
-        if self.unsafe:
-            yield "--unsafe-fixes"
-
-
-@dataclass(frozen=True)
-class RunRuffFormat(ShellTask):
-    on: Path
-
-    check: bool = False
-
-    @property
-    def _command(self) -> Iterable[str]:
-        yield "ruff"
-        yield "format"
-        yield str(self.on)
-
-        if self.check:
-            yield "--check"
-
-
-@dataclass(frozen=True)
-class RunMypy(ShellTask):
-    on: Path
-
-    @property
-    def _command(self) -> Iterable[str]:
-        yield "mypy"
-        yield str(self.on)
-
-
-@dataclass(frozen=True)
-class RunPoetryCheck(ShellTask):
-    on: Path
-
-    @property
-    def _command(self) -> Iterable[str]:
-        yield "poetry"
-        yield "check"
-        yield "--strict"
-        yield f"--project={self.on}"

apexdevkit-1.27.2/pycodex/tasks/update.py

@@ -1,117 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from functools import cached_property
-from pathlib import Path
-from typing import Any
-
-import tomlkit
-
-from pycodex.tasks.result import TaskResult
-
-
-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 SyncToml:
-    of: Path
-
-    dry_run: bool = False
-
-    @cached_property
-    def _toml(self) -> Path:
-        return self.of / "pyproject.toml"
-
-    def run(self) -> TaskResult:
-        if not self._toml.exists():
-            return TaskResult.fail(stderr=f"{self._toml.name} not found.")
-
-        document = tomlkit.parse(self._toml.read_text(encoding="utf-8"))
-
-        # Create a copy for comparison if dry-run
-        original = tomlkit.dumps(document)
-        deep_merge(STANDARDS, document)
-        modified = tomlkit.dumps(document)
-
-        if original == modified:
-            return TaskResult.success(stdout="Configuration is already up to date.")
-
-        if self.dry_run:
-            return TaskResult.success(stdout=f"Changes would be applied:\n{modified}")
-
-        self._toml.write_text(modified, encoding="utf-8", newline="\n")
-
-        return TaskResult.success(stdout="Configuration synchronized successfully.")
-
-
-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():
-        if isinstance(value, dict):
-            # Create a table if the key doesn't exist
-            if key not in destination:
-                destination[key] = tomlkit.table()
-            deep_merge(value, destination[key])
-        elif isinstance(value, list):
-            # Create a multiline array
-            new_array = tomlkit.array()
-            for item in value:
-                new_array.append(item)
-            new_array.multiline(True)
-            destination[key] = new_array
-        else:
-            destination[key] = value