biblicus 0.9.0__py3-none-any.whl → 0.11.0__py3-none-any.whl

biblicus/__init__.py

@@ -27,4 +27,4 @@ __all__ = [
     "RetrievalRun",
 ]
 
-__version__ = "0.9.0"
+__version__ = "0.11.0"

biblicus/_vendor/dotyaml/__init__.py

@@ -11,4 +11,3 @@ from .interpolation import interpolate_env_vars
 from .loader import ConfigLoader, load_config
 
 __all__ = ["ConfigLoader", "interpolate_env_vars", "load_config"]
-

biblicus/_vendor/dotyaml/interpolation.py

@@ -60,4 +60,3 @@ def _interpolate_string(text: str) -> str:
         raise ValueError(f"Required environment variable '{env_var}' not found")
 
     return re.sub(pattern, replace_match, text)
-

biblicus/_vendor/dotyaml/loader.py

@@ -178,4 +178,3 @@ class ConfigLoader:
         for key, value in flat_config.items():
             if override or key not in os.environ:
                 os.environ[key] = value
-

biblicus/_vendor/dotyaml/transformer.py

@@ -132,4 +132,3 @@ def convert_string_to_value(value: str) -> Any:
         return json.loads(value)
     except (json.JSONDecodeError, ValueError):
         return value
-

biblicus/analysis/__init__.py

@@ -7,6 +7,7 @@ from __future__ import annotations
 from typing import Dict, Type
 
 from .base import CorpusAnalysisBackend
+from .profiling import ProfilingBackend
 from .topic_modeling import TopicModelingBackend
 
 
@@ -18,6 +19,7 @@ def available_analysis_backends() -> Dict[str, Type[CorpusAnalysisBackend]]:
     :rtype: dict[str, Type[CorpusAnalysisBackend]]
     """
     return {
+        ProfilingBackend.analysis_id: ProfilingBackend,
         TopicModelingBackend.analysis_id: TopicModelingBackend,
     }
 

biblicus/analysis/models.py

@@ -84,6 +84,221 @@ class AnalysisRunManifest(AnalysisSchemaModel):
     stats: Dict[str, Any] = Field(default_factory=dict)
 
 
+class ProfilingRecipeConfig(AnalysisSchemaModel):
+    """
+    Recipe configuration for profiling analysis.
+
+    :ivar schema_version: Analysis schema version.
+    :vartype schema_version: int
+    :ivar sample_size: Optional sample size for distribution metrics.
+    :vartype sample_size: int or None
+    :ivar min_text_characters: Optional minimum character count for extracted text inclusion.
+    :vartype min_text_characters: int or None
+    :ivar percentiles: Percentiles to compute for distributions.
+    :vartype percentiles: list[int]
+    :ivar top_tag_count: Maximum number of tags to include in top tag output.
+    :vartype top_tag_count: int
+    :ivar tag_filters: Optional tag filters to limit tag coverage metrics.
+    :vartype tag_filters: list[str] or None
+    """
+
+    schema_version: int = Field(default=ANALYSIS_SCHEMA_VERSION, ge=1)
+    sample_size: Optional[int] = Field(default=None, ge=1)
+    min_text_characters: Optional[int] = Field(default=None, ge=1)
+    percentiles: List[int] = Field(default_factory=lambda: [50, 90, 99])
+    top_tag_count: int = Field(default=10, ge=1)
+    tag_filters: Optional[List[str]] = None
+
+    @model_validator(mode="after")
+    def _validate_schema_version(self) -> "ProfilingRecipeConfig":
+        if self.schema_version != ANALYSIS_SCHEMA_VERSION:
+            raise ValueError(f"Unsupported analysis schema version: {self.schema_version}")
+        return self
+
+    @field_validator("percentiles", mode="after")
+    @classmethod
+    def _validate_percentiles(cls, value: List[int]) -> List[int]:
+        if not value:
+            raise ValueError("percentiles must include at least one value")
+        if any(percentile < 1 or percentile > 100 for percentile in value):
+            raise ValueError("percentiles must be between 1 and 100")
+        if value != sorted(value):
+            raise ValueError("percentiles must be sorted in ascending order")
+        return value
+
+    @field_validator("tag_filters", mode="before")
+    @classmethod
+    def _validate_tag_filters(cls, value: object) -> object:
+        if value is None:
+            return None
+        if not isinstance(value, list):
+            raise ValueError("tag_filters must be a list of strings")
+        cleaned = [str(tag).strip() for tag in value]
+        if not cleaned or any(not tag for tag in cleaned):
+            raise ValueError("tag_filters must be a list of non-empty strings")
+        return cleaned
+
+
+class ProfilingPercentileValue(AnalysisSchemaModel):
+    """
+    Percentile entry for a distribution.
+
+    :ivar percentile: Percentile value between 1 and 100.
+    :vartype percentile: int
+    :ivar value: Percentile value.
+    :vartype value: float
+    """
+
+    percentile: int = Field(ge=1, le=100)
+    value: float
+
+
+class ProfilingDistributionReport(AnalysisSchemaModel):
+    """
+    Distribution summary for numeric values.
+
+    :ivar count: Count of values included.
+    :vartype count: int
+    :ivar min_value: Minimum value observed.
+    :vartype min_value: float
+    :ivar max_value: Maximum value observed.
+    :vartype max_value: float
+    :ivar mean_value: Mean value observed.
+    :vartype mean_value: float
+    :ivar percentiles: Percentile values.
+    :vartype percentiles: list[ProfilingPercentileValue]
+    """
+
+    count: int = Field(ge=0)
+    min_value: float
+    max_value: float
+    mean_value: float
+    percentiles: List[ProfilingPercentileValue] = Field(default_factory=list)
+
+
+class ProfilingTagCount(AnalysisSchemaModel):
+    """
+    Tag count entry for profiling output.
+
+    :ivar tag: Tag name.
+    :vartype tag: str
+    :ivar count: Number of items with this tag.
+    :vartype count: int
+    """
+
+    tag: str
+    count: int = Field(ge=0)
+
+
+class ProfilingTagReport(AnalysisSchemaModel):
+    """
+    Tag coverage summary for raw items.
+
+    :ivar tagged_items: Count of items with tags.
+    :vartype tagged_items: int
+    :ivar untagged_items: Count of items without tags.
+    :vartype untagged_items: int
+    :ivar total_unique_tags: Count of unique tags.
+    :vartype total_unique_tags: int
+    :ivar top_tags: Most frequent tags.
+    :vartype top_tags: list[ProfilingTagCount]
+    :ivar tag_filters: Optional tag filters applied.
+    :vartype tag_filters: list[str] or None
+    """
+
+    tagged_items: int = Field(ge=0)
+    untagged_items: int = Field(ge=0)
+    total_unique_tags: int = Field(ge=0)
+    top_tags: List[ProfilingTagCount] = Field(default_factory=list)
+    tag_filters: Optional[List[str]] = None
+
+
+class ProfilingRawItemsReport(AnalysisSchemaModel):
+    """
+    Summary of raw corpus items.
+
+    :ivar total_items: Total number of catalog items.
+    :vartype total_items: int
+    :ivar media_type_counts: Count of items per media type.
+    :vartype media_type_counts: dict[str, int]
+    :ivar bytes_distribution: Distribution of raw item sizes in bytes.
+    :vartype bytes_distribution: ProfilingDistributionReport
+    :ivar tags: Tag coverage summary.
+    :vartype tags: ProfilingTagReport
+    """
+
+    total_items: int = Field(ge=0)
+    media_type_counts: Dict[str, int] = Field(default_factory=dict)
+    bytes_distribution: ProfilingDistributionReport
+    tags: ProfilingTagReport
+
+
+class ProfilingExtractedTextReport(AnalysisSchemaModel):
+    """
+    Summary of extracted text coverage.
+
+    :ivar source_items: Count of source items in the extraction run.
+    :vartype source_items: int
+    :ivar extracted_nonempty_items: Count of extracted items with non-empty text.
+    :vartype extracted_nonempty_items: int
+    :ivar extracted_empty_items: Count of extracted items with empty text.
+    :vartype extracted_empty_items: int
+    :ivar extracted_missing_items: Count of items with no extracted text artifact.
+    :vartype extracted_missing_items: int
+    :ivar characters_distribution: Distribution of extracted text lengths.
+    :vartype characters_distribution: ProfilingDistributionReport
+    """
+
+    source_items: int = Field(ge=0)
+    extracted_nonempty_items: int = Field(ge=0)
+    extracted_empty_items: int = Field(ge=0)
+    extracted_missing_items: int = Field(ge=0)
+    characters_distribution: ProfilingDistributionReport
+
+
+class ProfilingReport(AnalysisSchemaModel):
+    """
+    Report for profiling analysis.
+
+    :ivar raw_items: Raw corpus item summary.
+    :vartype raw_items: ProfilingRawItemsReport
+    :ivar extracted_text: Extracted text coverage summary.
+    :vartype extracted_text: ProfilingExtractedTextReport
+    :ivar warnings: Warning messages.
+    :vartype warnings: list[str]
+    :ivar errors: Error messages.
+    :vartype errors: list[str]
+    """
+
+    raw_items: ProfilingRawItemsReport
+    extracted_text: ProfilingExtractedTextReport
+    warnings: List[str] = Field(default_factory=list)
+    errors: List[str] = Field(default_factory=list)
+
+
+class ProfilingOutput(AnalysisSchemaModel):
+    """
+    Output bundle for profiling analysis.
+
+    :ivar schema_version: Analysis schema version.
+    :vartype schema_version: int
+    :ivar analysis_id: Analysis backend identifier.
+    :vartype analysis_id: str
+    :ivar generated_at: International Organization for Standardization 8601 timestamp for output creation.
+    :vartype generated_at: str
+    :ivar run: Analysis run manifest.
+    :vartype run: AnalysisRunManifest
+    :ivar report: Profiling report data.
+    :vartype report: ProfilingReport
+    """
+
+    schema_version: int = Field(default=ANALYSIS_SCHEMA_VERSION, ge=1)
+    analysis_id: str
+    generated_at: str
+    run: AnalysisRunManifest
+    report: ProfilingReport
+
+
 class TopicModelingTextSourceConfig(AnalysisSchemaModel):
     """
     Configuration for text collection within topic modeling.
@@ -124,7 +339,9 @@ class TopicModelingLlmExtractionConfig(AnalysisSchemaModel):
     """
 
     enabled: bool = Field(default=False)
-    method: TopicModelingLlmExtractionMethod = Field(default=TopicModelingLlmExtractionMethod.SINGLE)
+    method: TopicModelingLlmExtractionMethod = Field(
+        default=TopicModelingLlmExtractionMethod.SINGLE
+    )
     client: Optional[LlmClientConfig] = None
     prompt_template: Optional[str] = None
     system_prompt: Optional[str] = None
@@ -136,7 +353,9 @@ class TopicModelingLlmExtractionConfig(AnalysisSchemaModel):
             return value
         if isinstance(value, str):
             return TopicModelingLlmExtractionMethod(value)
-        raise ValueError("llm_extraction.method must be a string or TopicModelingLlmExtractionMethod")
+        raise ValueError(
+            "llm_extraction.method must be a string or TopicModelingLlmExtractionMethod"
+        )
 
     @model_validator(mode="after")
     def _validate_requirements(self) -> "TopicModelingLlmExtractionConfig":
@@ -188,7 +407,9 @@ class TopicModelingVectorizerConfig(AnalysisSchemaModel):
     def _validate_ngram_range(self) -> "TopicModelingVectorizerConfig":
         start, end = self.ngram_range
         if start < 1 or end < start:
-            raise ValueError("vectorizer.ngram_range must include two integers with start >= 1 and end >= start")
+            raise ValueError(
+                "vectorizer.ngram_range must include two integers with start >= 1 and end >= start"
+            )
         return self
 
     @field_validator("stop_words", mode="before")
@@ -201,7 +422,7 @@ class TopicModelingVectorizerConfig(AnalysisSchemaModel):
                 raise ValueError("vectorizer.stop_words must be 'english' or a list of strings")
             return value
         if isinstance(value, list):
-            if not all(isinstance(entry, str) and entry for entry in value):
+            if not value or not all(isinstance(entry, str) and entry for entry in value):
                 raise ValueError("vectorizer.stop_words must be 'english' or a list of strings")
             return value
         raise ValueError("vectorizer.stop_words must be 'english' or a list of strings")
@@ -280,7 +501,9 @@ class TopicModelingRecipeConfig(AnalysisSchemaModel):
     """
 
     schema_version: int = Field(default=ANALYSIS_SCHEMA_VERSION, ge=1)
-    text_source: TopicModelingTextSourceConfig = Field(default_factory=TopicModelingTextSourceConfig)
+    text_source: TopicModelingTextSourceConfig = Field(
+        default_factory=TopicModelingTextSourceConfig
+    )
     llm_extraction: TopicModelingLlmExtractionConfig = Field(
         default_factory=TopicModelingLlmExtractionConfig
     )

biblicus/analysis/profiling.py

@@ -0,0 +1,337 @@
+"""
+Profiling analysis backend for Biblicus.
+"""
+
+from __future__ import annotations
+
+import json
+import math
+from pathlib import Path
+from typing import Dict, Iterable, List, Sequence
+
+from pydantic import BaseModel
+
+from ..corpus import Corpus
+from ..models import CatalogItem, ExtractionRunReference
+from ..retrieval import hash_text
+from ..time import utc_now_iso
+from .base import CorpusAnalysisBackend
+from .models import (
+    AnalysisRecipeManifest,
+    AnalysisRunInput,
+    AnalysisRunManifest,
+    ProfilingDistributionReport,
+    ProfilingExtractedTextReport,
+    ProfilingOutput,
+    ProfilingPercentileValue,
+    ProfilingRawItemsReport,
+    ProfilingRecipeConfig,
+    ProfilingReport,
+    ProfilingTagCount,
+    ProfilingTagReport,
+)
+
+
+class ProfilingBackend(CorpusAnalysisBackend):
+    """
+    Profiling analysis backend for corpus composition and coverage.
+
+    :ivar analysis_id: Backend identifier.
+    :vartype analysis_id: str
+    """
+
+    analysis_id = "profiling"
+
+    def run_analysis(
+        self,
+        corpus: Corpus,
+        *,
+        recipe_name: str,
+        config: Dict[str, object],
+        extraction_run: ExtractionRunReference,
+    ) -> BaseModel:
+        """
+        Run the profiling analysis pipeline.
+
+        :param corpus: Corpus to analyze.
+        :type corpus: Corpus
+        :param recipe_name: Human-readable recipe name.
+        :type recipe_name: str
+        :param config: Analysis configuration values.
+        :type config: dict[str, object]
+        :param extraction_run: Extraction run reference for text inputs.
+        :type extraction_run: biblicus.models.ExtractionRunReference
+        :return: Profiling output model.
+        :rtype: pydantic.BaseModel
+        """
+        parsed_config = (
+            config
+            if isinstance(config, ProfilingRecipeConfig)
+            else ProfilingRecipeConfig.model_validate(config)
+        )
+        return _run_profiling(
+            corpus=corpus,
+            recipe_name=recipe_name,
+            config=parsed_config,
+            extraction_run=extraction_run,
+        )
+
+
+def _run_profiling(
+    *,
+    corpus: Corpus,
+    recipe_name: str,
+    config: ProfilingRecipeConfig,
+    extraction_run: ExtractionRunReference,
+) -> ProfilingOutput:
+    recipe = _create_recipe_manifest(name=recipe_name, config=config)
+    catalog = corpus.load_catalog()
+    run_id = _analysis_run_id(
+        recipe_id=recipe.recipe_id,
+        extraction_run=extraction_run,
+        catalog_generated_at=catalog.generated_at,
+    )
+    run_manifest = AnalysisRunManifest(
+        run_id=run_id,
+        recipe=recipe,
+        corpus_uri=catalog.corpus_uri,
+        catalog_generated_at=catalog.generated_at,
+        created_at=utc_now_iso(),
+        input=AnalysisRunInput(extraction_run=extraction_run),
+        artifact_paths=[],
+        stats={},
+    )
+    run_dir = corpus.analysis_run_dir(analysis_id=ProfilingBackend.analysis_id, run_id=run_id)
+    output_path = run_dir / "output.json"
+    run_dir.mkdir(parents=True, exist_ok=True)
+
+    ordered_items = _ordered_catalog_items(catalog.items, catalog.order)
+    raw_report = _build_raw_items_report(items=ordered_items, config=config)
+    extracted_report = _build_extracted_text_report(
+        corpus=corpus,
+        extraction_run=extraction_run,
+        config=config,
+    )
+
+    report = ProfilingReport(
+        raw_items=raw_report,
+        extracted_text=extracted_report,
+        warnings=[],
+        errors=[],
+    )
+
+    run_stats = {
+        "raw_items": raw_report.total_items,
+        "extracted_nonempty_items": extracted_report.extracted_nonempty_items,
+        "extracted_missing_items": extracted_report.extracted_missing_items,
+    }
+    run_manifest = run_manifest.model_copy(
+        update={"artifact_paths": ["output.json"], "stats": run_stats}
+    )
+    _write_analysis_run_manifest(run_dir=run_dir, manifest=run_manifest)
+
+    output = ProfilingOutput(
+        analysis_id=ProfilingBackend.analysis_id,
+        generated_at=utc_now_iso(),
+        run=run_manifest,
+        report=report,
+    )
+    _write_profiling_output(path=output_path, output=output)
+    return output
+
+
+def _create_recipe_manifest(*, name: str, config: ProfilingRecipeConfig) -> AnalysisRecipeManifest:
+    recipe_payload = json.dumps(
+        {
+            "analysis_id": ProfilingBackend.analysis_id,
+            "name": name,
+            "config": config.model_dump(),
+        },
+        sort_keys=True,
+    )
+    recipe_id = hash_text(recipe_payload)
+    return AnalysisRecipeManifest(
+        recipe_id=recipe_id,
+        analysis_id=ProfilingBackend.analysis_id,
+        name=name,
+        created_at=utc_now_iso(),
+        config=config.model_dump(),
+    )
+
+
+def _analysis_run_id(
+    *, recipe_id: str, extraction_run: ExtractionRunReference, catalog_generated_at: str
+) -> str:
+    run_seed = f"{recipe_id}:{extraction_run.as_string()}:{catalog_generated_at}"
+    return hash_text(run_seed)
+
+
+def _ordered_catalog_items(
+    items: Dict[str, CatalogItem],
+    order: Sequence[str],
+) -> List[CatalogItem]:
+    ordered: List[CatalogItem] = []
+    seen = set()
+    for item_id in order:
+        item = items.get(item_id)
+        if item is None:
+            continue
+        ordered.append(item)
+        seen.add(item_id)
+    for item_id in sorted(items):
+        if item_id in seen:
+            continue
+        ordered.append(items[item_id])
+    return ordered
+
+
+def _build_raw_items_report(
+    *, items: Sequence[CatalogItem], config: ProfilingRecipeConfig
+) -> ProfilingRawItemsReport:
+    media_type_counts: Dict[str, int] = {}
+    for item in items:
+        media_type_counts[item.media_type] = media_type_counts.get(item.media_type, 0) + 1
+
+    bytes_values = [item.bytes for item in _apply_sample(items, config.sample_size)]
+    bytes_distribution = _build_distribution(bytes_values, config.percentiles)
+    tag_report = _build_tag_report(items=items, config=config)
+
+    return ProfilingRawItemsReport(
+        total_items=len(items),
+        media_type_counts=media_type_counts,
+        bytes_distribution=bytes_distribution,
+        tags=tag_report,
+    )
+
+
+def _build_tag_report(
+    *, items: Sequence[CatalogItem], config: ProfilingRecipeConfig
+) -> ProfilingTagReport:
+    tag_filters = config.tag_filters
+    tag_filter_set = set(tag_filters or [])
+    tag_counts: Dict[str, int] = {}
+    tagged_items = 0
+
+    for item in items:
+        tags = list(item.tags)
+        if tag_filters is not None:
+            tags = [tag for tag in tags if tag in tag_filter_set]
+        if tags:
+            tagged_items += 1
+        for tag in tags:
+            tag_counts[tag] = tag_counts.get(tag, 0) + 1
+
+    untagged_items = len(items) - tagged_items
+    top_tags = sorted(tag_counts.items(), key=lambda entry: (-entry[1], entry[0]))
+    top_tags = top_tags[: config.top_tag_count]
+    return ProfilingTagReport(
+        tagged_items=tagged_items,
+        untagged_items=untagged_items,
+        total_unique_tags=len(tag_counts),
+        top_tags=[ProfilingTagCount(tag=tag, count=count) for tag, count in top_tags],
+        tag_filters=tag_filters,
+    )
+
+
+def _build_extracted_text_report(
+    *,
+    corpus: Corpus,
+    extraction_run: ExtractionRunReference,
+    config: ProfilingRecipeConfig,
+) -> ProfilingExtractedTextReport:
+    manifest = corpus.load_extraction_run_manifest(
+        extractor_id=extraction_run.extractor_id,
+        run_id=extraction_run.run_id,
+    )
+    nonempty_items = 0
+    empty_items = 0
+    missing_items = 0
+    text_lengths: List[int] = []
+    text_dir = corpus.extraction_run_dir(
+        extractor_id=extraction_run.extractor_id,
+        run_id=extraction_run.run_id,
+    )
+
+    for item_result in manifest.items:
+        if item_result.status != "extracted" or item_result.final_text_relpath is None:
+            missing_items += 1
+            continue
+        text_path = text_dir / item_result.final_text_relpath
+        text_value = text_path.read_text(encoding="utf-8")
+        stripped = text_value.strip()
+        if not stripped:
+            empty_items += 1
+            continue
+        if config.min_text_characters is not None and len(stripped) < config.min_text_characters:
+            empty_items += 1
+            continue
+        nonempty_items += 1
+        text_lengths.append(len(stripped))
+
+    sampled_lengths = _apply_sample(text_lengths, config.sample_size)
+    characters_distribution = _build_distribution(sampled_lengths, config.percentiles)
+    return ProfilingExtractedTextReport(
+        source_items=len(manifest.items),
+        extracted_nonempty_items=nonempty_items,
+        extracted_empty_items=empty_items,
+        extracted_missing_items=missing_items,
+        characters_distribution=characters_distribution,
+    )
+
+
+def _apply_sample(values: Sequence, sample_size: int | None) -> List:
+    if sample_size is None:
+        return list(values)
+    return list(values[:sample_size])
+
+
+def _build_distribution(
+    values: Sequence[int], percentiles: Iterable[int]
+) -> ProfilingDistributionReport:
+    if not values:
+        percentile_values = [
+            ProfilingPercentileValue(percentile=percentile, value=0.0) for percentile in percentiles
+        ]
+        return ProfilingDistributionReport(
+            count=0,
+            min_value=0.0,
+            max_value=0.0,
+            mean_value=0.0,
+            percentiles=percentile_values,
+        )
+    sorted_values = sorted(values)
+    count = len(sorted_values)
+    min_value = float(sorted_values[0])
+    max_value = float(sorted_values[-1])
+    mean_value = float(sum(sorted_values)) / count
+    percentile_values = [
+        ProfilingPercentileValue(
+            percentile=percentile,
+            value=float(_percentile_value(sorted_values, percentile)),
+        )
+        for percentile in percentiles
+    ]
+    return ProfilingDistributionReport(
+        count=count,
+        min_value=min_value,
+        max_value=max_value,
+        mean_value=mean_value,
+        percentiles=percentile_values,
+    )
+
+
+def _percentile_value(sorted_values: Sequence[int], percentile: int) -> int:
+    if not sorted_values:
+        return 0
+    index = max(0, math.ceil((percentile / 100) * len(sorted_values)) - 1)
+    index = min(index, len(sorted_values) - 1)
+    return int(sorted_values[index])
+
+
+def _write_analysis_run_manifest(*, run_dir: Path, manifest: AnalysisRunManifest) -> None:
+    manifest_path = run_dir / "manifest.json"
+    manifest_path.write_text(manifest.model_dump_json(indent=2) + "\n", encoding="utf-8")
+
+
+def _write_profiling_output(*, path: Path, output: ProfilingOutput) -> None:
+    path.write_text(output.model_dump_json(indent=2) + "\n", encoding="utf-8")

biblicus/analysis/topic_modeling.py

@@ -452,7 +452,7 @@ def _run_bertopic(
             except ImportError as import_error:
                 raise ValueError(
                     "Vectorizer configuration requires scikit-learn. "
-                    "Install with pip install \"biblicus[topic-modeling]\"."
+                    'Install with pip install "biblicus[topic-modeling]".'
                 ) from import_error
             bertopic_kwargs["vectorizer_model"] = CountVectorizer(
                 ngram_range=tuple(config.vectorizer.ngram_range),
@@ -504,13 +504,10 @@ def _group_documents_by_topic(
     return grouped
 
 
-def _resolve_topic_keywords(
-    *, topic_model: Any, topic_id: int
-) -> List[TopicModelingKeyword]:
+def _resolve_topic_keywords(*, topic_model: Any, topic_id: int) -> List[TopicModelingKeyword]:
     raw_keywords = topic_model.get_topic(topic_id) or []
     return [
-        TopicModelingKeyword(keyword=str(entry[0]), score=float(entry[1]))
-        for entry in raw_keywords
+        TopicModelingKeyword(keyword=str(entry[0]), score=float(entry[1])) for entry in raw_keywords
     ]