File size: 4,498 Bytes
b4d7ac8 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 |
# Copyright (c) MONAI Consortium
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
# http://www.apache.org/licenses/LICENSE-2.0
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
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")) # internal value pair
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")
|