apexdevkit 1.30.4__tar.gz → 1.32.1__tar.gz

{apexdevkit-1.30.4 → apexdevkit-1.32.1}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: apexdevkit
-Version: 1.30.4
+Version: 1.32.1
 Summary: Apex Development Tools for python.
 License-File: LICENSE
 Author: Apex Dev
 Author-email: dev@apex.ge
-Requires-Python: >=3.11
+Requires-Python: >=3.11,<4
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
@@ -13,11 +13,10 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: fastapi
 Requires-Dist: httpx
+Requires-Dist: pydantic
 Requires-Dist: pymssql (==2.*)
 Requires-Dist: python-dotenv
 Requires-Dist: sentry-sdk[fastapi]
-Requires-Dist: tomlkit
-Requires-Dist: typer
 Requires-Dist: uvicorn
 Description-Content-Type: text/markdown
 

{apexdevkit-1.30.4 → apexdevkit-1.32.1}/apexdevkit/fastapi/__init__.py

@@ -1,5 +1,6 @@
 from apexdevkit.fastapi.builder import FastApiBuilder, RestfulServiceBuilder
 from apexdevkit.fastapi.dependable import inject
+from apexdevkit.fastapi.router import RestfulRouter, RouterWithHiddenUnderscoreRoutes
 from apexdevkit.fastapi.service import RestfulRepository
 
 __all__ = [
@@ -7,4 +8,6 @@ __all__ = [
     "RestfulServiceBuilder",
     "inject",
     "RestfulRepository",
+    "RestfulRouter",
+    "RouterWithHiddenUnderscoreRoutes",
 ]

{apexdevkit-1.30.4 → apexdevkit-1.32.1}/apexdevkit/fastapi/resource.py

@@ -3,8 +3,8 @@ from collections.abc import Callable
 from dataclasses import dataclass
 from typing import Any, Union
 
+from fastapi.responses import JSONResponse
 from pydantic import BaseModel
-from starlette.responses import JSONResponse
 
 from apexdevkit.error import DoesNotExistError, ExistsError, ForbiddenError
 from apexdevkit.fastapi.response import RestfulResponse

{apexdevkit-1.30.4 → apexdevkit-1.32.1}/apexdevkit/fastapi/router.py

@@ -1,3 +1,4 @@
+from collections.abc import Callable
 from dataclasses import dataclass, field
 from enum import Enum
 from typing import Annotated, Any, Protocol, Self, TypeVar
@@ -12,6 +13,38 @@ from apexdevkit.fastapi.schema import RestfulSchema, Schema, SchemaFields
 from apexdevkit.fastapi.service import RawCollection, RawItem, RestfulService
 from apexdevkit.fluent import FluentDict
 
+
+class RouterWithHiddenUnderscoreRoutes(APIRouter):
+    def add_api_route(
+        self,
+        path: str,
+        endpoint: Callable[..., Any],
+        **kwargs: Any,
+    ) -> None:
+        super().add_api_route(path, endpoint, **kwargs)
+        self._add_underscored_api_route(path, endpoint, kwargs.copy())
+
+    def _add_underscored_api_route(
+        self,
+        path: str,
+        endpoint: Callable[..., Any],
+        kwargs: dict[str, Any],
+    ) -> None:
+        if "-" not in path:
+            return
+
+        op_id = kwargs.get("operation_id", endpoint.__name__) or endpoint.__name__
+        kwargs["operation_id"] = f"{op_id}_alias"
+        kwargs["include_in_schema"] = False
+
+        # Register the underscored route pointing to the same endpoint
+        super().add_api_route(
+            path=path.replace("-", "_"),
+            endpoint=endpoint,
+            **kwargs,
+        )
+
+
 _Response = JSONResponse | dict[str, Any]
 
 T = TypeVar("T")
@@ -27,7 +60,7 @@ class RestfulRouter:
     name: RestfulName
 
     parent: RestfulName | None = None
-    router: APIRouter = field(default_factory=APIRouter)
+    router: APIRouter = field(default_factory=RouterWithHiddenUnderscoreRoutes)
 
     _schema: RestfulSchema = field(init=False)
     _dependency: Dependency | None = field(init=False, default=None)

{apexdevkit-1.30.4 → apexdevkit-1.32.1}/apexdevkit/key_fn.py

@@ -1,8 +1,11 @@
 from __future__ import annotations
 
+from collections.abc import Callable
 from dataclasses import dataclass
 from typing import Any
 
+KeyFn = Callable[[Any], str]
+
 
 @dataclass(frozen=True)
 class AttributeKey:

apexdevkit-1.32.1/apexdevkit/sync/__init__.py

@@ -0,0 +1,19 @@
+from .observer import SyncObserver
+from .source import EmptySource, Source, SourceDecorator, SourceFailing, SourcePreSet
+from .sync import Sync, SyncProbe
+from .target import NoTarget, Target, TargetDecorator, TargetFailing
+
+__all__ = [
+    "Sync",
+    "SyncObserver",
+    "SyncProbe",
+    "EmptySource",
+    "Source",
+    "SourceDecorator",
+    "SourceFailing",
+    "SourcePreSet",
+    "NoTarget",
+    "Target",
+    "TargetDecorator",
+    "TargetFailing",
+]

apexdevkit-1.32.1/apexdevkit/sync/observer.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from typing import Protocol, Self
+
+
+@dataclass(frozen=True)
+class ObservableSync:
+    observers: list[SyncObserver] = field(default_factory=list)
+
+    def attach(self, observer: SyncObserver, when: bool = True) -> Self:
+        if when:
+            self.observers.append(observer)
+
+        return self
+
+    def before_prune(self, n_items: int) -> None:
+        for observer in self.observers:
+            observer.before_prune(n_items)
+
+    def after_prune(self, n_items: int) -> None:
+        _ = n_items
+
+        for observer in self.observers:
+            observer.after_prune()
+
+    def before_load(self, n_items: int) -> None:
+        for observer in self.observers:
+            observer.before_load(n_items)
+
+    def after_load(self, n_items: int) -> None:
+        _ = n_items
+
+        for observer in self.observers:
+            observer.after_load()
+
+    def before_update(self, n_items: int) -> None:
+        for observer in self.observers:
+            observer.before_update(n_items)
+
+    def after_update(self, n_items: int) -> None:
+        _ = n_items
+
+        for observer in self.observers:
+            observer.after_update()
+
+
+class SyncObserver(Protocol):  # pragma: no cover
+    def before_prune(self, n_items: int) -> None:
+        pass
+
+    def after_prune(self) -> None:
+        pass
+
+    def before_load(self, n_items: int) -> None:
+        pass
+
+    def after_load(self) -> None:
+        pass
+
+    def before_update(self, n_items: int) -> None:
+        pass
+
+    def after_update(self) -> None:
+        pass
+
+
+@dataclass(frozen=True)
+class DefaultLog:
+    echo: Callable[[str], None] = print
+
+    def before_prune(self, n_items: int) -> None:
+        self.echo(f"Total # of absent items: {n_items}")
+
+    def after_prune(self) -> None:
+        self.echo("Pruning completed")
+
+    def before_load(self, n_items: int) -> None:
+        self.echo(f"Total # of new items: {n_items}")
+
+    def after_load(self) -> None:
+        self.echo("Loading completed")
+
+    def before_update(self, n_items: int) -> None:
+        self.echo(f"Total # of updates: {n_items}")
+
+    def after_update(self) -> None:
+        self.echo("Updating completed")

apexdevkit-1.32.1/apexdevkit/sync/source.py

@@ -0,0 +1,122 @@
+from __future__ import annotations
+
+from collections.abc import Iterable
+from dataclasses import dataclass, field
+from typing import Generic, Protocol, TypeVar
+
+from apexdevkit.key_fn import AttributeKey, KeyFn
+
+T = TypeVar("T")
+
+
+class Source(Protocol):  # pragma: no cover
+    def absent(self) -> Iterable[T]:
+        pass
+
+    def new(self) -> Iterable[T]:
+        pass
+
+    def updates(self) -> Iterable[T]:
+        pass
+
+
+@dataclass(frozen=True)
+class EmptySource:  # pragma: no cover
+    def absent(self) -> Iterable[T]:
+        return []
+
+    def new(self) -> Iterable[T]:
+        return []
+
+    def updates(self) -> Iterable[T]:
+        return []
+
+
+@dataclass(frozen=True, kw_only=True)
+class SourceDecorator:  # pragma: no cover
+    inner: Source = field(default_factory=EmptySource)
+
+    def absent(self) -> Iterable[T]:
+        return self.inner.absent()
+
+    def new(self) -> Iterable[T]:
+        return self.inner.new()
+
+    def updates(self) -> Iterable[T]:
+        return self.inner.updates()
+
+
+@dataclass(frozen=True, kw_only=True)
+class SourcePreSet(Generic[T]):
+    removals: Iterable[T]
+    additions: Iterable[T]
+    changes: Iterable[T]
+
+    def absent(self) -> Iterable[T]:
+        return self.removals
+
+    def new(self) -> Iterable[T]:
+        return self.additions
+
+    def updates(self) -> Iterable[T]:
+        return self.changes
+
+
+class SourceFailing:
+    @staticmethod
+    def on_everything(using: Source | None = None) -> Source:
+        return SourceFailing.on_absent(
+            using=SourceFailing.on_new(
+                using=SourceFailing.on_update(
+                    using=using or EmptySource(),
+                ),
+            ),
+        )
+
+    @staticmethod
+    def on_absent(using: Source | None = None) -> Source:
+        return SourceFailing.OnAbsent(inner=using or EmptySource())
+
+    @dataclass(frozen=True, kw_only=True)
+    class OnAbsent(SourceDecorator):
+        def absent(self) -> Iterable[T]:  # pragma: no cover
+            raise RuntimeError("Should not request absent!")
+
+    @staticmethod
+    def on_new(using: Source | None = None) -> Source:
+        return SourceFailing.OnNew(inner=using or EmptySource())
+
+    @dataclass(frozen=True, kw_only=True)
+    class OnNew(SourceDecorator):
+        def new(self) -> Iterable[T]:  # pragma: no cover
+            raise RuntimeError("Should not request new!")
+
+    @staticmethod
+    def on_update(using: Source | None = None) -> Source:
+        return SourceFailing.OnUpdate(inner=using or EmptySource())
+
+    @dataclass(frozen=True, kw_only=True)
+    class OnUpdate(SourceDecorator):
+        def updates(self) -> Iterable[T]:  # pragma: no cover
+            raise RuntimeError("Should not request updates!")
+
+
+@dataclass(frozen=True, kw_only=True)
+class SourceDiscriminator(Generic[T]):
+    current: Iterable[T]
+    latest: Iterable[T]
+
+    key_fn: KeyFn = AttributeKey("id")
+
+    def absent(self) -> Iterable[T]:
+        index = {self.key_fn(item) for item in self.latest}
+
+        return [item for item in self.current if self.key_fn(item) not in index]
+
+    def new(self) -> Iterable[T]:
+        index = {self.key_fn(item) for item in self.current}
+
+        return [item for item in self.latest if self.key_fn(item) not in index]
+
+    def updates(self) -> Iterable[T]:
+        return set(self.latest).difference(self.current)

apexdevkit-1.32.1/apexdevkit/sync/sync.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Collection, Iterable
+from dataclasses import dataclass
+from typing import Any, Self
+
+from .observer import DefaultLog, ObservableSync
+from .source import Source
+from .target import Target
+
+
+@dataclass(frozen=True, kw_only=True)
+class Sync(ObservableSync):
+    source: Source
+    target: Target
+
+    dry_run: bool = False
+
+    def with_log(self, using: Callable[[str], None]) -> Self:
+        return self.attach(DefaultLog(echo=using))
+
+    def run(self, prune: bool = True, load: bool = True, update: bool = True) -> None:
+        if prune:
+            self.prune()
+
+        if load:
+            self.load()
+
+        if update:
+            self.update()
+
+    def prune(self) -> None:
+        (
+            SyncProbe(source=set(self.source.absent()))
+            .disable(when=self.dry_run)
+            .notify(using=self.before_prune)
+            .send(using=self.target.prune)
+            .notify(using=self.after_prune)
+        )
+
+    def load(self) -> None:
+        (
+            SyncProbe(source=set(self.source.new()))
+            .disable(when=self.dry_run)
+            .notify(using=self.before_load)
+            .send(using=self.target.load)
+            .notify(using=self.after_load)
+        )
+
+    def update(self) -> None:
+        (
+            SyncProbe(source=set(self.source.updates()))
+            .disable(when=self.dry_run)
+            .notify(using=self.before_update)
+            .send(using=self.target.renew)
+            .notify(using=self.after_update)
+        )
+
+
+@dataclass(frozen=True, kw_only=True)
+class SyncProbe:
+    source: Collection[Any]
+
+    is_enabled: bool = True
+
+    def disable(self, when: bool) -> SyncProbe:
+        return SyncProbe(source=self.source, is_enabled=not when)
+
+    def notify(self, using: Callable[[int], None]) -> SyncProbe:
+        using(len(self.source))
+
+        return self
+
+    def send(self, using: Callable[[Iterable[Any]], None]) -> SyncProbe:
+        if self.is_enabled and len(self.source) > 0:
+            using(self.source)
+
+        return self

apexdevkit-1.32.1/apexdevkit/sync/target.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+from collections.abc import Iterable
+from dataclasses import dataclass, field
+from typing import Protocol, TypeVar
+
+T = TypeVar("T")
+
+
+class Target(Protocol):  # pragma: no cover
+    def prune(self, source: Iterable[T]) -> None:
+        pass
+
+    def load(self, source: Iterable[T]) -> None:
+        pass
+
+    def renew(self, source: Iterable[T]) -> None:
+        pass
+
+
+class NoTarget:  # pragma: no cover
+    def prune(self, source: Iterable[T]) -> None:
+        pass
+
+    def load(self, source: Iterable[T]) -> None:
+        pass
+
+    def renew(self, source: Iterable[T]) -> None:
+        pass
+
+
+@dataclass(frozen=True, kw_only=True)
+class TargetDecorator:
+    inner: Target = field(default_factory=NoTarget)
+
+    def prune(self, source: Iterable[T]) -> None:
+        self.inner.prune(source)
+
+    def load(self, source: Iterable[T]) -> None:
+        self.inner.load(source)
+
+    def renew(self, source: Iterable[T]) -> None:
+        self.inner.renew(source)
+
+
+class TargetFailing:
+    @staticmethod
+    def on_everything(using: Target | None = None) -> Target:
+        return TargetFailing.on_prune(
+            using=TargetFailing.on_load(
+                using=TargetFailing.on_update(
+                    using=using or NoTarget(),
+                ),
+            ),
+        )
+
+    @staticmethod
+    def on_prune(using: Target | None = None) -> Target:
+        return TargetFailing.OnPrune(inner=using or NoTarget())
+
+    @dataclass(frozen=True, kw_only=True)
+    class OnPrune(TargetDecorator):
+        def prune(self, source: Iterable[T]) -> None:  # pragma: no cover
+            raise RuntimeError(source)
+
+    @staticmethod
+    def on_load(using: Target | None = None) -> Target:
+        return TargetFailing.OnLoad(inner=using or NoTarget())
+
+    @dataclass(frozen=True, kw_only=True)
+    class OnLoad(TargetDecorator):
+        def load(self, source: Iterable[T]) -> None:  # pragma: no cover
+            raise RuntimeError(source)
+
+    @staticmethod
+    def on_update(using: Target | None = None) -> Target:
+        return TargetFailing.OnUpdate(inner=using or NoTarget())
+
+    @dataclass(frozen=True, kw_only=True)
+    class OnUpdate(TargetDecorator):
+        def renew(self, source: Iterable[T]) -> None:  # pragma: no cover
+            raise RuntimeError(source)

{apexdevkit-1.30.4 → apexdevkit-1.32.1}/pyproject.toml

@@ -1,38 +1,33 @@
 [project]
 name = "apexdevkit"
-version = "1.30.4"
+version = "1.32.1"
 description = "Apex Development Tools for python."
 readme = "README.md"
 authors = [
     { name = "Apex Dev", email = "dev@apex.ge" }
 ]
 dynamic = ["dependencies"]
-requires-python = ">=3.11"
+requires-python = ">=3.11,<4"
 
 [tool.poetry.dependencies]
-httpx = "*"
 fastapi = "*"
-uvicorn = "*"
-sentry-sdk = { extras = ["fastapi"], version = "*" }
+httpx = "*"
 python-dotenv = "*"
 pymssql = "2.*"
-typer = "*"
-tomlkit = "*"
+pydantic = "*"
+sentry-sdk = { extras = ["fastapi"], version = "*" }
+uvicorn = "*"
 
 [tool.poetry.group.dev.dependencies]
-approvaltests = "*"
+apexcodexpy = "0.6.5"
 pytest = "*"
 pytest-approvaltests = "*"
 pytest-cov = "*"
-pytest-env = "^1.6.0"
+pytest-env = "*"
 pytest-recording = "*"
 coverage = "*"
 faker = "*"
 
-
-[tool.poetry.group.lint.dependencies]
-apexcodexpy = "0.4.1"
-
 [tool.mypy]
 ignore_missing_imports = true
 strict = true
@@ -43,6 +38,11 @@ exclude = [
 show_error_codes = true
 pretty = true
 
+[tool.deptry]
+extend_exclude = [
+    "apexdevkit/testing",
+]
+
 [tool.ruff.lint]
 select = [
     "A",