anydi 0.70.2__py3-none-any.whl → 0.72.0__py3-none-any.whl

anydi/_container.py

@@ -58,6 +58,7 @@ class Container:
 
         self._resources: dict[str, list[Any]] = defaultdict(list)
         self._aliases: dict[Any, Any] = {}  # alias_type → canonical_type
+        self._aliases_by_canonical: dict[Any, set[Any]] = defaultdict(set)
         self._singleton_context = InstanceContext()
         self._scoped_context: dict[str, ContextVar[InstanceContext]] = {}
 
@@ -405,12 +406,22 @@ class Container:
                 f"Alias `{type_repr(alias_type)}` is already registered "
                 f"for `{type_repr(self._aliases[alias_type])}`."
             )
+        if canonical_type not in self._providers:
+            raise ValueError(
+                f"Cannot create alias: provider for `{type_repr(canonical_type)}` "
+                "is not registered. Register the provider first."
+            )
         self._aliases[alias_type] = canonical_type
+        self._aliases_by_canonical[canonical_type].add(alias_type)
 
     def _resolve_alias(self, dependency_type: Any) -> Any:
         """Resolve an alias to its canonical type."""
         return self._aliases.get(dependency_type, dependency_type)
 
+    def get_aliases_for(self, canonical_type: Any, /) -> set[Any]:
+        """Get all aliases that point to the given canonical type."""
+        return self._aliases_by_canonical.get(canonical_type, set())
+
     def is_registered(self, dependency_type: Any, /) -> bool:
         """Check if a provider is registered for the specified dependency type."""
         canonical = self._resolve_alias(dependency_type)
@@ -722,20 +733,23 @@ class Container:
                 # Check if it's a @provided class
                 if inspect.isclass(dependency_type) and is_provided(dependency_type):
                     provided_scope = dependency_type.__provided__["scope"]
+                    from_context = dependency_type.__provided__.get(
+                        "from_context", False
+                    )
 
                     # Auto-register @provided class
                     dep_provider = self._register_provider(
                         dependency_type,
                         dependency_type,
                         provided_scope,
-                        False,
+                        from_context,
                         False,
                         None,
                     )
                     # Register aliases if specified
                     aliases = to_list(dependency_type.__provided__.get("alias"))
                     for alias_type in aliases:
-                        self._aliases[alias_type] = dependency_type
+                        self.alias(alias_type, dependency_type)
                     # Recursively ensure the @provided class is resolved
                     dep_provider = self._ensure_provider_resolved(
                         dep_provider, resolving
@@ -833,6 +847,9 @@ class Container:
             del self._providers[provider.dependency_type]
         if provider.is_resource:
             self._resources[provider.scope].remove(provider.dependency_type)
+        # Remove aliases pointing to this provider
+        for alias in self._aliases_by_canonical.pop(provider.dependency_type, set()):
+            self._aliases.pop(alias, None)
 
     # == Instance Resolution ==
 
@@ -1039,7 +1056,7 @@ class Container:
                         # Register aliases if specified
                         provided_meta = param_dependency_type.__provided__
                         for alias_type in to_list(provided_meta.get("alias")):
-                            self._aliases[alias_type] = param_dependency_type
+                            self.alias(alias_type, param_dependency_type)
                     elif param.has_default:
                         # Has default, can be missing
                         resolved_params.append(param)

anydi/_decorators.py

@@ -34,12 +34,22 @@ class ProvidedMetadata(TypedDict):
     from_context: NotRequired[bool]
 
 
+def _check_already_provided(cls: type) -> None:
+    """Check if class already has __provided__ defined directly on it."""
+    if "__provided__" in cls.__dict__:
+        raise TypeError(
+            f"Class `{cls.__name__}` already has `__provided__` defined. "
+            "Remove the duplicate scope decorator or manual `__provided__` attribute."
+        )
+
+
 def provided(
     *, scope: Scope, alias: Any = NOT_SET, from_context: bool = False
 ) -> Callable[[ClassT], ClassT]:
     """Decorator for marking a class as provided by AnyDI with a specific scope."""
 
     def decorator(cls: ClassT) -> ClassT:
+        _check_already_provided(cls)
         metadata: ProvidedMetadata = {"scope": scope}
         if alias is not NOT_SET:
             metadata["alias"] = alias
@@ -67,6 +77,7 @@ def singleton(
     """Decorator for marking a class as a singleton dependency."""
 
     def decorator(c: ClassT) -> ClassT:
+        _check_already_provided(c)
         metadata: ProvidedMetadata = {"scope": "singleton"}
         if alias is not NOT_SET:
             metadata["alias"] = alias
@@ -95,6 +106,7 @@ def transient(
     """Decorator for marking a class as a transient dependency."""
 
     def decorator(c: ClassT) -> ClassT:
+        _check_already_provided(c)
         metadata: ProvidedMetadata = {"scope": "transient"}
         if alias is not NOT_SET:
             metadata["alias"] = alias
@@ -127,6 +139,7 @@ def request(
     """Decorator for marking a class as a request-scoped dependency."""
 
     def decorator(c: ClassT) -> ClassT:
+        _check_already_provided(c)
         metadata: ProvidedMetadata = {"scope": "request"}
         if alias is not NOT_SET:
             metadata["alias"] = alias

anydi/_graph.py

@@ -21,11 +21,10 @@ class Graph:
 
     def _get_aliases_for(self, dependency_type: Any) -> list[str]:
         """Get list of alias names that point to a dependency type."""
-        aliases: list[str] = []
-        for alias, canonical in self._container.aliases.items():
-            if canonical == dependency_type:
-                aliases.append(type_repr(alias).rsplit(".", 1)[-1])
-        return aliases
+        return [
+            type_repr(alias).rsplit(".", 1)[-1]
+            for alias in self._container.get_aliases_for(dependency_type)
+        ]
 
     def draw(
         self,

anydi/_resolver.py

@@ -53,22 +53,20 @@ class Resolver:
     def add_override(self, dependency_type: Any, instance: Any) -> None:
         """Add an override for a type, its canonical type, and all aliases."""
         self._overrides[dependency_type] = instance
-        canonical = self._container.aliases.get(dependency_type)
-        if canonical is not None:
-            self._overrides[canonical] = instance
-        for alias, canon in self._container.aliases.items():
-            if canon == dependency_type:
-                self._overrides[alias] = instance
+        canonical_type = self._container.aliases.get(dependency_type)
+        if canonical_type is not None:
+            self._overrides[canonical_type] = instance
+        for alias in self._container.get_aliases_for(dependency_type):
+            self._overrides[alias] = instance
 
     def remove_override(self, dependency_type: Any) -> None:
         """Remove an override for a type, its canonical type, and all aliases."""
         self._overrides.pop(dependency_type, None)
-        canonical = self._container.aliases.get(dependency_type)
-        if canonical is not None:
-            self._overrides.pop(canonical, None)
-        for alias, canon in self._container.aliases.items():
-            if canon == dependency_type:
-                self._overrides.pop(alias, None)
+        canonical_type = self._container.aliases.get(dependency_type)
+        if canonical_type is not None:
+            self._overrides.pop(canonical_type, None)
+        for alias in self._container.get_aliases_for(dependency_type):
+            self._overrides.pop(alias, None)
 
     def clear_caches(self) -> None:
         """Clear all cached resolvers."""
@@ -103,7 +101,11 @@ class Resolver:
         for param in provider.parameters:
             if param.provider is not None:
                 # Look up the current provider to handle overrides
-                current_provider = self._container.providers.get(param.dependency_type)
+                # Resolve alias to canonical type if needed
+                canonical_type = self._container.aliases.get(
+                    param.dependency_type, param.dependency_type
+                )
+                current_provider = self._container.providers.get(canonical_type)
                 if current_provider is not None:
                     self.compile(current_provider, is_async=is_async)
                 else:
@@ -117,10 +119,9 @@ class Resolver:
         # Store the compiled functions in the cache
         cache[provider.dependency_type] = compiled
 
-        # Also store under all aliases that point to this type
-        for alias, canonical in self._container.aliases.items():
-            if canonical == provider.dependency_type:
-                cache[alias] = compiled
+        # Also store under aliases that point to this canonical type
+        for alias in self._container.get_aliases_for(provider.dependency_type):
+            cache[alias] = compiled
 
         return compiled
 
@@ -198,7 +199,11 @@ class Resolver:
 
             if param.provider is not None:
                 # Look up the current provider from the container to handle overrides
-                current_provider = self._container.providers.get(param.dependency_type)
+                # Resolve alias to canonical type if needed
+                canonical_type = self._container.aliases.get(
+                    param.dependency_type, param.dependency_type
+                )
+                current_provider = self._container.providers.get(canonical_type)
                 if current_provider is not None:
                     compiled = cache.get(current_provider.dependency_type)
                 else:

anydi/_scanner.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import importlib
 import inspect
 import pkgutil
-from collections.abc import Callable, Iterable, Iterator
+from collections.abc import Iterable, Iterator
 from dataclasses import dataclass
 from types import ModuleType
 from typing import TYPE_CHECKING, Any
@@ -30,8 +30,11 @@ class ScannedDependency:
 
 
 class Scanner:
+    _scanning_packages: set[str] = set()
+
     def __init__(self, container: Container) -> None:
         self._container = container
+        self._importing_modules: set[str] = set()
 
     def scan(
         self,
@@ -41,21 +44,75 @@ class Scanner:
         tags: Iterable[str] | None = None,
         ignore: PackageOrIterable | None = None,
     ) -> None:
-        """Scan packages or modules for decorated members and inject dependencies."""
+        """Scan packages or modules for decorated members and inject dependencies.
+
+        Supports relative package paths (like Python's relative imports):
+        - "." scans the caller's package
+        - ".submodule" scans a submodule of the caller's package
+        - ".." scans the parent package
+        - "..sibling" scans a sibling package
+        """
+        if isinstance(packages, (ModuleType, str)):
+            packages = [packages]
+
+        # Resolve relative package paths
+        caller_package = self._get_caller_package(packages, ignore)
+        packages = self._resolve_relative_packages(packages, caller_package)
+        ignore = self._resolve_relative_packages(ignore, caller_package)
+
+        pkg_names = {p if isinstance(p, str) else p.__name__ for p in packages}
+        overlap = pkg_names & Scanner._scanning_packages
+        if overlap:
+            raise RuntimeError(
+                f"Circular import detected: scan() called recursively!\n\n"
+                f"Already scanning packages: {', '.join(sorted(overlap))}\n\n"
+                "This happens when a scanned module triggers container creation "
+                "(e.g., via lazy proxy).\n\n"
+                "Solutions:\n"
+                "- Add the problematic module to scan() ignore list\n"
+                "- Move container imports inside functions (lazy import)\n"
+                "- Avoid lazy container initialization in scanned modules"
+            )
+
+        Scanner._scanning_packages.update(pkg_names)
+        try:
+            self._do_scan(packages, tags=tags, ignore=ignore)
+        finally:
+            Scanner._scanning_packages -= pkg_names
+
+    def _do_scan(  # noqa: C901
+        self,
+        packages: PackageOrIterable,
+        *,
+        tags: Iterable[str] | None = None,
+        ignore: PackageOrIterable | None = None,
+    ) -> None:
+        """Internal scan implementation."""
         if isinstance(packages, (ModuleType, str)):
             packages = [packages]
 
-        tags_list = list(tags) if tags else []
+        tags_set: set[str] = set(tags) if tags else set()
         ignore_prefixes = self._normalize_ignore(ignore)
         provided_classes: list[type[Provided]] = []
         injectable_dependencies: list[ScannedDependency] = []
 
         # Single pass: collect both @provided classes and @injectable functions
         for module in self._iter_modules(packages, ignore_prefixes=ignore_prefixes):
-            provided_classes.extend(self._scan_module_for_provided(module))
-            injectable_dependencies.extend(
-                self._scan_module_for_injectable(module, tags=tags_list)
-            )
+            module_name = module.__name__
+            for name, member in vars(module).items():
+                if name.startswith("_"):
+                    continue
+                if getattr(member, "__module__", None) != module_name:
+                    continue
+
+                if inspect.isclass(member) and is_provided(member):
+                    provided_classes.append(member)
+                elif callable(member) and is_injectable(member):
+                    member_tags = set(member.__injectable__["tags"] or ())
+                    if not tags_set or (tags_set & member_tags):
+                        injectable_dependencies.append(
+                            ScannedDependency(member=member, module=module)
+                        )
 
         # First: register @provided classes
         for cls in provided_classes:
@@ -74,33 +131,124 @@ class Scanner:
             decorated = self._container.inject()(dependency.member)
             setattr(dependency.module, dependency.member.__name__, decorated)
 
-    def _normalize_ignore(self, ignore: PackageOrIterable | None) -> list[str]:
-        """Normalize ignore parameter to a list of module name prefixes."""
-        if ignore is None:
+    def _has_relative_packages(self, *package_lists: PackageOrIterable | None) -> bool:
+        """Check if any package list contains relative paths."""
+        for packages in package_lists:
+            if packages is None:
+                continue
+            if isinstance(packages, str):
+                if packages.startswith("."):
+                    return True
+            elif isinstance(packages, ModuleType):
+                continue
+            else:
+                for p in packages:
+                    if isinstance(p, str) and p.startswith("."):
+                        return True
+        return False
+
+    def _get_caller_package(
+        self,
+        packages: Iterable[Package],
+        ignore: PackageOrIterable | None,
+    ) -> str | None:
+        """Get the package name of the module that called scan()."""
+        if not self._has_relative_packages(packages, ignore):
+            return None
+
+        frame = inspect.currentframe()
+        try:
+            while frame is not None:
+                frame = frame.f_back
+                if frame is None:
+                    break
+                module_name = frame.f_globals.get("__name__")
+                if module_name and not module_name.startswith("anydi"):
+                    # Return package portion (remove module name if present)
+                    if "." in module_name:
+                        return module_name.rsplit(".", 1)[0]
+                    return module_name
+        finally:
+            del frame
+
+        raise ValueError(
+            "Cannot use relative package paths: unable to determine caller package. "
+            "Use absolute package names instead."
+        )
+
+    def _resolve_relative_name(self, relative_name: str, base_package: str) -> str:
+        """Resolve a relative package name to absolute."""
+        num_dots = len(relative_name) - len(relative_name.lstrip("."))
+        remainder = relative_name[num_dots:]
+
+        package_parts = base_package.split(".")
+
+        # Navigate up for parent references (..)
+        if num_dots > 1:
+            levels_up = num_dots - 1
+            if levels_up >= len(package_parts):
+                raise ValueError(
+                    f"Cannot resolve '{relative_name}': "
+                    f"too many parent levels for base package '{base_package}'"
+                )
+            package_parts = package_parts[:-levels_up]
+
+        if remainder:
+            return ".".join(package_parts) + "." + remainder
+        return ".".join(package_parts)
+
+    def _resolve_relative_packages(
+        self,
+        packages: PackageOrIterable | None,
+        caller_package: str | None,
+    ) -> list[Package]:
+        """Resolve relative package names to absolute names."""
+        if packages is None:
             return []
 
+        if isinstance(packages, (ModuleType, str)):
+            packages = [packages]
+
+        resolved: list[Package] = []
+        for package in packages:
+            if isinstance(package, ModuleType):
+                resolved.append(package)
+            elif not package.startswith("."):
+                resolved.append(package)
+            else:
+                if caller_package is None:
+                    raise ValueError(
+                        "Cannot use relative package paths: "
+                        "unable to determine caller package. "
+                        "Use absolute package names instead."
+                    )
+                resolved.append(self._resolve_relative_name(package, caller_package))
+
+        return resolved
+
+    def _normalize_ignore(self, ignore: PackageOrIterable | None) -> tuple[str, ...]:
+        """Normalize ignore parameter to a tuple of module name prefixes."""
+        if ignore is None:
+            return ()
+
         if isinstance(ignore, (ModuleType, str)):
             ignore = [ignore]
 
         prefixes: list[str] = []
         for item in ignore:
-            if isinstance(item, ModuleType):
-                prefixes.append(item.__name__)
-            else:
-                prefixes.append(item)
-        return prefixes
+            name = item.__name__ if isinstance(item, ModuleType) else item
+            prefixes.append(name)
+            prefixes.append(name + ".")  # For startswith check
+        return tuple(prefixes)
 
     def _should_ignore_module(
-        self, module_name: str, ignore_prefixes: list[str]
+        self, module_name: str, ignore_prefixes: tuple[str, ...]
     ) -> bool:
         """Check if a module should be ignored based on ignore prefixes."""
-        for prefix in ignore_prefixes:
-            if module_name == prefix or module_name.startswith(prefix + "."):
-                return True
-        return False
+        return module_name.startswith(ignore_prefixes) if ignore_prefixes else False
 
     def _iter_modules(
-        self, packages: Iterable[Package], *, ignore_prefixes: list[str]
+        self, packages: Iterable[Package], *, ignore_prefixes: tuple[str, ...]
     ) -> Iterator[ModuleType]:
         """Iterate over all modules in the given packages."""
         for package in packages:
@@ -118,43 +266,33 @@ class Scanner:
                 package.__path__, prefix=package.__name__ + "."
             ):
                 if not self._should_ignore_module(module_info.name, ignore_prefixes):
-                    yield importlib.import_module(module_info.name)
-
-    def _scan_module_for_provided(self, module: ModuleType) -> list[type[Provided]]:
-        """Scan a module for @provided classes."""
-        provided_classes: list[type[Provided]] = []
-
-        for _, member in inspect.getmembers(module, predicate=inspect.isclass):
-            if getattr(member, "__module__", None) != module.__name__:
-                continue
-
-            if is_provided(member):
-                provided_classes.append(member)
-
-        return provided_classes
+                    yield from self._import_module_with_tracking(module_info.name)
 
-    def _scan_module_for_injectable(
-        self, module: ModuleType, *, tags: list[str]
-    ) -> list[ScannedDependency]:
-        """Scan a module for @injectable functions."""
-        dependencies: list[ScannedDependency] = []
-
-        for _, member in inspect.getmembers(module, predicate=callable):
-            if getattr(member, "__module__", None) != module.__name__:
-                continue
-
-            if self._should_include_member(member, tags=tags):
-                dependencies.append(ScannedDependency(member=member, module=module))
-
-        return dependencies
-
-    @staticmethod
-    def _should_include_member(member: Callable[..., Any], *, tags: list[str]) -> bool:
-        """Determine if a member should be included based on tags or marker defaults."""
-        if is_injectable(member):
-            member_tags = set(member.__injectable__["tags"] or [])
-            if tags:
-                return bool(set(tags) & member_tags)
-            return True  # No tags passed → include all injectables
+    def _import_module_with_tracking(self, module_name: str) -> Iterator[ModuleType]:
+        """Import a module while tracking for circular imports."""
+        # Check if we're already importing this module (circular import)
+        if module_name in self._importing_modules:
+            import_chain = " -> ".join(sorted(self._importing_modules))
+            raise RuntimeError(
+                f"Circular import detected during container scanning!\n"
+                f"Module '{module_name}' is being imported while already "
+                f"in the import chain.\n"
+                f"Import chain: {import_chain} -> {module_name}\n\n"
+                f"This usually happens when:\n"
+                f"1. A scanned module imports the container at module level\n"
+                f"2. The container creation triggers scanning\n"
+                f"3. Scanning tries to import the module again\n\n"
+                f"Solutions:\n"
+                f"- Add '{module_name}' to the ignore list\n"
+                f"- Move container imports inside functions (lazy import)\n"
+                f"- Check for modules importing the container module"
+            )
 
-        return False
+        # Track that we're importing this module
+        self._importing_modules.add(module_name)
+        try:
+            module = importlib.import_module(module_name)
+            yield module
+        finally:
+            # Always cleanup, even if import fails
+            self._importing_modules.discard(module_name)

anydi/ext/typer.py

@@ -97,8 +97,10 @@ def _process_callback(callback: Callable[..., Any], container: Container) -> Any
         processed_parameter = container._injector.unwrap_parameter(parameter)
         if should_inject:
             injected_param_names.add(parameter.name)
+            # Resolve alias to canonical type if needed
+            canonical_type = container.aliases.get(dependency_type, dependency_type)
             try:
-                scopes.add(container.providers[dependency_type].scope)
+                scopes.add(container.providers[canonical_type].scope)
             except KeyError:
                 if inspect.isclass(dependency_type) and is_provided(dependency_type):
                     scopes.add(dependency_type.__provided__["scope"])

{anydi-0.70.2.dist-info → anydi-0.72.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: anydi
-Version: 0.70.2
+Version: 0.72.0
 Summary: Dependency Injection library
 Keywords: dependency injection,dependencies,di,async,asyncio,application
 Author: Anton Ruhlov

{anydi-0.70.2.dist-info → anydi-0.72.0.dist-info}/RECORD

@@ -1,16 +1,16 @@
 anydi/__init__.py,sha256=KFX8OthKXwBuYDPCV61t-044DpJ88tAOzIxeUWRC5OA,633
 anydi/_async_lock.py,sha256=3dwZr0KthXFYha0XKMyXf8jMmGb1lYoNC0O5w29V9ic,1104
 anydi/_cli.py,sha256=0BhNvWPyuIGzUkDELIBm_nsEMWk7MtLi3oTvgXj5oko,2072
-anydi/_container.py,sha256=0Mhper1g4O4cmAaGOeXAkcfMeJhoJqcYTowhNKPQhhs,49237
+anydi/_container.py,sha256=91phEt-x5jEXlCX0BsLqQz-_V5XzHIvJviqv_odvFBc,50146
 anydi/_context.py,sha256=ZQWxtBXWkrMsCk_L7K_A7-e09v5Mv9HApPH3LZ6ZF9k,3648
-anydi/_decorators.py,sha256=27AQBzp_P_ajO_bRk1ybgwuxTy9PMWGMJmfBvjriJ-8,5435
-anydi/_graph.py,sha256=WN_N1nNNPp74YU1mqxM-dJlf0rWF9ooGNTIv87DJpKI,8619
+anydi/_decorators.py,sha256=Ra9Rg42lzbMGsVXFp_LSefjBNLMt1Nrdnq5KvVL_8lg,5937
+anydi/_graph.py,sha256=jwQHnuypchiJxohVjr7gHNab5-0CTUN2PLg_w05b0zw,8535
 anydi/_injector.py,sha256=RvnPEYOgkg-WOIW1ItvVsoAZaSC9wmCnWQrfXad_86A,4507
 anydi/_marker.py,sha256=yXSPbIVU-X-jMSawtCHWFMKke5VpWMiBRZlEH8PlUqE,3373
 anydi/_module.py,sha256=2kN5uEXLd2Dsc58gz5IWK43wJewr_QgIVGSO3iWp798,2609
 anydi/_provider.py,sha256=1hUah9xmAVEVfE1AOFraodJiyfgRhO05egWq1aeRZCA,2923
-anydi/_resolver.py,sha256=xpBgFhUTMdHeNjqmUfOZMU5J8PviVkc5q_ckgwrdAhs,33603
-anydi/_scanner.py,sha256=gLs6Gdv12VVgT-J1vfCVOQ515drGtZQ4QNI8Bs0fqE0,5916
+anydi/_resolver.py,sha256=czKDOEiKldFmBbeCZVXiqDPctAXW9RNmoCIoaF5YF9c,33922
+anydi/_scanner.py,sha256=Jmt2sXUcTij_lplFuEqqN2V_sP-MWQTPfsLSBKyLFVg,11826
 anydi/_types.py,sha256=QQY_WG6-e2VuqH2AqrStiM1bg2ACQMHaPtdOQVsDimU,1439
 anydi/ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 anydi/ext/django/__init__.py,sha256=Ve8lncLU9dPY_Vjt4zihPgsSxwAtFHACn0XvBM5JG8k,367
@@ -20,10 +20,10 @@ anydi/ext/pydantic_settings.py,sha256=y6uz0MiLtqPvRO186bIdRZVQfezLvRUfT3KvvB5fCW
 anydi/ext/pytest_plugin.py,sha256=rLZ6NZUYklSg1rYx0FPdSvVmEY-faZTYqEY5qUWqZXk,7336
 anydi/ext/starlette/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 anydi/ext/starlette/middleware.py,sha256=n_JJ7BcG2Mg2M5HwM_SBboxZ-mnnD6WWJn4khq7Bgbs,1860
-anydi/ext/typer.py,sha256=c7HapXQfKhnLJQcHNncJAGd8jZ3crX5it6-MRCJjyPM,6268
+anydi/ext/typer.py,sha256=l35PIjEscs9cD5YuXxxW96DLiFa1RDPoXh-p_5HmghY,6408
 anydi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 anydi/testing.py,sha256=cHg3mMScZbEep9smRqSNQ81BZMQOkyugHe8TvKdPnEg,1347
-anydi-0.70.2.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
-anydi-0.70.2.dist-info/entry_points.txt,sha256=oDl_yEX12KlWcDzsZBTg85GG1Jl1rpiYOG4C7EJvebs,87
-anydi-0.70.2.dist-info/METADATA,sha256=kDJCV_O9IcrhLR-X4gWYTHM0h5AvO8H_q53p9VBe1Ew,8061
-anydi-0.70.2.dist-info/RECORD,,
+anydi-0.72.0.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
+anydi-0.72.0.dist-info/entry_points.txt,sha256=oDl_yEX12KlWcDzsZBTg85GG1Jl1rpiYOG4C7EJvebs,87
+anydi-0.72.0.dist-info/METADATA,sha256=-l5YAQo5EC_t0c2S2KOdf1n2cSQDyldWWbIOU2a-EOE,8061
+anydi-0.72.0.dist-info/RECORD,,