11118854255

Committed 01 Oct 2024 04:51AM UTC coverage: 90.379% (+0.3%) from 90.097%

Build # 11118854255

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #14 from p2p-ld/roll-down

roll down parent inheritance recursively

Run Details

1323 of 1451 branches covered (91.18%)

Branch coverage included in aggregate %.

216 of 230 new or added lines in 15 files covered. (93.91%)

2 existing lines in 2 files now uncovered.

2425 of 2696 relevant lines covered (89.95%)

2.69 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

99.53

/nwb_linkml/src/nwb_linkml/generators/pydantic.py

"""
Subclass of :class:`linkml.generators.PydanticGenerator`
customized to support NWB models.

See class and module docstrings for details :)
"""

import re
from dataclasses import dataclass, field
from pathlib import Path
from types import ModuleType
from typing import Callable, ClassVar, Dict, List, Optional, Tuple

from linkml.generators import PydanticGenerator
from linkml.generators.pydanticgen.array import ArrayRepresentation, NumpydanticArray
from linkml.generators.pydanticgen.build import ClassResult, SlotResult
from linkml.generators.pydanticgen.pydanticgen import SplitMode
from linkml.generators.pydanticgen.template import Import, Imports, ObjectImport, PydanticModule
from linkml_runtime.linkml_model.meta import (
    ArrayExpression,
    SchemaDefinition,
    SlotDefinition,
    SlotDefinitionName,
)
from linkml_runtime.utils.formatutils import remove_empty_items
from linkml_runtime.utils.schemaview import SchemaView

from nwb_linkml.includes.base import (
    BASEMODEL_CAST_WITH_VALUE,
    BASEMODEL_COERCE_CHILD,
    BASEMODEL_COERCE_VALUE,
    BASEMODEL_EXTRA_TO_VALUE,
    BASEMODEL_GETITEM,
)
from nwb_linkml.includes.hdmf import (
    DYNAMIC_TABLE_IMPORTS,
    DYNAMIC_TABLE_INJECTS,
    TSRVD_IMPORTS,
    TSRVD_INJECTS,
)
from nwb_linkml.includes.types import ModelTypeString, NamedImports, NamedString, _get_name

OPTIONAL_PATTERN = re.compile(r"Optional\[(.*)\]")


@dataclass
class NWBPydanticGenerator(PydanticGenerator):
    """
    Subclass of pydantic generator, custom behavior is in overridden lifecycle methods :)
    """

    injected_fields: List[str] = (
        (
            'hdf5_path: Optional[str] = Field(None, description="The absolute path that this object'
            ' is stored in an NWB file")'
        ),
        'object_id: Optional[str] = Field(None, description="Unique UUID for each object")',
        BASEMODEL_GETITEM,
        BASEMODEL_COERCE_VALUE,
        BASEMODEL_CAST_WITH_VALUE,
        BASEMODEL_COERCE_CHILD,
        BASEMODEL_EXTRA_TO_VALUE,
    )
    split: bool = True
    imports: list[Import] = field(
        default_factory=lambda: [
            Import(module="numpy", alias="np"),
            Import(module="pydantic", objects=[ObjectImport(name="model_validator")]),
        ]
    )

    schema_map: Optional[Dict[str, SchemaDefinition]] = None
    """See :meth:`.LinkMLProvider.build` for usage - a list of specific versions to import from"""
    array_representations: List[ArrayRepresentation] = field(
        default_factory=lambda: [ArrayRepresentation.NUMPYDANTIC]
    )
    black: bool = False
    inlined: bool = True
    emit_metadata: bool = True
    gen_classvars: bool = True
    gen_slots: bool = True
    # extra_fields: Literal["allow", "forbid", "ignore"] = "allow"

    skip_meta: ClassVar[Tuple[str]] = ("domain_of", "alias")

    def _check_anyof(
        self, s: SlotDefinition, sn: SlotDefinitionName, sv: SchemaView
    ) -> None:  # pragma: no cover
        """
        Overridden to allow `array` in any_of
        """
        # Confirm that the original slot range (ignoring the default that comes in from
        # induced_slot) isn't in addition to setting any_of
        allowed_keys = ("array",)

        if len(s.any_of) > 0 and sv.get_slot(sn).range is not None:
            allowed = True
            for option in s.any_of:
                items = remove_empty_items(option)
                if not all([key in allowed_keys for key in items]):
                    allowed = False
            if allowed:
                return
            base_range_subsumes_any_of = False
            base_range = sv.get_slot(sn).range
            base_range_cls = sv.get_class(base_range, strict=False)
            if base_range_cls is not None and base_range_cls.class_uri == "linkml:Any":
                base_range_subsumes_any_of = True
            if not base_range_subsumes_any_of:
                raise ValueError("Slot cannot have both range and any_of defined")

    def render(self) -> PydanticModule:
        """
        Override of super's render method to switch the split_mode before generation depending
        on whether it's a namespace schema or not
        """
        is_namespace = False
        ns_annotation = self.schemaview.schema.annotations.get("is_namespace", None)
        if ns_annotation:
            is_namespace = ns_annotation.value
        self.split_mode = SplitMode.FULL if is_namespace else SplitMode.AUTO

        return super().render()

    def before_generate_slot(self, slot: SlotDefinition, sv: SchemaView) -> SlotDefinition:
        """
        Force some properties to be optional
        """
        if slot.name == "target" and "index" in slot.description:
            slot.required = False
        return slot

    def after_generate_slot(self, slot: SlotResult, sv: SchemaView) -> SlotResult:
        """
        - strip unwanted metadata
        - generate range with any_of
        """
        slot = AfterGenerateSlot.skip_meta(slot, self.skip_meta)
        slot = AfterGenerateSlot.make_array_anyofs(slot)
        slot = AfterGenerateSlot.make_named_class_range(slot)

        return slot

    def after_generate_class(self, cls: ClassResult, sv: SchemaView) -> ClassResult:
        """Customize dynamictable behavior"""
        cls = AfterGenerateClass.inject_dynamictable(cls)
        cls = AfterGenerateClass.wrap_dynamictable_columns(cls, sv)
        cls = AfterGenerateClass.inject_dynamictable_imports(cls, sv, self._get_element_import)
        cls = AfterGenerateClass.strip_vector_data_slots(cls, sv)
        return cls

    def before_render_template(self, template: PydanticModule, sv: SchemaView) -> PydanticModule:
        """
        Remove source file from metadata
        """
        if "source_file" in template.meta:
            del template.meta["source_file"]
        return template

    def compile_module(
        self, module_path: Path = None, module_name: str = "test", **kwargs
    ) -> ModuleType:  # pragma: no cover - replaced with provider
        """
        Compiles generated python code to a module
        :return:
        """
        pycode = self.serialize(**kwargs)
        if module_path is not None:
            module_path = Path(module_path)
            init_file = module_path / "__init__.py"
            with open(init_file, "w") as ifile:
                ifile.write(" ")

        try:
            return compile_python(pycode, module_path, module_name)
        except NameError as e:
            raise e


class AfterGenerateSlot:
    """
    Container class for slot-modification methods
    """

    @staticmethod
    def skip_meta(slot: SlotResult, skip_meta: tuple[str]) -> SlotResult:
        """
        Skip additional metadata slots
        """
        for key in skip_meta:
            if key in slot.attribute.meta:
                del slot.attribute.meta[key]
        return slot

    @staticmethod
    def make_array_anyofs(slot: SlotResult) -> SlotResult:
        """
        Make a Union of array ranges if multiple array types specified in ``any_of``
        """
        # make array ranges in any_of
        if "any_of" in slot.attribute.meta:
            any_ofs = slot.attribute.meta["any_of"]
            if all(["array" in expr for expr in any_ofs]):
                ranges = []
                is_optional = False
                for expr in any_ofs:
                    # remove optional from inner type
                    pyrange = slot.attribute.range
                    is_optional = OPTIONAL_PATTERN.match(pyrange)
                    if is_optional:
                        pyrange = is_optional.groups()[0]
                    range_generator = NumpydanticArray(ArrayExpression(**expr["array"]), pyrange)
                    ranges.append(range_generator.make().range)

                slot.attribute.range = "Union[" + ", ".join(ranges) + "]"
                if is_optional:
                    slot.attribute.range = "Optional[" + slot.attribute.range + "]"
                del slot.attribute.meta["any_of"]

                # merge injects/imports from the numpydantic array without using the merge method
                if slot.injected_classes is None:
                    slot.injected_classes = NumpydanticArray.INJECTS.copy()
                else:  # pragma: no cover - for completeness, shouldn't happen
                    slot.injected_classes.extend(NumpydanticArray.INJECTS.copy())
                if isinstance(
                    slot.imports, list
                ):  # pragma: no cover - for completeness, shouldn't happen
                    slot.imports = (
                        Imports(imports=slot.imports) + NumpydanticArray.IMPORTS.model_copy()
                    )
                elif isinstance(slot.imports, Imports):
                    slot.imports += NumpydanticArray.IMPORTS.model_copy()
                else:  # pragma: no cover - for completeness, shouldn't happen
                    slot.imports = NumpydanticArray.IMPORTS.model_copy()

        return slot

    @staticmethod
    def make_named_class_range(slot: SlotResult) -> SlotResult:
        """
        When a slot has a ``named`` annotation, wrap it in :class:`.Named`
        """

        if "named" in slot.source.annotations and slot.source.annotations["named"].value:

            slot.attribute.range = wrap_preserving_optional(slot.attribute.range, "Named")
            named_injects = [ModelTypeString, _get_name, NamedString]
            if slot.injected_classes is None:
                slot.injected_classes = named_injects
            else:  # pragma: no cover - for completeness, shouldn't happen
                slot.injected_classes.extend([ModelTypeString, _get_name, NamedString])
            if isinstance(
                slot.imports, list
            ):  # pragma: no cover - for completeness, shouldn't happen
                slot.imports = Imports(imports=slot.imports) + NamedImports
            elif isinstance(slot.imports, Imports):
                slot.imports += NamedImports
            else:  # pragma: no cover - for completeness, shouldn't happen
                slot.imports = NamedImports
        return slot


class AfterGenerateClass:
    """
    Container class for class-modification methods
    """

    @staticmethod
    def inject_dynamictable(cls: ClassResult) -> ClassResult:
        """
        Modify dynamictable class bases and inject needed objects :)
        Args:
            cls:

        Returns:

        """
        if cls.cls.name == "DynamicTable":
            cls.cls.bases = ["DynamicTableMixin"]

            if (
                cls.injected_classes is None
            ):  # pragma: no cover - for completeness, shouldn't happen
                cls.injected_classes = DYNAMIC_TABLE_INJECTS.copy()
            else:
                cls.injected_classes.extend(DYNAMIC_TABLE_INJECTS.copy())

            if isinstance(cls.imports, Imports):
                cls.imports += DYNAMIC_TABLE_IMPORTS
            elif isinstance(
                cls.imports, list
            ):  # pragma: no cover - for completeness, shouldn't happen
                cls.imports = Imports(imports=cls.imports) + DYNAMIC_TABLE_IMPORTS
            else:  # pragma: no cover - for completeness, shouldn't happen
                cls.imports = DYNAMIC_TABLE_IMPORTS.model_copy()
        elif cls.cls.name == "VectorData":
            cls.cls.bases = ["VectorDataMixin"]
            # make ``value`` generic on T
            if "value" in cls.cls.attributes:
                cls.cls.attributes["value"].range = "Optional[T]"
        elif cls.cls.name == "VectorIndex":
            cls.cls.bases = ["VectorIndexMixin"]
        elif cls.cls.name == "DynamicTableRegion":
            cls.cls.bases = ["DynamicTableRegionMixin", "VectorData"]
        elif cls.cls.name == "AlignedDynamicTable":
            cls.cls.bases = ["AlignedDynamicTableMixin", "DynamicTable"]
        elif cls.cls.name == "ElementIdentifiers":
            cls.cls.bases = ["ElementIdentifiersMixin", "Data"]
            # make ``value`` generic on T
            if "value" in cls.cls.attributes:
                cls.cls.attributes["value"].range = "Optional[T]"
        elif cls.cls.name == "TimeSeriesReferenceVectorData":
            # in core.nwb.base, so need to inject and import again
            cls.cls.bases = ["TimeSeriesReferenceVectorDataMixin", "VectorData"]
            if (
                cls.injected_classes is None
            ):  # pragma: no cover - for completeness, shouldn't happen
                cls.injected_classes = TSRVD_INJECTS.copy()
            else:
                cls.injected_classes.extend(TSRVD_INJECTS.copy())

            if isinstance(cls.imports, Imports):
                cls.imports += TSRVD_IMPORTS
            elif isinstance(
                cls.imports, list
            ):  # pragma: no cover - for completeness, shouldn't happen
                cls.imports = Imports(imports=cls.imports) + TSRVD_IMPORTS
            else:  # pragma: no cover - for completeness, shouldn't happen
                cls.imports = TSRVD_IMPORTS.model_copy()

        return cls

    @staticmethod
    def wrap_dynamictable_columns(cls: ClassResult, sv: SchemaView) -> ClassResult:
        """
        Wrap NDArray columns inside of dynamictables with ``VectorData`` or
        ``VectorIndex``, which are generic classes whose value slot is
        parameterized by the NDArray
        """
        if cls.source.is_a == "DynamicTable" or "DynamicTable" in sv.class_ancestors(
            cls.source.name
        ):
            for an_attr in cls.cls.attributes:
                if "NDArray" in (slot_range := cls.cls.attributes[an_attr].range):
                    if an_attr == "id":
                        cls.cls.attributes[an_attr].range = "ElementIdentifiers"
                        return cls

                    wrap_cls = "VectorIndex" if an_attr.endswith("_index") else "VectorData"

                    cls.cls.attributes[an_attr].range = wrap_preserving_optional(
                        slot_range, wrap_cls
                    )

        return cls

    @staticmethod
    def inject_dynamictable_imports(
        cls: ClassResult, sv: SchemaView, import_method: Callable[[str], Import]
    ) -> ClassResult:
        """
        Ensure that schema that contain dynamictables have all the imports needed to use them
        """
        if (
            cls.source.is_a == "DynamicTable"
            or "DynamicTable" in sv.class_ancestors(cls.source.name)
        ) and sv.schema.name != "hdmf-common.table":
            imp = [
                import_method("ElementIdentifiers"),
                import_method("VectorData"),
                import_method("VectorIndex"),
            ]
            cls.imports += imp
        return cls

    @staticmethod
    def strip_vector_data_slots(cls: ClassResult, sv: SchemaView) -> ClassResult:
        """
        Remove spurious ``vector_data`` slots from DynamicTables
        """
        if "vector_data" in cls.cls.attributes:
            del cls.cls.attributes["vector_data"]
        return cls


def wrap_preserving_optional(annotation: str, wrap: str) -> str:
    """
    Add a wrapping type to a type annotation string,
    preserving any `Optional[]` annotation, bumping it to the outside

    Examples:

        >>> wrap_preserving_optional('Optional[list[str]]', 'NewType')
        'Optional[NewType[list[str]]]'

    """

    is_optional = OPTIONAL_PATTERN.match(annotation)
    if is_optional:
        annotation = is_optional.groups()[0]
        annotation = f"Optional[{wrap}[{annotation}]]"
    else:
        annotation = f"{wrap}[{annotation}]"
    return annotation

1	"""
2	Subclass of :class:`linkml.generators.PydanticGenerator`
3	customized to support NWB models.
4
5	See class and module docstrings for details :)
6	"""
7
8	import re	3✔
9	from dataclasses import dataclass, field	3✔
10	from pathlib import Path	3✔
11	from types import ModuleType	3✔
12	from typing import Callable, ClassVar, Dict, List, Optional, Tuple	3✔
13
14	from linkml.generators import PydanticGenerator	3✔
15	from linkml.generators.pydanticgen.array import ArrayRepresentation, NumpydanticArray	3✔
16	from linkml.generators.pydanticgen.build import ClassResult, SlotResult	3✔
17	from linkml.generators.pydanticgen.pydanticgen import SplitMode	3✔
18	from linkml.generators.pydanticgen.template import Import, Imports, ObjectImport, PydanticModule	3✔
19	from linkml_runtime.linkml_model.meta import (	3✔
20	ArrayExpression,
21	SchemaDefinition,
22	SlotDefinition,
23	SlotDefinitionName,
24	)
25	from linkml_runtime.utils.formatutils import remove_empty_items	3✔
26	from linkml_runtime.utils.schemaview import SchemaView	3✔
27
28	from nwb_linkml.includes.base import (	3✔
29	BASEMODEL_CAST_WITH_VALUE,
30	BASEMODEL_COERCE_CHILD,
31	BASEMODEL_COERCE_VALUE,
32	BASEMODEL_EXTRA_TO_VALUE,
33	BASEMODEL_GETITEM,
34	)
35	from nwb_linkml.includes.hdmf import (	3✔
36	DYNAMIC_TABLE_IMPORTS,
37	DYNAMIC_TABLE_INJECTS,
38	TSRVD_IMPORTS,
39	TSRVD_INJECTS,
40	)
41	from nwb_linkml.includes.types import ModelTypeString, NamedImports, NamedString, _get_name	3✔
42
43	OPTIONAL_PATTERN = re.compile(r"Optional\[(.*)\]")	3✔
44
45
46	@dataclass	3✔
47	class NWBPydanticGenerator(PydanticGenerator):	3✔
48	"""
49	Subclass of pydantic generator, custom behavior is in overridden lifecycle methods :)
50	"""
51
52	injected_fields: List[str] = (	3✔
53	(
54	'hdf5_path: Optional[str] = Field(None, description="The absolute path that this object'
55	' is stored in an NWB file")'
56	),
57	'object_id: Optional[str] = Field(None, description="Unique UUID for each object")',
58	BASEMODEL_GETITEM,
59	BASEMODEL_COERCE_VALUE,
60	BASEMODEL_CAST_WITH_VALUE,
61	BASEMODEL_COERCE_CHILD,
62	BASEMODEL_EXTRA_TO_VALUE,
63	)
64	split: bool = True	3✔
65	imports: list[Import] = field(	3✔
66	default_factory=lambda: [
67	Import(module="numpy", alias="np"),
68	Import(module="pydantic", objects=[ObjectImport(name="model_validator")]),
69	]
70	)
71
72	schema_map: Optional[Dict[str, SchemaDefinition]] = None	3✔
73	"""See :meth:`.LinkMLProvider.build` for usage - a list of specific versions to import from"""	3✔
74	array_representations: List[ArrayRepresentation] = field(	3✔
75	default_factory=lambda: [ArrayRepresentation.NUMPYDANTIC]
76	)
77	black: bool = False	3✔
78	inlined: bool = True	3✔
79	emit_metadata: bool = True	3✔
80	gen_classvars: bool = True	3✔
81	gen_slots: bool = True	3✔
82	# extra_fields: Literal["allow", "forbid", "ignore"] = "allow"
83
84	skip_meta: ClassVar[Tuple[str]] = ("domain_of", "alias")	3✔
85
86	def _check_anyof(
87	self, s: SlotDefinition, sn: SlotDefinitionName, sv: SchemaView
88	) -> None: # pragma: no cover
89	"""
90	Overridden to allow `array` in any_of
91	"""
92	# Confirm that the original slot range (ignoring the default that comes in from
93	# induced_slot) isn't in addition to setting any_of
94	allowed_keys = ("array",)
95
96	if len(s.any_of) > 0 and sv.get_slot(sn).range is not None:
97	allowed = True
98	for option in s.any_of:
99	items = remove_empty_items(option)
100	if not all([key in allowed_keys for key in items]):
101	allowed = False
102	if allowed:
103	return
104	base_range_subsumes_any_of = False
105	base_range = sv.get_slot(sn).range
106	base_range_cls = sv.get_class(base_range, strict=False)
107	if base_range_cls is not None and base_range_cls.class_uri == "linkml:Any":
108	base_range_subsumes_any_of = True
109	if not base_range_subsumes_any_of:
110	raise ValueError("Slot cannot have both range and any_of defined")
111
112	def render(self) -> PydanticModule:	3✔
113	"""
114	Override of super's render method to switch the split_mode before generation depending
115	on whether it's a namespace schema or not
116	"""
117	is_namespace = False	3✔
118	ns_annotation = self.schemaview.schema.annotations.get("is_namespace", None)	3✔
119	if ns_annotation:	3✔
120	is_namespace = ns_annotation.value	3✔
121	self.split_mode = SplitMode.FULL if is_namespace else SplitMode.AUTO	3✔
122
123	return super().render()	3✔
124
125	def before_generate_slot(self, slot: SlotDefinition, sv: SchemaView) -> SlotDefinition:	3✔
126	"""
127	Force some properties to be optional
128	"""
129	if slot.name == "target" and "index" in slot.description:	3✔
130	slot.required = False	3✔
131	return slot	3✔
132
133	def after_generate_slot(self, slot: SlotResult, sv: SchemaView) -> SlotResult:	3✔
134	"""
135	- strip unwanted metadata
136	- generate range with any_of
137	"""
138	slot = AfterGenerateSlot.skip_meta(slot, self.skip_meta)	3✔
139	slot = AfterGenerateSlot.make_array_anyofs(slot)	3✔
140	slot = AfterGenerateSlot.make_named_class_range(slot)	3✔
141
142	return slot	3✔
143
144	def after_generate_class(self, cls: ClassResult, sv: SchemaView) -> ClassResult:	3✔
145	"""Customize dynamictable behavior"""
146	cls = AfterGenerateClass.inject_dynamictable(cls)	3✔
147	cls = AfterGenerateClass.wrap_dynamictable_columns(cls, sv)	3✔
148	cls = AfterGenerateClass.inject_dynamictable_imports(cls, sv, self._get_element_import)	3✔
149	cls = AfterGenerateClass.strip_vector_data_slots(cls, sv)	3✔
150	return cls	3✔
151
152	def before_render_template(self, template: PydanticModule, sv: SchemaView) -> PydanticModule:	3✔
153	"""
154	Remove source file from metadata
155	"""
156	if "source_file" in template.meta:	3✔
157	del template.meta["source_file"]	3✔
158	return template	3✔
159
160	def compile_module(
161	self, module_path: Path = None, module_name: str = "test", **kwargs
162	) -> ModuleType: # pragma: no cover - replaced with provider
163	"""
164	Compiles generated python code to a module
165	:return:
166	"""
167	pycode = self.serialize(**kwargs)
168	if module_path is not None:
169	module_path = Path(module_path)
170	init_file = module_path / "__init__.py"
171	with open(init_file, "w") as ifile:
172	ifile.write(" ")
173
174	try:
175	return compile_python(pycode, module_path, module_name)
176	except NameError as e:
177	raise e
178
179
180	class AfterGenerateSlot:	3✔
181	"""
182	Container class for slot-modification methods
183	"""
184
185	@staticmethod	3✔
186	def skip_meta(slot: SlotResult, skip_meta: tuple[str]) -> SlotResult:	3✔
187	"""
188	Skip additional metadata slots
189	"""
190	for key in skip_meta:	3✔
191	if key in slot.attribute.meta:	3✔
192	del slot.attribute.meta[key]	3✔
193	return slot	3✔
194
195	@staticmethod	3✔
196	def make_array_anyofs(slot: SlotResult) -> SlotResult:	3✔
197	"""
198	Make a Union of array ranges if multiple array types specified in ``any_of``
199	"""
200	# make array ranges in any_of
201	if "any_of" in slot.attribute.meta:	3✔
202	any_ofs = slot.attribute.meta["any_of"]	3✔
203	if all(["array" in expr for expr in any_ofs]):	3✔
204	ranges = []	3✔
205	is_optional = False	3✔
206	for expr in any_ofs:	3✔
207	# remove optional from inner type
208	pyrange = slot.attribute.range	3✔
209	is_optional = OPTIONAL_PATTERN.match(pyrange)	3✔
210	if is_optional:	3✔
211	pyrange = is_optional.groups()[0]	3✔
212	range_generator = NumpydanticArray(ArrayExpression(**expr["array"]), pyrange)	3✔
213	ranges.append(range_generator.make().range)	3✔
214
215	slot.attribute.range = "Union[" + ", ".join(ranges) + "]"	3✔
216	if is_optional:	3✔
217	slot.attribute.range = "Optional[" + slot.attribute.range + "]"	3✔
218	del slot.attribute.meta["any_of"]	3✔
219
220	# merge injects/imports from the numpydantic array without using the merge method
221	if slot.injected_classes is None:	3✔
222	slot.injected_classes = NumpydanticArray.INJECTS.copy()	3✔
223	else: # pragma: no cover - for completeness, shouldn't happen
224	slot.injected_classes.extend(NumpydanticArray.INJECTS.copy())
225	if isinstance(
226	slot.imports, list
227	): # pragma: no cover - for completeness, shouldn't happen
228	slot.imports = (
229	Imports(imports=slot.imports) + NumpydanticArray.IMPORTS.model_copy()
230	)
231	elif isinstance(slot.imports, Imports):	3✔
232	slot.imports += NumpydanticArray.IMPORTS.model_copy()	3✔
233	else: # pragma: no cover - for completeness, shouldn't happen
234	slot.imports = NumpydanticArray.IMPORTS.model_copy()
235
236	return slot	3✔
237
238	@staticmethod	3✔
239	def make_named_class_range(slot: SlotResult) -> SlotResult:	3✔
240	"""
241	When a slot has a ``named`` annotation, wrap it in :class:`.Named`
242	"""
243
244	if "named" in slot.source.annotations and slot.source.annotations["named"].value:	3✔
245
246	slot.attribute.range = wrap_preserving_optional(slot.attribute.range, "Named")	3✔
247	named_injects = [ModelTypeString, _get_name, NamedString]	3✔
248	if slot.injected_classes is None:	3✔
249	slot.injected_classes = named_injects	3✔
250	else: # pragma: no cover - for completeness, shouldn't happen
251	slot.injected_classes.extend([ModelTypeString, _get_name, NamedString])
252	if isinstance(
253	slot.imports, list
254	): # pragma: no cover - for completeness, shouldn't happen
255	slot.imports = Imports(imports=slot.imports) + NamedImports
256	elif isinstance(slot.imports, Imports):	3✔
257	slot.imports += NamedImports	3✔
258	else: # pragma: no cover - for completeness, shouldn't happen
259	slot.imports = NamedImports
260	return slot	3✔
261
262
263	class AfterGenerateClass:	3✔
264	"""
265	Container class for class-modification methods
266	"""
267
268	@staticmethod	3✔
269	def inject_dynamictable(cls: ClassResult) -> ClassResult:	3✔
270	"""
271	Modify dynamictable class bases and inject needed objects :)
272	Args:
273	cls:
274
275	Returns:
276
277	"""
278	if cls.cls.name == "DynamicTable":	3✔
279	cls.cls.bases = ["DynamicTableMixin"]	3✔
280
281	if (
282	cls.injected_classes is None
283	): # pragma: no cover - for completeness, shouldn't happen
284	cls.injected_classes = DYNAMIC_TABLE_INJECTS.copy()
285	else:
286	cls.injected_classes.extend(DYNAMIC_TABLE_INJECTS.copy())	3✔
287
288	if isinstance(cls.imports, Imports):	3✔
289	cls.imports += DYNAMIC_TABLE_IMPORTS	3✔
290	elif isinstance(
291	cls.imports, list
292	): # pragma: no cover - for completeness, shouldn't happen
293	cls.imports = Imports(imports=cls.imports) + DYNAMIC_TABLE_IMPORTS
294	else: # pragma: no cover - for completeness, shouldn't happen
295	cls.imports = DYNAMIC_TABLE_IMPORTS.model_copy()
296	elif cls.cls.name == "VectorData":	3✔
297	cls.cls.bases = ["VectorDataMixin"]	3✔
298	# make ``value`` generic on T
299	if "value" in cls.cls.attributes:	3✔
300	cls.cls.attributes["value"].range = "Optional[T]"	3✔
301	elif cls.cls.name == "VectorIndex":	3✔
302	cls.cls.bases = ["VectorIndexMixin"]	3✔
303	elif cls.cls.name == "DynamicTableRegion":	3✔
304	cls.cls.bases = ["DynamicTableRegionMixin", "VectorData"]	3✔
305	elif cls.cls.name == "AlignedDynamicTable":	3✔
306	cls.cls.bases = ["AlignedDynamicTableMixin", "DynamicTable"]	3✔
307	elif cls.cls.name == "ElementIdentifiers":	3✔
308	cls.cls.bases = ["ElementIdentifiersMixin", "Data"]	3✔
309	# make ``value`` generic on T
310	if "value" in cls.cls.attributes:	3✔
311	cls.cls.attributes["value"].range = "Optional[T]"	3✔
312	elif cls.cls.name == "TimeSeriesReferenceVectorData":	3✔
313	# in core.nwb.base, so need to inject and import again
314	cls.cls.bases = ["TimeSeriesReferenceVectorDataMixin", "VectorData"]	3✔
315	if (
316	cls.injected_classes is None
317	): # pragma: no cover - for completeness, shouldn't happen
318	cls.injected_classes = TSRVD_INJECTS.copy()
319	else:
320	cls.injected_classes.extend(TSRVD_INJECTS.copy())	3✔
321
322	if isinstance(cls.imports, Imports):	3✔
323	cls.imports += TSRVD_IMPORTS	3✔
324	elif isinstance(
325	cls.imports, list
326	): # pragma: no cover - for completeness, shouldn't happen
327	cls.imports = Imports(imports=cls.imports) + TSRVD_IMPORTS
328	else: # pragma: no cover - for completeness, shouldn't happen
329	cls.imports = TSRVD_IMPORTS.model_copy()
330
331	return cls	3✔
332
333	@staticmethod	3✔
334	def wrap_dynamictable_columns(cls: ClassResult, sv: SchemaView) -> ClassResult:	3✔
335	"""
336	Wrap NDArray columns inside of dynamictables with ``VectorData`` or
337	``VectorIndex``, which are generic classes whose value slot is
338	parameterized by the NDArray
339	"""
340	if cls.source.is_a == "DynamicTable" or "DynamicTable" in sv.class_ancestors(	3✔
341	cls.source.name
342	):
343	for an_attr in cls.cls.attributes:	3✔
344	if "NDArray" in (slot_range := cls.cls.attributes[an_attr].range):	3✔
345	if an_attr == "id":	3✔
346	cls.cls.attributes[an_attr].range = "ElementIdentifiers"	3✔
347	return cls	3✔
348
349	wrap_cls = "VectorIndex" if an_attr.endswith("_index") else "VectorData"	3✔
350
351	cls.cls.attributes[an_attr].range = wrap_preserving_optional(	3✔
352	slot_range, wrap_cls
353	)
354
355	return cls	3✔
356
357	@staticmethod	3✔
358	def inject_dynamictable_imports(	3✔
359	cls: ClassResult, sv: SchemaView, import_method: Callable[[str], Import]
360	) -> ClassResult:
361	"""
362	Ensure that schema that contain dynamictables have all the imports needed to use them
363	"""
364	if (	3✔
365	cls.source.is_a == "DynamicTable"
366	or "DynamicTable" in sv.class_ancestors(cls.source.name)
367	) and sv.schema.name != "hdmf-common.table":
368	imp = [	3✔
369	import_method("ElementIdentifiers"),
370	import_method("VectorData"),
371	import_method("VectorIndex"),
372	]
373	cls.imports += imp	3✔
374	return cls	3✔
375
376	@staticmethod	3✔
377	def strip_vector_data_slots(cls: ClassResult, sv: SchemaView) -> ClassResult:	3✔
378	"""
379	Remove spurious ``vector_data`` slots from DynamicTables
380	"""
381	if "vector_data" in cls.cls.attributes:	3✔
UNCOV 382	del cls.cls.attributes["vector_data"]	×
383	return cls	3✔
384
385
386	def wrap_preserving_optional(annotation: str, wrap: str) -> str:	3✔
387	"""
388	Add a wrapping type to a type annotation string,
389	preserving any `Optional[]` annotation, bumping it to the outside
390
391	Examples:
392
393	>>> wrap_preserving_optional('Optional[list[str]]', 'NewType')
394	'Optional[NewType[list[str]]]'
395
396	"""
397
398	is_optional = OPTIONAL_PATTERN.match(annotation)	3✔
399	if is_optional:	3✔
400	annotation = is_optional.groups()[0]	3✔
401	annotation = f"Optional[{wrap}[{annotation}]]"	3✔
402	else:
403	annotation = f"{wrap}[{annotation}]"	3✔
404	return annotation	3✔

p2p-ld / nwb-linkml / 11118854255

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous