linkml 1.8.3__tar.gz → 1.8.4__tar.gz

{linkml-1.8.3 → linkml-1.8.4}/PKG-INFO

@@ -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)

{linkml-1.8.3 → linkml-1.8.4}/linkml/generators/__init__.py

@@ -10,6 +10,7 @@ from linkml.generators.jsonschemagen import JsonSchemaGenerator
 from linkml.generators.owlgen import OwlSchemaGenerator
 from linkml.generators.pydanticgen import PydanticGenerator
 from linkml.generators.pythongen import PythonGenerator
+from linkml.generators.rdfgen import RDFGenerator
 from linkml.generators.shaclgen import ShaclGenerator
 from linkml.generators.shexgen import ShExGenerator
 from linkml.generators.sqlalchemygen import SQLAlchemyGenerator
@@ -50,6 +51,7 @@ __all__ = [
     "ShExGenerator",
     "SQLAlchemyGenerator",
     "SQLTableGenerator",
+    "RDFGenerator",
 ]
 
 # TODO: deprecate usage of these

{linkml-1.8.3 → linkml-1.8.4}/linkml/generators/docgen/index.md.jinja2

@@ -21,11 +21,11 @@ Name: {{ schema.name }}
 | --- | --- |
 {% if gen.hierarchical_class_view -%}
 {% for u, v in gen.class_hierarchy_as_tuples() -%}
-| {{ " "|safe*u*8 }}{{ gen.link(schemaview.get_class(v)) }} | {{ schemaview.get_class(v).description }} |
+| {{ " "|safe*u*8 }}{{ gen.link(schemaview.get_class(v), True) }} | {{ schemaview.get_class(v).description }} |
 {% endfor %}
 {% else -%}
 {% for c in gen.all_class_objects()|sort(attribute=sort_by) -%}
-| {{gen.link(c)}} | {{c.description|enshorten}} |
+| {{gen.link(c, True)}} | {{c.description|enshorten}} |
 {% endfor %}
 {% endif %}
 
@@ -34,7 +34,7 @@ Name: {{ schema.name }}
 | Slot | Description |
 | --- | --- |
 {% for s in gen.all_slot_objects()|sort(attribute=sort_by) -%}
-| {{gen.link(s)}} | {{s.description|enshorten}} |
+| {{gen.link(s, True)}} | {{s.description|enshorten}} |
 {% endfor %}
 
 ## Enumerations
@@ -42,7 +42,7 @@ Name: {{ schema.name }}
 | Enumeration | Description |
 | --- | --- |
 {% for e in gen.all_enum_objects()|sort(attribute=sort_by) -%}
-| {{gen.link(e)}} | {{e.description|enshorten}} |
+| {{gen.link(e, True)}} | {{e.description|enshorten}} |
 {% endfor %}
 
 ## Types
@@ -50,7 +50,7 @@ Name: {{ schema.name }}
 | Type | Description |
 | --- | --- |
 {% for t in gen.all_type_objects()|sort(attribute=sort_by) -%}
-| {{gen.link(t)}} | {{t.description|enshorten}} |
+| {{gen.link(t, True)}} | {{t.description|enshorten}} |
 {% endfor %}
 
 ## Subsets
@@ -58,5 +58,5 @@ Name: {{ schema.name }}
 | Subset | Description |
 | --- | --- |
 {% for ss in schemaview.all_subsets().values()|sort(attribute='name') -%}
-| {{gen.link(ss)}} | {{ss.description|enshorten}} |
+| {{gen.link(ss, True)}} | {{ss.description|enshorten}} |
 {% endfor %}

{linkml-1.8.3 → linkml-1.8.4}/linkml/generators/docgen.py

@@ -50,6 +50,13 @@ DIALECT = MarkdownDialect
 MAX_CHARS_IN_TABLE = 80
 MAX_RANK = 1000
 
+SCHEMA_SUBFOLDER = "schemas"
+CLASS_SUBFOLDER = "classes"
+SLOT_SUBFOLDER = "slots"
+ENUM_SUBFOLDER = "enums"
+TYPE_SUBFOLDER = "types"
+SUBSET_SUBFOLDER = "subsets"
+
 
 def enshorten(input):
     """
@@ -144,6 +151,9 @@ class DocGenerator(Generator):
     include_top_level_diagram: bool = False
     """Whether the index page should include a schema diagram"""
 
+    subfolder_type_separation: bool = False
+    """Whether each type (class, slot, etc.) should be put in separate subfolder for navigation purposes"""
+
     example_directory: Optional[str] = None
     example_runner: ExampleRunner = field(default_factory=lambda: ExampleRunner())
 
@@ -205,7 +215,11 @@ class DocGenerator(Generator):
             self.logger.debug(f"  Generating doc for {schema_name}")
             imported_schema = sv.schema_map.get(schema_name)
             out_str = template.render(gen=self, schema=imported_schema, schemaview=sv, **template_vars)
-            self._write(out_str, directory, imported_schema.name)
+            self._write(
+                out_str,
+                f"{directory}/{SCHEMA_SUBFOLDER}" if self.subfolder_type_separation else directory,
+                imported_schema.name,
+            )
         self.logger.debug("Processing Classes...")
         template = self._get_template("class")
         for cn, c in sv.all_classes().items():
@@ -214,7 +228,7 @@ class DocGenerator(Generator):
             n = self.name(c)
             self.logger.debug(f"  Generating doc for {n}")
             out_str = template.render(gen=self, element=c, schemaview=sv, **template_vars)
-            self._write(out_str, directory, n)
+            self._write(out_str, f"{directory}/{CLASS_SUBFOLDER}" if self.subfolder_type_separation else directory, n)
         self.logger.debug("Processing Slots...")
         template = self._get_template("slot")
         for sn, s in sv.all_slots().items():
@@ -224,7 +238,7 @@ class DocGenerator(Generator):
             self.logger.debug(f"  Generating doc for {n}")
             s = sv.induced_slot(sn)
             out_str = template.render(gen=self, element=s, schemaview=sv, **template_vars)
-            self._write(out_str, directory, n)
+            self._write(out_str, f"{directory}/{SLOT_SUBFOLDER}" if self.subfolder_type_separation else directory, n)
         self.logger.debug("Processing Enums...")
         template = self._get_template("enum")
         for en, e in sv.all_enums().items():
@@ -233,7 +247,7 @@ class DocGenerator(Generator):
             n = self.name(e)
             self.logger.debug(f"  Generating doc for {n}")
             out_str = template.render(gen=self, element=e, schemaview=sv, **template_vars)
-            self._write(out_str, directory, n)
+            self._write(out_str, f"{directory}/{ENUM_SUBFOLDER}" if self.subfolder_type_separation else directory, n)
         self.logger.debug("Processing Types...")
         template = self._get_template("type")
         for tn, t in sv.all_types().items():
@@ -243,7 +257,7 @@ class DocGenerator(Generator):
             self.logger.debug(f"  Generating doc for {n}")
             t = sv.induced_type(tn)
             out_str = template.render(gen=self, element=t, schemaview=sv, **template_vars)
-            self._write(out_str, directory, n)
+            self._write(out_str, f"{directory}/{TYPE_SUBFOLDER}" if self.subfolder_type_separation else directory, n)
         self.logger.debug("Processing Subsets...")
         template = self._get_template("subset")
         for _, s in sv.all_subsets().items():
@@ -252,7 +266,7 @@ class DocGenerator(Generator):
             n = self.name(s)
             self.logger.debug(f"  Generating doc for {n}")
             out_str = template.render(gen=self, element=s, schemaview=sv, **template_vars)
-            self._write(out_str, directory, n)
+            self._write(out_str, f"{directory}/{SUBSET_SUBFOLDER}" if self.subfolder_type_separation else directory, n)
 
     def _write(self, out_str: str, directory: str, name: str) -> None:
         """
@@ -384,13 +398,19 @@ class DocGenerator(Generator):
         curie = self.uri(element, expand=False)
         return f"[{curie}]({uri})"
 
-    def link(self, e: Union[Definition, DefinitionName]) -> str:
+    def link(self, e: Union[Definition, DefinitionName], index_link: bool = False) -> str:
         """
         Render an element as a hyperlink
 
         :param e:
+        :param index_link: Whether this is a link for the index page or not
         :return:
         """
+        if index_link:
+            subfolder = ""
+        else:
+            subfolder = "../"
+
         if e is None:
             return "NONE"
         if not isinstance(e, Definition):
@@ -401,20 +421,43 @@ class DocGenerator(Generator):
             if self.use_class_uris:
                 curie = self.schemaview.get_uri(e)
                 if curie is not None:
-                    return self._markdown_link(n=curie.split(":")[1], name=e.name)
-            return self._markdown_link(camelcase(e.name))
+                    return self._markdown_link(
+                        n=curie.split(":")[1],
+                        name=e.name,
+                        subfolder=subfolder + CLASS_SUBFOLDER if self.subfolder_type_separation else None,
+                    )
+            return self._markdown_link(
+                camelcase(e.name),
+                subfolder=subfolder + CLASS_SUBFOLDER if self.subfolder_type_separation else None,
+            )
         elif isinstance(e, EnumDefinition):
-            return self._markdown_link(camelcase(e.name))
+            return self._markdown_link(
+                camelcase(e.name),
+                subfolder=subfolder + ENUM_SUBFOLDER if self.subfolder_type_separation else None,
+            )
         elif isinstance(e, SlotDefinition):
             if self.use_slot_uris:
                 curie = self.schemaview.get_uri(e)
                 if curie is not None:
-                    return self._markdown_link(n=curie.split(":")[1], name=e.name)
-            return self._markdown_link(underscore(e.name))
+                    return self._markdown_link(
+                        n=curie.split(":")[1],
+                        name=e.name,
+                        subfolder=subfolder + SLOT_SUBFOLDER if self.subfolder_type_separation else None,
+                    )
+            return self._markdown_link(
+                underscore(e.name),
+                subfolder=subfolder + SLOT_SUBFOLDER if self.subfolder_type_separation else None,
+            )
         elif isinstance(e, TypeDefinition):
-            return self._markdown_link(camelcase(e.name))
+            return self._markdown_link(
+                camelcase(e.name),
+                subfolder=subfolder + TYPE_SUBFOLDER if self.subfolder_type_separation else None,
+            )
         elif isinstance(e, SubsetDefinition):
-            return self._markdown_link(camelcase(e.name))
+            return self._markdown_link(
+                camelcase(e.name),
+                subfolder=subfolder + SUBSET_SUBFOLDER if self.subfolder_type_separation else None,
+            )
         else:
             return e.name
 
@@ -977,6 +1020,11 @@ Include LinkML Schema outside of imports mechanism.  Helpful in including deprec
 YAML, and including it when necessary but not by default (e.g. in documentation or for backwards compatibility)
 """,
 )
+@click.option(
+    "--subfolder-type-separation/--no-subfolder-type-separation",
+    default=False,
+    help="Separate type (class, slot, etc.) outputs in different subfolders for navigation purposes",
+)
 @click.version_option(__version__, "-V", "--version")
 @click.command(name="doc")
 def cli(
@@ -988,6 +1036,7 @@ def cli(
     use_slot_uris,
     use_class_uris,
     hierarchical_class_view,
+    subfolder_type_separation,
     **args,
 ):
     """Generate documentation folder from a LinkML YAML schema
@@ -1018,6 +1067,7 @@ def cli(
         use_class_uris=use_class_uris,
         hierarchical_class_view=hierarchical_class_view,
         index_name=index_name,
+        subfolder_type_separation=subfolder_type_separation,
         **args,
     )
     print(gen.serialize())

{linkml-1.8.3 → linkml-1.8.4}/linkml/generators/golanggen.py

@@ -11,6 +11,8 @@ from linkml_runtime.utils.formatutils import camelcase, underscore
 from linkml._version import __version__
 from linkml.utils.generator import Generator, shared_arguments
 
+logger = logging.getLogger(__name__)
+
 type_map = {
     "str": "string",
     "int": "int",
@@ -175,7 +177,7 @@ class GolangGenerator(Generator):
                 if t.base and t.base in type_map:
                     return type_map[t.base]
                 else:
-                    logging.warning(f"Unknown type.base: {t.name}")
+                    logger.warning(f"Unknown type.base: {t.name}")
             return "string"
 
     @staticmethod

{linkml-1.8.3 → linkml-1.8.4}/linkml/generators/jsonschemagen.py

@@ -24,6 +24,8 @@ from linkml._version import __version__
 from linkml.generators.common.type_designators import get_type_designator_value
 from linkml.utils.generator import Generator, shared_arguments
 
+logger = logging.getLogger(__name__)
+
 # Map from underlying python data type to json equivalent
 # Note: The underlying types are a union of any built-in python datatype + any type defined in
 #       linkml-runtime/utils/metamodelcore.py
@@ -222,14 +224,14 @@ class JsonSchemaGenerator(Generator):
 
     def __post_init__(self):
         if self.topClass:
-            logging.warning("topClass is deprecated - use top_class")
+            logger.warning("topClass is deprecated - use top_class")
             self.top_class = self.topClass
 
         super().__post_init__()
 
         if self.top_class:
             if self.schemaview.get_class(self.top_class) is None:
-                logging.warning(f"No class in schema named {self.top_class}")
+                logger.warning(f"No class in schema named {self.top_class}")
 
     def start_schema(self, inline: bool = False) -> JsonSchema:
         self.inline = inline

{linkml-1.8.3 → linkml-1.8.4}/linkml/generators/owlgen.py

@@ -40,6 +40,8 @@ from linkml import METAMODEL_NAMESPACE_NAME
 from linkml._version import __version__
 from linkml.utils.generator import Generator, shared_arguments
 
+logger = logging.getLogger(__name__)
+
 OWL_TYPE = URIRef  ## RDFS.Literal or OWL.Thing
 
 SWRL = rdflib.Namespace("http://www.w3.org/2003/11/swrl#")
@@ -270,7 +272,7 @@ class OwlSchemaGenerator(Generator):
                     # if isinstance(v, str):
                     #    obj = URIRef(msv.expand_curie(v))
                     # else:
-                    #    logging.debug(f"Skipping {uri} {metaslot_uri} => {v}")
+                    #    logger.debug(f"Skipping {uri} {metaslot_uri} => {v}")
                 else:
                     obj = Literal(v)
                 self.graph.add((uri, metaslot_uri, obj))
@@ -438,7 +440,7 @@ class OwlSchemaGenerator(Generator):
                 if slot:
                     own_slots.append(slot)
                 else:
-                    logging.warning(f"Unknown top-level slot {slot_name}")
+                    logger.warning(f"Unknown top-level slot {slot_name}")
         else:
             own_slots = []
         own_slots.extend(cls.slot_conditions.values())
@@ -503,9 +505,9 @@ class OwlSchemaGenerator(Generator):
             owl_exprs.append(self._complement_of_union_of([self.transform_class_expression(x) for x in cls.none_of]))
         for slot in own_slots:
             if slot.name:
-                owltypes = self.slot_node_owltypes(sv.get_slot(slot.name))
+                owltypes = self.slot_node_owltypes(sv.get_slot(slot.name), owning_class=cls)
             else:
-                owltypes = self.slot_node_owltypes(slot)
+                owltypes = self.slot_node_owltypes(slot, owning_class=cls)
             x = self.transform_class_slot_expression(cls, slot, slot, owltypes)
             if not x:
                 range = sv.schema.default_range
@@ -552,12 +554,28 @@ class OwlSchemaGenerator(Generator):
                     owl_exprs.append(self._some_values_from(slot_uri, has_member_expr))
         return self._intersection_of(owl_exprs)
 
-    def slot_node_owltypes(self, slot: Union[SlotDefinition, AnonymousSlotExpression]) -> Set[URIRef]:
+    def slot_node_owltypes(
+        self,
+        slot: Union[SlotDefinition, AnonymousSlotExpression],
+        owning_class: Optional[Union[ClassDefinition, AnonymousClassExpression]] = None,
+    ) -> Set[URIRef]:
+        """
+        Determine the OWL types of a named slot or slot expression
+
+        The OWL type is either OWL.Thing or RDFS.Datatype
+
+        :param slot:
+        :param owning_class:
+        :return:
+        """
         sv = self.schemaview
         node_types = set()
         if isinstance(slot, SlotDefinition):
-            if slot.range in sv.all_classes():
-                range_class = sv.get_class(slot.range)
+            slot_range = slot.range
+            if isinstance(owning_class, ClassDefinition):
+                slot_range = sv.induced_slot(slot.name, owning_class.name).range
+            if slot_range in sv.all_classes():
+                range_class = sv.get_class(slot_range)
                 if not (range_class and range_class.class_uri == "linkml:Any"):
                     node_types.add(OWL.Thing)
             if slot.range in sv.all_types():
@@ -565,7 +583,7 @@ class OwlSchemaGenerator(Generator):
         for k in ["any_of", "all_of", "exactly_one_of", "none_of"]:
             subslot = getattr(slot, k, None)
             if subslot:
-                node_types.update(self.slot_node_owltypes(subslot))
+                node_types.update(self.slot_node_owltypes(subslot, owning_class=owning_class))
         return node_types
 
     def transform_class_slot_expression(
@@ -679,7 +697,7 @@ class OwlSchemaGenerator(Generator):
         if element.equals_string is not None:
             equals_string = element.equals_string
             if is_literal is None:
-                logging.warning(f"ignoring equals_string={equals_string} as unable to tell if literal")
+                logger.warning(f"ignoring equals_string={equals_string} as unable to tell if literal")
             elif is_literal:
                 constraints[XSD.pattern] = equals_string
             else:
@@ -688,7 +706,7 @@ class OwlSchemaGenerator(Generator):
         if element.equals_string_in:
             equals_string_in = element.equals_string_in
             if is_literal is None:
-                logging.warning(f"ignoring equals_string={equals_string_in} as unable to tell if literal")
+                logger.warning(f"ignoring equals_string={equals_string_in} as unable to tell if literal")
             elif is_literal:
                 dt_exprs = [
                     self._datatype_restriction(XSD.string, [self._facet(XSD.pattern, s)]) for s in equals_string_in
@@ -754,7 +772,7 @@ class OwlSchemaGenerator(Generator):
                     if slot_uri == URIRef(att_uri):
                         n += 1
             if n > 1:
-                logging.warning(f"Ambiguous attribute: {slot.name} {slot_uri}")
+                logger.warning(f"Ambiguous attribute: {slot.name} {slot_uri}")
                 return
 
         self.add_metadata(slot, slot_uri)
@@ -845,6 +863,7 @@ class OwlSchemaGenerator(Generator):
                 if not isinstance(v, list):
                     v = [v]
                 impls.extend(v)
+            impls.extend(element.implements)
         for impl in impls:
             if impl.startswith("owl:"):
                 return OWL[impl.split(":")[1]]
@@ -889,7 +908,7 @@ class OwlSchemaGenerator(Generator):
             if pv_owl_type == RDFS.Literal:
                 pv_node = Literal(pv.text)
                 if pv.meaning:
-                    logging.warning(f"Meaning on literal {pv.text} in {e.name} is ignored")
+                    logger.warning(f"Meaning on literal {pv.text} in {e.name} is ignored")
             else:
                 pv_node = self._permissible_value_uri(pv, enum_uri, e)
             pv_uris.append(pv_node)
@@ -950,7 +969,7 @@ class OwlSchemaGenerator(Generator):
     def _add_rule(self, subject: Union[URIRef, BNode], rule: ClassRule, cls: ClassDefinition):
         if not self.use_swrl:
             return
-        logging.warning("SWRL support is experimental and incomplete")
+        logger.warning("SWRL support is experimental and incomplete")
         head = []
         body = []
         for pre in rule.preconditions:
@@ -997,7 +1016,7 @@ class OwlSchemaGenerator(Generator):
                 owltypes.update(x_owltypes)
         owltypes.update(current)
         if len(owltypes) > 1:
-            logging.warning(f"Multiple owl types {owltypes}")
+            logger.warning(f"Multiple owl types {owltypes}")
             # if self.target_profile == OWLProfile.dl:
         return owltypes
 
@@ -1125,7 +1144,7 @@ class OwlSchemaGenerator(Generator):
     ) -> Optional[Union[BNode, URIRef]]:
         graph = self.graph
         if [x for x in exprs if x is None]:
-            logging.warning(f"Null expr in: {exprs} for {predicate} {node}")
+            logger.warning(f"Null expr in: {exprs} for {predicate} {node}")
             exprs = [x for x in exprs if x is not None]
         if len(exprs) == 0:
             return None
@@ -1251,10 +1270,10 @@ class OwlSchemaGenerator(Generator):
             return OWL.ObjectProperty
         is_literal_vals = self.slot_is_literal_map[slot.name]
         if len(is_literal_vals) > 1:
-            logging.warning(f"Ambiguous type for: {slot.name}")
+            logger.warning(f"Ambiguous type for: {slot.name}")
         if range is None:
             if not is_literal_vals:
-                logging.warning(f"Guessing type for {slot.name}")
+                logger.warning(f"Guessing type for {slot.name}")
                 return OWL.ObjectProperty
             if (list(is_literal_vals))[0]:
                 return OWL.DatatypeProperty

{linkml-1.8.3 → linkml-1.8.4}/linkml/generators/projectgen.py

@@ -26,6 +26,8 @@ from linkml.generators.sqltablegen import SQLTableGenerator
 from linkml.utils.cli_utils import log_level_option
 from linkml.utils.generator import Generator
 
+logger = logging.getLogger(__name__)
+
 PATH_FSTRING = str
 GENERATOR_NAME = str
 ARG_DICT = Dict[str, Any]
@@ -63,14 +65,14 @@ GEN_MAP = {
 
 @lru_cache()
 def get_local_imports(schema_path: str, dir: str):
-    logging.info(f"GETTING IMPORTS = {schema_path}")
+    logger.info(f"GETTING IMPORTS = {schema_path}")
     all_imports = [schema_path]
     with open(schema_path) as stream:
         with open(schema_path) as stream:
             schema = yaml.safe_load(stream)
             for imp in schema.get("imports", []):
                 imp_path = os.path.join(dir, imp) + ".yaml"
-                logging.info(f" IMP={imp} //  path={imp_path}")
+                logger.info(f" IMP={imp} //  path={imp_path}")
                 if os.path.isfile(imp_path):
                     all_imports += get_local_imports(imp_path, dir)
     return all_imports
@@ -105,23 +107,23 @@ class ProjectGenerator:
             all_schemas = [schema_path]
         else:
             all_schemas = get_local_imports(schema_path, os.path.dirname(schema_path))
-        logging.debug(f"ALL_SCHEMAS = {all_schemas}")
+        logger.debug(f"ALL_SCHEMAS = {all_schemas}")
         for gen_name, (gen_cls, gen_path_fmt, default_gen_args) in GEN_MAP.items():
             if config.includes is not None and config.includes != [] and gen_name not in config.includes:
-                logging.info(f"Skipping {gen_name} as not in inclusion list: {config.includes}")
+                logger.info(f"Skipping {gen_name} as not in inclusion list: {config.includes}")
                 continue
             if config.excludes is not None and gen_name in config.excludes:
-                logging.info(f"Skipping {gen_name} as it is in exclusion list")
+                logger.info(f"Skipping {gen_name} as it is in exclusion list")
                 continue
-            logging.info(f"Generating: {gen_name}")
+            logger.info(f"Generating: {gen_name}")
             for local_path in all_schemas:
-                logging.info(f" SCHEMA: {local_path}")
+                logger.info(f" SCHEMA: {local_path}")
                 name = os.path.basename(local_path).replace(".yaml", "")
                 gen_path = gen_path_fmt.format(name=name)
                 gen_path_full = f"{config.directory}/{gen_path}"
                 parts = gen_path_full.split("/")
                 parent_dir = "/".join(parts[0:-1])
-                logging.info(f" PARENT={parent_dir}")
+                logger.info(f" PARENT={parent_dir}")
                 Path(parent_dir).mkdir(parents=True, exist_ok=True)
                 gen_path_full = "/".join(parts)
                 all_gen_args = {
@@ -143,13 +145,13 @@ class ProjectGenerator:
                     if isinstance(v, str):
                         v = v.format(name=name, parent=parent_dir)
                     serialize_args[k] = v
-                logging.info(f" {gen_name} ARGS: {serialize_args}")
+                logger.info(f" {gen_name} ARGS: {serialize_args}")
                 gen_dump = gen.serialize(**serialize_args)
 
                 if gen_name != "excel":
                     if parts[-1] != "":
                         # markdowngen does not write to a file
-                        logging.info(f"  WRITING TO: {gen_path_full}")
+                        logger.info(f"  WRITING TO: {gen_path_full}")
                         with open(gen_path_full, "w", encoding="UTF-8") as stream:
                             stream.write(gen_dump)
                 else:
@@ -249,7 +251,7 @@ def cli(
             project_config.generator_args = yaml.safe_load(generator_arguments)
         except Exception:
             raise Exception("Argument must be a valid YAML blob")
-        logging.info(f"generator args: {project_config.generator_args}")
+        logger.info(f"generator args: {project_config.generator_args}")
     if dir is not None:
         project_config.directory = dir
     project_config.mergeimports = mergeimports