MindsDB 25.9.1.2__py3-none-any.whl → 25.9.3rc1__py3-none-any.whl

mindsdb/utilities/ml_task_queue/producer.py

@@ -8,11 +8,7 @@ from mindsdb.utilities.config import Config
 from mindsdb.utilities.ml_task_queue.utils import RedisKey, to_bytes
 from mindsdb.utilities.ml_task_queue.task import Task
 from mindsdb.utilities.ml_task_queue.base import BaseRedisQueue
-from mindsdb.utilities.ml_task_queue.const import (
-    TASKS_STREAM_NAME,
-    ML_TASK_TYPE,
-    ML_TASK_STATUS
-)
+from mindsdb.utilities.ml_task_queue.const import TASKS_STREAM_NAME, ML_TASK_TYPE, ML_TASK_STATUS
 from mindsdb.utilities import log
 from mindsdb.utilities.sentry import sentry_sdk  # noqa: F401
 
@@ -20,25 +16,25 @@ logger = log.getLogger(__name__)
 
 
 class MLTaskProducer(BaseRedisQueue):
-    """ Interface around the redis for putting tasks to the queue
+    """Interface around the redis for putting tasks to the queue
 
-        Attributes:
-            db (Redis): database object
-            stream
-            cache
-            pubsub
+    Attributes:
+        db (Redis): database object
+        stream
+        cache
+        pubsub
     """
 
     def __init__(self) -> None:
-        config = Config().get('ml_task_queue', {})
+        config = Config().get("ml_task_queue", {})
 
         self.db = Database(
-            host=config.get('host', 'localhost'),
-            port=config.get('port', 6379),
-            db=config.get('db', 0),
-            username=config.get('username'),
-            password=config.get('password'),
-            protocol=3
+            host=config.get("host", "localhost"),
+            port=config.get("port", 6379),
+            db=config.get("db", 0),
+            username=config.get("username"),
+            password=config.get("password"),
+            protocol=3,
         )
         self.wait_redis_ping(60)
 
@@ -47,26 +43,26 @@ class MLTaskProducer(BaseRedisQueue):
         self.pubsub = self.db.pubsub()
 
     def apply_async(self, task_type: ML_TASK_TYPE, model_id: int, payload: dict, dataframe: DataFrame = None) -> Task:
-        ''' Add tasks to the queue
+        """Add tasks to the queue
 
-            Args:
-                task_type (ML_TASK_TYPE): type of the task
-                model_id (int): model identifier
-                payload (dict): lightweight model data that will be added to stream message
-                dataframe (DataFrame): dataframe will be transfered via regular redis storage
+        Args:
+            task_type (ML_TASK_TYPE): type of the task
+            model_id (int): model identifier
+            payload (dict): lightweight model data that will be added to stream message
+            dataframe (DataFrame): dataframe will be transfered via regular redis storage
 
-            Returns:
-                Task: object representing the task
-        '''
+        Returns:
+            Task: object representing the task
+        """
         try:
             payload = pickle.dumps(payload, protocol=5)
             redis_key = RedisKey.new()
             message = {
                 "task_type": task_type.value,
-                "company_id": '' if ctx.company_id is None else ctx.company_id,     # None can not be dumped
+                "company_id": "" if ctx.company_id is None else ctx.company_id,  # None can not be dumped
                 "model_id": model_id,
                 "payload": payload,
-                "redis_key": redis_key.base
+                "redis_key": redis_key.base,
             }
 
             self.wait_redis_ping()
@@ -77,5 +73,5 @@ class MLTaskProducer(BaseRedisQueue):
             self.stream.add(message)
             return Task(self.db, redis_key)
         except ConnectionError:
-            logger.error('Cant send message to redis: connect failed')
+            logger.exception("Cant send message to redis: connect failed")
             raise

mindsdb/utilities/render/sqlalchemy_render.py

@@ -47,7 +47,7 @@ def _compile_interval(element, compiler, **kw):
         if items[1].upper().endswith("S"):
             items[1] = items[1][:-1]
 
-    if compiler.dialect.driver in ["snowflake"] or compiler.dialect.name in ["postgresql"]:
+    if getattr(compiler.dialect, "driver", None) == "snowflake" or compiler.dialect.name == "postgresql":
         # quote all
         args = " ".join(map(str, items))
         args = f"'{args}'"
@@ -383,7 +383,7 @@ class SqlalchemyRender:
         elif isinstance(t, ast.Parameter):
             col = sa.column(t.value, is_literal=True)
             if t.alias:
-                raise RenderError()
+                raise RenderError("Parameter aliases are not supported in the renderer")
         elif isinstance(t, ast.Tuple):
             col = [self.to_expression(i) for i in t.items]
         elif isinstance(t, ast.Variable):
@@ -574,17 +574,18 @@ class SqlalchemyRender:
                         else:
                             condition = self.to_expression(item["condition"])
 
-                        if "ASOF" in join_type:
+                        if "ASOF" in join_type or "RIGHT" in join_type:
                             raise NotImplementedError(f"Unsupported join type: {join_type}")
-                        method = "join"
+
                         is_full = False
-                        if join_type == "LEFT JOIN":
-                            method = "outerjoin"
+                        is_outer = False
+                        if join_type in ("LEFT JOIN", "LEFT OUTER JOIN"):
+                            is_outer = True
                         if join_type == "FULL JOIN":
                             is_full = True
 
                         # perform join
-                        query = getattr(query, method)(table, condition, full=is_full)
+                        query = query.join(table, condition, isouter=is_outer, full=is_full)
             elif isinstance(from_table, (ast.Union, ast.Intersect, ast.Except)):
                 alias = None
                 if from_table.alias:

mindsdb/utilities/utils.py

@@ -22,13 +22,13 @@ def parse_csv_attributes(csv_attributes: typing.Optional[str] = "") -> typing.Di
         for row in reader:
             for pair in row:
                 # Match key=value pattern
-                match = re.match(r'^\s*([^=]+?)\s*=\s*(.+?)\s*$', pair)
+                match = re.match(r"^\s*([^=]+?)\s*=\s*(.+?)\s*$", pair)
                 if match:
                     key, value = match.groups()
                     attributes[key.strip()] = value.strip()
                 else:
                     raise ValueError(f"Invalid attribute format: {pair}")
     except Exception as e:
-        raise ValueError(f"Failed to parse csv_attributes='{csv_attributes}': {e}")
+        raise ValueError(f"Failed to parse csv_attributes='{csv_attributes}': {e}") from e
 
     return attributes