apexdevkit 1.32.6__tar.gz → 1.32.8__tar.gz

{apexdevkit-1.32.6 → apexdevkit-1.32.8}/PKG-INFO

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

{apexdevkit-1.32.6 → apexdevkit-1.32.8}/apexdevkit/sync/observer.py

@@ -68,22 +68,23 @@ class SyncObserver(Protocol):  # pragma: no cover
 
 @dataclass(frozen=True)
 class DefaultLog:
+    name: str = "items"
     echo: Callable[[str], None] = print
 
     def before_prune(self, n_items: int) -> None:
-        self.echo(f"Total # of absent items: {n_items}")
+        self.echo(f"Total # of absent {self.name}: {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}")
+        self.echo(f"Total # of new {self.name}: {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}")
+        self.echo(f"Total # of changed {self.name}: {n_items}")
 
     def after_update(self) -> None:
         self.echo("Updating completed")

{apexdevkit-1.32.6 → apexdevkit-1.32.8}/apexdevkit/sync/source.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from collections.abc import Iterable
 from dataclasses import dataclass, field
-from typing import Generic, Protocol, TypeVar
+from typing import Any, Generic, Protocol, TypeVar
 
 from apexdevkit.key_fn import AttributeKey, KeyFn
 
@@ -48,9 +48,9 @@ class SourceDecorator(Generic[T]):  # pragma: no cover
 
 @dataclass(frozen=True, kw_only=True)
 class SourcePreSet(Generic[T]):
-    removals: Iterable[T]
-    additions: Iterable[T]
-    changes: Iterable[T]
+    removals: Iterable[T] = field(default_factory=list)
+    additions: Iterable[T] = field(default_factory=list)
+    changes: Iterable[T] = field(default_factory=list)
 
     def absent(self) -> Iterable[T]:
         return self.removals
@@ -109,17 +109,28 @@ class SourceDiscriminator(Generic[T]):
     current: Iterable[T]
     latest: Iterable[T]
 
-    key_fn: KeyFn = AttributeKey("id")
+    key_fn: KeyFn | None = None
 
     def absent(self) -> Iterable[T]:
-        index = {self.key_fn(item) for item in self.latest}
+        index = {self.key_of(item) for item in self.latest}
 
-        return [item for item in self.current if self.key_fn(item) not in index]
+        return [item for item in self.current if self.key_of(item) not in index]
 
     def new(self) -> Iterable[T]:
-        index = {self.key_fn(item) for item in self.current}
+        index = {self.key_of(item) for item in self.current}
 
-        return [item for item in self.latest if self.key_fn(item) not in index]
+        return [item for item in self.latest if self.key_of(item) not in index]
 
     def updates(self) -> Iterable[T]:
-        return set(self.latest).difference(self.current)
+        index = {self.key_of(item) for item in self.current}
+
+        return [
+            item
+            for item in set(self.latest).difference(self.current)
+            if self.key_of(item) in index
+        ]
+
+    def key_of(self, item: Any) -> str:
+        key_fn = self.key_fn or AttributeKey("id")
+
+        return key_fn(item)

{apexdevkit-1.32.6 → apexdevkit-1.32.8}/apexdevkit/sync/sync.py

@@ -4,9 +4,11 @@ from collections.abc import Callable, Collection, Iterable
 from dataclasses import dataclass, field, replace
 from typing import Any, Generic, Self, TypeVar
 
+from apexdevkit.key_fn import AttributeKey, KeyFn
+
 from .observer import DefaultLog, ObservableSync
-from .source import EmptySource, Source
-from .target import NoTarget, Target
+from .source import EmptySource, Source, SourceDiscriminator, SourcePreSet
+from .target import IterableTarget, NoTarget, Target
 
 T = TypeVar("T")
 
@@ -18,6 +20,12 @@ class Sync(ObservableSync, Generic[T]):
 
     dry_run: bool = False
 
+    def purge(self) -> _Purge[T]:
+        return _Purge[T](sync=self)
+
+    def discriminate(self, latest: Iterable[T]) -> _Discriminate[T]:
+        return _Discriminate[T](sync=self, latest=latest)
+
     def and_target(self, value: Target[T]) -> Sync[T]:
         return self.with_target(value)
 
@@ -30,8 +38,8 @@ class Sync(ObservableSync, Generic[T]):
     def with_source(self, value: Source[T]) -> Sync[T]:
         return replace(self, source=value)
 
-    def with_log(self, using: Callable[[str], None]) -> Self:
-        return self.attach(DefaultLog(echo=using))
+    def with_log(self, using: Callable[[str], None], named: str = "items") -> Self:
+        return self.attach(DefaultLog(name=named, echo=using))
 
     def dry(self, *, when: bool = True) -> Sync[T]:
         return replace(self, dry_run=when)
@@ -74,6 +82,58 @@ class Sync(ObservableSync, Generic[T]):
         )
 
 
+@dataclass(frozen=True, kw_only=True)
+class _Purge(Generic[T]):
+    sync: Sync[T]
+
+    def target(self, value: IterableTarget[T]) -> _Purge[T]:
+        return _Purge[T](
+            sync=replace(
+                self.sync,
+                target=value,
+                source=SourcePreSet[T](removals=list(value)),
+            )
+        )
+
+    def __call__(self) -> None:
+        self.run()
+
+    def run(self) -> None:
+        self.sync.prune()
+
+
+@dataclass
+class _Discriminate(Generic[T]):
+    sync: Sync[T]
+    latest: Iterable[T]
+
+    current: Iterable[T] = field(default_factory=list)
+
+    def against(self, target: IterableTarget[T]) -> _Discriminate[T]:
+        return self.target(target).and_current(list(target))
+
+    def target(self, value: Target[T]) -> _Discriminate[T]:
+        return replace(self, sync=self.sync.with_target(value))
+
+    def and_current(self, value: Iterable[T]) -> _Discriminate[T]:
+        return replace(self, current=value)
+
+    def default(self) -> Sync[T]:
+        return self.using_attribute(name="id")
+
+    def using_attribute(self, name: str) -> Sync[T]:
+        return self.using(key_fn=AttributeKey(name))
+
+    def using(self, key_fn: KeyFn) -> Sync[T]:
+        return self.sync.with_source(
+            SourceDiscriminator(
+                current=self.current,
+                latest=self.latest,
+                key_fn=key_fn,
+            )
+        )
+
+
 @dataclass(frozen=True, kw_only=True)
 class SyncProbe:
     source: Collection[Any]
@@ -88,8 +148,12 @@ class SyncProbe:
 
         return self
 
-    def send(self, using: Callable[[Iterable[Any]], None]) -> SyncProbe:
+    def send(self, using: Callable[[Iterable[Any]], Iterable[Any] | None]) -> SyncProbe:
+        result = None
         if self.is_enabled and len(self.source) > 0:
-            using(self.source)
+            result = using(self.source)
+
+        if result:
+            list(result)
 
         return self

{apexdevkit-1.32.6 → apexdevkit-1.32.8}/apexdevkit/sync/target.py

@@ -2,30 +2,34 @@ from __future__ import annotations
 
 from collections.abc import Iterable
 from dataclasses import dataclass, field
-from typing import Any, Generic, Protocol, TypeVar
+from typing import Generic, Protocol, TypeVar
 
-T = TypeVar("T", contravariant=True)
+T = TypeVar("T")
 
 
 class Target(Protocol[T]):  # pragma: no cover
-    def prune(self, source: Iterable[T]) -> Any:
+    def prune(self, source: Iterable[T]) -> Iterable[T] | None:
         pass
 
-    def load(self, source: Iterable[T]) -> Any:
+    def load(self, source: Iterable[T]) -> Iterable[T] | None:
         pass
 
-    def renew(self, source: Iterable[T]) -> Any:
+    def renew(self, source: Iterable[T]) -> Iterable[T] | None:
         pass
 
 
+class IterableTarget(Target[T], Iterable[T], Protocol[T]):
+    pass
+
+
 class NoTarget(Generic[T]):  # pragma: no cover
-    def prune(self, source: Iterable[T]) -> Any:
+    def prune(self, source: Iterable[T]) -> Iterable[T] | None:
         pass
 
-    def load(self, source: Iterable[T]) -> Any:
+    def load(self, source: Iterable[T]) -> Iterable[T] | None:
         pass
 
-    def renew(self, source: Iterable[T]) -> Any:
+    def renew(self, source: Iterable[T]) -> Iterable[T] | None:
         pass
 
 
@@ -33,14 +37,14 @@ class NoTarget(Generic[T]):  # pragma: no cover
 class TargetDecorator(Generic[T]):
     inner: Target[T] = field(default_factory=NoTarget)
 
-    def prune(self, source: Iterable[T]) -> Any:
-        self.inner.prune(source)
+    def prune(self, source: Iterable[T]) -> Iterable[T] | None:
+        return self.inner.prune(source)
 
-    def load(self, source: Iterable[T]) -> Any:
-        self.inner.load(source)
+    def load(self, source: Iterable[T]) -> Iterable[T] | None:
+        return self.inner.load(source)
 
-    def renew(self, source: Iterable[T]) -> Any:
-        self.inner.renew(source)
+    def renew(self, source: Iterable[T]) -> Iterable[T] | None:
+        return self.inner.renew(source)
 
 
 class TargetFailing(Generic[T]):
@@ -69,17 +73,17 @@ class TargetFailing(Generic[T]):
 
 @dataclass(frozen=True, kw_only=True)
 class _FailOnPrune(TargetDecorator[T]):
-    def prune(self, source: Iterable[T]) -> Any:  # pragma: no cover
+    def prune(self, source: Iterable[T]) -> Iterable[T] | None:  # pragma: no cover
         raise RuntimeError(source)
 
 
 @dataclass(frozen=True, kw_only=True)
 class _FailOnLoad(TargetDecorator[T]):
-    def load(self, source: Iterable[T]) -> Any:  # pragma: no cover
+    def load(self, source: Iterable[T]) -> Iterable[T] | None:  # pragma: no cover
         raise RuntimeError(source)
 
 
 @dataclass(frozen=True, kw_only=True)
 class _FailOnUpdate(TargetDecorator[T]):
-    def renew(self, source: Iterable[T]) -> Any:  # pragma: no cover
+    def renew(self, source: Iterable[T]) -> Iterable[T] | None:  # pragma: no cover
         raise RuntimeError(source)

{apexdevkit-1.32.6 → apexdevkit-1.32.8}/pyproject.toml

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