persistence-kit 3.0.0__tar.gz → 3.0.2__tar.gz

{persistence_kit-3.0.0 → persistence_kit-3.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: persistence-kit
-Version: 3.0.0
+Version: 3.0.2
 Summary: Reusable persistence and repository toolkit
 License: MIT
 License-File: LICENSE

{persistence_kit-3.0.0 → persistence_kit-3.0.2}/persistence_kit/repository/filter_ops.py

@@ -1,11 +1,15 @@
 from __future__ import annotations
 
+import re
+import unicodedata
 from typing import Any, Callable, Iterable, Mapping
 
 
 _SIMPLE_OPS = {"gte", "gt", "lte", "lt", "eq", "ne"}
 _STRING_OPS = {"contains", "icontains", "startswith", "istartswith", "endswith", "iendswith"}
 _LOGICAL_KEYS = {"or", "and"}
+_NON_ALNUM_RE = re.compile(r"[^0-9a-z]+")
+_WHITESPACE_RE = re.compile(r"\s+")
 
 
 def is_multi_value(value: Any) -> bool:
@@ -49,6 +53,23 @@ def iter_range_ops(value: Mapping[str, Any]) -> Iterable[tuple[str, Any]]:
     return items
 
 
+def normalize_search_text(value: Any) -> str:
+    if value is None:
+        return ""
+    normalized = unicodedata.normalize("NFKD", str(value))
+    without_marks = "".join(ch for ch in normalized if not unicodedata.combining(ch))
+    lowered = without_marks.lower()
+    collapsed = _NON_ALNUM_RE.sub(" ", lowered)
+    return _WHITESPACE_RE.sub(" ", collapsed).strip()
+
+
+def tokenize_search_text(value: Any) -> list[str]:
+    normalized = normalize_search_text(value)
+    if not normalized:
+        return []
+    return normalized.split()
+
+
 def _matches_string_op(current: Any, op: str, expected: Any) -> bool:
     if current is None:
         return False
@@ -57,15 +78,25 @@ def _matches_string_op(current: Any, op: str, expected: Any) -> bool:
     if op == "contains":
         return expected_text in current_text
     if op == "icontains":
-        return expected_text.lower() in current_text.lower()
+        expected_tokens = tokenize_search_text(expected)
+        if not expected_tokens:
+            return False
+        normalized_current = normalize_search_text(current)
+        return all(token in normalized_current for token in expected_tokens)
     if op == "startswith":
         return current_text.startswith(expected_text)
     if op == "istartswith":
-        return current_text.lower().startswith(expected_text.lower())
+        normalized_expected = normalize_search_text(expected)
+        if not normalized_expected:
+            return False
+        return normalize_search_text(current).startswith(normalized_expected)
     if op == "endswith":
         return current_text.endswith(expected_text)
     if op == "iendswith":
-        return current_text.lower().endswith(expected_text.lower())
+        normalized_expected = normalize_search_text(expected)
+        if not normalized_expected:
+            return False
+        return normalize_search_text(current).endswith(normalized_expected)
     raise ValueError(f"Unsupported operator: {op}")
 
 

{persistence_kit-3.0.0 → persistence_kit-3.0.2}/persistence_kit/repository/mongo_repo/mongo_repo.py

@@ -16,10 +16,21 @@ from persistence_kit.repository.filter_ops import (
     is_multi_value,
     is_range_dict,
     iter_range_ops,
+    normalize_search_text,
+    tokenize_search_text,
 )
 
 T = TypeVar("T")
 TId = TypeVar("TId", bound=Hashable)
+_ACCENT_CLASSES = {
+    "a": "[aáàäâã]",
+    "e": "[eéèëê]",
+    "i": "[iíìïî]",
+    "o": "[oóòöôõ]",
+    "u": "[uúùüû]",
+    "n": "[nñ]",
+    "c": "[cç]",
+}
 
 class EntityMapper(Protocol[T, TId]):
     def collection(self) -> str: ...
@@ -34,6 +45,36 @@ class EntityMapper(Protocol[T, TId]):
 def _normalize_field(mapper: EntityMapper[T, TId], field: str) -> str:
     return mapper.attr_to_storage(field)
 
+
+def _token_to_regex(token: str) -> str:
+    parts: list[str] = []
+    for ch in token:
+        parts.append(_ACCENT_CLASSES.get(ch, re.escape(ch)))
+    return "".join(parts)
+
+
+def _build_icontains_pattern(value: Any) -> str | None:
+    terms = tokenize_search_text(value)
+    if not terms:
+        return None
+    return "".join(f"(?=.*{_token_to_regex(term)})" for term in terms)
+
+
+def _build_ordered_pattern(value: Any, *, anchor_start: bool = False, anchor_end: bool = False) -> str | None:
+    normalized = normalize_search_text(value)
+    if not normalized:
+        return None
+    terms = tokenize_search_text(normalized)
+    if not terms:
+        return None
+    core = ".*".join(_token_to_regex(term) for term in terms)
+    if anchor_start:
+        core = f"^{core}"
+    if anchor_end:
+        core = f"{core}$"
+    return core
+
+
 def _range_to_mongo(value: Mapping[str, Any]) -> Mapping[str, Any]:
     query: dict[str, Any] = {}
     for op, v in iter_range_ops(value):
@@ -57,17 +98,26 @@ def _range_to_mongo(value: Mapping[str, Any]) -> Mapping[str, Any]:
         elif op == "contains":
             query["$regex"] = re.escape(str(v))
         elif op == "icontains":
-            query["$regex"] = re.escape(str(v))
+            pattern = _build_icontains_pattern(v)
+            if pattern is None:
+                continue
+            query["$regex"] = pattern
             query["$options"] = "i"
         elif op == "startswith":
             query["$regex"] = f"^{re.escape(str(v))}"
         elif op == "istartswith":
-            query["$regex"] = f"^{re.escape(str(v))}"
+            pattern = _build_ordered_pattern(v, anchor_start=True)
+            if pattern is None:
+                continue
+            query["$regex"] = pattern
             query["$options"] = "i"
         elif op == "endswith":
             query["$regex"] = f"{re.escape(str(v))}$"
         elif op == "iendswith":
-            query["$regex"] = f"{re.escape(str(v))}$"
+            pattern = _build_ordered_pattern(v, anchor_end=True)
+            if pattern is None:
+                continue
+            query["$regex"] = pattern
             query["$options"] = "i"
     return query
 

{persistence_kit-3.0.0 → persistence_kit-3.0.2}/persistence_kit/repository/sqlalchemy_repo/sqlalchemy_engine.py

@@ -5,7 +5,10 @@ from persistence_kit.settings.repo_settings import RepoSettings
 @lru_cache
 def get_engine() -> AsyncEngine:
     s = RepoSettings()
-    url = getattr(s, "postgres_dsn", None)
+    url = s.postgres_dsn
     if not url:
         url = f"postgresql+asyncpg://{s.postgres_user}:{s.postgres_password}@{s.postgres_host}:{s.postgres_port}/{s.postgres_db}"
-    return create_async_engine(url, future=True)
+    kwargs: dict = {"future": True}
+    if s.postgres_ssl:
+        kwargs["connect_args"] = {"ssl": "require"}
+    return create_async_engine(url, **kwargs)

{persistence_kit-3.0.0 → persistence_kit-3.0.2}/persistence_kit/repository/sqlalchemy_repo/sqlalchemy_repo.py

@@ -6,7 +6,7 @@ try:
 except ImportError:
     from typing_extensions import override
 
-from sqlalchemy import Table, select, insert, update as sql_update, delete as sql_delete, Index, and_, or_, func, distinct
+from sqlalchemy import Table, select, insert, update as sql_update, delete as sql_delete, Index, and_, or_, func, distinct, String, cast
 from sqlalchemy.ext.asyncio import AsyncEngine
 
 from persistence_kit.contracts.repository import Repository
@@ -16,6 +16,8 @@ from persistence_kit.repository.filter_ops import (
     is_multi_value,
     is_range_dict,
     iter_range_ops,
+    normalize_search_text,
+    tokenize_search_text,
 )
 from persistence_kit.repository.sqlalchemy_repo.schema_evolve import (
     ensure_missing_columns,
@@ -25,6 +27,8 @@ from persistence_kit.repository_factory.registry.entity_registry import build_fk
 
 T = TypeVar("T")
 TId = TypeVar("TId", bound=Hashable)
+_ACCENTED_CHARS = "ÁÀÄÂÃáàäâãÉÈËÊéèëêÍÌÏÎíìïîÓÒÖÔÕóòöôõÚÙÜÛúùüûÑñÇç"
+_PLAIN_CHARS = "AAAAAaaaaaEEEEeeeeIIIIiiiiOOOOOoooooUUUUuuuuNnCc"
 
 
 class SqlAlchemyEntityMapper(Protocol[T, TId]):
@@ -39,6 +43,12 @@ class SqlAlchemyEntityMapper(Protocol[T, TId]):
     def attr_to_storage(self, name: str) -> str: ...
 
 
+def _normalized_text_expr(col: Any) -> Any:
+    text_col = cast(func.coalesce(col, ""), String)
+    lowered = func.lower(func.translate(text_col, _ACCENTED_CHARS, _PLAIN_CHARS))
+    return func.regexp_replace(lowered, r"[^a-z0-9]+", " ", "g")
+
+
 def _build_where_clauses(
     table: Table,
     mapper: SqlAlchemyEntityMapper[T, TId],
@@ -104,15 +114,26 @@ def _build_where_clauses(
                 elif op == "contains":
                     clauses.append(col.contains(str(v)))
                 elif op == "icontains":
-                    clauses.append(col.ilike(f"%{v}%"))
+                    normalized_terms = tokenize_search_text(v)
+                    if not normalized_terms:
+                        return None
+                    normalized_col = _normalized_text_expr(col)
+                    for term in normalized_terms:
+                        clauses.append(normalized_col.like(f"%{term}%"))
                 elif op == "startswith":
                     clauses.append(col.startswith(str(v)))
                 elif op == "istartswith":
-                    clauses.append(col.ilike(f"{v}%"))
+                    normalized_value = normalize_search_text(v)
+                    if not normalized_value:
+                        return None
+                    clauses.append(_normalized_text_expr(col).like(f"{normalized_value}%"))
                 elif op == "endswith":
                     clauses.append(col.endswith(str(v)))
                 elif op == "iendswith":
-                    clauses.append(col.ilike(f"%{v}"))
+                    normalized_value = normalize_search_text(v)
+                    if not normalized_value:
+                        return None
+                    clauses.append(_normalized_text_expr(col).like(f"%{normalized_value}"))
         else:
             clauses.append(col == value)
     return clauses

{persistence_kit-3.0.0 → persistence_kit-3.0.2}/persistence_kit/settings/repo_settings.py

@@ -12,11 +12,13 @@ class RepoSettings(BaseSettings):
     mongo_dsn: str | None = None
     mongo_db: str | None = None
 
+    postgres_dsn: str | None = None
     postgres_user: str | None = None
     postgres_password: str | None = None
     postgres_host: str | None = None
     postgres_port: int | None = 5432
     postgres_db: str | None = None
+    postgres_ssl: bool = False
 
     dynamodb_table_prefix: str = ""
     dynamodb_region: str = "us-east-1"

{persistence_kit-3.0.0 → persistence_kit-3.0.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "persistence-kit"
-version = "3.0.0"
+version = "3.0.2"
 description = "Reusable persistence and repository toolkit"
 authors = ["Andres Felipe Serrano Barrios <andresfserrano1@gmail.com>"]
 readme = "README.md"