| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
| from __future__ import annotations |
|
|
| from collections import namedtuple |
| from keyword import iskeyword |
| from textwrap import dedent, indent |
| from typing import Any, Callable, Iterable, TypeVar |
|
|
| T = TypeVar("T") |
|
|
|
|
| def is_variable(name): |
| """Returns True if `name` is a valid Python variable name and also not a keyword.""" |
| return name.isidentifier() and not iskeyword(name) |
|
|
|
|
| class ComponentStore: |
| """ |
| Represents a storage object for other objects (specifically functions) keyed to a name with a description. |
| |
| These objects act as global named places for storing components for objects parameterised by component names. |
| Typically this is functions although other objects can be added. Printing a component store will produce a |
| list of members along with their docstring information if present. |
| |
| Example: |
| |
| .. code-block:: python |
| |
| TestStore = ComponentStore("Test Store", "A test store for demo purposes") |
| |
| @TestStore.add_def("my_func_name", "Some description of your function") |
| def _my_func(a, b): |
| '''A description of your function here.''' |
| return a * b |
| |
| print(TestStore) # will print out name, description, and 'my_func_name' with the docstring |
| |
| func = TestStore["my_func_name"] |
| result = func(7, 6) |
| |
| """ |
|
|
| _Component = namedtuple("_Component", ("description", "value")) |
|
|
| def __init__(self, name: str, description: str) -> None: |
| self.components: dict[str, ComponentStore._Component] = {} |
| self.name: str = name |
| self.description: str = description |
|
|
| self.__doc__ = f"Component Store '{name}': {description}\n{self.__doc__ or ''}".strip() |
|
|
| def add(self, name: str, desc: str, value: T) -> T: |
| """Store the object `value` under the name `name` with description `desc`.""" |
| if not is_variable(name): |
| raise ValueError("Name of component must be valid Python identifier") |
|
|
| self.components[name] = self._Component(desc, value) |
| return value |
|
|
| def add_def(self, name: str, desc: str) -> Callable: |
| """Returns a decorator which stores the decorated function under `name` with description `desc`.""" |
|
|
| def deco(func): |
| """Decorator to add a function to a store.""" |
| return self.add(name, desc, func) |
|
|
| return deco |
|
|
| @property |
| def names(self) -> tuple[str, ...]: |
| """ |
| Produces all factory names. |
| """ |
|
|
| return tuple(self.components) |
|
|
| def __contains__(self, name: str) -> bool: |
| """Returns True if the given name is stored.""" |
| return name in self.components |
|
|
| def __len__(self) -> int: |
| """Returns the number of stored components.""" |
| return len(self.components) |
|
|
| def __iter__(self) -> Iterable: |
| """Yields name/component pairs.""" |
| for k, v in self.components.items(): |
| yield k, v.value |
|
|
| def __str__(self): |
| result = f"Component Store '{self.name}': {self.description}\nAvailable components:" |
| for k, v in self.components.items(): |
| result += f"\n* {k}:" |
|
|
| if hasattr(v.value, "__doc__") and v.value.__doc__: |
| doc = indent(dedent(v.value.__doc__.lstrip("\n").rstrip()), " ") |
| result += f"\n{doc}\n" |
| else: |
| result += f" {v.description}" |
|
|
| return result |
|
|
| def __getattr__(self, name: str) -> Any: |
| """Returns the stored object under the given name.""" |
| if name in self.components: |
| return self.components[name].value |
| else: |
| return self.__getattribute__(name) |
|
|
| def __getitem__(self, name: str) -> Any: |
| """Returns the stored object under the given name.""" |
| if name in self.components: |
| return self.components[name].value |
| else: |
| raise ValueError(f"Component '{name}' not found") |
|
|
