linkml 1.8.3__py3-none-any.whl → 1.8.4__py3-none-any.whl

linkml/generators/typescriptgen.py

@@ -19,6 +19,9 @@ from linkml._version import __version__
 from linkml.generators.oocodegen import OOCodeGenerator
 from linkml.utils.generator import shared_arguments
 
+logger = logging.getLogger(__name__)
+
+
 type_map = {
     "str": "string",
     "int": "number",
@@ -120,7 +123,7 @@ class TypescriptGenerator(OOCodeGenerator):
     gen_type_utils: bool = False
     include_induced_slots: bool = False
 
-    def serialize(self) -> str:
+    def serialize(self, output=None) -> str:
         """Serialize a schema to typescript string"""
 
         sv: SchemaView = self.schemaview
@@ -132,6 +135,9 @@ class TypescriptGenerator(OOCodeGenerator):
             view=self.schemaview,
             enums=enums,
         )
+        if output is not None:
+            with open(output, "w") as out:
+                out.write(out_str)
         return out_str
 
     @staticmethod
@@ -207,7 +213,7 @@ class TypescriptGenerator(OOCodeGenerator):
                 elif t.typeof and t.typeof in type_map:
                     tsrange = type_map[t.typeof]
                 else:
-                    logging.warning(f"Unknown type.base: {t.name}")
+                    logger.warning(f"Unknown type.base: {t.name}")
                 if slot.multivalued:
                     tsrange = f"{tsrange}[]"
                 return tsrange
@@ -241,7 +247,7 @@ class TypescriptGenerator(OOCodeGenerator):
                 elif t.typeof and t.typeof in type_map:
                     return type_init_map[t.typeof]
                 else:
-                    logging.warning(f"Unknown type.base: {t.name}")
+                    logger.warning(f"Unknown type.base: {t.name}")
                 return "null"
             return "null"
 
@@ -264,8 +270,9 @@ class TypescriptGenerator(OOCodeGenerator):
 @click.version_option(__version__, "-V", "--version")
 @click.option("--gen-type-utils/", "-u", help="Generate Type checking utils", is_flag=True)
 @click.option("--include-induced-slots/", help="Generate slots induced through inheritance", is_flag=True)
-@click.command(name="typescript")
-def cli(yamlfile, gen_type_utils=False, include_induced_slots=False, **args):
+@click.option("--output", type=click.Path(dir_okay=False))
+@click.command()
+def cli(yamlfile, gen_type_utils=False, include_induced_slots=False, output=None, **args):
     """Generate typescript interfaces and types
 
     See https://github.com/linkml/linkml-runtime.js
@@ -273,7 +280,7 @@ def cli(yamlfile, gen_type_utils=False, include_induced_slots=False, **args):
     gen = TypescriptGenerator(
         yamlfile, gen_type_utils=gen_type_utils, include_induced_slots=include_induced_slots, **args
     )
-    print(gen.serialize())
+    gen.serialize(output=output)
 
 
 if __name__ == "__main__":

linkml/linter/linter.py

@@ -8,6 +8,7 @@ from typing import Any, Dict, Iterable, Union
 import jsonschema
 import yaml
 from jsonschema.exceptions import best_match
+from jsonschema.protocols import Validator
 from linkml_runtime import SchemaView
 from linkml_runtime.dumpers import yaml_dumper
 from linkml_runtime.linkml_model import SchemaDefinition
@@ -35,7 +36,7 @@ def get_named_config(name: str) -> Dict[str, Any]:
 
 
 @lru_cache
-def get_metamodel_validator() -> jsonschema.Validator:
+def get_metamodel_validator() -> Validator:
     meta_json_gen = JsonSchemaGenerator(LOCAL_METAMODEL_YAML_FILE, not_closed=False)
     meta_json_schema = meta_json_gen.generate()
     validator_cls = jsonschema.validators.validator_for(meta_json_schema, default=jsonschema.Draft7Validator)

linkml/transformers/logical_model_transformer.py

@@ -360,13 +360,13 @@ class LogicalModelTransformer(ModelTransformer):
         target_schema = target_schemaview.schema
         for tn, typ in target_schema.types.items():
             ancs = sv.type_ancestors(tn, reflexive=False)
-            logging.debug(f"Unrolling type {tn}, merging {len(ancs)}")
+            logger.debug(f"Unrolling type {tn}, merging {len(ancs)}")
             if ancs:
                 for type_anc in ancs:
                     self._merge_type_ancestors(target=typ, source=sv.get_type(type_anc))
         for sn, slot in target_schema.slots.items():
             ancs = sv.slot_ancestors(sn, reflexive=False)
-            logging.debug(f"Unrolling slot {sn}, merging {len(ancs)}")
+            logger.debug(f"Unrolling slot {sn}, merging {len(ancs)}")
             if ancs:
                 for slot_anc in ancs:
                     self._merge_slot_ancestors(target=slot, source=target_schema.slots[slot_anc])
@@ -379,7 +379,7 @@ class LogicalModelTransformer(ModelTransformer):
                 depth_first=False,
             )
             ancs = list(reversed(ancs))
-            logging.debug(f"Unrolling class {cn}, merging {len(ancs)}")
+            logger.debug(f"Unrolling class {cn}, merging {len(ancs)}")
             self._roll_down(target_schema, cn, ancs)
         self.apply_defaults(target_schema)
         if simplify:

linkml/transformers/relmodel_transformer.py

@@ -12,9 +12,12 @@ from linkml_runtime.linkml_model import (
     SchemaDefinition,
     SlotDefinition,
 )
+from linkml_runtime.linkml_model.meta import UniqueKey
 from linkml_runtime.utils.schemaview import SchemaView, SlotDefinitionName
 from sqlalchemy import Enum
 
+logger = logging.getLogger(__name__)
+
 
 class RelationalAnnotations(Enum):
     PRIMARY_KEY = "primary_key"
@@ -215,11 +218,11 @@ class RelationalModelTransformer:
         for cn in target_sv.all_classes():
             pk = self.get_direct_identifier_attribute(target_sv, cn)
             if self.foreign_key_policy == ForeignKeyPolicy.NO_FOREIGN_KEYS:
-                logging.info(f"Will not inject any PKs, and policy == {self.foreign_key_policy}")
+                logger.info(f"Will not inject any PKs, and policy == {self.foreign_key_policy}")
             else:
                 if pk is None:
                     pk = self.add_primary_key(cn, target_sv)
-                    logging.info(f"Added primary key {cn}.{pk.name}")
+                    logger.info(f"Added primary key {cn}.{pk.name}")
                 for link in links:
                     if link.target_class == cn:
                         link.target_slot = pk.name
@@ -233,7 +236,7 @@ class RelationalModelTransformer:
                 continue
             pk_slot = self.get_direct_identifier_attribute(target_sv, cn)
             # if self.is_skip(c) and len(incoming_links) == 0:
-            #    logging.info(f'Skipping class: {c.name}')
+            #    logger.info(f'Skipping class: {c.name}')
             #    del target.classes[cn]
             #    continue
             for src_slot in list(c.attributes.values()):
@@ -278,6 +281,17 @@ class RelationalModelTransformer:
                                 target_slot=backref_slot.name,
                             )
                         )
+                        backref_key_slots = [s for s in backref_class.attributes.values() if s.key]
+                        if backref_key_slots:
+                            if len(backref_key_slots) > 1:
+                                raise ValueError(f"Multiple keys for {c.name}: {backref_key_slots}")
+                            backref_key_slot = backref_key_slots[0]
+                            unique_key_name = f"{c.name}_{backref_key_slot.name}"
+                            backref_class.unique_keys[unique_key_name] = UniqueKey(
+                                unique_key_name=unique_key_name,
+                                unique_key_slots=[backref_slot.name, backref_key_slot.name],
+                            )
+
                     else:
                         # MANY-TO-MANY
                         # create new linking table
@@ -375,7 +389,7 @@ class RelationalModelTransformer:
             removed_ucs = []
             for uc_name, uc in c.unique_keys.items():
                 if any(sn in multivalued_slots_original for sn in uc.unique_key_slots):
-                    logging.warning(
+                    logger.warning(
                         f"Cannot represent uniqueness constraint {uc_name}. "
                         f"one of the slots {uc.unique_key_slots} is multivalued"
                     )

linkml/utils/converter.py

@@ -23,6 +23,8 @@ from linkml.utils.datautils import (
     infer_root_class,
 )
 
+logger = logging.getLogger(__name__)
+
 
 @click.command(name="convert")
 @click.option("--module", "-m", help="Path to python datamodel module")
@@ -119,7 +121,7 @@ def cli(
                 sv.set_modified()
     if target_class is None and target_class_from_path:
         target_class = os.path.basename(input).split("-")[0]
-        logging.info(f"inferred target class = {target_class} from {input}")
+        logger.info(f"inferred target class = {target_class} from {input}")
     if target_class is None:
         target_class = infer_root_class(sv)
     if target_class is None:

linkml/utils/exceptions.py

@@ -0,0 +1,11 @@
+"""
+Custom exceptions
+"""
+
+
+class SchemaError(ValueError):
+    """Base class for errors relating to schema specification, parsing, structure, etc."""
+
+
+class ValidationError(SchemaError):
+    """Schema is invalid!"""

linkml/utils/execute_tutorial.py

@@ -10,6 +10,8 @@ import click
 
 from linkml._version import __version__
 
+logger = logging.getLogger(__name__)
+
 re_decl = re.compile(r"^(\S+):$")
 re_start_yaml = re.compile(r"^```(\w+)$")
 re_end_yaml = re.compile(r"^```$")
@@ -46,17 +48,17 @@ def execute_blocks(directory: str, blocks: List[Block]) -> List[str]:
     :return: errors
     """
     Path(directory).mkdir(parents=True, exist_ok=True)
-    logging.info(f"Executing in: {directory}")
+    logger.info(f"Executing in: {directory}")
     last_block = None
     errs = []
 
     def err(e):
         errs.append(e)
-        logging.error(e)
+        logger.error(e)
 
     for block in blocks:
         write_lines(block.prior_lines)
-        logging.info(f"# Block: {block.category} {block.title}")
+        logger.info(f"# Block: {block.category} {block.title}")
         if block.is_file_block():
             path = PurePath(directory, block.title)
             with open(path, "w", encoding="UTF-8") as stream:
@@ -73,44 +75,44 @@ def execute_blocks(directory: str, blocks: List[Block]) -> List[str]:
                 if len(outpath) > 1:
                     raise Exception(f"Maximum 1 token after > in {block.content}. Got: {outpath}")
                 outpath = str(Path(directory, *outpath))
-                logging.info(f"OUTPATH = {outpath}")
+                logger.info(f"OUTPATH = {outpath}")
             else:
                 outpath = None
-            logging.info(f"Executing: {cmd}")
+            logger.info(f"Executing: {cmd}")
             r = subprocess.run(cmd, cwd=directory, capture_output=True)
             block.output = r.stdout.decode("utf-8")
             if outpath:
                 with open(outpath, "w", encoding="UTF-8") as stream:
-                    logging.info(f"WRITING {len(block.output)} TO = {outpath}")
+                    logger.info(f"WRITING {len(block.output)} TO = {outpath}")
                     stream.write(block.output)
             block.error = r.stderr.decode("utf-8")
-            logging.info(f"OUT [sample] = {block.output[0:30]}")
+            logger.info(f"OUT [sample] = {block.output[0:30]}")
             if block.expected_fail:
                 if r.returncode == 0:
                     err(f"Command unexpectedly succeeded: {cmd}")
                 else:
-                    logging.info("Failed as expected")
+                    logger.info("Failed as expected")
                 if block.error:
-                    logging.info(f"ERR [sample] = ...{block.error[-200:]}")
+                    logger.info(f"ERR [sample] = ...{block.error[-200:]}")
             else:
                 if block.error:
-                    logging.info(f"ERR = {block.error}")
+                    logger.info(f"ERR = {block.error}")
                 if r.returncode != 0:
                     err(f"Command failed: {cmd}")
                 else:
-                    logging.info("Success!")
+                    logger.info("Success!")
         elif block.is_stdout():
             if "compare_rdf" in block.annotations:
-                logging.warning("SKIPPING RDF COMPARISON. TODO: https://github.com/linkml/linkml/issues/427")
+                logger.warning("SKIPPING RDF COMPARISON. TODO: https://github.com/linkml/linkml/issues/427")
             elif last_block.output:
                 if last_block.output.strip() != block.content.strip():
                     err(f"Mismatch: {str(last_block.output)} != {block.content}")
                 else:
-                    logging.info("Hurray! Contents match!")
+                    logger.info("Hurray! Contents match!")
             else:
-                logging.info("No comparison performed")
+                logger.info("No comparison performed")
         else:
-            logging.warning(f"Ignoring block: {block}")
+            logger.warning(f"Ignoring block: {block}")
         last_block = block
     return errs
 
@@ -201,20 +203,20 @@ def cli(inputs, directory):
     logging.basicConfig(level=logging.INFO)
     errs = []
     for input in inputs:
-        logging.info(f"INPUT={input}")
+        logger.info(f"INPUT={input}")
         blocks = parse_file_to_blocks(input)
         print(f"## {len(blocks)} Blocks")
         localdir = Path(input).stem
         subdir = PurePath(directory, localdir)
         input_errs = execute_blocks(str(subdir), blocks)
         if len(input_errs) > 0:
-            logging.error(f"TUTORIAL {input} FAILURES: {len(input_errs)}")
+            logger.error(f"TUTORIAL {input} FAILURES: {len(input_errs)}")
         errs += input_errs
-    logging.info(f"Errors = {len(errs)}")
+    logger.info(f"Errors = {len(errs)}")
     if len(errs) > 0:
-        logging.error(f"Encountered {len(errs)} Errors")
+        logger.error(f"Encountered {len(errs)} Errors")
         for err in errs:
-            logging.error(f"Error: {err}")
+            logger.error(f"Error: {err}")
         sys.exit(1)
 
 

linkml/utils/generator.py

@@ -54,6 +54,8 @@ from linkml.utils.mergeutils import alias_root
 from linkml.utils.schemaloader import SchemaLoader
 from linkml.utils.typereferences import References
 
+logger = logging.getLogger(__name__)
+
 
 @lru_cache
 def _resolved_metamodel(mergeimports):
@@ -61,7 +63,7 @@ def _resolved_metamodel(mergeimports):
         raise AssertionError(f"{LOCAL_METAMODEL_YAML_FILE} not found")
 
     base_dir = str(Path(str(LOCAL_METAMODEL_YAML_FILE)).parent)
-    logging.debug(f"BASE={base_dir}")
+    logger.debug(f"BASE={base_dir}")
     metamodel = SchemaLoader(
         LOCAL_METAMODEL_YAML_FILE,
         importmap={"linkml": base_dir},
@@ -179,7 +181,7 @@ class Generator(metaclass=abc.ABCMeta):
 
     def __post_init__(self) -> None:
         if not self.logger:
-            self.logger = logging.getLogger()
+            self.logger = logger
         if self.log_level is not None:
             self.logger.setLevel(self.log_level)
         if self.format is None:
@@ -203,7 +205,7 @@ class Generator(metaclass=abc.ABCMeta):
         if self.uses_schemaloader:
             self._initialize_using_schemaloader(schema)
         else:
-            logging.info(f"Using SchemaView with im={self.importmap} // base_dir={self.base_dir}")
+            self.logger.info(f"Using SchemaView with im={self.importmap} // base_dir={self.base_dir}")
             self.schemaview = SchemaView(schema, importmap=self.importmap, base_dir=self.base_dir)
             if self.include:
                 if isinstance(self.include, (str, Path)):
@@ -840,7 +842,7 @@ class Generator(metaclass=abc.ABCMeta):
             if ":" not in mapping or len(mapping.split(":")) != 2:
                 raise ValueError(f"Definition {defn.name} - unrecognized mapping: {mapping}")
             ns = mapping.split(":")[0]
-            logging.debug(f"Adding {ns} from {mapping} // {defn}")
+            self.logger.debug(f"Adding {ns} from {mapping} // {defn}")
             if ns:
                 self.add_prefix(ns)
 

linkml/utils/mergeutils.py

@@ -18,6 +18,8 @@ from linkml_runtime.utils.namespaces import Namespaces
 from linkml_runtime.utils.yamlutils import extended_str
 from rdflib import URIRef
 
+logger = logging.getLogger(__name__)
+
 
 def merge_schemas(
     target: SchemaDefinition,
@@ -72,7 +74,7 @@ def merge_namespaces(target: SchemaDefinition, mergee: SchemaDefinition, namespa
             # We cannot resolve this to an absolute path, so we have to assume that
             # this prefix is already defined correctly in the target
             if prefix.prefix_prefix not in namespaces:
-                logging.info(
+                logger.info(
                     "Adding an unadjusted relative prefix for %s from %s, "
                     + "as the prefix is not yet defined, even as we cannot adjust it relative to the final file. "
                     + "If it cannot be resolved, add the prefix definition to the input schema!",
@@ -85,7 +87,7 @@ def merge_namespaces(target: SchemaDefinition, mergee: SchemaDefinition, namespa
                     prefix.prefix_prefix in target.prefixes
                     and target.prefixes[prefix.prefix_prefix].prefix_reference != prefix.prefix_reference
                 ):
-                    logging.info(
+                    logger.info(
                         "Ignoring different relative prefix for %s from %s, "
                         + "as we cannot adjust it relative to the final file. "
                         + "Assuming the first found location is correct: %s!",

linkml/utils/schema_fixer.py

@@ -94,7 +94,7 @@ class SchemaFixer:
         tree_roots = [c for c in sv.all_classes().values() if c.tree_root]
         if len(tree_roots) > 0:
             if force:
-                logging.info("Forcing addition of containers")
+                logger.info("Forcing addition of containers")
             else:
                 raise ValueError(f"Schema already has containers: {tree_roots}")
         container = ClassDefinition(class_name, tree_root=True)
@@ -228,7 +228,7 @@ class SchemaFixer:
             # slots within that are redundant
             slot_usage_keys = list(cls.slot_usage.keys())
             for slot_usage_key in slot_usage_keys:
-                logging.debug(f"TESTING: {class_name}.{slot_usage_key}")
+                logger.debug(f"TESTING: {class_name}.{slot_usage_key}")
                 slot_usage_value = cls.slot_usage[slot_usage_key]
                 # perform a deletion test: what can be retrieved by inference
                 del cls.slot_usage[slot_usage_key]
@@ -236,7 +236,7 @@ class SchemaFixer:
                 try:
                     induced_slot = sv.induced_slot(slot_usage_key, class_name)
                 except ValueError:
-                    logging.warning(f"slot_usage with no slot: {slot_usage_key}")
+                    logger.warning(f"slot_usage with no slot: {slot_usage_key}")
                     continue
                 # restore value
                 cls.slot_usage[slot_usage_key] = slot_usage_value
@@ -258,7 +258,7 @@ class SchemaFixer:
                         continue
                     induced_v = getattr(induced_slot, metaslot_name, None)
                     if v is not None and v != [] and v != {} and v == induced_v:
-                        logging.info(f"REDUNDANT: {class_name}.{slot_usage_key}[{metaslot_name}] = {v}")
+                        logger.info(f"REDUNDANT: {class_name}.{slot_usage_key}[{metaslot_name}] = {v}")
                         to_delete.append(metaslot_name)
                 for metaslot_name in to_delete:
                     del slot_usage_value[metaslot_name]
@@ -302,7 +302,7 @@ class SchemaFixer:
                 if len(vals_strs) == 1:
                     harmonized_slot[k] = vals.pop()
                 elif len(vals_strs) > 1:
-                    logging.info(f"Variable values in {slot_name}.{k}: {vals_strs}")
+                    logger.info(f"Variable values in {slot_name}.{k}: {vals_strs}")
             new_slots[str(slot_name)] = harmonized_slot
         return new_slots
 

linkml/utils/schemaloader.py

@@ -29,6 +29,8 @@ from linkml.utils.mergeutils import merge_classes, merge_schemas, merge_slots, s
 from linkml.utils.rawloader import load_raw_schema
 from linkml.utils.schemasynopsis import SchemaSynopsis
 
+lgr = logging.getLogger(__name__)
+
 
 class SchemaLoader:
     def __init__(
@@ -57,7 +59,7 @@ class SchemaLoader:
         :param source_file_date: modification of source file
         :param source_file_size: size of source file
         """
-        self.logger = logger if logger is not None else logging.getLogger(self.__class__.__name__)
+        self.logger = logger if logger is not None else lgr
         if isinstance(data, SchemaDefinition):
             self.schema = data
         else:
@@ -176,7 +178,7 @@ class SchemaLoader:
                     # mangled names are overwritten if a schema with attributes is passed in
                     # TODO: handle this in a more graceful way
                     #  see https://github.com/linkml/linkml/issues/872
-                    logging.warning(
+                    self.logger.warning(
                         f'Class: "{cls.name}" attribute "{attribute.name}" - '
                         f"mangled name: {mangled_slot_name} already exists",
                     )
@@ -770,7 +772,7 @@ class SchemaLoader:
             if slotname in self.schema.slots:
                 base_slot = self.schema.slots[slotname]
             else:
-                logging.error(f"slot_usage for undefined slot: {slotname}")
+                self.logger.error(f"slot_usage for undefined slot: {slotname}")
                 base_slot = None
             parent_slot = self.schema.slots.get(slot_usage.is_a)
             # Follow the ancestry of the class to get the most proximal parent

linkml/utils/sqlutils.py

@@ -40,6 +40,8 @@ from linkml.utils.datautils import (
     infer_root_class,
 )
 
+logger = logging.getLogger(__name__)
+
 
 @dataclass
 class SQLStore:
@@ -376,7 +378,7 @@ def dump(
 
         inputs = [item for input in inputs for item in glob.glob(input)]
     for input in inputs:
-        logging.info(f"Loading: {input}")
+        logger.info(f"Loading: {input}")
         input_format = _get_format(input, input_format)
         loader = get_loader(input_format)
 

linkml/validator/plugins/pydantic_validation_plugin.py

@@ -37,7 +37,7 @@ class PydanticValidationPlugin(ValidationPlugin):
         """
         pydantic_model = context.pydantic_model(closed=self.closed)
         try:
-            instance = pydantic_model.parse_obj(instance)
+            instance = pydantic_model.model_validate(instance)
         except Exception as e:
             yield ValidationResult(
                 type="Pydantic validation",

linkml/validators/jsonschemavalidator.py

@@ -19,6 +19,8 @@ from linkml.generators.pythongen import PythonGenerator
 from linkml.utils import datautils
 from linkml.utils.datavalidator import DataValidator
 
+logger = logging.getLogger(__name__)
+
 
 class HashableSchemaDefinition(SchemaDefinition):
     def __hash__(self) -> int:
@@ -27,7 +29,7 @@ class HashableSchemaDefinition(SchemaDefinition):
 
 @lru_cache(maxsize=None)
 def _generate_jsonschema(schema, top_class, closed, include_range_class_descendants):
-    logging.debug("Generating JSON Schema")
+    logger.debug("Generating JSON Schema")
     not_closed = not closed
     return JsonSchemaGenerator(
         schema=schema,

linkml/validators/sparqlvalidator.py

@@ -15,6 +15,8 @@ from linkml.reporting import CheckResult, Report
 from linkml.utils.datautils import _get_format, dumpers_loaders, get_dumper
 from linkml.utils.datavalidator import DataValidator
 
+logger = logging.getLogger(__name__)
+
 
 def sparqljson2dict(row: dict):
     return {k: v["value"] for k, v in row.items()}
@@ -55,7 +57,7 @@ class SparqlDataValidator(DataValidator):
                 for row in qres:
                     invalid += row
             except Exception:
-                logging.error(f"FAILED: {qn}")
+                logger.error(f"FAILED: {qn}")
         return invalid
 
     def validate_endpoint(self, url: str, **kwargs):
@@ -65,8 +67,8 @@ class SparqlDataValidator(DataValidator):
         report = Report()
         for qn, q in self.queries.items():
             q += " LIMIT 20"
-            logging.debug(f"QUERY: {qn}")
-            logging.debug(f"{q}")
+            logger.debug(f"QUERY: {qn}")
+            logger.debug(f"{q}")
             sw = SPARQLWrapper(url)
             sw.setQuery(q)
             sw.setReturnFormat(JSON)

linkml/workspaces/example_runner.py

@@ -24,6 +24,8 @@ from linkml._version import __version__
 from linkml.generators.pythongen import PythonGenerator
 from linkml.validator import Validator, _get_default_validator
 
+logger = logging.getLogger(__name__)
+
 
 @dataclass
 class SummaryDocument:
@@ -134,7 +136,7 @@ class ExampleRunner:
             input_examples = glob.glob(os.path.join(str(input_dir), f"*.{fmt}"))
             input_counter_examples = glob.glob(os.path.join(str(counter_example_dir), f"*.{fmt}"))
             if not input_counter_examples:
-                logging.warning(f"No counter examples found in {self.counter_example_input_directory}")
+                logger.warning(f"No counter examples found in {self.counter_example_input_directory}")
             self.process_examples_from_list(input_examples, fmt, False)
             self.process_examples_from_list(input_counter_examples, fmt, True)
 

{linkml-1.8.3.dist-info → linkml-1.8.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: linkml
-Version: 1.8.3
+Version: 1.8.4
 Summary: Linked Open Data Modeling Language
 Home-page: https://linkml.io/linkml/
 Keywords: schema,linked data,data modeling,rdf,owl,biolink
@@ -24,6 +24,7 @@ Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Provides-Extra: black
+Provides-Extra: numpydantic
 Provides-Extra: shacl
 Provides-Extra: tests
 Requires-Dist: antlr4-python3-runtime (>=4.9.0,<4.10)
@@ -37,6 +38,7 @@ Requires-Dist: jsonasobj2 (>=1.0.3,<2.0.0)
 Requires-Dist: jsonschema[format] (>=4.0.0)
 Requires-Dist: linkml-dataops
 Requires-Dist: linkml-runtime (>=1.8.1,<2.0.0)
+Requires-Dist: numpydantic (>=1.6.1) ; (python_version >= "3.9") and (extra == "numpydantic" or extra == "tests")
 Requires-Dist: openpyxl
 Requires-Dist: parse
 Requires-Dist: prefixcommons (>=0.1.7)