databao-context-engine 0.1.4.dev1__py3-none-any.whl → 0.1.6__py3-none-any.whl

databao_context_engine/datasources/datasource_context.py

@@ -6,7 +6,7 @@ from pathlib import Path
 import yaml
 
 from databao_context_engine.datasources.types import Datasource, DatasourceId, DatasourceType
-from databao_context_engine.project.layout import ProjectLayout, get_output_dir
+from databao_context_engine.project.layout import ProjectLayout
 
 logger = logging.getLogger(__name__)
 
@@ -37,33 +37,31 @@ def _read_datasource_type_from_context_file(context_path: Path) -> DatasourceTyp
 
 
 def get_introspected_datasource_list(project_layout: ProjectLayout) -> list[Datasource]:
-    output_dir = get_output_dir(project_dir=project_layout.project_dir)
-
     result = []
-    for main_type_dir in sorted((p for p in output_dir.iterdir() if p.is_dir()), key=lambda p: p.name.lower()):
-        for context_path in sorted(
-            (p for p in main_type_dir.iterdir() if p.suffix in [".yaml", ".yml"]), key=lambda p: p.name.lower()
-        ):
+    for dirpath, dirnames, filenames in os.walk(project_layout.output_dir):
+        for context_file_name in filenames:
+            if Path(context_file_name).suffix not in DatasourceId.ALLOWED_YAML_SUFFIXES:
+                continue
+            context_file = Path(dirpath).joinpath(context_file_name)
+            relative_context_file = context_file.relative_to(project_layout.output_dir)
             try:
                 result.append(
                     Datasource(
-                        id=DatasourceId.from_datasource_config_file_path(context_path),
-                        type=_read_datasource_type_from_context_file(context_path),
+                        id=DatasourceId.from_datasource_context_file_path(relative_context_file),
+                        type=_read_datasource_type_from_context_file(context_file),
                     )
                 )
             except ValueError as e:
                 logger.debug(str(e), exc_info=True, stack_info=True)
                 logger.warning(
-                    f"Ignoring introspected datasource: Failed to read datasource_type from context file at {context_path.resolve()}"
+                    f"Ignoring introspected datasource: Failed to read datasource_type from context file at {context_file.resolve()}"
                 )
 
-    return result
+    return sorted(result, key=lambda ds: str(ds.id).lower())
 
 
 def get_datasource_context(project_layout: ProjectLayout, datasource_id: DatasourceId) -> DatasourceContext:
-    output_dir = get_output_dir(project_dir=project_layout.project_dir)
-
-    context_path = output_dir.joinpath(datasource_id.relative_path_to_context_file())
+    context_path = project_layout.output_dir.joinpath(datasource_id.relative_path_to_context_file())
     if not context_path.is_file():
         raise ValueError(f"Context file not found for datasource {str(datasource_id)}")
 
@@ -72,21 +70,20 @@ def get_datasource_context(project_layout: ProjectLayout, datasource_id: Datasou
 
 
 def get_all_contexts(project_layout: ProjectLayout) -> list[DatasourceContext]:
-    output_dir = get_output_dir(project_dir=project_layout.project_dir)
-
     result = []
-    for main_type_dir in sorted((p for p in output_dir.iterdir() if p.is_dir()), key=lambda p: p.name.lower()):
-        for context_path in sorted(
-            (p for p in main_type_dir.iterdir() if p.suffix in [".yaml", ".yml"]), key=lambda p: p.name.lower()
-        ):
+    for dirpath, dirnames, filenames in os.walk(project_layout.output_dir):
+        for context_file_name in filenames:
+            if Path(context_file_name).suffix not in DatasourceId.ALLOWED_YAML_SUFFIXES:
+                continue
+            context_file = Path(dirpath).joinpath(context_file_name)
+            relative_context_file = context_file.relative_to(project_layout.output_dir)
             result.append(
                 DatasourceContext(
-                    datasource_id=DatasourceId.from_datasource_context_file_path(context_path),
-                    context=context_path.read_text(),
+                    datasource_id=DatasourceId.from_datasource_context_file_path(relative_context_file),
+                    context=context_file.read_text(),
                 )
             )
-
-    return result
+    return sorted(result, key=lambda context: str(context.datasource_id).lower())
 
 
 def get_context_header_for_datasource(datasource_id: DatasourceId) -> str:

databao_context_engine/datasources/datasource_discovery.py

@@ -1,4 +1,5 @@
 import logging
+import os
 from pathlib import Path
 from typing import Any
 
@@ -14,15 +15,15 @@ from databao_context_engine.datasources.types import (
     PreparedFile,
 )
 from databao_context_engine.pluginlib.build_plugin import DatasourceType
-from databao_context_engine.project.layout import get_source_dir
+from databao_context_engine.project.layout import ProjectLayout
 from databao_context_engine.templating.renderer import render_template
 
 logger = logging.getLogger(__name__)
 
 
-def get_datasource_list(project_dir: Path) -> list[Datasource]:
+def get_datasource_list(project_layout: ProjectLayout) -> list[Datasource]:
     result = []
-    for discovered_datasource in discover_datasources(project_dir=project_dir):
+    for discovered_datasource in discover_datasources(project_layout=project_layout):
         try:
             prepared_source = prepare_source(discovered_datasource)
         except Exception as e:
@@ -32,7 +33,7 @@ def get_datasource_list(project_dir: Path) -> list[Datasource]:
 
         result.append(
             Datasource(
-                id=DatasourceId.from_datasource_config_file_path(discovered_datasource.path),
+                id=DatasourceId.from_datasource_config_file_path(project_layout, discovered_datasource.path),
                 type=prepared_source.datasource_type,
             )
         )
@@ -40,7 +41,7 @@ def get_datasource_list(project_dir: Path) -> list[Datasource]:
     return result
 
 
-def discover_datasources(project_dir: Path) -> list[DatasourceDescriptor]:
+def discover_datasources(project_layout: ProjectLayout) -> list[DatasourceDescriptor]:
     """Scan the project's src/ directory and return all discovered sources.
 
     Rules:
@@ -48,24 +49,21 @@ def discover_datasources(project_dir: Path) -> list[DatasourceDescriptor]:
         - Unsupported or unreadable entries are skipped.
         - The returned list is sorted by directory and then filename
 
+    Args:
+        project_layout: ProjectLayout instance representing the project directory and configuration.
+
     Returns:
         A list of DatasourceDescriptor instances representing the discovered datasources.
-
-    Raises:
-        ValueError: If the src directory does not exist in the project directory.
     """
-    src = get_source_dir(project_dir)
-    if not src.exists() or not src.is_dir():
-        raise ValueError(f"src directory does not exist in {project_dir}")
-
     datasources: list[DatasourceDescriptor] = []
-    for main_dir in sorted((p for p in src.iterdir() if p.is_dir()), key=lambda p: p.name.lower()):
-        for path in sorted((p for p in main_dir.iterdir() if _is_datasource_file(p)), key=lambda p: p.name.lower()):
-            datasource = _load_datasource_descriptor(path)
+    for dirpath, dirnames, filenames in os.walk(project_layout.src_dir):
+        for config_file_name in filenames:
+            context_file = Path(dirpath).joinpath(config_file_name)
+            datasource = _load_datasource_descriptor(project_layout, context_file)
             if datasource is not None:
                 datasources.append(datasource)
 
-    return datasources
+    return sorted(datasources, key=lambda ds: str(ds.datasource_id.relative_path_to_config_file()).lower())
 
 
 def _is_datasource_file(p: Path) -> bool:
@@ -73,42 +71,44 @@ def _is_datasource_file(p: Path) -> bool:
     return p.is_file() and not p.suffix.endswith("~")
 
 
-def get_datasource_descriptors(project_dir: Path, datasource_ids: list[DatasourceId]):
-    src = get_source_dir(project_dir)
-    if not src.exists() or not src.is_dir():
-        raise ValueError(f"src directory does not exist in {project_dir}")
-
+def get_datasource_descriptors(
+    project_layout: ProjectLayout, datasource_ids: list[DatasourceId]
+) -> list[DatasourceDescriptor]:
     datasources: list[DatasourceDescriptor] = []
     for datasource_id in sorted(datasource_ids, key=lambda id: str(id)):
-        config_file_path = src.joinpath(datasource_id.relative_path_to_config_file())
+        config_file_path = project_layout.src_dir.joinpath(datasource_id.relative_path_to_config_file())
         if not config_file_path.is_file():
             raise ValueError(f"Datasource config file not found: {config_file_path}")
 
-        datasource = _load_datasource_descriptor(config_file_path)
+        datasource = _load_datasource_descriptor(project_layout, config_file_path)
         if datasource is not None:
             datasources.append(datasource)
 
     return datasources
 
 
-def _load_datasource_descriptor(path: Path) -> DatasourceDescriptor | None:
+def _load_datasource_descriptor(project_layout: ProjectLayout, config_file: Path) -> DatasourceDescriptor | None:
     """Load a single file with src/<parent_name>/ into a DatasourceDescriptor."""
-    if not path.is_file():
+    if not config_file.is_file():
         return None
 
-    parent_name = path.parent.name
-    extension = path.suffix.lower().lstrip(".")
+    parent_name = config_file.parent.name
+    extension = config_file.suffix.lower().lstrip(".")
+    relative_config_file = config_file.relative_to(project_layout.src_dir)
 
-    if parent_name == "files":
-        return DatasourceDescriptor(path=path.resolve(), main_type=parent_name, kind=DatasourceKind.FILE)
+    if parent_name == "files" and len(relative_config_file.parts) == 2:
+        datasource_id = DatasourceId.from_datasource_config_file_path(project_layout, config_file)
+        return DatasourceDescriptor(datasource_id=datasource_id, path=config_file.resolve(), kind=DatasourceKind.FILE)
 
     if extension in {"yaml", "yml"}:
-        return DatasourceDescriptor(path=path.resolve(), main_type=parent_name, kind=DatasourceKind.CONFIG)
+        datasource_id = DatasourceId.from_datasource_config_file_path(project_layout, config_file)
+        return DatasourceDescriptor(datasource_id=datasource_id, path=config_file.resolve(), kind=DatasourceKind.CONFIG)
 
     if extension:
-        return DatasourceDescriptor(path=path.resolve(), main_type=parent_name, kind=DatasourceKind.FILE)
+        datasource_id = DatasourceId.from_datasource_config_file_path(project_layout, config_file)
+        return DatasourceDescriptor(datasource_id=datasource_id, path=config_file.resolve(), kind=DatasourceKind.FILE)
 
-    logger.debug("Skipping file without extension: %s", path)
+    logger.debug("Skipping file without extension: %s", config_file)
     return None
 
 
@@ -117,23 +117,24 @@ def prepare_source(datasource: DatasourceDescriptor) -> PreparedDatasource:
     if datasource.kind is DatasourceKind.FILE:
         file_subtype = datasource.path.suffix.lower().lstrip(".")
         return PreparedFile(
-            datasource_type=DatasourceType.from_main_and_subtypes(main_type=datasource.main_type, subtype=file_subtype),
+            datasource_id=datasource.datasource_id,
+            datasource_type=DatasourceType(full_type=file_subtype),
             path=datasource.path,
         )
 
-    else:
-        config = _parse_config_file(datasource.path)
+    config = _parse_config_file(datasource.path)
 
-        subtype = config.get("type")
-        if not subtype or not isinstance(subtype, str):
-            raise ValueError("Config missing 'type' at %s - skipping", datasource.path)
+    ds_type = config.get("type")
+    if not ds_type or not isinstance(ds_type, str):
+        raise ValueError("Config missing 'type' at %s - skipping", datasource.path)
 
-        return PreparedConfig(
-            datasource_type=DatasourceType.from_main_and_subtypes(main_type=datasource.main_type, subtype=subtype),
-            path=datasource.path,
-            config=config,
-            datasource_name=datasource.path.stem,
-        )
+    return PreparedConfig(
+        datasource_id=datasource.datasource_id,
+        datasource_type=DatasourceType(full_type=ds_type),
+        path=datasource.path,
+        config=config,
+        datasource_name=datasource.path.stem,
+    )
 
 
 def _parse_config_file(file_path: Path) -> dict[Any, Any]:

databao_context_engine/datasources/types.py

@@ -1,10 +1,10 @@
-import os
 from dataclasses import dataclass
 from enum import StrEnum
 from pathlib import Path
 from typing import Any
 
 from databao_context_engine.pluginlib.build_plugin import DatasourceType
+from databao_context_engine.project.layout import ProjectLayout
 
 
 class DatasourceKind(StrEnum):
@@ -14,13 +14,14 @@ class DatasourceKind(StrEnum):
 
 @dataclass(frozen=True)
 class DatasourceDescriptor:
+    datasource_id: "DatasourceId"
     path: Path
     kind: DatasourceKind
-    main_type: str
 
 
 @dataclass(frozen=True)
 class PreparedConfig:
+    datasource_id: "DatasourceId"
     datasource_type: DatasourceType
     path: Path
     config: dict[Any, Any]
@@ -29,6 +30,7 @@ class PreparedConfig:
 
 @dataclass(frozen=True)
 class PreparedFile:
+    datasource_id: "DatasourceId"
     datasource_type: DatasourceType
     path: Path
 
@@ -45,38 +47,29 @@ class DatasourceId:
     Use the provided factory methods `from_string_repr` and `from_datasource_config_file_path` to create a DatasourceId, rather than its constructor.
 
     Attributes:
-        datasource_config_folder: The folder where the datasource's config file is located.
-        datasource_name: The name of the datasource.
+        datasource_path: The path to the datasource relative to project's src folder.
         config_file_suffix: The suffix of the config (or raw) file.
     """
 
-    datasource_config_folder: str
-    datasource_name: str
+    ALLOWED_YAML_SUFFIXES = [".yaml", ".yml"]
+    CONTEXT_FILE_SUFFIX = ".yaml"
+
+    datasource_path: str
     config_file_suffix: str
 
     def __post_init__(self):
-        if not self.datasource_config_folder.strip():
-            raise ValueError(f"Invalid DatasourceId ({str(self)}): datasource_config_folder must not be empty")
-        if not self.datasource_name.strip():
-            raise ValueError(f"Invalid DatasourceId ({str(self)}): datasource_name must not be empty")
+        if not self.datasource_path.strip():
+            raise ValueError(f"Invalid DatasourceId ({str(self)}): datasource_path must not be empty")
         if not self.config_file_suffix.strip():
             raise ValueError(f"Invalid DatasourceId ({str(self)}): config_file_suffix must not be empty")
 
-        if os.sep in self.datasource_config_folder:
-            raise ValueError(
-                f"Invalid DatasourceId ({str(self)}): datasource_config_folder must not contain a path separator"
-            )
-
-        if os.sep in self.datasource_name:
-            raise ValueError(f"Invalid DatasourceId ({str(self)}): datasource_name must not contain a path separator")
-
         if not self.config_file_suffix.startswith("."):
             raise ValueError(
                 f'Invalid DatasourceId ({str(self)}): config_file_suffix must start with a dot "." (e.g.: .yaml)'
             )
 
-        if self.datasource_name.endswith(self.config_file_suffix):
-            raise ValueError(f"Invalid DatasourceId ({str(self)}): datasource_name must not contain the file suffix")
+        if self.datasource_path.endswith(self.config_file_suffix):
+            raise ValueError(f"Invalid DatasourceId ({str(self)}): datasource_path must not contain the file suffix")
 
     def __str__(self):
         return str(self.relative_path_to_config_file())
@@ -89,7 +82,7 @@ class DatasourceId:
         Returns:
             The path to the config file relative to the src folder in the project.
         """
-        return Path(self.datasource_config_folder).joinpath(self.datasource_name + self.config_file_suffix)
+        return Path(self.datasource_path + self.config_file_suffix)
 
     def relative_path_to_context_file(self) -> Path:
         """Return a path to the config file for this datasource.
@@ -100,9 +93,13 @@ class DatasourceId:
             The path to the context file relative to the output folder in the project.
         """
         # Keep the suffix in the filename if this datasource is a raw file, to handle multiple files with the same name and different extensions
-        suffix = ".yaml" if self.config_file_suffix == ".yaml" else (self.config_file_suffix + ".yaml")
+        suffix = (
+            DatasourceId.CONTEXT_FILE_SUFFIX
+            if self.config_file_suffix in DatasourceId.ALLOWED_YAML_SUFFIXES
+            else (self.config_file_suffix + DatasourceId.CONTEXT_FILE_SUFFIX)
+        )
 
-        return Path(self.datasource_config_folder).joinpath(self.datasource_name + suffix)
+        return Path(self.datasource_path + suffix)
 
     @classmethod
     def from_string_repr(cls, datasource_id_as_string: str) -> "DatasourceId":
@@ -115,34 +112,36 @@ class DatasourceId:
 
         Returns:
             The DatasourceId instance created from the string representation.
-
-        Raises:
-            ValueError: If the string representation is invalid (e.g. too many parent folders).
         """
         config_file_path = Path(datasource_id_as_string)
-
-        if len(config_file_path.parents) > 2:
-            raise ValueError(
-                f"Invalid string representation of a DatasourceId: too many parent folders defined in {datasource_id_as_string}"
-            )
-
-        return DatasourceId.from_datasource_config_file_path(config_file_path)
+        return DatasourceId._from_relative_datasource_config_file_path(config_file_path)
 
     @classmethod
-    def from_datasource_config_file_path(cls, datasource_config_file: Path) -> "DatasourceId":
+    def from_datasource_config_file_path(
+        cls, project_layout: ProjectLayout, datasource_config_file: Path
+    ) -> "DatasourceId":
         """Create a DatasourceId from a config file path.
 
         Args:
+            project_layout: The databao context engine project layout.
             datasource_config_file: The path to the datasource config file.
                 This path can either be the config file path relative to the src folder or the full path to the config file.
 
         Returns:
             The DatasourceId instance created from the config file path.
         """
+        relative_datasource_config_file = datasource_config_file.relative_to(project_layout.src_dir)
+        return DatasourceId._from_relative_datasource_config_file_path(relative_datasource_config_file)
+
+    @classmethod
+    def _from_relative_datasource_config_file_path(cls, relative_datasource_config_file: Path) -> "DatasourceId":
+        if relative_datasource_config_file.is_absolute():
+            raise ValueError(
+                f"Path to datasource config file should be relative to project's src folder: {relative_datasource_config_file}"
+            )
         return DatasourceId(
-            datasource_config_folder=datasource_config_file.parent.name,
-            datasource_name=datasource_config_file.stem,
-            config_file_suffix=datasource_config_file.suffix,
+            datasource_path=_extract_datasource_path(relative_datasource_config_file),
+            config_file_suffix=relative_datasource_config_file.suffix,
         )
 
     @classmethod
@@ -157,19 +156,31 @@ class DatasourceId:
 
         Returns:
             The DatasourceId instance created from the context file path.
+
+        Raises:
+            ValueError: If the wrong datasource_context_file is provided.
         """
-        if len(datasource_context_file.suffixes) > 1 and datasource_context_file.suffix == ".yaml":
+        if (
+            len(datasource_context_file.suffixes) > 1
+            and datasource_context_file.suffix == DatasourceId.CONTEXT_FILE_SUFFIX
+        ):
             # If there is more than 1 suffix, we remove the latest suffix (.yaml) to keep only the actual datasource file suffix
-            context_file_name_without_yaml_extension = datasource_context_file.name[: -len(".yaml")]
+            context_file_name_without_yaml_extension = datasource_context_file.name[
+                : -len(DatasourceId.CONTEXT_FILE_SUFFIX)
+            ]
             datasource_context_file = datasource_context_file.with_name(context_file_name_without_yaml_extension)
-
+        if datasource_context_file.is_absolute():
+            raise ValueError(f"Path to datasource context file should be a relative path: {datasource_context_file}")
         return DatasourceId(
-            datasource_config_folder=datasource_context_file.parent.name,
-            datasource_name=datasource_context_file.stem,
+            datasource_path=_extract_datasource_path(datasource_context_file),
             config_file_suffix=datasource_context_file.suffix,
         )
 
 
+def _extract_datasource_path(datasource_file: Path) -> str:
+    return str(datasource_file.with_suffix(""))
+
+
 @dataclass
 class Datasource:
     """A datasource contained in the project.

databao_context_engine/generate_configs_schemas.py

@@ -38,9 +38,9 @@ def generate_configs_schemas(
     try:
         schema_list = _generate_json_schema_output_for_plugins(include_plugins, exclude_plugins)
 
-        print(f"{os.linesep}{os.linesep}".join(schema_list))
+        click.echo(f"{os.linesep}{os.linesep}".join(schema_list))
     except Exception as e:
-        print(str(e))
+        click.echo(str(e))
 
 
 def _generate_json_schema_output_for_plugins(
@@ -54,10 +54,9 @@ def _generate_json_schema_output_for_plugins(
     if len(filtered_plugins) == 0:
         if include_plugins:
             raise ValueError(f"No plugin found with id in {include_plugins}")
-        elif exclude_plugins:
+        if exclude_plugins:
             raise ValueError(f"No plugin found when excluding {exclude_plugins}")
-        else:
-            raise ValueError("No plugin found")
+        raise ValueError("No plugin found")
 
     results = []
     for plugin in filtered_plugins:

databao_context_engine/introspection/property_extract.py

@@ -1,6 +1,16 @@
 import types
 from dataclasses import MISSING, fields, is_dataclass
-from typing import Annotated, Any, ForwardRef, Union, get_args, get_origin, get_type_hints
+from typing import (
+    Annotated,
+    Any,
+    ForwardRef,
+    Iterable,
+    Mapping,
+    Union,
+    get_args,
+    get_origin,
+    get_type_hints,
+)
 
 from pydantic import BaseModel
 from pydantic_core import PydanticUndefinedType
@@ -14,10 +24,10 @@ from databao_context_engine.pluginlib.config import (
 
 
 def get_property_list_from_type(root_type: type) -> list[ConfigPropertyDefinition]:
-    return _get_property_list_from_type(parent_type=root_type, is_root_type=True)
+    return _get_property_list_from_type(parent_type=root_type)
 
 
-def _get_property_list_from_type(*, parent_type: type, is_root_type: bool) -> list[ConfigPropertyDefinition]:
+def _get_property_list_from_type(*, parent_type: type) -> list[ConfigPropertyDefinition]:
     if is_dataclass(parent_type):
         return _get_property_list_from_dataclass(parent_type=parent_type)
 
@@ -29,20 +39,15 @@ def _get_property_list_from_type(*, parent_type: type, is_root_type: bool) -> li
         # issubclass is raising a TypeError: issubclass() arg 1 must be a class
         pass
 
-    return _get_property_list_from_type_hints(parent_type=parent_type, is_root_type=is_root_type)
+    return _get_property_list_from_type_hints(parent_type=parent_type)
 
 
-def _get_property_list_from_type_hints(*, parent_type: type, is_root_type: bool) -> list[ConfigPropertyDefinition]:
+def _get_property_list_from_type_hints(*, parent_type: type) -> list[ConfigPropertyDefinition]:
     try:
         type_hints = get_type_hints(parent_type, include_extras=True)
-    except TypeError as e:
-        if is_root_type:
-            # Ignore root types that don't have type hints like dict or list
-            return []
-        else:
-            # If we're evaluating a nested property, we want to propagate the exception
-            # to let the parent property know that this type should be ignored
-            raise e
+    except TypeError:
+        # Return an empty list of properties for any type that is not an object (e.g: primitives like str or containers like dict, list, tuple, etc.
+        return []
 
     result = []
     for property_key, property_type in type_hints.items():
@@ -137,13 +142,7 @@ def _create_property(
         type_properties: dict[type, list[ConfigPropertyDefinition]] = {}
 
         for union_type in actual_property_types:
-            try:
-                nested_props = _get_property_list_from_type(
-                    parent_type=union_type,
-                    is_root_type=False,
-                )
-            except TypeError:
-                nested_props = []
+            nested_props = _get_property_list_from_type(parent_type=union_type)
 
             type_properties[union_type] = nested_props
 
@@ -152,31 +151,38 @@ def _create_property(
             types=actual_property_types,
             type_properties=type_properties,
         )
-    else:
-        actual_property_type = actual_property_types[0]
-        try:
-            nested_properties = _get_property_list_from_type(
-                parent_type=actual_property_type,
-                is_root_type=False,
-            )
-        except TypeError:
-            return None
-
-        resolved_type = actual_property_type if not nested_properties else None
-        default_value = compute_default_value(
-            annotation=annotation,
-            property_default=property_default,
-            has_nested_properties=nested_properties is not None and len(nested_properties) > 0,
-        )
 
-        return ConfigSinglePropertyDefinition(
-            property_key=property_name,
-            property_type=resolved_type,
-            required=required,
-            default_value=default_value,
-            nested_properties=nested_properties or None,
-            secret=secret,
-        )
+    actual_property_type = actual_property_types[0]
+    nested_properties = _get_property_list_from_type(parent_type=actual_property_type)
+
+    if len(nested_properties) == 0 and _is_mapping_or_iterable(actual_property_type):
+        # Ignore Iterables and Mappings for which we didn't resolve nested properties
+        # (TypedDict is a Mapping but since we manage to resolve nested properties, it won't be ignored)
+        return None
+
+    resolved_type = actual_property_type if not nested_properties else None
+    default_value = compute_default_value(
+        annotation=annotation,
+        property_default=property_default,
+        has_nested_properties=nested_properties is not None and len(nested_properties) > 0,
+    )
+
+    return ConfigSinglePropertyDefinition(
+        property_key=property_name,
+        property_type=resolved_type,
+        required=required,
+        default_value=default_value,
+        nested_properties=nested_properties or None,
+        secret=secret,
+    )
+
+
+def _is_mapping_or_iterable(property_type: type):
+    # For types like list[str], we need to get the origin (ie. list) to use in issubclass
+    origin = get_origin(property_type)
+
+    # We make sure to not return True for str, which is an Iterable
+    return property_type is not str and issubclass(origin if origin else property_type, (Mapping, Iterable))
 
 
 def _get_config_property_annotation(property_type) -> ConfigPropertyAnnotation | None:
@@ -194,9 +200,8 @@ def _read_actual_property_type(property_type: type) -> tuple[type, ...]:
 
     if property_type_origin is Annotated:
         return _read_actual_property_type(property_type.__origin__)  # type: ignore[attr-defined]
-    elif property_type_origin in (Union, types.UnionType):
-        args = tuple(arg for arg in get_args(property_type) if arg is not type(None))
-        return args
+    if property_type_origin in (Union, types.UnionType):
+        return tuple(arg for arg in get_args(property_type) if arg is not type(None))
 
     return (property_type,)
 

databao_context_engine/llm/__init__.py

@@ -0,0 +1,10 @@
+from databao_context_engine.llm.api import download_ollama_models_if_needed, install_ollama_if_needed
+from databao_context_engine.llm.errors import OllamaError, OllamaPermanentError, OllamaTransientError
+
+__all__ = [
+    "install_ollama_if_needed",
+    "download_ollama_models_if_needed",
+    "OllamaError",
+    "OllamaTransientError",
+    "OllamaPermanentError",
+]