upgini 1.2.124__py3-none-any.whl → 1.2.146a4__py3-none-any.whl

upgini/utils/features_validator.py

@@ -44,12 +44,14 @@ class FeaturesValidator:
                 else:
                     empty_or_constant_features.append(f)
 
-        if one_hot_encoded_features:
-            msg = bundle.get("one_hot_encoded_features").format(one_hot_encoded_features)
-            warnings.append(msg)
-
         columns_renaming = columns_renaming or {}
 
+        if one_hot_encoded_features and len(one_hot_encoded_features) > 1:
+            msg = bundle.get("one_hot_encoded_features").format(
+                [columns_renaming.get(f, f) for f in one_hot_encoded_features]
+            )
+            warnings.append(msg)
+
         if empty_or_constant_features:
             msg = bundle.get("empty_or_contant_features").format(
                 [columns_renaming.get(f, f) for f in empty_or_constant_features]

upgini/utils/postal_code_utils.py

@@ -4,16 +4,49 @@ from pandas.api.types import (
     is_object_dtype,
     is_string_dtype,
 )
+import re
 
 from upgini.utils.base_search_key_detector import BaseSearchKeyDetector
 
 
 class PostalCodeSearchKeyDetector(BaseSearchKeyDetector):
+    postal_pattern = re.compile(r'^[A-Za-z0-9][A-Za-z0-9\s\-]{1,9}$')
+
     def _is_search_key_by_name(self, column_name: str) -> bool:
-        return str(column_name).lower() in ["zip", "zipcode", "zip_code", "postal_code", "postalcode"]
+        return "zip" in str(column_name).lower() or "postal" in str(column_name).lower()
 
     def _is_search_key_by_values(self, column: pd.Series) -> bool:
-        return False
+        """
+        # Fast two-step check whether the column looks like a postal code.
+        # Returns True if, after removing missing values, values remain,
+        # and all of them match the common characteristics of a postal code.
+        """
+        # Check only columns that are candidates for postal code by column name
+        if not self._is_search_key_by_name(column.name):
+            return False
+
+        s = column.copy().dropna().astype(str).str.strip()
+        s = s[s != ""]  # remove empty strings
+        if s.empty:
+            return False
+
+        # remove suffix ".0" (often after float)
+        s = s.str.replace(r"\.0$", "", regex=True)
+
+        # --- Step 1: fast filtering ---
+        mask_len = s.str.len().between(2, 10)
+        mask_digit = s.str.contains(r'\d', regex=True)
+        mask_chars = ~s.str.contains(r'[^A-Za-z0-9\s\-]', regex=True)
+        fast_mask = mask_len & mask_digit & mask_chars
+
+        # if any of them failed the fast check, return False
+        if not fast_mask.all():
+            return False
+
+        # --- Step 2: regex check ---
+        # only if the first step passed
+        valid_mask = s.apply(lambda x: bool(self.postal_pattern.fullmatch(x)))
+        return valid_mask.all()
 
 
 class PostalCodeSearchKeyConverter:

upgini/utils/target_utils.py

@@ -31,6 +31,7 @@ def define_task(
 ) -> ModelTaskType:
     if logger is None:
         logger = logging.getLogger()
+        logger.setLevel(logging.FATAL)
 
     # Replace inf and -inf with NaN to handle extreme values correctly
     y = y.replace([np.inf, -np.inf], np.nan, inplace=False)
@@ -143,7 +144,8 @@ def is_imbalanced(
         msg = bundle.get("dataset_rarest_class_less_min").format(
             min_class_value, min_class_count, MIN_TARGET_CLASS_ROWS
         )
-        raise ValidationError(msg)
+        print(msg)
+        # raise ValidationError(msg)
 
     min_class_percent = IMBALANCE_THESHOLD / target_classes_count
     min_class_threshold = min_class_percent * count

upgini/utils/track_info.py

@@ -5,6 +5,7 @@ import sys
 from functools import lru_cache
 from getpass import getuser
 from hashlib import sha256
+from threading import Event, Lock
 from typing import Optional
 from uuid import getnode
 
@@ -51,8 +52,12 @@ def _get_execution_ide() -> str:
         return "other"
 
 
+_inflight_lock = Lock()
+_inflight_events = {}
+
+
 @lru_cache
-def get_track_metrics(client_ip: Optional[str] = None, client_visitorid: Optional[str] = None) -> dict:
+def _compute_track_metrics(client_ip: Optional[str] = None, client_visitorid: Optional[str] = None) -> dict:
     # default values
     track = {"ide": _get_execution_ide()}
     ident_res = "https://api64.ipify.org"
@@ -164,3 +169,26 @@ def get_track_metrics(client_ip: Optional[str] = None, client_visitorid: Optiona
                 track["ip"] = "0.0.0.0"
 
     return track
+
+
+def get_track_metrics(client_ip: Optional[str] = None, client_visitorid: Optional[str] = None) -> dict:
+    key = (client_ip, client_visitorid)
+    with _inflight_lock:
+        event = _inflight_events.get(key)
+        if event is None:
+            event = Event()
+            _inflight_events[key] = event
+            is_owner = True
+        else:
+            is_owner = False
+
+    if not is_owner:
+        event.wait()
+        return _compute_track_metrics(client_ip, client_visitorid)
+
+    try:
+        return _compute_track_metrics(client_ip, client_visitorid)
+    finally:
+        with _inflight_lock:
+            event.set()
+            _inflight_events.pop(key, None)