genesis-flow 1.0.0__py3-none-any.whl

mlflow/utils/string_utils.py

@@ -0,0 +1,138 @@
+import re
+import shlex
+
+from mlflow.utils.os import is_windows
+
+
+def strip_prefix(original, prefix):
+    if original.startswith(prefix):
+        return original[len(prefix) :]
+    return original
+
+
+def strip_suffix(original, suffix):
+    if original.endswith(suffix) and suffix != "":
+        return original[: -len(suffix)]
+    return original
+
+
+def is_string_type(item):
+    return isinstance(item, str)
+
+
+def generate_feature_name_if_not_string(s):
+    if isinstance(s, str):
+        return s
+
+    return f"feature_{s}"
+
+
+def truncate_str_from_middle(s, max_length):
+    assert max_length > 5
+    if len(s) <= max_length:
+        return s
+    else:
+        left_part_len = (max_length - 3) // 2
+        right_part_len = max_length - 3 - left_part_len
+        return f"{s[:left_part_len]}...{s[-right_part_len:]}"
+
+
+def _create_table(
+    rows: list[list[str]], headers: list[str], column_sep: str = " " * 2, min_column_width: int = 4
+) -> str:
+    """
+    Creates a table from a list of rows and headers.
+
+    Example
+    =======
+    >>> print(_create_table([["a", "b", "c"], ["d", "e", "f"]], ["x", "y", "z"]))
+    x     y     z
+    ----  ----  ----
+    a     b     c
+    d     e     f
+    """
+    column_widths = [
+        max(len(max(col, key=len)), len(header) + 2, min_column_width)
+        for col, header in zip(zip(*rows), headers)
+    ]
+    aligned_rows = [
+        column_sep.join(header.ljust(width) for header, width in zip(headers, column_widths)),
+        column_sep.join("-" * width for width in column_widths),
+        *(
+            column_sep.join(cell.ljust(width) for cell, width in zip(row, column_widths))
+            for row in rows
+        ),
+    ]
+    return "\n".join(aligned_rows)
+
+
+# Source: https://github.com/smoofra/mslex/blob/3338c347324d52af619ba39cebfdf7cbf46fa51b/mslex.py#L89-L139
+cmd_meta = r"([\"\^\&\|\<\>\(\)\%\!])"
+cmd_meta_or_space = r"[\s\"\^\&\|\<\>\(\)\%\!]"
+cmd_meta_inside_quotes = r"([\"\%\!])"
+
+
+def mslex_quote(s, for_cmd=True):
+    """
+    Quote a string for use as a command line argument in DOS or Windows.
+
+    On windows, before a command line argument becomes a char* in a
+    program's argv, it must be parsed by both cmd.exe, and by
+    CommandLineToArgvW.
+
+    If for_cmd is true, then this will quote the string so it will
+    be parsed correctly by cmd.exe and then by CommandLineToArgvW.
+
+    If for_cmd is false, then this will quote the string so it will
+    be parsed correctly when passed directly to CommandLineToArgvW.
+
+    For some strings there is no way to quote them so they will
+    parse correctly in both situations.
+    """
+    if not s:
+        return '""'
+    if not re.search(cmd_meta_or_space, s):
+        return s
+    if for_cmd and re.search(cmd_meta, s):
+        if not re.search(cmd_meta_inside_quotes, s):
+            m = re.search(r"\\+$", s)
+            if m:
+                return '"' + s + m.group() + '"'
+            else:
+                return '"' + s + '"'
+        if not re.search(r"[\s\"]", s):
+            return re.sub(cmd_meta, r"^\1", s)
+        return re.sub(cmd_meta, r"^\1", mslex_quote(s, for_cmd=False))
+    i = re.finditer(r"(\\*)(\"+)|(\\+)|([^\\\"]+)", s)
+
+    def parts():
+        yield '"'
+        for m in i:
+            _, end = m.span()
+            slashes, quotes, onlyslashes, text = m.groups()
+            if quotes:
+                yield slashes
+                yield slashes
+                yield r"\"" * len(quotes)
+            elif onlyslashes:
+                if end == len(s):
+                    yield onlyslashes
+                    yield onlyslashes
+                else:
+                    yield onlyslashes
+            else:
+                yield text
+        yield '"'
+
+    return "".join(parts())
+
+
+def quote(s):
+    return mslex_quote(s) if is_windows() else shlex.quote(s)
+
+
+def _backtick_quote(s: str) -> str:
+    """
+    Quotes the given string with backticks if it is not already quoted with backticks.
+    """
+    return f"`{s}`" if not (s.startswith("`") and s.endswith("`")) else s

mlflow/utils/thread_utils.py

@@ -0,0 +1,63 @@
+import os
+import threading
+from typing import Any
+
+
+class ThreadLocalVariable:
+    """
+    Class for creating a thread local variable.
+
+    Args:
+        default_factory: A function used to create the default value
+        reset_in_subprocess: Indicating whether the variable is reset in subprocess.
+    """
+
+    def __init__(self, default_factory, reset_in_subprocess=True):
+        self.reset_in_subprocess = reset_in_subprocess
+        self.default_factory = default_factory
+        self.thread_local = threading.local()
+        # The `__global_thread_values` attribute saves all thread-local values,
+        # the key is thread ID.
+        self.__global_thread_values: dict[int, Any] = {}
+
+    def get(self):
+        """
+        Get the thread-local variable value.
+        If the thread-local variable is not set, return the provided `init_value` value.
+        If `get` is called in a forked subprocess and `reset_in_subprocess` is True,
+        return the provided `init_value` value
+        """
+        if hasattr(self.thread_local, "value"):
+            value, pid = self.thread_local.value
+            if self.reset_in_subprocess and pid != os.getpid():
+                # `get` is called in a forked subprocess, reset it.
+                init_value = self.default_factory()
+                self.set(init_value)
+                return init_value
+            else:
+                return value
+        else:
+            init_value = self.default_factory()
+            self.set(init_value)
+            return init_value
+
+    def set(self, value):
+        """
+        Set a value for the thread-local variable.
+        """
+        self.thread_local.value = (value, os.getpid())
+        self.__global_thread_values[threading.get_ident()] = value
+
+    def get_all_thread_values(self) -> dict[int, Any]:
+        """
+        Return all thread values as a dict, dict key is the thread ID.
+        """
+        return self.__global_thread_values.copy()
+
+    def reset(self):
+        """
+        Reset the thread-local variable.
+        Clear the global thread values and create a new thread local variable.
+        """
+        self.__global_thread_values.clear()
+        self.thread_local = threading.local()

mlflow/utils/time.py

@@ -0,0 +1,54 @@
+import datetime
+import time
+
+
+def get_current_time_millis():
+    """
+    Returns the time in milliseconds since the epoch as an integer number.
+    """
+    return int(time.time() * 1000)
+
+
+def conv_longdate_to_str(longdate, local_tz=True):
+    date_time = datetime.datetime.fromtimestamp(longdate / 1000.0)
+    str_long_date = date_time.strftime("%Y-%m-%d %H:%M:%S")
+    if local_tz:
+        tzinfo = datetime.datetime.now().astimezone().tzinfo
+        if tzinfo:
+            str_long_date += " " + tzinfo.tzname(date_time)
+
+    return str_long_date
+
+
+class Timer:
+    """
+    Measures elapsed time.
+
+    .. code-block:: python
+
+        from mlflow.utils.time import Timer
+
+        with Timer() as t:
+            ...
+
+        print(f"Elapsed time: {t:.2f} seconds")
+    """
+
+    def __init__(self):
+        self.elapsed = 0.0
+
+    def __enter__(self):
+        self.elapsed = time.perf_counter()
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.elapsed = time.perf_counter() - self.elapsed
+
+    def __format__(self, format_spec: str) -> str:
+        return self.elapsed.__format__(format_spec)
+
+    def __repr__(self) -> str:
+        return self.elapsed.__repr__()
+
+    def __str__(self) -> str:
+        return self.elapsed.__str__()

mlflow/utils/timeout.py

@@ -0,0 +1,42 @@
+import signal
+from contextlib import contextmanager
+
+from mlflow.exceptions import MlflowException
+from mlflow.protos.databricks_pb2 import NOT_IMPLEMENTED
+from mlflow.utils.os import is_windows
+
+
+class MlflowTimeoutError(Exception):
+    pass
+
+
+@contextmanager
+def run_with_timeout(seconds):
+    """
+    Context manager to runs a block of code with a timeout. If the block of code takes longer
+    than `seconds` to execute, a `TimeoutError` is raised.
+    NB: This function uses Unix signals to implement the timeout, so it is not thread-safe.
+    Also it does not work on non-Unix platforms such as Windows.
+
+    E.g.
+        ```
+        with run_with_timeout(5):
+            model.predict(data)
+        ```
+    """
+    if is_windows():
+        raise MlflowException(
+            "Timeouts are not implemented yet for non-Unix platforms",
+            error_code=NOT_IMPLEMENTED,
+        )
+
+    def signal_handler(signum, frame):
+        raise MlflowTimeoutError(f"Operation timed out after {seconds} seconds")
+
+    signal.signal(signal.SIGALRM, signal_handler)
+    signal.alarm(seconds)
+
+    try:
+        yield
+    finally:
+        signal.alarm(0)  # Disable the alarm after the operation completes or times out