pico-ioc 1.5.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

pico_ioc/builder.py

@@ -1,210 +0,0 @@
-from __future__ import annotations
-import inspect as _inspect
-import logging
-import os
-from typing import Any, Callable, Dict, Iterable, List, Optional, Sequence, Tuple
-from typing import get_origin, get_args, Annotated
-
-from .interceptors import MethodInterceptor, ContainerInterceptor
-from .container import PicoContainer, _is_compatible
-from .policy import apply_policy, _conditional_active
-from .plugins import PicoPlugin, run_plugin_hook
-from .scanner import scan_and_configure
-from .resolver import Resolver, _get_hints
-from . import _state
-from .config import ConfigRegistry
-
-class PicoContainerBuilder:
-    def __init__(self):
-        self._scan_plan: List[Tuple[Any, Optional[Callable[[str], bool]], Tuple[PicoPlugin, ...]]] = []
-        self._overrides: Dict[Any, Any] = {}
-        self._profiles: Optional[List[str]] = None
-        self._plugins: Tuple[PicoPlugin, ...] = ()
-        self._include_tags: Optional[set[str]] = None
-        self._exclude_tags: Optional[set[str]] = None
-        self._roots: Iterable[type] = ()
-        self._providers: Dict[Any, Dict] = {}
-        self._eager: bool = True
-        self._config_registry: ConfigRegistry | None = None
-
-    def with_config(self, registry: ConfigRegistry) -> "PicoContainerBuilder":
-        self._config_registry = registry
-        return self
-
-    def with_plugins(self, plugins: Tuple[PicoPlugin, ...]) -> "PicoContainerBuilder":
-        self._plugins = plugins or ()
-        return self
-
-    def with_profiles(self, profiles: Optional[List[str]]) -> "PicoContainerBuilder":
-        self._profiles = profiles
-        return self
-
-    def add_scan_package(self, package: Any, exclude: Optional[Callable[[str], bool]] = None) -> "PicoContainerBuilder":
-        self._scan_plan.append((package, exclude, self._plugins))
-        return self
-
-    def with_overrides(self, overrides: Optional[Dict[Any, Any]]) -> "PicoContainerBuilder":
-        self._overrides = overrides or {}
-        return self
-
-    def with_tag_filters(self, include: Optional[set[str]], exclude: Optional[set[str]]) -> "PicoContainerBuilder":
-        self._include_tags = include
-        self._exclude_tags = exclude
-        return self
-
-    def with_roots(self, roots: Iterable[type]) -> "PicoContainerBuilder":
-        self._roots = roots or ()
-        return self
-
-    def with_eager(self, eager: bool) -> "PicoContainerBuilder":
-        self._eager = bool(eager)
-        return self
-
-    def build(self) -> PicoContainer:
-        requested_profiles = _resolve_profiles(self._profiles)
-        container = PicoContainer(providers=self._providers)
-        container._active_profiles = tuple(requested_profiles)
-        setattr(container, "_config_registry", self._config_registry)
-        all_infras: list[tuple[type, dict]] = []
-        for pkg, exclude, scan_plugins in self._scan_plan:
-            with _state.scanning_flag():
-                c, f, infra_decls = scan_and_configure(pkg, container, exclude=exclude, plugins=scan_plugins)
-                logging.info("Scanned '%s' (components: %d, factories: %d)", getattr(pkg, "__name__", pkg), c, f)
-                all_infras.extend(infra_decls)
-        _run_infrastructure(container=container, infra_decls=all_infras, profiles=requested_profiles)
-        binder = container.binder()
-        if self._overrides:
-            _apply_overrides(container, self._overrides)
-        run_plugin_hook(self._plugins, "after_bind", container, binder)
-        run_plugin_hook(self._plugins, "before_eager", container, binder)
-        apply_policy(container, profiles=requested_profiles)
-        _filter_by_tags(container, self._include_tags, self._exclude_tags)
-        if self._roots:
-            _restrict_to_subgraph(container, self._roots, self._overrides)
-        run_plugin_hook(self._plugins, "after_ready", container, binder)
-        if self._eager:
-            container.eager_instantiate_all()
-        logging.info("Container configured and ready.")
-        return container
-
-def _resolve_profiles(profiles: Optional[List[str]]) -> List[str]:
-    if profiles is not None:
-        return list(profiles)
-    env_val = os.getenv("PICO_PROFILE", "")
-    return [p.strip() for p in env_val.split(",") if p.strip()]
-
-def _as_provider(val):
-    if isinstance(val, tuple) and len(val) == 2 and callable(val[0]) and isinstance(val[1], bool):
-        return val[0], val[1]
-    if callable(val):
-        return val, False
-    return (lambda v=val: v), False
-
-def _apply_overrides(container: PicoContainer, overrides: Dict[Any, Any]) -> None:
-    for key, val in overrides.items():
-        provider, lazy = _as_provider(val)
-        container.bind(key, provider, lazy=lazy)
-
-def _filter_by_tags(container: PicoContainer, include_tags: Optional[set[str]], exclude_tags: Optional[set[str]]) -> None:
-    if not include_tags and not exclude_tags:
-        return
-    def _tag_ok(meta: dict) -> bool:
-        tags = set(meta.get("tags", ()))
-        if include_tags and not tags.intersection(include_tags):
-            return False
-        if exclude_tags and tags.intersection(exclude_tags):
-            return False
-        return True
-    container._providers = {k: v for k, v in container._providers.items() if _tag_ok(v)}
-
-def _compute_allowed_subgraph(container: PicoContainer, roots: Iterable[type]) -> set:
-    allowed: set[Any] = set(roots)
-    stack = list(roots or ())
-    def _add_impls_for_base(base_t):
-        for prov_key, meta in container._providers.items():
-            cls = prov_key if isinstance(prov_key, type) else None
-            if cls is not None and _is_compatible(cls, base_t):
-                if prov_key not in allowed:
-                    allowed.add(prov_key)
-                    stack.append(prov_key)
-    while stack:
-        k = stack.pop()
-        allowed.add(k)
-        if isinstance(k, type):
-            _add_impls_for_base(k)
-        cls = k if isinstance(k, type) else None
-        if cls is None or not container.has(k):
-            continue
-        try:
-            sig = _inspect.signature(cls.__init__)
-            hints = _get_hints(cls.__init__, owner_cls=cls)
-        except Exception:
-            continue
-        for pname, param in sig.parameters.items():
-            if pname == "self":
-                continue
-            ann = hints.get(pname, param.annotation)
-            origin = get_origin(ann) or ann
-            if origin in (list, tuple):
-                inner = (get_args(ann) or (object,))[0]
-                if get_origin(inner) is Annotated:
-                    inner = (get_args(inner) or (object,))[0]
-                if isinstance(inner, type):
-                    if inner not in allowed:
-                        stack.append(inner)
-                continue
-            if isinstance(ann, type) and ann not in allowed:
-                stack.append(ann)
-            elif container.has(pname) and pname not in allowed:
-                stack.append(pname)
-    return allowed
-
-def _restrict_to_subgraph(container: PicoContainer, roots: Iterable[type], overrides: Optional[Dict[Any, Any]]) -> None:
-    allowed = _compute_allowed_subgraph(container, roots)
-    keep_keys: set[Any] = allowed | (set(overrides.keys()) if overrides else set())
-    container._providers = {k: v for k, v in container._providers.items() if k in keep_keys}
-
-def _run_infrastructure(*, container: PicoContainer, infra_decls: List[tuple[type, dict]], profiles: List[str]) -> None:
-    def _active(meta: dict) -> bool:
-        profs = tuple(meta.get("profiles", ())) or ()
-        if profs and (not profiles or not any(p in profs for p in profiles)):
-            return False
-        req_env = tuple(meta.get("require_env", ())) or ()
-        if req_env:
-            import os
-            if not all(os.getenv(k) not in (None, "") for k in req_env):
-                return False
-        pred = meta.get("predicate", None)
-        if callable(pred):
-            try:
-                if not bool(pred()):
-                    return False
-            except Exception:
-                return False
-        return True
-    from .resolver import Resolver
-    from .infra import Infra
-    resolver = Resolver(container)
-    active_infras: List[tuple[int, type]] = []
-    for cls, meta in infra_decls:
-        if not _active(meta):
-            continue
-        order = int(meta.get("order", 0))
-        active_infras.append((order, cls))
-    active_infras.sort(key=lambda t: (t[0], getattr(t[1], "__qualname__", "")))
-    for _ord, cls in active_infras:
-        try:
-            inst = resolver.create_instance(cls)
-        except Exception:
-            import logging
-            logging.exception("Failed to construct infrastructure %r", cls)
-            continue
-        infra = Infra(container=container, profiles=tuple(profiles))
-        fn = getattr(inst, "configure", None)
-        if callable(fn):
-            try:
-                fn(infra)
-            except Exception:
-                import logging
-                logging.exception("Infrastructure configure() failed for %r", cls)
-

pico_ioc/config.py

@@ -1,332 +0,0 @@
-# src/pico_ioc/config.py
-from __future__ import annotations
-
-import os, json, configparser, pathlib
-from dataclasses import is_dataclass, fields, MISSING
-from typing import Any, Callable, Dict, Iterable, Optional, Sequence, Tuple, Protocol
-
-# ---- Flags & metadata on classes / fields ----
-_CONFIG_FLAG = "_pico_is_config_component"
-_CONFIG_PREFIX = "_pico_config_prefix"
-_FIELD_META = "_pico_config_field_meta"  # dict: name -> FieldSpec
-
-# ---- Source protocol & implementations ----
-
-class ConfigSource(Protocol):
-    def get(self, key: str) -> Optional[str]: ...
-    def keys(self) -> Iterable[str]: ...
-
-class EnvSource:
-    def __init__(self, prefix: str = ""):
-        self.prefix = prefix or ""
-    def get(self, key: str) -> Optional[str]:
-        # try PREFIX+KEY first, then KEY
-        v = os.getenv(self.prefix + key)
-        if v is not None:
-            return v
-        return os.getenv(key)
-    def keys(self) -> Iterable[str]:
-        # best-effort; env keys only (without prefix expansion)
-        return os.environ.keys()
-
-class FileSource:
-    def __init__(self, path: os.PathLike[str] | str, optional: bool = False):
-        self.path = str(path)
-        self.optional = bool(optional)
-        self._cache: Dict[str, Any] = {}
-        self._load_once()
-
-    def _load_once(self):
-        p = pathlib.Path(self.path)
-        if not p.exists():
-            if self.optional:
-                self._cache = {}
-                return
-            raise FileNotFoundError(self.path)
-        text = p.read_text(encoding="utf-8")
-
-        # Try in order: JSON, INI, dotenv, YAML (if available)
-        # JSON
-        try:
-            data = json.loads(text)
-            self._cache = _flatten_obj(data)
-            return
-        except Exception:
-            pass
-        # INI
-        try:
-            cp = configparser.ConfigParser()
-            cp.read_string(text)
-            data = {s: dict(cp.items(s)) for s in cp.sections()}
-            # also root-level keys under DEFAULT
-            data.update(dict(cp.defaults()))
-            self._cache = _flatten_obj(data)
-            return
-        except Exception:
-            pass
-        # dotenv (simple KEY=VALUE per line)
-        try:
-            kv = {}
-            for line in text.splitlines():
-                line = line.strip()
-                if not line or line.startswith("#"): 
-                    continue
-                if "=" in line:
-                    k, v = line.split("=", 1)
-                    kv[k.strip()] = _strip_quotes(v.strip())
-            self._cache = _flatten_obj(kv)
-            if self._cache:
-                return
-        except Exception:
-            pass
-        # YAML if available
-        try:
-            import yaml  # type: ignore
-            data = yaml.safe_load(text) or {}
-            self._cache = _flatten_obj(data)
-            return
-        except Exception:
-            # if everything fails, fallback to empty (optional) or raise
-            if self.optional:
-                self._cache = {}
-                return
-            raise ValueError(f"Unrecognized file format: {self.path}")
-
-    def get(self, key: str) -> Optional[str]:
-        v = self._cache.get(key)
-        return None if v is None else str(v)
-
-    def keys(self) -> Iterable[str]:
-        return self._cache.keys()
-
-# ---- Field specs (overrides) ----
-
-class FieldSpec:
-    __slots__ = ("sources", "keys", "default", "path_is_dot")
-    def __init__(self, *, sources: Tuple[str, ...], keys: Tuple[str, ...], default: Any, path_is_dot: bool):
-        self.sources = sources
-        self.keys = keys
-        self.default = default
-        self.path_is_dot = path_is_dot  # true when keys are dotted-paths for structured files
-
-class _ValueSentinel:
-    def __getitem__(self, key_default: str | Tuple[str, Any], /):
-        if isinstance(key_default, tuple):
-            key, default = key_default
-        else:
-            key, default = key_default, MISSING
-        # default sources order env>file unless overridden in Value(...)
-        return _ValueFactory(key, default)
-Value = _ValueSentinel()
-
-class _ValueFactory:
-    def __init__(self, key: str, default: Any):
-        self.key = key
-        self.default = default
-    def __call__(self, *, sources: Tuple[str, ...] = ("env","file")):
-        return FieldSpec(sources=tuple(sources), keys=(self.key,), default=self.default, path_is_dot=False)
-
-class _EnvSentinel:
-    def __getitem__(self, key_default: str | Tuple[str, Any], /):
-        key, default = (key_default if isinstance(key_default, tuple) else (key_default, MISSING))
-        return FieldSpec(sources=("env",), keys=(key,), default=default, path_is_dot=False)
-Env = _EnvSentinel()
-
-class _FileSentinel:
-    def __getitem__(self, key_default: str | Tuple[str, Any], /):
-        key, default = (key_default if isinstance(key_default, tuple) else (key_default, MISSING))
-        return FieldSpec(sources=("file",), keys=(key,), default=default, path_is_dot=False)
-File = _FileSentinel()
-
-class _PathSentinel:
-    class _FilePath:
-        def __getitem__(self, key_default: str | Tuple[str, Any], /):
-            key, default = (key_default if isinstance(key_default, tuple) else (key_default, MISSING))
-            return FieldSpec(sources=("file",), keys=(key,), default=default, path_is_dot=True)
-    file = _FilePath()
-Path = _PathSentinel()
-
-# ---- Class decorator ----
-
-def config_component(*, prefix: str = ""):
-    def dec(cls):
-        setattr(cls, _CONFIG_FLAG, True)
-        setattr(cls, _CONFIG_PREFIX, prefix or "")
-        if not hasattr(cls, _FIELD_META):
-            setattr(cls, _FIELD_META, {})
-        return cls
-    return dec
-
-def is_config_component(cls: type) -> bool:
-    return bool(getattr(cls, _CONFIG_FLAG, False))
-
-# ---- Registry / resolution ----
-
-class ConfigRegistry:
-    """Holds ordered sources and provides typed resolution for @config_component classes."""
-    def __init__(self, sources: Sequence[ConfigSource]):
-        self.sources = tuple(sources or ())
-
-    def resolve(self, keys: Iterable[str]) -> Optional[str]:
-        # try each key across sources in order
-        for key in keys:
-            for src in self.sources:
-                v = src.get(key)
-                if v is not None:
-                    return v
-        return None
-
-def register_field_spec(cls: type, name: str, spec: FieldSpec) -> None:
-    meta: Dict[str, FieldSpec] = getattr(cls, _FIELD_META, None) or {}
-    meta[name] = spec
-    setattr(cls, _FIELD_META, meta)
-
-def build_component_instance(cls: type, registry: ConfigRegistry) -> Any:
-    prefix = getattr(cls, _CONFIG_PREFIX, "")
-    overrides: Dict[str, FieldSpec] = getattr(cls, _FIELD_META, {}) or {}
-
-    if is_dataclass(cls):
-        kwargs = {}
-        for f in fields(cls):
-            name = f.name
-            spec = overrides.get(name)
-            if spec:
-                val = _resolve_with_spec(spec, registry)
-            else:
-                # auto: PREFIX+NAME or NAME (env), NAME (file)
-                val = registry.resolve((prefix + name.upper(), name.upper()))
-                if val is None and f.default is not MISSING:
-                    val = f.default
-                elif val is None and f.default_factory is not MISSING:  # type: ignore
-                    val = f.default_factory()  # type: ignore
-            if val is None and f.default is MISSING and getattr(f, "default_factory", MISSING) is MISSING:  # type: ignore
-                raise NameError(f"Missing config for field {cls.__name__}.{name}")
-            kwargs[name] = _coerce_type(val, f.type)
-        return cls(**kwargs)
-
-    # Non-dataclass: inspect __init__ signature
-    import inspect
-    sig = inspect.signature(cls.__init__)
-    hints = _get_type_hints_safe(cls.__init__, owner=cls)
-    kwargs = {}
-    for pname, par in sig.parameters.items():
-        if pname == "self" or par.kind in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD):
-            continue
-        ann = hints.get(pname, par.annotation)
-        spec = overrides.get(pname)
-        if spec:
-            val = _resolve_with_spec(spec, registry)
-        else:
-            val = registry.resolve((prefix + pname.upper(), pname.upper()))
-            if val is None and par.default is not inspect._empty:
-                val = par.default
-        if val is None and par.default is inspect._empty:
-            raise NameError(f"Missing config for field {cls.__name__}.{pname}")
-        kwargs[pname] = _coerce_type(val, ann)
-    return cls(**kwargs)
-
-# ---- helpers ----
-
-def _resolve_with_spec(spec: FieldSpec, registry: ConfigRegistry) -> Any:
-    # respect spec.sources ordering, but try all keys for each source
-    for src_kind in spec.sources:
-        if src_kind == "env":
-            v = _resolve_from_sources(registry, spec.keys, predicate=lambda s: isinstance(s, EnvSource))
-        elif src_kind == "file":
-            if spec.path_is_dot:
-                v = _resolve_path_from_files(registry, spec.keys)
-            else:
-                v = _resolve_from_sources(registry, spec.keys, predicate=lambda s: isinstance(s, FileSource))
-        else:
-            v = None
-        if v is not None:
-            return v
-    return None if spec.default is MISSING else spec.default
-
-def _resolve_from_sources(registry: ConfigRegistry, keys: Tuple[str, ...], predicate: Callable[[ConfigSource], bool]) -> Optional[str]:
-    for key in keys:
-        for src in registry.sources:
-            if predicate(src):
-                v = src.get(key)
-                if v is not None:
-                    return v
-    return None
-
-def _resolve_path_from_files(registry: ConfigRegistry, dotted_keys: Tuple[str, ...]) -> Optional[str]:
-    for key in dotted_keys:
-        path = key.split(".")
-        for src in registry.sources:
-            if isinstance(src, FileSource):
-                # FileSource caches flattened dict already
-                v = src.get(key)
-                if v is not None:
-                    return v
-    return None
-
-def _flatten_obj(obj: Any, prefix: str = "") -> Dict[str, Any]:
-    out: Dict[str, Any] = {}
-    if isinstance(obj, dict):
-        for k, v in obj.items():
-            k2 = (prefix + "." + str(k)) if prefix else str(k)
-            out.update(_flatten_obj(v, k2))
-    elif isinstance(obj, (list, tuple)):
-        for i, v in enumerate(obj):
-            k2 = (prefix + "." + str(i)) if prefix else str(i)
-            out.update(_flatten_obj(v, k2))
-    else:
-        out[prefix] = obj
-        if "." in prefix:
-            # also expose leaf as KEY without dots if single-segment? no; keep dotted only
-            pass
-        # also expose top-level KEY without dots when no prefix used:
-        if prefix and "." not in prefix:
-            out[prefix] = obj
-    # Additionally mirror top-level simple keys as UPPERCASE for convenience
-    if prefix and "." not in prefix:
-        out[prefix.upper()] = obj
-    return out
-
-def _strip_quotes(s: str) -> str:
-    if (s.startswith('"') and s.endswith('"')) or (s.startswith("'") and s.endswith("'")):
-        return s[1:-1]
-    return s
-
-def _coerce_type(val: Any, ann: Any) -> Any:
-    if val is None:
-        return None
-    # strings from sources come as str; coerce to basic types
-    try:
-        from typing import get_origin, get_args
-        origin = get_origin(ann) or ann
-        if origin in (int,):
-            return int(val)
-        if origin in (float,):
-            return float(val)
-        if origin in (bool,):
-            s = str(val).strip().lower()
-            if s in ("1","true","yes","y","on"): return True
-            if s in ("0","false","no","n","off"): return False
-            return bool(val)
-    except Exception:
-        pass
-    return val
-
-def _get_type_hints_safe(fn, owner=None):
-    try:
-        import inspect
-        mod = inspect.getmodule(fn)
-        g = getattr(mod, "__dict__", {})
-        l = vars(owner) if owner is not None else None
-        from typing import get_type_hints
-        return get_type_hints(fn, globalns=g, localns=l, include_extras=True)
-    except Exception:
-        return {}
-
-# ---- Public API helpers to be imported by users ----
-
-__all__ = [
-    "config_component", "EnvSource", "FileSource",
-    "Env", "File", "Path", "Value",
-    "ConfigRegistry", "register_field_spec", "is_config_component",
-]
-

pico_ioc/decorators.py

@@ -1,120 +0,0 @@
-from __future__ import annotations
-import functools
-from typing import Any, Iterable, Optional, Callable, Tuple
-
-COMPONENT_FLAG = "_is_component"
-COMPONENT_KEY = "_component_key"
-COMPONENT_LAZY = "_component_lazy"
-
-FACTORY_FLAG = "_is_factory_component"
-PROVIDES_KEY = "_provides_name"
-PROVIDES_LAZY = "_pico_lazy"
-
-PLUGIN_FLAG = "_is_pico_plugin"
-QUALIFIERS_KEY = "_pico_qualifiers"
-
-COMPONENT_TAGS = "_pico_tags"
-PROVIDES_TAGS = "_pico_tags"
-
-ON_MISSING_META = "_pico_on_missing"
-PRIMARY_FLAG = "_pico_primary"
-CONDITIONAL_META = "_pico_conditional"
-
-INFRA_META = "__pico_infrastructure__"
-
-def factory_component(cls):
-    setattr(cls, FACTORY_FLAG, True)
-    return cls
-
-def component(cls=None, *, name: Any = None, lazy: bool = False, tags: Iterable[str] = ()):
-    def dec(c):
-        setattr(c, COMPONENT_FLAG, True)
-        setattr(c, COMPONENT_KEY, name if name is not None else c)
-        setattr(c, COMPONENT_LAZY, bool(lazy))
-        setattr(c, COMPONENT_TAGS, tuple(tags) if tags else ())
-        return c
-    return dec(cls) if cls else dec
-
-def provides(key: Any, *, lazy: bool = False, tags: Iterable[str] = ()):
-    def dec(fn):
-        @functools.wraps(fn)
-        def w(*a, **k):
-            return fn(*a, **k)
-        setattr(w, PROVIDES_KEY, key)
-        setattr(w, PROVIDES_LAZY, bool(lazy))
-        setattr(w, PROVIDES_TAGS, tuple(tags) if tags else ())
-        return w
-    return dec
-
-def plugin(cls):
-    setattr(cls, PLUGIN_FLAG, True)
-    return cls
-
-class Qualifier(str):
-    __slots__ = ()
-
-def qualifier(*qs: Qualifier):
-    def dec(cls):
-        current: Iterable[Qualifier] = getattr(cls, QUALIFIERS_KEY, ())
-        seen = set(current)
-        merged = list(current)
-        for q in qs:
-            if q not in seen:
-                merged.append(q)
-                seen.add(q)
-        setattr(cls, QUALIFIERS_KEY, tuple(merged))
-        return cls
-    return dec
-
-def on_missing(selector: object, *, priority: int = 0):
-    def dec(obj):
-        setattr(obj, ON_MISSING_META, {"selector": selector, "priority": int(priority)})
-        return obj
-    return dec
-
-def primary(obj):
-    setattr(obj, PRIMARY_FLAG, True)
-    return obj
-
-def conditional(
-    *,
-    profiles: Tuple[str, ...] = (),
-    require_env: Tuple[str, ...] = (),
-    predicate: Optional[Callable[[], bool]] = None,
-):
-    def dec(obj):
-        setattr(obj, CONDITIONAL_META, {
-            "profiles": tuple(profiles),
-            "require_env": tuple(require_env),
-            "predicate": predicate,
-        })
-        return obj
-    return dec
-
-def infrastructure(
-    _cls=None, *, order: int = 0,
-    profiles: Tuple[str, ...] = (),
-    require_env: Tuple[str, ...] = (),
-    predicate: Optional[Callable[[], bool]] = None,
-):
-    def dec(cls):
-        setattr(cls, INFRA_META, {
-            "order": int(order),
-            "profiles": tuple(profiles),
-            "require_env": tuple(require_env),
-            "predicate": predicate,
-        })
-        return cls
-    return dec if _cls is None else dec(_cls)
-
-__all__ = [
-    "component", "factory_component", "provides", "plugin",
-    "Qualifier", "qualifier",
-    "on_missing", "primary", "conditional", "infrastructure",
-    "COMPONENT_FLAG", "COMPONENT_KEY", "COMPONENT_LAZY",
-    "FACTORY_FLAG", "PROVIDES_KEY", "PROVIDES_LAZY",
-    "PLUGIN_FLAG", "QUALIFIERS_KEY", "COMPONENT_TAGS", "PROVIDES_TAGS",
-    "ON_MISSING_META", "PRIMARY_FLAG", "CONDITIONAL_META",
-    "INFRA_META",
-]
-