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

linkml/generators/pydanticgen/pydanticgen.py

@@ -45,6 +45,9 @@ from linkml.generators.python.python_ifabsent_processor import PythonIfAbsentPro
 from linkml.utils import deprecation_warning
 from linkml.utils.generator import shared_arguments
 
+logger = logging.getLogger(__name__)
+
+
 if int(PYDANTIC_VERSION[0]) == 1:
     deprecation_warning("pydantic-v1")
 
@@ -189,7 +192,7 @@ class PydanticGenerator(OOCodeGenerator, LifecycleMixin):
     template_dir: Optional[Union[str, Path]] = None
     """
     Override templates for each PydanticTemplateModel.
-    
+
     Directory with templates that override the default :attr:`.PydanticTemplateModel.template`
     for each class. If a matching template is not found in the override directory,
     the default templates will be used.
@@ -218,7 +221,7 @@ class PydanticGenerator(OOCodeGenerator, LifecycleMixin):
         )
 
     """
-    imports: Optional[List[Import]] = None
+    imports: Optional[Union[List[Import], Imports]] = None
     """
     Additional imports to inject into generated module.
 
@@ -266,6 +269,13 @@ class PydanticGenerator(OOCodeGenerator, LifecycleMixin):
         else:
             from typing_extensions import Literal
 
+    """
+    sort_imports: bool = True
+    """
+    Before returning from :meth:`.PydanticGenerator.render`, sort imports with :meth:`.Imports.sort`
+
+    Default ``True``, but optional in case import order must be explicitly given,
+    eg. to avoid circular import errors in complex generator subclasses.
     """
     metadata_mode: Union[MetadataMode, str, None] = MetadataMode.AUTO
     """
@@ -358,8 +368,8 @@ class PydanticGenerator(OOCodeGenerator, LifecycleMixin):
         try:
             return compile_python(pycode)
         except NameError as e:
-            logging.error(f"Code:\n{pycode}")
-            logging.error(f"Error compiling generated python code: {e}")
+            logger.error(f"Code:\n{pycode}")
+            logger.error(f"Error compiling generated python code: {e}")
             raise e
 
     def _get_classes(self, sv: SchemaView) -> Tuple[List[ClassDefinition], Optional[List[ClassDefinition]]]:
@@ -448,11 +458,12 @@ class PydanticGenerator(OOCodeGenerator, LifecycleMixin):
 
     def generate_slot(self, slot: SlotDefinition, cls: ClassDefinition) -> SlotResult:
         slot_args = {
-            k: slot._as_dict.get(k, None)
+            k: getattr(slot, k, None)
             for k in PydanticAttribute.model_fields.keys()
-            if slot._as_dict.get(k, None) is not None
+            if getattr(slot, k, None) is not None
         }
-        slot_args["name"] = underscore(slot.name)
+        slot_alias = slot.alias if slot.alias else slot.name
+        slot_args["name"] = underscore(slot_alias)
         slot_args["description"] = slot.description.replace('"', '\\"') if slot.description is not None else None
         predef = self.predefined_slot_values.get(camelcase(cls.name), {}).get(slot.name, None)
         if predef is not None:
@@ -665,7 +676,7 @@ class PydanticGenerator(OOCodeGenerator, LifecycleMixin):
         else:
             # TODO: default ranges in schemagen
             # pyrange = 'str'
-            # logging.error(f'range: {s.range} is unknown')
+            # logger.error(f'range: {s.range} is unknown')
             raise Exception(f"range: {slot_range}")
         return pyrange
 
@@ -921,14 +932,20 @@ class PydanticGenerator(OOCodeGenerator, LifecycleMixin):
         return Import(module=module, objects=[ObjectImport(name=camelcase(class_name))], is_schema=True)
 
     def render(self) -> PydanticModule:
+        """
+        Render the schema to a :class:`PydanticModule` model
+        """
         sv: SchemaView
         sv = self.schemaview
 
         # imports
         imports = DEFAULT_IMPORTS
         if self.imports is not None:
-            for i in self.imports:
-                imports += i
+            if isinstance(self.imports, Imports):
+                imports += self.imports
+            else:
+                for i in self.imports:
+                    imports += i
         if self.split_mode == SplitMode.FULL:
             imports += self._get_imports()
 
@@ -965,13 +982,14 @@ class PydanticGenerator(OOCodeGenerator, LifecycleMixin):
         class_results = self.after_generate_classes(class_results, sv)
 
         classes = {r.cls.name: r.cls for r in class_results}
-
         injected_classes = self._clean_injected_classes(injected_classes)
 
+        imports.render_sorted = self.sort_imports
+
         module = PydanticModule(
             metamodel_version=self.schema.metamodel_version,
             version=self.schema.version,
-            python_imports=imports.imports,
+            python_imports=imports,
             base_model=base_model,
             injected_classes=injected_classes,
             enums=enums,
@@ -987,7 +1005,8 @@ class PydanticGenerator(OOCodeGenerator, LifecycleMixin):
 
         Args:
             rendered_module ( :class:`.PydanticModule` ): Optional, if schema was previously
-                rendered with :meth:`.render` , use that, otherwise :meth:`.render` fresh.
+                rendered with :meth:`~.PydanticGenerator.render` , use that,
+                otherwise :meth:`~.PydanticGenerator.render` fresh.
         """
         if rendered_module is not None:
             module = rendered_module
@@ -1147,9 +1166,9 @@ def _ensure_inits(paths: List[Path]):
     help="""
 Optional jinja2 template directory to use for class generation.
 
-Pass a directory containing templates with the same name as any of the default 
-:class:`.PydanticTemplateModel` templates to override them. The given directory will be 
-searched for matching templates, and use the default templates as a fallback 
+Pass a directory containing templates with the same name as any of the default
+:class:`.PydanticTemplateModel` templates to override them. The given directory will be
+searched for matching templates, and use the default templates as a fallback
 if an override is not found
 
 Available templates to override:

linkml/generators/pydanticgen/template.py

@@ -1,5 +1,6 @@
+import sys
 from importlib.util import find_spec
-from typing import Any, ClassVar, Dict, Generator, List, Literal, Optional, Union
+from typing import Any, ClassVar, Dict, Generator, List, Literal, Optional, Tuple, Union, get_args
 
 from jinja2 import Environment, PackageLoader
 from pydantic import BaseModel, Field, field_validator
@@ -28,6 +29,14 @@ else:
         return f
 
 
+IMPORT_GROUPS = Literal["future", "stdlib", "thirdparty", "local", "conditional"]
+"""
+See :attr:`.Import.group` and :attr:`.Imports.sort`
+
+Order of this literal is used in sort and therefore not arbitrary.
+"""
+
+
 class PydanticTemplateModel(TemplateModel):
     """
     Metaclass to render pydantic models with jinja templates.
@@ -292,6 +301,28 @@ class Import(PydanticTemplateModel):
     Used primarily in split schema generation, see :func:`.pydanticgen.generate_split` for example usage.
     """
 
+    @computed_field
+    def group(self) -> IMPORT_GROUPS:
+        """
+        Import group used when sorting
+
+        * ``future`` - from `__future__` import...
+        * ``stdlib`` - ... the standard library
+        * ``thirdparty`` - other dependencies not in the standard library
+        * ``local`` - relative imports (eg. from split generation)
+        * ``conditional`` - a :class:`.ConditionalImport`
+        """
+        if self.module == "__future__":
+            return "future"
+        elif sys.version_info.minor >= 10 and self.module in sys.stdlib_module_names:
+            return "stdlib"
+        elif sys.version_info.minor < 10 and self.module in _some_stdlib_module_names:
+            return "stdlib"
+        elif self.module.startswith("."):
+            return "local"
+        else:
+            return "thirdparty"
+
     def merge(self, other: "Import") -> List["Import"]:
         """
         Merge one import with another, see :meth:`.Imports` for an example.
@@ -346,6 +377,16 @@ class Import(PydanticTemplateModel):
             # one is a module, the other imports objects, keep both
             return [self, other]
 
+    def sort(self) -> None:
+        """
+        Sort imported objects
+
+        * First by whether the first letter is capitalized or not,
+        * Then alphabetically (by object name rather than alias)
+        """
+        if self.objects:
+            self.objects = sorted(self.objects, key=lambda obj: (obj.name[0].islower(), obj.name))
+
 
 class ConditionalImport(Import):
     """
@@ -391,6 +432,17 @@ class ConditionalImport(Import):
     condition: str
     alternative: Import
 
+    @computed_field
+    def group(self) -> Literal["conditional"]:
+        return "conditional"
+
+    def sort(self) -> None:
+        """
+        :meth:`.Import.sort` called for self and :attr:`.alternative`
+        """
+        super(ConditionalImport, self).sort()
+        self.alternative.sort()
+
 
 class Imports(PydanticTemplateModel):
     """
@@ -427,6 +479,10 @@ class Imports(PydanticTemplateModel):
     template: ClassVar[str] = "imports.py.jinja"
 
     imports: List[Union[Import, ConditionalImport]] = Field(default_factory=list)
+    group_order: Tuple[str, ...] = get_args(IMPORT_GROUPS)
+    """Order in which to sort imports by their :attr:`.Import.group`"""
+    render_sorted: bool = True
+    """When rendering, render in sorted groups"""
 
     @classmethod
     def _merge(
@@ -484,13 +540,17 @@ class Imports(PydanticTemplateModel):
                         break
 
         # SPECIAL CASE - __future__ annotations must happen at the top of a file
+        # sort here outside of sort method because our imports are invalid without it,
+        # where calling ``sort`` should be optional.
         imports = sorted(imports, key=lambda i: i.module == "__future__", reverse=True)
         return imports
 
     def __add__(self, other: Union[Import, "Imports", List[Import]]) -> "Imports":
         imports = self.imports.copy()
         imports = self._merge(imports, other)
-        return Imports.model_construct(imports=imports)
+        return Imports.model_construct(
+            imports=imports, **{k: getattr(self, k, None) for k in self.model_fields if k != "imports"}
+        )
 
     def __len__(self) -> int:
         return len(self.imports)
@@ -552,6 +612,36 @@ class Imports(PydanticTemplateModel):
             merged_imports = cls._merge(merged_imports, i)
         return merged_imports
 
+    @computed_field
+    def import_groups(self) -> List[IMPORT_GROUPS]:
+        """
+        List of what group each import belongs to
+        """
+        return [i.group for i in self.imports]
+
+    def sort(self) -> None:
+        """
+        Sort imports recursively, mimicking isort:
+
+        * First by :attr:`.Import.group` according to :attr:`.Imports.group_order`
+        * Then by whether the :class:`.Import` has any objects
+          (``import module`` comes before ``from module import name``)
+        * Then alphabetically by module name
+        """
+
+        def _sort_key(i: Import) -> Tuple[int, int, str]:
+            return (self.group_order.index(i.group), int(i.objects is not None), i.module)
+
+        imports = sorted(self.imports, key=_sort_key)
+        for i in imports:
+            i.sort()
+        self.imports = imports
+
+    def render(self, environment: Optional[Environment] = None, black: bool = False) -> str:
+        if self.render_sorted:
+            self.sort()
+        return super(Imports, self).render(environment=environment, black=black)
+
 
 class PydanticModule(PydanticTemplateModel):
     """
@@ -565,7 +655,7 @@ class PydanticModule(PydanticTemplateModel):
     version: Optional[str] = None
     base_model: PydanticBaseModel = PydanticBaseModel()
     injected_classes: Optional[List[str]] = None
-    python_imports: List[Union[Import, ConditionalImport]] = Field(default_factory=list)
+    python_imports: Union[Imports, List[Union[Import, ConditionalImport]]] = Imports()
     enums: Dict[str, PydanticEnum] = Field(default_factory=dict)
     classes: Dict[str, PydanticClass] = Field(default_factory=dict)
     meta: Optional[Dict[str, Any]] = None
@@ -573,6 +663,21 @@ class PydanticModule(PydanticTemplateModel):
     Metadata for the schema to be included in a linkml_meta module-level instance of LinkMLMeta
     """
 
+    @field_validator("python_imports", mode="after")
+    @classmethod
+    def cast_imports(cls, imports: Union[Imports, List[Union[Import, ConditionalImport]]]) -> Imports:
+        if isinstance(imports, list):
+            imports = Imports(imports=imports)
+        return imports
+
     @computed_field
     def class_names(self) -> List[str]:
         return [c.name for c in self.classes.values()]
+
+
+_some_stdlib_module_names = {"copy", "datetime", "decimal", "enum", "inspect", "os", "re", "sys", "typing"}
+"""
+sys.stdlib_module_names is only present in 3.10 and later
+so we make a cheap copy of the stdlib modules that we commonly use here,
+but this should be removed whenever support for 3.9 is dropped.
+"""

linkml/generators/pydanticgen/templates/imports.py.jinja

@@ -20,12 +20,20 @@ from {{ module }} import (
     {%- endif %}
 {%- endif %}
 {% endmacro %}
+{#- For when used with Import model -#}
 {%- if module %}
 {{ import_(module, alias, objects) }}
 {% endif -%}
 {#- For when used with Imports container -#}
 {%- if imports -%}
-{%- for i in imports -%}
-{{ i }}
-{%- endfor -%}
+    {%- if render_sorted -%}
+        {% for i in range(imports | length) %}
+{{ imports[i] }}
+{%- if not loop.last and import_groups[i] != import_groups[i+1] %}{{ '\n' }}{% endif -%}
+        {% endfor %}
+    {%- else -%}
+        {%- for import in imports -%}
+{{ import }}
+        {%- endfor -%}
+    {%- endif -%}
 {% endif -%}

linkml/generators/pydanticgen/templates/module.py.jinja

@@ -1,6 +1,4 @@
-{% for import in python_imports %}
-{{ import }}
-{%- endfor -%}
+{{ python_imports }}
 
 metamodel_version = "{{metamodel_version}}"
 version = "{{version if version else None}}"

linkml/generators/pydanticgen/templates/validator.py.jinja

@@ -3,9 +3,9 @@
         pattern=re.compile(r"{{pattern}}")
         if isinstance(v,list):
             for element in v:
-                if not pattern.match(element):
+                if isinstance(v, str) and not pattern.match(element):
                     raise ValueError(f"Invalid {{name}} format: {element}")
         elif isinstance(v,str):
             if not pattern.match(v):
                 raise ValueError(f"Invalid {{name}} format: {v}")
-        return v
+        return v

linkml/generators/pythongen.py

@@ -32,6 +32,8 @@ from linkml._version import __version__
 from linkml.generators.python.python_ifabsent_processor import PythonIfAbsentProcessor
 from linkml.utils.generator import Generator, shared_arguments
 
+logger = logging.getLogger(__name__)
+
 
 @dataclass
 class PythonGenerator(Generator):
@@ -57,10 +59,10 @@ class PythonGenerator(Generator):
     dataclass_repr: bool = False
     """
     Whether generated dataclasses should also generate a default __repr__ method.
-    
+
     Default ``False`` so that the parent :class:`linkml_runtime.utils.yamlutils.YAMLRoot` 's
     ``__repr__`` method is inherited for model pretty printing.
-    
+
     References:
         - https://docs.python.org/3/library/dataclasses.html#dataclasses.dataclass
     """
@@ -75,7 +77,7 @@ class PythonGenerator(Generator):
         if self.format is None:
             self.format = self.valid_formats[0]
         if self.schema.default_prefix == "linkml" and not self.genmeta:
-            logging.error("Generating metamodel without --genmeta is highly inadvisable!")
+            logger.error("Generating metamodel without --genmeta is highly inadvisable!")
         if not self.schema.source_file and isinstance(self.sourcefile, str) and "\n" not in self.sourcefile:
             self.schema.source_file = os.path.basename(self.sourcefile)
 
@@ -88,8 +90,8 @@ class PythonGenerator(Generator):
         try:
             return compile_python(pycode)
         except NameError as e:
-            logging.error(f"Code:\n{pycode}")
-            logging.error(f"Error compiling generated python code: {e}")
+            logger.error(f"Code:\n{pycode}")
+            logger.error(f"Error compiling generated python code: {e}")
             raise e
 
     def visit_schema(self, **kwargs) -> None:
@@ -944,11 +946,11 @@ dataclasses._init_fn = dataclasses_init_fn_with_kwargs
 
     def forward_reference(self, slot_range: str, owning_class: str) -> bool:
         """Determine whether slot_range is a forward reference"""
-        # logging.info(f"CHECKING: {slot_range} {owning_class}")
+        # logger.info(f"CHECKING: {slot_range} {owning_class}")
         if (slot_range in self.schema.classes and self.schema.classes[slot_range].imported_from) or (
             slot_range in self.schema.enums and self.schema.enums[slot_range].imported_from
         ):
-            logging.info(
+            logger.info(
                 f"FALSE: FORWARD: {slot_range} {owning_class} // IMP={self.schema.classes[slot_range].imported_from}"
             )
             return False
@@ -957,10 +959,10 @@ dataclasses._init_fn = dataclasses_init_fn_with_kwargs
         clist = [x.name for x in self._sort_classes(self.schema.classes.values())]
         for cname in clist:
             if cname == owning_class:
-                logging.info(f"TRUE: OCCURS SAME: {cname} == {slot_range} owning: {owning_class}")
+                logger.info(f"TRUE: OCCURS SAME: {cname} == {slot_range} owning: {owning_class}")
                 return True  # Occurs on or after
             elif cname == slot_range:
-                logging.info(f"FALSE: OCCURS BEFORE: {cname} == {slot_range} owning: {owning_class}")
+                logger.info(f"FALSE: OCCURS BEFORE: {cname} == {slot_range} owning: {owning_class}")
                 return False  # Occurs before
         return True
 
@@ -1214,7 +1216,7 @@ def cli(
     )
     if validate:
         mod = gen.compile_module()
-        logging.info(f"Module {mod} compiled successfully")
+        logger.info(f"Module {mod} compiled successfully")
     print(gen.serialize(emit_metadata=head, **args))
 
 

linkml/generators/shaclgen.py

@@ -5,19 +5,21 @@ from typing import Callable, List
 
 import click
 from jsonasobj2 import JsonObj, as_dict
-from linkml_runtime.linkml_model.meta import ElementName
+from linkml_runtime.linkml_model.meta import ClassDefinition, ElementName
 from linkml_runtime.utils.formatutils import underscore
 from linkml_runtime.utils.schemaview import SchemaView
 from linkml_runtime.utils.yamlutils import TypedNode, extended_float, extended_int, extended_str
 from rdflib import BNode, Graph, Literal, URIRef
 from rdflib.collection import Collection
-from rdflib.namespace import RDF, RDFS, SH, XSD
+from rdflib.namespace import RDF, SH, XSD
 
 from linkml._version import __version__
 from linkml.generators.shacl.shacl_data_type import ShaclDataType
 from linkml.generators.shacl.shacl_ifabsent_processor import ShaclIfAbsentProcessor
 from linkml.utils.generator import Generator, shared_arguments
 
+logger = logging.getLogger(__name__)
+
 
 @dataclass
 class ShaclGenerator(Generator):
@@ -74,9 +76,6 @@ class ShaclGenerator(Generator):
             shape_pv(RDF.type, SH.NodeShape)
             shape_pv(SH.targetClass, class_uri)  # TODO
 
-            if c.is_a:
-                shape_pv(RDFS.subClassOf, URIRef(sv.get_uri(c.is_a, expand=True)))
-
             if self.closed:
                 if c.mixin or c.abstract:
                     shape_pv(SH.closed, Literal(False))
@@ -88,9 +87,9 @@ class ShaclGenerator(Generator):
                 shape_pv(SH.name, Literal(c.title))
             if c.description is not None:
                 shape_pv(SH.description, Literal(c.description))
-            list_node = BNode()
-            Collection(g, list_node, [RDF.type])
-            shape_pv(SH.ignoredProperties, list_node)
+
+            shape_pv(SH.ignoredProperties, self._build_ignored_properties(g, c))
+
             if c.annotations and self.include_annotations:
                 self._add_annotations(shape_pv, c)
             order = 0
@@ -130,7 +129,7 @@ class ShaclGenerator(Generator):
                     # slot definition, as both are mapped to sh:in in SHACL
                     if s.equals_string or s.equals_string_in:
                         error = "'equals_string'/'equals_string_in' and 'any_of' are mutually exclusive"
-                        raise ValueError(f'{TypedNode.yaml_loc(s, suffix="")} {error}')
+                        raise ValueError(f'{TypedNode.yaml_loc(str(s), suffix="")} {error}')
 
                     or_node = BNode()
                     prop_pv(SH["or"], or_node)
@@ -244,7 +243,7 @@ class ShaclGenerator(Generator):
             if rt.annotations and self.include_annotations:
                 self._add_annotations(func, rt)
         else:
-            logging.error(f"No URI for type {rt.name}")
+            logger.error(f"No URI for type {rt.name}")
 
     def _and_equals_string(self, g: Graph, func: Callable, values: List) -> None:
         pv_node = BNode()
@@ -301,6 +300,31 @@ class ShaclGenerator(Generator):
         )
         func(SH["in"], pv_node)
 
+    def _build_ignored_properties(self, g: Graph, c: ClassDefinition) -> BNode:
+        def collect_child_properties(class_name: str, output: set) -> None:
+            for childName in self.schemaview.class_children(class_name, imports=True, mixins=False, is_a=True):
+                output.update(
+                    {
+                        URIRef(self.schemaview.get_uri(prop, expand=True))
+                        for prop in self.schemaview.class_slots(childName)
+                    }
+                )
+                collect_child_properties(childName, output)
+
+        child_properties = set()
+        collect_child_properties(c.name, child_properties)
+
+        class_slot_uris = {
+            URIRef(self.schemaview.get_uri(prop, expand=True)) for prop in self.schemaview.class_slots(c.name)
+        }
+        ignored_properties = child_properties.difference(class_slot_uris)
+
+        list_node = BNode()
+        ignored_properties.add(RDF.type)
+        Collection(g, list_node, list(ignored_properties))
+
+        return list_node
+
 
 def add_simple_data_type(func: Callable, r: ElementName) -> None:
     for datatype in list(ShaclDataType):

linkml/generators/sparqlgen.py

@@ -14,6 +14,8 @@ from linkml_runtime.utils.schemaview import SchemaView
 from linkml._version import __version__
 from linkml.utils.generator import Generator, shared_arguments
 
+logger = logging.getLogger(__name__)
+
 template = """
 {% for pfxn, pfx in schema.prefixes.items() -%}
 PREFIX {{pfxn}}: <{{pfx.prefix_reference}}>
@@ -150,7 +152,7 @@ class SparqlGenerator(Generator):
         extra = ""
         if named_graphs is not None:
             extra += f'FILTER( ?graph in ( {",".join(named_graphs)} ))'
-        logging.info(f"Named Graphs = {named_graphs} // extra={extra}")
+        logger.info(f"Named Graphs = {named_graphs} // extra={extra}")
         if limit is not None and isinstance(limit, int):
             limit = f"LIMIT {limit}"
         else:

linkml/generators/sqlalchemygen.py

@@ -21,6 +21,8 @@ from linkml.generators.sqltablegen import SQLTableGenerator
 from linkml.transformers.relmodel_transformer import ForeignKeyPolicy, RelationalModelTransformer
 from linkml.utils.generator import Generator, shared_arguments
 
+logger = logging.getLogger(__name__)
+
 
 class TemplateEnum(Enum):
     DECLARATIVE = "declarative"
@@ -84,7 +86,7 @@ class SQLAlchemyGenerator(Generator):
         template_obj = Template(template_str)
         if model_path is None:
             model_path = self.schema.name
-        logging.info(f"Package for dataclasses ==  {model_path}")
+        logger.info(f"Package for dataclasses ==  {model_path}")
         backrefs = defaultdict(list)
         for m in tr_result.mappings:
             backrefs[m.source_class].append(m)
@@ -113,7 +115,7 @@ class SQLAlchemyGenerator(Generator):
             is_join_table=lambda c: any(tag for tag in c.annotations.keys() if tag == "linkml:derived_from"),
             classes=rel_schema_classes_ordered,
         )
-        logging.debug(f"# Generated code:\n{code}")
+        logger.debug(f"# Generated code:\n{code}")
         return code
 
     def serialize(self, **kwargs) -> str:
@@ -173,7 +175,7 @@ class SQLAlchemyGenerator(Generator):
     def skip(cls: ClassDefinition) -> bool:
         is_skip = len(cls.attributes) == 0
         if is_skip:
-            logging.error(f"SKIPPING: {cls.name}")
+            logger.error(f"SKIPPING: {cls.name}")
         return is_skip
 
     # TODO: move this

linkml/generators/sqltablegen.py

@@ -16,6 +16,8 @@ from linkml.transformers.relmodel_transformer import ForeignKeyPolicy, Relationa
 from linkml.utils.generator import Generator, shared_arguments
 from linkml.utils.schemaloader import SchemaLoader
 
+logger = logging.getLogger(__name__)
+
 
 class SqlNamingPolicy(Enum):
     preserve = "preserve"
@@ -262,12 +264,12 @@ class SQLTableGenerator(Generator):
         elif range is None:
             return Text()
         else:
-            logging.error(f"Unknown range: {range} for {slot.name} = {slot.range}")
+            logger.error(f"Unknown range: {range} for {slot.name} = {slot.range}")
             return Text()
         if range_base in RANGEMAP:
             return RANGEMAP[range_base]
         else:
-            logging.error(f"UNKNOWN range base: {range_base} for {slot.name} = {slot.range}")
+            logger.error(f"UNKNOWN range base: {range_base} for {slot.name} = {slot.range}")
             return Text()
 
     @staticmethod