apexdevkit 1.32.1__tar.gz → 1.32.3__tar.gz

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

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

{apexdevkit-1.32.1 → apexdevkit-1.32.3}/apexdevkit/sync/source.py

@@ -6,10 +6,10 @@ from typing import Generic, Protocol, TypeVar
 
 from apexdevkit.key_fn import AttributeKey, KeyFn
 
-T = TypeVar("T")
+T = TypeVar("T", covariant=True)
 
 
-class Source(Protocol):  # pragma: no cover
+class Source(Protocol[T]):  # pragma: no cover
     def absent(self) -> Iterable[T]:
         pass
 
@@ -21,7 +21,7 @@ class Source(Protocol):  # pragma: no cover
 
 
 @dataclass(frozen=True)
-class EmptySource:  # pragma: no cover
+class EmptySource(Generic[T]):  # pragma: no cover
     def absent(self) -> Iterable[T]:
         return []
 
@@ -33,8 +33,8 @@ class EmptySource:  # pragma: no cover
 
 
 @dataclass(frozen=True, kw_only=True)
-class SourceDecorator:  # pragma: no cover
-    inner: Source = field(default_factory=EmptySource)
+class SourceDecorator(Generic[T]):  # pragma: no cover
+    inner: Source[T] = field(default_factory=EmptySource)
 
     def absent(self) -> Iterable[T]:
         return self.inner.absent()
@@ -62,9 +62,9 @@ class SourcePreSet(Generic[T]):
         return self.changes
 
 
-class SourceFailing:
+class SourceFailing(Generic[T]):
     @staticmethod
-    def on_everything(using: Source | None = None) -> Source:
+    def on_everything(using: Source[T] | None = None) -> Source[T]:
         return SourceFailing.on_absent(
             using=SourceFailing.on_new(
                 using=SourceFailing.on_update(
@@ -74,31 +74,34 @@ class SourceFailing:
         )
 
     @staticmethod
-    def on_absent(using: Source | None = None) -> Source:
-        return SourceFailing.OnAbsent(inner=using or EmptySource())
+    def on_absent(using: Source[T] | None = None) -> Source[T]:
+        return _FailOnAbsent(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[T] | None = None) -> Source[T]:
+        return _FailOnNew(inner=using or EmptySource())
 
     @staticmethod
-    def on_new(using: Source | None = None) -> Source:
-        return SourceFailing.OnNew(inner=using or EmptySource())
+    def on_update(using: Source[T] | None = None) -> Source[T]:
+        return _FailOnUpdate(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 _FailOnAbsent(SourceDecorator[T]):
+    def absent(self) -> Iterable[T]:  # pragma: no cover
+        raise RuntimeError("Should not request absent!")
+
 
-    @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 _FailOnNew(SourceDecorator[T]):
+    def new(self) -> Iterable[T]:  # pragma: no cover
+        raise RuntimeError("Should not request new!")
+
+
+@dataclass(frozen=True, kw_only=True)
+class _FailOnUpdate(SourceDecorator[T]):
+    def updates(self) -> Iterable[T]:  # pragma: no cover
+        raise RuntimeError("Should not request updates!")
 
 
 @dataclass(frozen=True, kw_only=True)

{apexdevkit-1.32.1 → apexdevkit-1.32.3}/apexdevkit/sync/sync.py

@@ -1,24 +1,41 @@
 from __future__ import annotations
 
 from collections.abc import Callable, Collection, Iterable
-from dataclasses import dataclass
-from typing import Any, Self
+from dataclasses import dataclass, field, replace
+from typing import Any, Generic, Self, TypeVar
 
 from .observer import DefaultLog, ObservableSync
-from .source import Source
-from .target import Target
+from .source import EmptySource, Source
+from .target import NoTarget, Target
+
+T = TypeVar("T")
 
 
 @dataclass(frozen=True, kw_only=True)
-class Sync(ObservableSync):
-    source: Source
-    target: Target
+class Sync(ObservableSync, Generic[T]):
+    source: Source[T] = field(default_factory=EmptySource)
+    target: Target[T] = field(default_factory=NoTarget)
 
     dry_run: bool = False
 
+    def and_target(self, value: Target[T]) -> Sync[T]:
+        return self.with_target(value)
+
+    def with_target(self, value: Target[T]) -> Sync[T]:
+        return replace(self, target=value)
+
+    def and_source(self, value: Source[T]) -> Sync[T]:
+        return self.with_source(value)
+
+    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 dry(self, *, when: bool = True) -> Sync[T]:
+        return replace(self, dry_run=when)
+
     def run(self, prune: bool = True, load: bool = True, update: bool = True) -> None:
         if prune:
             self.prune()

apexdevkit-1.32.3/apexdevkit/sync/target.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+from collections.abc import Iterable
+from dataclasses import dataclass, field
+from typing import Any, Generic, Protocol, TypeVar
+
+T = TypeVar("T", contravariant=True)
+
+
+class Target(Protocol[T]):  # pragma: no cover
+    def prune(self, source: Iterable[T]) -> Any:
+        pass
+
+    def load(self, source: Iterable[T]) -> Any:
+        pass
+
+    def renew(self, source: Iterable[T]) -> Any:
+        pass
+
+
+class NoTarget(Generic[T]):  # pragma: no cover
+    def prune(self, source: Iterable[T]) -> Any:
+        pass
+
+    def load(self, source: Iterable[T]) -> Any:
+        pass
+
+    def renew(self, source: Iterable[T]) -> Any:
+        pass
+
+
+@dataclass(frozen=True, kw_only=True)
+class TargetDecorator(Generic[T]):
+    inner: Target[T] = field(default_factory=NoTarget)
+
+    def prune(self, source: Iterable[T]) -> Any:
+        self.inner.prune(source)
+
+    def load(self, source: Iterable[T]) -> Any:
+        self.inner.load(source)
+
+    def renew(self, source: Iterable[T]) -> Any:
+        self.inner.renew(source)
+
+
+class TargetFailing(Generic[T]):
+    @staticmethod
+    def on_everything(using: Target[T] | None = None) -> Target[T]:
+        return TargetFailing.on_prune(
+            using=TargetFailing.on_load(
+                using=TargetFailing.on_update(
+                    using=using or NoTarget(),
+                ),
+            ),
+        )
+
+    @staticmethod
+    def on_prune(using: Target[T] | None = None) -> Target[T]:
+        return _FailOnPrune(inner=using or NoTarget())
+
+    @staticmethod
+    def on_load(using: Target[T] | None = None) -> Target[T]:
+        return _FailOnLoad(inner=using or NoTarget())
+
+    @staticmethod
+    def on_update(using: Target[T] | None = None) -> Target[T]:
+        return _FailOnUpdate(inner=using or NoTarget())
+
+
+@dataclass(frozen=True, kw_only=True)
+class _FailOnPrune(TargetDecorator[T]):
+    def prune(self, source: Iterable[T]) -> Any:  # 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
+        raise RuntimeError(source)
+
+
+@dataclass(frozen=True, kw_only=True)
+class _FailOnUpdate(TargetDecorator[T]):
+    def renew(self, source: Iterable[T]) -> Any:  # pragma: no cover
+        raise RuntimeError(source)

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

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

apexdevkit-1.32.1/apexdevkit/sync/target.py

@@ -1,82 +0,0 @@
-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)