csrlite 0.1.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

csrlite/common/rtf.py

@@ -0,0 +1,137 @@
+# pyre-strict
+from typing import Any
+
+import polars as pl
+from rtflite import RTFBody, RTFColumnHeader, RTFDocument, RTFFootnote, RTFPage, RTFSource, RTFTitle
+
+
+def create_rtf_table_n_pct(
+    df: pl.DataFrame,
+    col_header_1: list[str],
+    col_header_2: list[str] | None,
+    col_widths: list[float] | None,
+    title: list[str] | str,
+    footnote: list[str] | str | None,
+    source: list[str] | str | None,
+    borders_2: bool = True,
+    orientation: str = "landscape",
+) -> RTFDocument:
+    """
+    Create a standardized RTF table document with 1 or 2 header rows.
+
+    Args:
+        df: Polars DataFrame containing the table data.
+        col_header_1: List of strings for the first header row.
+        col_header_2: Optional list of strings for the second header row.
+        col_widths: Optional list of relative column widths. Defaults to equal widths.
+        title: Title string or list of title strings.
+        footnote: Footnote string or list of footnote strings.
+        source: Source string or list of source strings.
+        borders_2: Whether to show borders for the second header row. Defaults to True.
+        orientation: Page orientation, "landscape" or "portrait". Defaults to "landscape".
+
+    Returns:
+        RTFDocument object.
+    """
+    n_cols = len(df.columns)
+
+    # Calculate column widths if None - simple default
+    if col_widths is None:
+        col_widths = [1.0] * n_cols
+
+    # Normalize metadata
+    title_list = [title] if isinstance(title, str) else title
+    footnote_list = [footnote] if isinstance(footnote, str) else (footnote or [])
+    source_list = [source] if isinstance(source, str) else (source or [])
+
+    headers = [
+        RTFColumnHeader(
+            text=col_header_1,
+            col_rel_width=col_widths,
+            text_justification=["l"] + ["c"] * (n_cols - 1),
+        )
+    ]
+
+    if col_header_2:
+        h2_kwargs = {
+            "text": col_header_2,
+            "col_rel_width": col_widths,
+            "text_justification": ["l"] + ["c"] * (n_cols - 1),
+        }
+        if borders_2:
+            h2_kwargs["border_left"] = ["single"]
+            h2_kwargs["border_top"] = [""]
+
+        headers.append(RTFColumnHeader(**h2_kwargs))
+
+    rtf_components: dict[str, Any] = {
+        "df": df,
+        "rtf_page": RTFPage(orientation=orientation),
+        "rtf_title": RTFTitle(text=title_list),
+        "rtf_column_header": headers,
+        "rtf_body": RTFBody(
+            col_rel_width=col_widths,
+            text_justification=["l"] + ["c"] * (n_cols - 1),
+            border_left=["single"] * n_cols,
+        ),
+    }
+
+    if footnote_list:
+        rtf_components["rtf_footnote"] = RTFFootnote(text=footnote_list)
+
+    if source_list:
+        rtf_components["rtf_source"] = RTFSource(text=source_list)
+
+    return RTFDocument(**rtf_components)
+
+
+def create_rtf_listing(
+    df: pl.DataFrame,
+    col_header: list[str],
+    col_widths: list[float] | None,
+    title: list[str] | str,
+    footnote: list[str] | str | None,
+    source: list[str] | str | None,
+    orientation: str = "landscape",
+) -> RTFDocument:
+    """
+    Create a standardized RTF listing document.
+    """
+    n_cols = len(df.columns)
+
+    # Calculate column widths if None
+    if col_widths is None:
+        col_widths = [1.0] * n_cols
+
+    # Normalize metadata
+    title_list = [title] if isinstance(title, str) else title
+    footnote_list = [footnote] if isinstance(footnote, str) else (footnote or [])
+    source_list = [source] if isinstance(source, str) else (source or [])
+
+    headers = [
+        RTFColumnHeader(
+            text=col_header,
+            col_rel_width=col_widths,
+            text_justification=["l"] * n_cols,
+        )
+    ]
+
+    rtf_components: dict[str, Any] = {
+        "df": df,
+        "rtf_page": RTFPage(orientation=orientation),
+        "rtf_title": RTFTitle(text=title_list),
+        "rtf_column_header": headers,
+        "rtf_body": RTFBody(
+            col_rel_width=col_widths,
+            text_justification=["l"] * n_cols,
+            border_left=["single"] * n_cols,
+        ),
+    }
+
+    if footnote_list:
+        rtf_components["rtf_footnote"] = RTFFootnote(text=footnote_list)
+
+    if source_list:
+        rtf_components["rtf_source"] = RTFSource(text=source_list)
+
+    return RTFDocument(**rtf_components)

csrlite/common/utils.py

@@ -1,33 +1,33 @@
-# pyre-strict
-import polars as pl
-
-
-def apply_common_filters(
-    population: pl.DataFrame,
-    observation: pl.DataFrame,
-    population_filter: str | None,
-    observation_filter: str | None,
-    parameter_filter: str | None = None,
-) -> tuple[pl.DataFrame, pl.DataFrame]:
-    """
-    Apply standard population, observation, and parameter filters.
-
-    Returns:
-        Tuple of (filtered_population, filtered_observation_pre_id_match)
-    """
-    # Apply population filter
-    if population_filter:
-        population_filtered = population.filter(pl.sql_expr(population_filter))
-    else:
-        population_filtered = population
-
-    # Apply observation filter
-    observation_filtered = observation
-    if observation_filter:
-        observation_filtered = observation_filtered.filter(pl.sql_expr(observation_filter))
-
-    # Apply parameter filter
-    if parameter_filter:
-        observation_filtered = observation_filtered.filter(pl.sql_expr(parameter_filter))
-
-    return population_filtered, observation_filtered
+# pyre-strict
+import polars as pl
+
+
+def apply_common_filters(
+    population: pl.DataFrame,
+    observation: pl.DataFrame | None,
+    population_filter: str | None,
+    observation_filter: str | None,
+    parameter_filter: str | None = None,
+) -> tuple[pl.DataFrame, pl.DataFrame | None]:
+    """
+    Apply standard population, observation, and parameter filters.
+
+    Returns:
+        Tuple of (filtered_population, filtered_observation_pre_id_match)
+    """
+    # Apply population filter
+    if population_filter:
+        population_filtered = population.filter(pl.sql_expr(population_filter))
+    else:
+        population_filtered = population
+
+    # Apply observation filter
+    observation_filtered = observation
+    if observation_filter and observation_filtered is not None:
+        observation_filtered = observation_filtered.filter(pl.sql_expr(observation_filter))
+
+    # Apply parameter filter
+    if parameter_filter and observation_filtered is not None:
+        observation_filtered = observation_filtered.filter(pl.sql_expr(parameter_filter))
+
+    return population_filtered, observation_filtered

csrlite/common/yaml_loader.py

@@ -1,71 +1,71 @@
-# pyre-strict
-from copy import deepcopy
-from pathlib import Path
-from typing import Any, Dict, Optional
-
-import yaml
-
-
-class YamlInheritanceLoader:
-    def __init__(self, base_path: Optional[Path] = None) -> None:
-        self.base_path: Path = base_path or Path(".")
-
-    def load(self, file_name: str) -> Dict[str, Any]:
-        """
-        Load a YAML file by name relative to base_path and resolve inheritance.
-        """
-        file_path = self.base_path / file_name
-        if not file_path.exists():
-            raise FileNotFoundError(f"YAML file not found: {file_path}")
-
-        with open(file_path, "r") as f:
-            data = yaml.safe_load(f) or {}
-
-        return self._resolve_inheritance(data)
-
-    def _resolve_inheritance(self, data: Dict[str, Any]) -> Dict[str, Any]:
-        templates = data.get("study", {}).get("template", [])
-        if isinstance(templates, str):
-            templates = [templates]
-
-        if not templates:
-            return data
-
-        merged_template_data: Dict[str, Any] = {}
-        for template_file in templates:
-            template_data = self.load(template_file)
-            merged_template_data = self._deep_merge(merged_template_data, template_data)
-
-        return self._deep_merge(merged_template_data, data)
-
-    def _deep_merge(self, dict1: Dict[str, Any], dict2: Dict[str, Any]) -> Dict[str, Any]:
-        merged = deepcopy(dict1)
-        for key, value in dict2.items():
-            if key in merged and isinstance(merged[key], list) and isinstance(value, list):
-                # Heuristic to check if these are lists of keywords (dicts with a 'name')
-                # This logic is specific to how this project uses YAML inheritance.
-                is_keyword_list = all(isinstance(i, dict) and "name" in i for i in value) and all(
-                    isinstance(i, dict) and "name" in i for i in merged[key]
-                )
-
-                if is_keyword_list:
-                    merged_by_name = {item["name"]: item for item in merged[key]}
-                    for item in value:
-                        if item["name"] in merged_by_name:
-                            # It's a dict merge, so we can recursively call _deep_merge
-                            merged_by_name[item["name"]] = self._deep_merge(
-                                merged_by_name[item["name"]], item
-                            )
-                        else:
-                            merged_by_name[item["name"]] = item
-                    merged[key] = list(merged_by_name.values())
-                else:
-                    # Fallback for simple lists: concatenate and remove duplicates
-                    # Note: This is a simple approach and might not be suitable for all list types.
-                    merged[key].extend([item for item in value if item not in merged[key]])
-
-            elif key in merged and isinstance(merged[key], dict) and isinstance(value, dict):
-                merged[key] = self._deep_merge(merged[key], value)
-            else:
-                merged[key] = value
-        return merged
+# pyre-strict
+from copy import deepcopy
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+import yaml
+
+
+class YamlInheritanceLoader:
+    def __init__(self, base_path: Optional[Path] = None) -> None:
+        self.base_path: Path = base_path or Path(".")
+
+    def load(self, file_name: str) -> Dict[str, Any]:
+        """
+        Load a YAML file by name relative to base_path and resolve inheritance.
+        """
+        file_path = self.base_path / file_name
+        if not file_path.exists():
+            raise FileNotFoundError(f"YAML file not found: {file_path}")
+
+        with open(file_path, "r") as f:
+            data = yaml.safe_load(f) or {}
+
+        return self._resolve_inheritance(data)
+
+    def _resolve_inheritance(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        templates = data.get("study", {}).get("template", [])
+        if isinstance(templates, str):
+            templates = [templates]
+
+        if not templates:
+            return data
+
+        merged_template_data: Dict[str, Any] = {}
+        for template_file in templates:
+            template_data = self.load(template_file)
+            merged_template_data = self._deep_merge(merged_template_data, template_data)
+
+        return self._deep_merge(merged_template_data, data)
+
+    def _deep_merge(self, dict1: Dict[str, Any], dict2: Dict[str, Any]) -> Dict[str, Any]:
+        merged = deepcopy(dict1)
+        for key, value in dict2.items():
+            if key in merged and isinstance(merged[key], list) and isinstance(value, list):
+                # Heuristic to check if these are lists of keywords (dicts with a 'name')
+                # This logic is specific to how this project uses YAML inheritance.
+                is_keyword_list = all(isinstance(i, dict) and "name" in i for i in value) and all(
+                    isinstance(i, dict) and "name" in i for i in merged[key]
+                )
+
+                if is_keyword_list:
+                    merged_by_name = {item["name"]: item for item in merged[key]}
+                    for item in value:
+                        if item["name"] in merged_by_name:
+                            # It's a dict merge, so we can recursively call _deep_merge
+                            merged_by_name[item["name"]] = self._deep_merge(
+                                merged_by_name[item["name"]], item
+                            )
+                        else:
+                            merged_by_name[item["name"]] = item
+                    merged[key] = list(merged_by_name.values())
+                else:
+                    # Fallback for simple lists: concatenate and remove duplicates
+                    # Note: This is a simple approach and might not be suitable for all list types.
+                    merged[key].extend([item for item in value if item not in merged[key]])
+
+            elif key in merged and isinstance(merged[key], dict) and isinstance(value, dict):
+                merged[key] = self._deep_merge(merged[key], value)
+            else:
+                merged[key] = value
+        return merged

csrlite/disposition/__init__.py

@@ -1,2 +1,2 @@
-# Disposition package
-# Import main functions but don't re-export to avoid shadowing
+# Disposition package
+# Import main functions but don't re-export to avoid shadowing