MindsDB 25.7.3.0__py3-none-any.whl → 25.8.2.0__py3-none-any.whl

mindsdb/interfaces/skills/skills_controller.py

@@ -23,13 +23,16 @@ class SkillsController:
             project_controller = ProjectController()
         self.project_controller = project_controller
 
-    def get_skill(self, skill_name: str, project_name: str = default_project) -> Optional[db.Skills]:
+    def get_skill(
+        self, skill_name: str, project_name: str = default_project, strict_case: bool = False
+    ) -> Optional[db.Skills]:
         """
         Gets a skill by name. Skills are expected to have unique names.
 
         Parameters:
             skill_name (str): The name of the skill
             project_name (str): The name of the containing project
+            strict_case (bool): If True, the skill name is case-sensitive. Defaults to False.
 
         Returns:
             skill (Optional[db.Skills]): The database skill object
@@ -39,11 +42,16 @@ class SkillsController:
         """
 
         project = self.project_controller.get(name=project_name)
-        return db.Skills.query.filter(
-            func.lower(db.Skills.name) == func.lower(skill_name),
+        query = db.Skills.query.filter(
             db.Skills.project_id == project.id,
             db.Skills.deleted_at == null(),
-        ).first()
+        )
+        if strict_case:
+            query = query.filter(db.Skills.name == skill_name)
+        else:
+            query = query.filter(func.lower(db.Skills.name) == func.lower(skill_name))
+
+        return query.first()
 
     def get_skills(self, project_name: Optional[str]) -> List[dict]:
         """
@@ -92,6 +100,9 @@ class SkillsController:
             project_name = default_project
         project = self.project_controller.get(name=project_name)
 
+        if not name.islower():
+            raise ValueError(f"The name must be in lower case: {name}")
+
         skill = self.get_skill(name, project_name)
 
         if skill is not None:
@@ -158,19 +169,20 @@ class SkillsController:
 
         return existing_skill
 
-    def delete_skill(self, skill_name: str, project_name: str = default_project):
+    def delete_skill(self, skill_name: str, project_name: str = default_project, strict_case: bool = False):
         """
         Deletes a skill by name.
 
         Parameters:
             skill_name (str): The name of the skill to delete
             project_name (str): The name of the containing project
+            strict_case (bool): If true, then skill_name is case sensitive
 
         Raises:
             ValueError: If `project_name` does not exist or skill doesn't exist
         """
 
-        skill = self.get_skill(skill_name, project_name)
+        skill = self.get_skill(skill_name, project_name, strict_case)
         if skill is None:
             raise ValueError(f"Skill with name doesn't exist: {skill_name}")
         if isinstance(skill.params, dict) and skill.params.get("is_demo") is True:

mindsdb/interfaces/storage/db.py

@@ -448,19 +448,53 @@ class Agents(Base):
     deleted_at = Column(DateTime)
 
     def as_dict(self) -> Dict:
-        return {
+        skills = []
+        skills_extra_parameters = {}
+        for rel in self.skills_relationships:
+            skill = rel.skill
+            # Skip auto-generated SQL skills
+            if skill.params.get("description", "").startswith("Auto-generated SQL skill for agent"):
+                continue
+            skills.append(skill.as_dict())
+            skills_extra_parameters[skill.name] = rel.parameters or {}
+
+        params = self.params.copy()
+
+        agent_dict = {
             "id": self.id,
             "name": self.name,
             "project_id": self.project_id,
-            "model_name": self.model_name,
-            "skills": [rel.skill.as_dict() for rel in self.skills_relationships],
-            "skills_extra_parameters": {rel.skill.name: (rel.parameters or {}) for rel in self.skills_relationships},
-            "provider": self.provider,
-            "params": self.params,
             "updated_at": self.updated_at,
             "created_at": self.created_at,
         }
 
+        if self.model_name:
+            agent_dict["model_name"] = self.model_name
+
+        if self.provider:
+            agent_dict["provider"] = self.provider
+
+        # Since skills were depreciated, they are only used with Minds
+        # Minds expects the parameters to be provided as is without breaking them down
+        if skills:
+            agent_dict["skills"] = skills
+            agent_dict["skills_extra_parameters"] = skills_extra_parameters
+            agent_dict["params"] = params
+        else:
+            data = params.pop("data", {})
+            model = params.pop("model", {})
+            prompt_template = params.pop("prompt_template", None)
+            if data:
+                agent_dict["data"] = data
+            if model:
+                agent_dict["model"] = model
+            if prompt_template:
+                agent_dict["prompt_template"] = prompt_template
+            if params:
+                agent_dict["params"] = params
+
+        return agent_dict
+
 
 class KnowledgeBase(Base):
     __tablename__ = "knowledge_base"

mindsdb/interfaces/variables/variables_controller.py

@@ -15,13 +15,9 @@ ENV_VAR_PREFIX = "MDB_"
 
 
 class VariablesController:
-
     def __init__(self) -> None:
-        self._storage = get_json_storage(
-            resource_id=0,
-            resource_group=RESOURCE_GROUP.SYSTEM
-        )
-        self._store_key = 'variables'
+        self._storage = get_json_storage(resource_id=0, resource_group=RESOURCE_GROUP.SYSTEM)
+        self._store_key = "variables"
         self._data = None
 
     def _get_data(self) -> dict:
@@ -54,7 +50,7 @@ class VariablesController:
         return os.environ[var_name]
 
     def _get_function(self, name: str) -> Callable:
-        if name == 'from_env':
+        if name == "from_env":
             return self._from_env
         raise ValueError(f"Function {name} is not found")
 
@@ -81,16 +77,13 @@ class VariablesController:
 
         if isinstance(var, Variable):
             return self.get_value(var.value.lower())
+        if isinstance(var, Function):
+            fnc = self._get_function(var.op)
+            return fnc(*var.args)
         elif isinstance(var, dict):
-            return {
-                key: self.fill_parameters(value)
-                for key, value in var.items()
-            }
+            return {key: self.fill_parameters(value) for key, value in var.items()}
         elif isinstance(var, list):
-            return [
-                self.fill_parameters(value)
-                for value in var
-            ]
+            return [self.fill_parameters(value) for value in var]
         return var
 
 

mindsdb/utilities/config.py

@@ -318,7 +318,7 @@ class Config:
             self._env_config["logging"]["handlers"]["console"]["level"] = os.environ["MINDSDB_LOG_LEVEL"]
             self._env_config["logging"]["handlers"]["console"]["enabled"] = True
         if os.environ.get("MINDSDB_CONSOLE_LOG_LEVEL", "") != "":
-            self._env_config["logging"]["handlers"]["console"]["level"] = os.environ["MINDSDB_LOG_LEVEL"]
+            self._env_config["logging"]["handlers"]["console"]["level"] = os.environ["MINDSDB_CONSOLE_LOG_LEVEL"]
             self._env_config["logging"]["handlers"]["console"]["enabled"] = True
         if os.environ.get("MINDSDB_FILE_LOG_LEVEL", "") != "":
             self._env_config["logging"]["handlers"]["file"]["level"] = os.environ["MINDSDB_FILE_LOG_LEVEL"]
@@ -459,8 +459,8 @@ class Config:
         """Merge multiple configs to one."""
         new_config = deepcopy(self._default_config)
         _merge_configs(new_config, self._user_config)
-        _merge_configs(new_config, self._auto_config)
-        _merge_configs(new_config, self._env_config)
+        _merge_configs(new_config, self._auto_config or {})
+        _merge_configs(new_config, self._env_config or {})
 
         # Apply command-line arguments for A2A
         a2a_config = {}
@@ -599,6 +599,7 @@ class Config:
                 ml_task_queue_consumer=None,
                 agent=None,
                 project=None,
+                update_gui=False,
             )
             return
 
@@ -635,6 +636,7 @@ class Config:
             help="MindsDB agent name to connect to",
         )
         parser.add_argument("--project-name", type=str, default=None, help="MindsDB project name")
+        parser.add_argument("--update-gui", action="store_true", default=False, help="Update GUI and exit")
 
         self._cmd_args = parser.parse_args()
 

mindsdb/utilities/fs.py

@@ -12,6 +12,10 @@ from mindsdb.utilities import log
 logger = log.getLogger(__name__)
 
 
+def get_tmp_dir() -> Path:
+    return Path(tempfile.gettempdir()).joinpath("mindsdb")
+
+
 def _get_process_mark_id(unified: bool = False) -> str:
     """Creates a text that can be used to identify process+thread
     Args:
@@ -26,7 +30,7 @@ def _get_process_mark_id(unified: bool = False) -> str:
 
 
 def create_process_mark(folder="learn"):
-    p = Path(tempfile.gettempdir()).joinpath(f"mindsdb/processes/{folder}/")
+    p = get_tmp_dir().joinpath(f"processes/{folder}/")
     p.mkdir(parents=True, exist_ok=True)
     mark = _get_process_mark_id()
     p.joinpath(mark).touch()
@@ -43,7 +47,7 @@ def set_process_mark(folder: str, mark: str) -> None:
     Returns:
         str: process mark
     """
-    p = Path(tempfile.gettempdir()).joinpath(f"mindsdb/processes/{folder}/")
+    p = get_tmp_dir().joinpath(f"processes/{folder}/")
     p.mkdir(parents=True, exist_ok=True)
     mark = f"{os.getpid()}-{threading.get_native_id()}-{mark}"
     p.joinpath(mark).touch()
@@ -53,11 +57,7 @@ def set_process_mark(folder: str, mark: str) -> None:
 def delete_process_mark(folder: str = "learn", mark: Optional[str] = None):
     if mark is None:
         mark = _get_process_mark_id()
-    p = (
-        Path(tempfile.gettempdir())
-        .joinpath(f"mindsdb/processes/{folder}/")
-        .joinpath(mark)
-    )
+    p = get_tmp_dir().joinpath(f"processes/{folder}/").joinpath(mark)
     if p.exists():
         p.unlink()
 
@@ -65,7 +65,7 @@ def delete_process_mark(folder: str = "learn", mark: Optional[str] = None):
 def clean_process_marks():
     """delete all existing processes marks"""
     logger.debug("Deleting PIDs..")
-    p = Path(tempfile.gettempdir()).joinpath("mindsdb/processes/")
+    p = get_tmp_dir().joinpath("processes/")
     if p.exists() is False:
         return
     for path in p.iterdir():
@@ -81,7 +81,7 @@ def get_processes_dir_files_generator() -> Tuple[Path, int, int]:
     Yields:
         Tuple[Path, int, int]: file object, process is and thread id
     """
-    p = Path(tempfile.gettempdir()).joinpath("mindsdb/processes/")
+    p = get_tmp_dir().joinpath("processes/")
     if p.exists() is False:
         return
     for path in p.iterdir():
@@ -112,9 +112,7 @@ def clean_unlinked_process_marks() -> List[int]:
             try:
                 next(t for t in threads if t.id == thread_id)
             except StopIteration:
-                logger.warning(
-                    f"We have mark for process/thread {process_id}/{thread_id} but it does not exists"
-                )
+                logger.warning(f"We have mark for process/thread {process_id}/{thread_id} but it does not exists")
                 deleted_pids.append(process_id)
                 file.unlink()
 
@@ -124,14 +122,53 @@ def clean_unlinked_process_marks() -> List[int]:
             continue
 
         except psutil.NoSuchProcess:
-            logger.warning(
-                f"We have mark for process/thread {process_id}/{thread_id} but it does not exists"
-            )
+            logger.warning(f"We have mark for process/thread {process_id}/{thread_id} but it does not exists")
             deleted_pids.append(process_id)
             file.unlink()
     return deleted_pids
 
 
+def create_pid_file():
+    """
+    Create mindsdb process pid file. Check if previous process exists and is running
+    """
+
+    p = get_tmp_dir()
+    p.mkdir(parents=True, exist_ok=True)
+    pid_file = p.joinpath("pid")
+    if pid_file.exists():
+        # if process exists raise exception
+        pid = pid_file.read_text().strip()
+        try:
+            psutil.Process(int(pid))
+            raise Exception(f"Found PID file with existing process: {pid}")
+        except (psutil.Error, ValueError):
+            ...
+
+        logger.warning(f"Found existing PID file ({pid}), removing")
+        pid_file.unlink()
+
+    pid_file.write_text(str(os.getpid()))
+
+
+def delete_pid_file():
+    """
+    Remove existing process pid file if it matches current process
+    """
+    pid_file = get_tmp_dir().joinpath("pid")
+
+    if not pid_file.exists():
+        logger.warning("Mindsdb PID file does not exist")
+        return
+
+    pid = pid_file.read_text().strip()
+    if pid != str(os.getpid()):
+        logger.warning("Process id in PID file doesn't match mindsdb pid")
+        return
+
+    pid_file.unlink()
+
+
 def __is_within_directory(directory, target):
     abs_directory = os.path.abspath(directory)
     abs_target = os.path.abspath(target)
@@ -141,8 +178,8 @@ def __is_within_directory(directory, target):
 
 def safe_extract(tarfile, path=".", members=None, *, numeric_owner=False):
     # for py >= 3.12
-    if hasattr(tarfile, 'data_filter'):
-        tarfile.extractall(path, members=members, numeric_owner=numeric_owner, filter='data')
+    if hasattr(tarfile, "data_filter"):
+        tarfile.extractall(path, members=members, numeric_owner=numeric_owner, filter="data")
         return
 
     # for py < 3.12

mindsdb/utilities/functions.py

@@ -35,20 +35,19 @@ def get_handler_install_message(handler_name):
 
 
 def cast_row_types(row, field_types):
-    '''
-    '''
+    """ """
     keys = [x for x in row.keys() if x in field_types]
     for key in keys:
         t = field_types[key]
-        if t == 'Timestamp' and isinstance(row[key], (int, float)):
-            timestamp = datetime.datetime.utcfromtimestamp(row[key])
-            row[key] = timestamp.strftime('%Y-%m-%d %H:%M:%S')
-        elif t == 'Date' and isinstance(row[key], (int, float)):
-            timestamp = datetime.datetime.utcfromtimestamp(row[key])
-            row[key] = timestamp.strftime('%Y-%m-%d')
-        elif t == 'Int' and isinstance(row[key], (int, float, str)):
+        if t == "Timestamp" and isinstance(row[key], (int, float)):
+            timestamp = datetime.datetime.fromtimestamp(row[key], datetime.timezone.utc)
+            row[key] = timestamp.strftime("%Y-%m-%d %H:%M:%S")
+        elif t == "Date" and isinstance(row[key], (int, float)):
+            timestamp = datetime.datetime.fromtimestamp(row[key], datetime.timezone.utc)
+            row[key] = timestamp.strftime("%Y-%m-%d")
+        elif t == "Int" and isinstance(row[key], (int, float, str)):
             try:
-                logger.debug(f'cast {row[key]} to {int(row[key])}')
+                logger.debug(f"cast {row[key]} to {int(row[key])}")
                 row[key] = int(row[key])
             except Exception:
                 pass
@@ -67,13 +66,16 @@ def mark_process(name: str, custom_mark: str = None) -> Callable:
                 return func(*args, **kwargs)
             finally:
                 delete_process_mark(name, mark)
+
         return wrapper
+
     return mark_process_wrapper
 
 
 def init_lexer_parsers():
     from mindsdb_sql_parser.lexer import MindsDBLexer
     from mindsdb_sql_parser.parser import MindsDBParser
+
     return MindsDBLexer(), MindsDBParser()
 
 
@@ -86,62 +88,72 @@ def resolve_table_identifier(identifier: Identifier, default_database: str = Non
     elif parts_count == 2:
         return (parts[0], parts[1])
     else:
-        raise Exception(f'Table identifier must contain max 2 parts: {parts}')
+        raise Exception(f"Table identifier must contain max 2 parts: {parts}")
 
 
 def resolve_model_identifier(identifier: Identifier) -> tuple:
-    """ split model name to parts
-
-        Identifier may be:
-
-        Examples:
-            >>> resolve_model_identifier(['a', 'b'])
-            ('a', 'b', None)
-
-            >>> resolve_model_identifier(['a', '1'])
-            (None, 'a', 1)
-
-            >>> resolve_model_identifier(['a'])
-            (None, 'a', None)
-
-            >>> resolve_model_identifier(['a', 'b', 'c'])
-            (None, None, None)  # not found
-
-        Args:
-            name (Identifier): Identifier parts
-
-        Returns:
-            tuple: (database_name, model_name, model_version)
     """
-    parts = identifier.parts
-    database_name = None
+    Splits a model identifier into its database, model name, and version components.
+
+    The identifier may contain one, two, or three parts.
+    The function supports both quoted and unquoted identifiers, and normalizes names to lowercase if unquoted.
+
+    Examples:
+        >>> resolve_model_identifier(Identifier(parts=['a', 'b']))
+        ('a', 'b', None)
+        >>> resolve_model_identifier(Identifier(parts=['a', '1']))
+        (None, 'a', 1)
+        >>> resolve_model_identifier(Identifier(parts=['a']))
+        (None, 'a', None)
+        >>> resolve_model_identifier(Identifier(parts=['a', 'b', 'c']))
+        (None, None, None)  # not found
+
+    Args:
+        identifier (Identifier): The identifier object containing parts and is_quoted attributes.
+
+    Returns:
+        tuple: (database_name, model_name, model_version)
+            - database_name (str or None): The name of the database/project, or None if not specified.
+            - model_name (str or None): The name of the model, or None if not found.
+            - model_version (int or None): The model version as an integer, or None if not specified.
+    """
     model_name = None
-    model_version = None
+    db_name = None
+    version = None
+    model_name_quoted = None
+    db_name_quoted = None
+
+    match identifier.parts, identifier.is_quoted:
+        case [model_name], [model_name_quoted]:
+            ...
+        case [model_name, str(version)], [model_name_quoted, _] if version.isdigit():
+            ...
+        case [model_name, int(version)], [model_name_quoted, _]:
+            ...
+        case [db_name, model_name], [db_name_quoted, model_name_quoted]:
+            ...
+        case [db_name, model_name, str(version)], [db_name_quoted, model_name_quoted, _] if version.isdigit():
+            ...
+        case [db_name, model_name, int(version)], [db_name_quoted, model_name_quoted, _]:
+            ...
+        case [db_name, model_name, str(version)], [db_name_quoted, model_name_quoted, _]:
+            # for back compatibility. May be delete?
+            return (None, None, None)
+        case _:
+            ...  # may be raise ValueError?
+
+    if model_name_quoted is False:
+        model_name = model_name.lower()
+
+    if db_name_quoted is False:
+        db_name = db_name.lower()
+
+    if isinstance(version, int) or isinstance(version, str) and version.isdigit():
+        version = int(version)
+    else:
+        version = None
 
-    parts_count = len(parts)
-    if parts_count == 1:
-        database_name = None
-        model_name = parts[0]
-        model_version = None
-    elif parts_count == 2:
-        if parts[-1].isdigit():
-            database_name = None
-            model_name = parts[0]
-            model_version = int(parts[-1])
-        else:
-            database_name = parts[0]
-            model_name = parts[1]
-            model_version = None
-    elif parts_count == 3:
-        database_name = parts[0]
-        model_name = parts[1]
-        if parts[2].isdigit():
-            model_version = int(parts[2])
-        else:
-            # not found
-            return None, None, None
-
-    return database_name, model_name, model_version
+    return db_name, model_name, version
 
 
 def encrypt(string: bytes, key: str) -> bytes:

mindsdb/utilities/log.py

@@ -43,6 +43,13 @@ class ColorFormatter(logging.Formatter):
         return log_fmt.format(record)
 
 
+FORMATTERS = {
+    "default": {"()": ColorFormatter},
+    "json": {"()": JsonFormatter},
+    "file": {"format": "%(asctime)s %(processName)15s %(levelname)-8s %(name)s: %(message)s"},
+}
+
+
 def get_console_handler_config_level() -> int:
     console_handler_config = app_config["logging"]["handlers"]["console"]
     return getattr(logging, console_handler_config["level"])
@@ -60,7 +67,7 @@ def get_mindsdb_log_level() -> int:
     return min(console_handler_config_level, file_handler_config_level)
 
 
-def configure_logging(process_name: str = None):
+def get_handlers_config(process_name: str) -> dict:
     handlers_config = {}
     console_handler_config = app_config["logging"]["handlers"]["console"]
     console_handler_config_level = getattr(logging, console_handler_config["level"])
@@ -89,16 +96,41 @@ def configure_logging(process_name: str = None):
             "maxBytes": file_handler_config["maxBytes"],  # 0.5 Mb
             "backupCount": file_handler_config["backupCount"],
         }
+    return handlers_config
+
+
+def get_uvicorn_logging_config(process_name: str) -> dict:
+    """Generate a logging configuration dictionary for Uvicorn using MindsDB's logging settings.
+
+    Args:
+        process_name (str): The name of the process to include in log file names and handlers.
+
+    Returns:
+        dict: A dictionary suitable for use with logging.config.dictConfig, configured for Uvicorn logging.
+    """
+    handlers_config = get_handlers_config(process_name)
+    mindsdb_log_level = get_mindsdb_log_level()
+    return {
+        "version": 1,
+        "formatters": FORMATTERS,
+        "handlers": handlers_config,
+        "loggers": {
+            "uvicorn": {
+                "handlers": list(handlers_config.keys()),
+                "level": mindsdb_log_level,
+                "propagate": False,
+            }
+        },
+    }
+
 
+def configure_logging(process_name: str = None):
+    handlers_config = get_handlers_config(process_name)
     mindsdb_log_level = get_mindsdb_log_level()
 
     logging_config = dict(
         version=1,
-        formatters={
-            "default": {"()": ColorFormatter},
-            "json": {"()": JsonFormatter},
-            "file": {"format": "%(asctime)s %(processName)15s %(levelname)-8s %(name)s: %(message)s"},
-        },
+        formatters=FORMATTERS,
         handlers=handlers_config,
         loggers={
             "": {  # root logger

mindsdb/utilities/ps.py

@@ -11,23 +11,23 @@ def get_child_pids(pid):
 
 def net_connections():
     """Cross-platform psutil.net_connections like interface"""
-    if sys.platform.lower().startswith('linux'):
+    if sys.platform.lower().startswith("linux"):
         return psutil.net_connections()
 
     all_connections = []
     Pconn = None
-    for p in psutil.process_iter(['pid']):
+    for p in psutil.process_iter(["pid"]):
         try:
             process = psutil.Process(p.pid)
-            connections = process.connections()
+            connections = process.net_connections()
             if connections:
                 for conn in connections:
                     # Adding pid to the returned instance
                     # for consistency with psutil.net_connections()
                     if Pconn is None:
                         fields = list(conn._fields)
-                        fields.append('pid')
-                        _conn = namedtuple('Pconn', fields)
+                        fields.append("pid")
+                        _conn = namedtuple("Pconn", fields)
                     for attr in conn._fields:
                         setattr(_conn, attr, getattr(conn, attr))
                     _conn.pid = p.pid
@@ -43,7 +43,7 @@ def is_port_in_use(port_num):
     parent_process = psutil.Process()
     child_pids = [x.pid for x in parent_process.children(recursive=True)]
     conns = net_connections()
-    portsinuse = [x.laddr[1] for x in conns if x.pid in child_pids and x.status == 'LISTEN']
+    portsinuse = [x.laddr[1] for x in conns if x.pid in child_pids and x.status == "LISTEN"]
     portsinuse.sort()
     return int(port_num) in portsinuse
 
@@ -66,7 +66,7 @@ def wait_port(port_num, timeout):
 def get_listen_ports(pid):
     try:
         p = psutil.Process(pid)
-        cons = p.connections()
+        cons = p.net_connections()
         cons = [x.laddr.port for x in cons]
     except Exception:
         return []