sdmxlib 0.41.3__tar.gz → 0.43.0__tar.gz

{sdmxlib-0.41.3 → sdmxlib-0.43.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: sdmxlib
-Version: 0.41.3
+Version: 0.43.0
 Summary: SDMX structural metadata library for Python
 Keywords: sdmx,statistics,metadata,datastructure
 Author: gabrielgellner

{sdmxlib-0.41.3 → sdmxlib-0.43.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sdmxlib"
-version = "0.41.3"
+version = "0.43.0"
 description = "SDMX structural metadata library for Python"
 readme = "README.md"
 license = { text = "Apache-2.0" }

{sdmxlib-0.41.3 → sdmxlib-0.43.0}/src/sdmxlib/model/code_query.py

@@ -956,14 +956,20 @@ def _emit_string_match(
     join_params: list[object],
     annotation_join_aliases: dict[str, str],
 ) -> tuple[str, list[object]]:
-    pattern = _ilike_pattern(pred.op, pred.value)
     field = pred.field
+    # Natural-language label fields (name / annotation title / annotation
+    # text) are matched accent- AND punctuation-INSENSITIVELY via
+    # :func:`_label_match_sql`, so "Montreal" finds "Montréal" and
+    # "Trois Rivieres" finds "Trois-Rivières". The raw value is passed and
+    # normalised in SQL. ID fields (code_id / parent_id) keep the plain ILIKE
+    # — codes and DGUIDs are ASCII identifiers, so folding them is a no-op
+    # that only defeats indexes.
     if isinstance(field, _IdField):
-        return f"{row_alias}.code_id ILIKE ?", [pattern]
+        return f"{row_alias}.code_id ILIKE ?", [_ilike_pattern(pred.op, pred.value)]
     if isinstance(field, _ParentIdField):
-        return f"{row_alias}.parent_id ILIKE ?", [pattern]
+        return f"{row_alias}.parent_id ILIKE ?", [_ilike_pattern(pred.op, pred.value)]
     if isinstance(field, _NameField):
-        return f"{row_alias}.name[?] ILIKE ?", [field.lang, pattern]
+        return _label_match_sql(f"{row_alias}.name[?]", pred.op), [field.lang, pred.value]
     if isinstance(field, _AnnotationField):
         alias = _ensure_annotation_join(
             field.type,
@@ -972,7 +978,7 @@ def _emit_string_match(
             join_params=join_params,
             annotation_join_aliases=annotation_join_aliases,
         )
-        return f"{alias}.title ILIKE ?", [pattern]
+        return _label_match_sql(f"{alias}.title", pred.op), [pred.value]
     if isinstance(field, _AnnotationTextField):
         text_alias = _ensure_annotation_text_join(
             field.type,
@@ -982,7 +988,7 @@ def _emit_string_match(
             join_params=join_params,
             annotation_join_aliases=annotation_join_aliases,
         )
-        return f"{text_alias}.text ILIKE ?", [pattern]
+        return _label_match_sql(f"{text_alias}.text", pred.op), [pred.value]
     msg = f"Unsupported field for string match: {type(field).__name__}"
     raise NotImplementedError(msg)
 
@@ -1160,6 +1166,41 @@ def _ilike_pattern(op: str, value: str) -> str:
     raise NotImplementedError(msg)
 
 
+# Accent- AND punctuation-insensitive label matching. ``strip_accents`` folds
+# diacritics; the regexp collapses runs of Unicode punctuation + separators
+# (``\p{P}\p{Z}`` + whitespace) to a single space, so "Trois Rivieres" matches
+# "Trois-Rivières", "St Johns" ~ "St. John's", etc. ``\p{P}\p{Z}`` keeps
+# letters of any script (Latin, Inuktitut syllabics, …) — unlike a naive
+# ``[^a-zA-Z0-9]``, which would destroy non-Latin names. The regexp also
+# strips ILIKE wildcards (``%`` / ``_`` are punctuation), so the bound value
+# needs no LIKE-escaping.
+_LABEL_NORM_REGEX = r"[\p{P}\p{Z}\s]+"
+
+
+def _label_norm(expr: str) -> str:
+    """Wrap ``expr`` in the accent + punctuation fold used for label search."""
+    return f"trim(regexp_replace(strip_accents({expr}), '{_LABEL_NORM_REGEX}', ' ', 'g'))"
+
+
+def _label_match_sql(col_expr: str, op: str) -> str:
+    """Build an accent/punctuation-insensitive ILIKE of ``col_expr`` vs a bound ``?``.
+
+    Both sides are folded by :func:`_label_norm`, then the op decides where
+    the ``%`` wildcards go. The value placeholder is normalised in SQL (not
+    pre-wrapped), so callers pass the raw value, not an ILIKE pattern.
+    """
+    col = _label_norm(col_expr)
+    val = _label_norm("?")
+    if op == "contains":
+        return f"{col} ILIKE '%' || {val} || '%'"
+    if op == "starts_with":
+        return f"{col} ILIKE {val} || '%'"
+    if op == "ends_with":
+        return f"{col} ILIKE '%' || {val}"
+    msg = f"Unsupported string op: {op}"
+    raise NotImplementedError(msg)
+
+
 # ── Row → Code construction ─────────────────────────────────────────────