apexdevkit 1.31.1__tar.gz → 1.32.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: apexdevkit
-Version: 1.31.1
+Version: 1.32.1
 Summary: Apex Development Tools for python.
 License-File: LICENSE
 Author: Apex Dev

{apexdevkit-1.31.1 → 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.31.1 → apexdevkit-1.32.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "apexdevkit"
-version = "1.31.1"
+version = "1.32.1"
 description = "Apex Development Tools for python."
 readme = "README.md"
 authors = [