unique_toolkit 0.7.7__py3-none-any.whl → 1.23.0__py3-none-any.whl

unique_toolkit/_common/pydantic_helpers.py

@@ -0,0 +1,154 @@
+import logging
+import warnings
+from typing import TypeVar, Unpack
+
+import humps
+from pydantic import BaseModel, ConfigDict, Field, create_model
+from pydantic.alias_generators import to_camel
+from pydantic.fields import ComputedFieldInfo, FieldInfo
+
+logger = logging.getLogger(__name__)
+
+
+def field_title_generator(
+    title: str,
+    info: FieldInfo | ComputedFieldInfo,
+) -> str:
+    return humps.decamelize(title).replace("_", " ").title()
+
+
+def model_title_generator(model: type) -> str:
+    return humps.decamelize(model.__name__).replace("_", " ").title()
+
+
+def get_configuration_dict(**kwargs: Unpack[ConfigDict]) -> ConfigDict:
+    config = {
+        "alias_generator": to_camel,
+        "field_title_generator": field_title_generator,
+        "model_title_generator": model_title_generator,
+        "populate_by_name": True,
+        # protected_namespaces=(),
+    }
+    config.update(kwargs)
+    return ConfigDict(**config)
+
+
+ModelTypeA = TypeVar("ModelTypeA", bound=BaseModel)
+ModelTypeB = TypeVar("ModelTypeB", bound=BaseModel)
+
+
+def _name_intersection(
+    model_type_a: type[ModelTypeA], model_type_b: type[ModelTypeB]
+) -> set[str]:
+    field_names_a = set(model_type_a.model_fields.keys())
+    field_names_b = set(model_type_b.model_fields.keys())
+    return field_names_a.intersection(field_names_b)
+
+
+def create_union_model(
+    model_type_a: type[ModelTypeA],
+    model_type_b: type[ModelTypeB],
+    model_name: str = "UnionModel",
+    config_dict: ConfigDict = ConfigDict(),
+) -> type[BaseModel]:
+    """
+    Creates a model that is the union of the two input models.
+    Prefers fields from model_type_a.
+    """
+
+    if len(_name_intersection(model_type_a, model_type_b)) > 0:
+        warnings.warn(
+            f"The two input models have common field names: {_name_intersection(model_type_a, model_type_b)}"
+        )
+
+    fields = {}
+    for name, field in model_type_b.model_fields.items():
+        fields[name] = (field.annotation, field)
+    for name, field in model_type_a.model_fields.items():
+        fields[name] = (field.annotation, field)
+
+    CombinedModel = create_model(model_name, __config__=config_dict, **fields)
+    return CombinedModel
+
+
+def create_intersection_model(
+    model_type_a: type[ModelTypeA],
+    model_type_b: type[ModelTypeB],
+    model_name: str = "IntersectionModel",
+    config_dict: ConfigDict = ConfigDict(),
+) -> type[BaseModel]:
+    """
+    Creates a model that is the intersection of the two input models.
+    Prefers fields from model_type_a.
+    """
+
+    if len(_name_intersection(model_type_a, model_type_b)) == 0:
+        warnings.warn(
+            f"The two input models have no common field names: {_name_intersection(model_type_a, model_type_b)}"
+        )
+
+    fields = {}
+    field_names1 = set(model_type_a.model_fields.keys())
+    field_names2 = set(model_type_b.model_fields.keys())
+    common_field_names = field_names1.intersection(field_names2)
+
+    for name in common_field_names:
+        if name in field_names1.intersection(field_names2):
+            fields[name] = (
+                model_type_a.model_fields[name].annotation,
+                model_type_a.model_fields[name],
+            )
+
+    IntersectionModel = create_model(model_name, __config__=config_dict, **fields)
+    return IntersectionModel
+
+
+def create_complement_model(
+    model_type_a: type[ModelTypeA],
+    model_type_b: type[ModelTypeB],
+    model_name: str = "ComplementModel",
+    config_dict: ConfigDict = ConfigDict(),
+) -> type[BaseModel]:
+    """
+    Creates a model that is the complement of the two input models
+    i.e all fields from model_type_a that are not in model_type_b
+    """
+
+    if len(_name_intersection(model_type_a, model_type_b)) == 0:
+        warnings.warn(
+            f"The two input models have no common field names: {_name_intersection(model_type_a, model_type_b)}"
+        )
+
+    fields = {}
+    field_names_a = set(model_type_a.model_fields.keys())
+    field_names_b = set(model_type_b.model_fields.keys())
+    complement_field_names = field_names_a.difference(field_names_b)
+
+    for name in complement_field_names:
+        fields[name] = (
+            model_type_a.model_fields[name].annotation,
+            model_type_a.model_fields[name],
+        )
+
+    ComplementModel = create_model(model_name, __config__=config_dict, **fields)
+
+    return ComplementModel
+
+
+if __name__ == "__main__":
+
+    class ModelType1(BaseModel):
+        field1: int = Field(default=1, description="Field 1")
+        field2: str = Field(
+            default="test",
+            description="Field 2",
+            json_schema_extra={"title": "Field 2"},
+        )
+
+    class ModelType2(BaseModel):
+        field3: float
+        field4: bool
+
+    combined_model = create_union_model(ModelType1, ModelType2)
+
+    print(combined_model.model_fields)

unique_toolkit/_common/referencing.py

@@ -0,0 +1,53 @@
+"""
+Utilities for handling references in the "postprocessed" format, i.e <sup>X</sup>
+"""
+
+import functools
+import re
+from typing import Generator
+
+_REF_DETECTION_PATTERN = re.compile(r"<sup>\s*(?P<reference_number>\d+)\s*</sup>")
+
+
+def _iter_ref_numbers(text: str) -> Generator[int, None, None]:
+    for match in _REF_DETECTION_PATTERN.finditer(text):
+        yield int(match.group("reference_number"))
+
+
+@functools.cache
+def _get_detection_pattern_for_ref(ref_number: int) -> re.Pattern[str]:
+    return re.compile(rf"<sup>\s*{ref_number}\s*</sup>")
+
+
+def get_reference_pattern(ref_number: int) -> str:
+    return f"<sup>{ref_number}</sup>"
+
+
+def get_all_ref_numbers(text: str) -> list[int]:
+    return sorted(set(_iter_ref_numbers(text)))
+
+
+def get_max_ref_number(text: str) -> int | None:
+    return max(_iter_ref_numbers(text), default=None)
+
+
+def replace_ref_number(text: str, ref_number: int, replacement: int | str) -> str:
+    if isinstance(replacement, int):
+        replacement = get_reference_pattern(replacement)
+
+    return _get_detection_pattern_for_ref(ref_number).sub(replacement, text)
+
+
+def remove_ref_number(text: str, ref_number: int) -> str:
+    return _get_detection_pattern_for_ref(ref_number).sub("", text)
+
+
+def remove_all_refs(text: str) -> str:
+    return _REF_DETECTION_PATTERN.sub("", text)
+
+
+def remove_consecutive_ref_space(text: str) -> str:
+    """
+    Remove spaces between consecutive references.
+    """
+    return re.sub(r"</sup>\s*<sup>", "</sup><sup>", text)

unique_toolkit/_common/string_utilities.py

@@ -0,0 +1,140 @@
+import json
+import re
+from typing import Any, Iterable, Sequence
+from uuid import uuid4
+
+
+def _is_elementary_type(value: Any) -> bool:
+    """Check if a value is an elementary type (str, int, float, bool, None)."""
+    return isinstance(value, (str, int, float, bool, type(None)))
+
+
+def _is_elementary_dict(data: dict[str, Any]) -> bool:
+    """Check if all values in the dictionary are elementary types."""
+    return all(_is_elementary_type(value) for value in data.values())
+
+
+def dict_to_markdown_table(data: dict[str, Any]) -> str:
+    """
+    Convert a dictionary to a markdown table if all values are elementary types,
+    otherwise return stringified JSON.
+
+    Args:
+        data: Dictionary to convert
+
+    Returns:
+        Markdown table string or JSON string
+    """
+    if not isinstance(data, dict):
+        return json.dumps(data, indent=2)
+
+    if not _is_elementary_dict(data):
+        return json.dumps(data, indent=2)
+
+    if not data:  # Empty dict
+        return "| Key | Value |\n|-----|-------|\n| (empty) | (empty) |"
+
+    # Create markdown table
+    table_lines = ["| Key | Value |", "|-----|-------|"]
+
+    for key, value in data.items():
+        # Handle None values
+        if value is None:
+            value_str = "null"
+        # Handle boolean values
+        elif isinstance(value, bool):
+            value_str = "true" if value else "false"
+        # Handle other values
+        else:
+            value_str = str(value)
+
+        # Escape pipe characters in the content
+        key_escaped = str(key).replace("|", "\\|")
+        value_escaped = value_str.replace("|", "\\|")
+
+        table_lines.append(f"| {key_escaped} | {value_escaped} |")
+
+    return "\n".join(table_lines) + "\n"
+
+
+def extract_dicts_from_string(text: str) -> list[dict[str, Any]]:
+    """
+    Extract and parse a JSON dictionary from a string.
+
+    The string should be wrapped in ```json tags. Example:
+
+    ```json
+    {"key": "value"}
+    ```
+
+    Args:
+        text: String that may contain JSON
+
+    Returns:
+        Parsed dictionary or None if no valid JSON found
+    """
+    # Find JSON-like content between ```json and ``` tags
+    pattern = r"```json\s*(\{.*?\})\s*```"
+    matches = re.findall(pattern, text, re.DOTALL)
+
+    dictionaries = []
+    for match in matches:
+        try:
+            # Try to parse as JSON
+            parsed = json.loads(match)
+            if isinstance(parsed, dict):
+                dictionaries.append(parsed)
+        except json.JSONDecodeError:
+            continue
+
+    return dictionaries
+
+
+def _replace_in_text_non_overlapping(
+    text: str, repls: Iterable[tuple[str | re.Pattern[str], str]]
+) -> str:
+    for pattern, replacement in repls:
+        text = re.sub(pattern, replacement, text)
+    return text
+
+
+def replace_in_text(
+    text: str, repls: Sequence[tuple[str | re.Pattern[str], str]]
+) -> str:
+    """
+    Replace multiple patterns in text without replacement interference.
+
+    This function performs all replacements independently, preventing cases where
+    a replacement value matches another pattern, which would cause unintended
+    cascading replacements.
+
+    Why this is needed:
+    - Naive sequential replacements can interfere with each other
+    - Example: replacing "foo" -> "bar" and "bar" -> "baz" would incorrectly
+      turn "foo" into "baz" if done sequentially
+    - This function uses a two-phase approach with UUID placeholders to ensure
+      each pattern is replaced exactly once with its intended value
+
+    Args:
+        text: The input text to perform replacements on
+        repls: Sequence of (pattern, replacement) tuples where pattern can be
+               a string or compiled regex pattern
+
+    Returns:
+        Text with all patterns replaced by their corresponding replacements
+
+    Example:
+        >>> text = "foo and bar"
+        >>> repls = [("foo", "bar"), ("bar", "baz")]
+        >>> replace_in_text(text, repls)
+        "bar and baz"  # Both replacements applied independently
+    """
+    if len(repls) == 0:
+        return text
+
+    placeholders = [uuid4().hex for _ in range(len(repls))]
+    orig, repls = zip(*repls)
+
+    # 2 phase replacement, since the map keys and values can overlap
+    text = _replace_in_text_non_overlapping(text, zip(orig, placeholders))
+    return _replace_in_text_non_overlapping(text, zip(placeholders, repls))