bluer-objects 6.104.1__py3-none-any.whl → 6.464.1__py3-none-any.whl

bluer_objects/mlflow/__main__.py

@@ -24,7 +24,6 @@ from bluer_objects.mlflow.runs import (
     start_run,
 )
 from bluer_objects.mlflow.tags import (
-    create_filter_string,
     get_tags,
     search,
     set_tags,
@@ -42,7 +41,23 @@ parser.add_argument(
     "task",
     type=str,
     default="",
-    help="clone_tags|create_filter_string|get_id|get_run_id|get_tags|list_registered_models|log_artifacts|log_run|rm|search|set_tags|start_end_run|test|transition",
+    help=" | ".join(
+        [
+            "clone_tags",
+            "get_id",
+            "get_run_id",
+            "get_tags",
+            "list_registered_models",
+            "log_artifacts",
+            "log_run",
+            "rm",
+            "search",
+            "set_tags",
+            "start_end_run",
+            "test",
+            "transition",
+        ]
+    ),
 )
 parser.add_argument(
     "--count",
@@ -115,13 +130,13 @@ parser.add_argument(
     "--log",
     type=int,
     default=1,
-    help="0|1",
+    help="0 | 1",
 )
 parser.add_argument(
-    "--explicit_query",
+    "--server_style",
     type=int,
     default=0,
-    help="0|1",
+    help="0 | 1",
 )
 parser.add_argument(
     "--start_end",
@@ -162,6 +177,12 @@ parser.add_argument(
     default="",
     help="",
 )
+parser.add_argument(
+    "--verbose",
+    type=int,
+    default=0,
+    help="0 | 1",
+)
 args = parser.parse_args()
 
 delim = " " if args.delim == "space" else args.delim
@@ -171,9 +192,6 @@ if args.task == "clone_tags":
     success, tags = get_tags(args.source_objects)
     if success:
         success = set_tags(args.destination_object, tags)
-elif args.task == "create_filter_string":
-    success = True
-    print(create_filter_string(args.tags))
 elif args.task == "rm":
     success = reduce(
         lambda x, y: x and y,
@@ -188,7 +206,10 @@ elif args.task == "rm":
         True,
     )
 elif args.task == "get_tags":
-    success, tags = get_tags(args.object_name)
+    success, tags = get_tags(
+        args.object_name,
+        verbose=args.verbose == 1,
+    )
     print(tags if not args.tag else tags.get(args.tag, args.default))
 elif args.task == "get_id":
     success, id = get_id(args.object_name)
@@ -217,36 +238,33 @@ elif args.task == "log_artifacts":
 elif args.task == "log_run":
     success = log_run(args.object_name)
 elif args.task == "search":
-    success = True
-
-    filter_string = (
-        create_filter_string(args.tags)
-        if args.explicit_query == 0
-        else "" if args.filter_string == "-" else args.filter_string
+    success, list_of_objects = search(
+        filter_string=args.tags,
+        server_style=args.server_style == 1,
     )
 
-    list_of_objects = search(filter_string)
-
-    list_of_objects = list_of_objects[args.offset :]
+    if success:
+        list_of_objects = list_of_objects[args.offset :]
 
-    if args.count != -1:
-        list_of_objects = list_of_objects[: args.count]
+        if args.count != -1:
+            list_of_objects = list_of_objects[: args.count]
 
-    if args.log:
-        logger.info(
-            "{:,} {}.".format(
-                len(list_of_objects),
-                args.item_name_plural,
-            ),
-        )
-        for index, object_name in enumerate(list_of_objects):
-            logger.info(f"#{index+1: 4d} - {object_name}")
-    else:
-        print(delim.join(list_of_objects))
+        if args.log:
+            logger.info(
+                "{:,} {}.".format(
+                    len(list_of_objects),
+                    args.item_name_plural,
+                ),
+            )
+            for index, object_name in enumerate(list_of_objects):
+                logger.info(f"#{index+1: 4d} - {object_name}")
+        else:
+            print(delim.join(list_of_objects))
 elif args.task == "set_tags":
     success = set_tags(
         args.object_name,
         args.tags,
+        verbose=args.verbose == 1,
     )
 elif args.task == "transition":
     success = transition(

bluer_objects/mlflow/lock/__init__.py

@@ -0,0 +1 @@
+

bluer_objects/mlflow/lock/__main__.py

@@ -0,0 +1,58 @@
+import argparse
+
+from blueness import module
+from blueness.argparse.generic import sys_exit
+
+from bluer_objects import NAME
+from bluer_objects.mlflow.lock.functions import lock, unlock
+from bluer_objects.logger import logger
+
+NAME = module.name(__file__, NAME)
+
+parser = argparse.ArgumentParser(NAME)
+parser.add_argument(
+    "task",
+    type=str,
+    help="lock | unlock",
+)
+parser.add_argument(
+    "--object_name",
+    type=str,
+)
+parser.add_argument(
+    "--lock",
+    type=str,
+    default="lock",
+)
+parser.add_argument(
+    "--timeout",
+    type=int,
+    default=-1,
+    help="in seconds",
+)
+parser.add_argument(
+    "--verbose",
+    type=int,
+    default=1,
+    help="0 | 1",
+)
+args = parser.parse_args()
+
+success = False
+if args.task == "lock":
+    success = lock(
+        object_name=args.object_name,
+        lock_name=args.lock,
+        timeout=args.timeout,
+        verbose=args.verbose == 1,
+    )
+elif args.task == "unlock":
+    success = unlock(
+        object_name=args.object_name,
+        lock_name=args.lock,
+        verbose=args.verbose == 1,
+    )
+else:
+    success = None
+
+sys_exit(logger, NAME, args.task, success)

bluer_objects/mlflow/lock/functions.py

@@ -0,0 +1,121 @@
+import time
+
+from blueness import module
+from bluer_options import string
+
+from bluer_objects import NAME, env
+from bluer_objects.mlflow.tags import get_tags, set_tags
+from bluer_objects.logger import logger
+
+
+NAME = module.name(__file__, NAME)
+
+
+def lock(
+    object_name: str,
+    lock_name: str = "lock",
+    timeout: int = -1,
+    verbose: bool = True,
+) -> bool:
+    logger.info(
+        "{}.lock: {}.{}{}".format(
+            NAME,
+            object_name,
+            lock_name,
+            "" if timeout == -1 else " @ {}".format(string.pretty_duration(timeout)),
+        )
+    )
+
+    start_time = time.time()
+    while True:
+        if time.time() - start_time > timeout > 0:
+            if verbose:
+                logger.warning(
+                    "{}.lock: {}.{} timeout.".format(
+                        NAME,
+                        object_name,
+                        lock_name,
+                    )
+                )
+            return False
+
+        success, list_of_tags = get_tags(object_name=object_name)
+        if not success:
+            return False
+
+        lock_value = list_of_tags.get(lock_name, "")
+        if lock_value:
+            if verbose:
+                logger.warning(
+                    "{}.lock: {}.{} is locked by {}.".format(
+                        NAME,
+                        object_name,
+                        lock_name,
+                        lock_value,
+                    )
+                )
+            time.sleep(env.MLFLOW_LOCK_WAIT_FOR_CLEARANCE)
+            continue
+
+        lock_value = string.random()
+        if not set_tags(
+            object_name=object_name,
+            tags={lock_name: lock_value},
+            log=verbose,
+            icon="🔒",
+        ):
+            return False
+
+        time.sleep(env.MLFLOW_LOCK_WAIT_FOR_EXCLUSIVITY)
+
+        success, list_of_tags = get_tags(object_name=object_name)
+        if not success:
+            return False
+
+        lock_value_read = list_of_tags.get(lock_name, "")
+        if lock_value_read != lock_value:
+            if verbose:
+                logger.warning(
+                    "{}.lock: {}.{} is relocked by {} != {}.".format(
+                        NAME,
+                        object_name,
+                        lock_name,
+                        lock_value_read,
+                        lock_value,
+                    )
+                )
+            time.sleep(env.MLFLOW_LOCK_WAIT_FOR_CLEARANCE)
+            continue
+
+        break
+
+    logger.info(
+        "{}.lock: {}.{} is locked by {}.".format(
+            NAME,
+            object_name,
+            lock_name,
+            lock_value,
+        )
+    )
+    return True
+
+
+def unlock(
+    object_name: str,
+    lock_name: str = "lock",
+    verbose: bool = True,
+) -> bool:
+    logger.info(
+        "{}.unlock: {}.{}".format(
+            NAME,
+            object_name,
+            lock_name,
+        )
+    )
+
+    return set_tags(
+        object_name=object_name,
+        tags={lock_name: ""},
+        log=verbose,
+        icon="🔒",
+    )

bluer_objects/mlflow/logging.py

@@ -6,7 +6,7 @@ import mlflow
 from blueness import module
 from bluer_options.logger import crash_report
 
-from bluer_objects import file, objects, NAME
+from bluer_objects import file, objects, NAME, env
 from bluer_objects.mlflow.runs import start_run, end_run
 from bluer_objects.logger import logger
 
@@ -17,65 +17,77 @@ def log_artifacts(
     object_name: str,
     model_name: str = "",
 ) -> bool:
+    if env.MLFLOW_IS_SERVERLESS:
+        return True
+
     if not start_run(object_name):
         return False
 
     object_path = objects.object_path(object_name, create=True)
 
-    try:
-        mlflow.log_artifacts(object_path)
+    if env.MLFLOW_LOG_ARTIFACTS:
+        try:
+            mlflow.log_artifacts(object_path)
 
-        logger.info("⬆️  {}".format(object_name))
+            logger.info("⬆️  {}".format(object_name))
 
-        # https://mlflow.org/docs/latest/python_api/mlflow.html#mlflow.register_model
-        # https://stackoverflow.com/a/71447758/17619982
-        if model_name:
-            mv = mlflow.register_model(
-                "runs:/{}".format(mlflow.active_run().info.run_id),
-                model_name,
-                await_registration_for=0,
-            )
+            # https://mlflow.org/docs/latest/python_api/mlflow.html#mlflow.register_model
+            # https://stackoverflow.com/a/71447758/17619982
+            if model_name:
+                mv = mlflow.register_model(
+                    "runs:/{}".format(mlflow.active_run().info.run_id),
+                    model_name,
+                    await_registration_for=0,
+                )
 
-            logger.info("*️⃣  {} -> {}.{}".format(object_name, mv.name, mv.version))
+                logger.info("*️⃣  {} -> {}.{}".format(object_name, mv.name, mv.version))
 
-    except:
-        crash_report(f"{NAME}.log_artifacts({object_name})")
-        return False
+        except:
+            crash_report(f"{NAME}.log_artifacts({object_name})")
+            return False
+    else:
+        logger.info("skipped log artifacts.")
 
     return end_run(object_name)
 
 
 def log_run(object_name: str) -> bool:
+    if env.MLFLOW_IS_SERVERLESS:
+        return True
+
     if not start_run(object_name):
         return False
 
     object_path = objects.object_path(object_name, create=True)
 
-    counts: Dict[str, int] = {}
-    skipped_count = 0
-    for extension in "dot,gif,jpeg,jpg,json,png,sh,xml,yaml".split(","):
-        for filename in glob.glob(
-            os.path.join(object_path, f"*.{extension}"),
-        ):
-            filename_name = file.name(filename)
-
-            counts[len(filename_name)] = counts.get(len(filename_name), 0) + 1
-
-            if any(
-                [
-                    file.size(filename) > 10 * 1024 * 1024,
-                    filename_name.startswith("thumbnail"),
-                    counts[len(filename_name)] > 20,
-                ]
+    if env.MLFLOW_LOG_ARTIFACTS:
+        counts: Dict[str, int] = {}
+        skipped_count = 0
+        for extension in "dot,gif,jpeg,jpg,json,png,sh,xml,yaml".split(","):
+            for filename in glob.glob(
+                os.path.join(object_path, f"*.{extension}"),
             ):
-                logger.info(f"skipping {filename}")
-                skipped_count += 1
-                continue
-
-            mlflow.log_artifact(filename)
-            logger.info(f"⬆️  {filename}")
-
-    if skipped_count:
-        logger.info(f"skipped {skipped_count:,} file(s).")
+                filename_name = file.name(filename)
+
+                counts[len(filename_name)] = counts.get(len(filename_name), 0) + 1
+
+                if any(
+                    [
+                        file.size(filename) > 10 * 1024 * 1024,
+                        filename_name.startswith("thumbnail"),
+                        counts[len(filename_name)] > 20,
+                    ]
+                ):
+                    logger.info(f"skipping {filename}")
+                    skipped_count += 1
+                    continue
+
+                mlflow.log_artifact(filename)
+                logger.info(f"⬆️  {filename}")
+
+        if skipped_count:
+            logger.info(f"skipped {skipped_count:,} file(s).")
+    else:
+        logger.info("skipped log artifacts.")
 
     return end_run(object_name)

bluer_objects/mlflow/models.py

@@ -5,6 +5,7 @@ from blueness import module
 from bluer_options.logger import crash_report
 
 from bluer_objects import NAME
+from bluer_objects import env
 from bluer_objects.logger import logger
 
 NAME = module.name(__file__, NAME)
@@ -14,6 +15,9 @@ def list_registered_models() -> Tuple[
     bool,
     List[str],
 ]:
+    if env.MLFLOW_IS_SERVERLESS:
+        return True, []
+
     try:
         client = MlflowClient()
         return True, [dict(rm)["name"] for rm in client.search_registered_models()]
@@ -29,6 +33,9 @@ def transition(
     stage_name: str,
     description: str,
 ) -> bool:
+    if env.MLFLOW_IS_SERVERLESS:
+        return True
+
     logger.info(
         '{}.transition: {}(#{}) ->  {} - "{}")'.format(
             NAME,

bluer_objects/mlflow/objects.py

@@ -6,6 +6,7 @@ from blueness import module
 from bluer_options.logger import crash_report
 
 from bluer_objects import NAME
+from bluer_objects import env
 from bluer_objects.env import ABCLI_MLFLOW_EXPERIMENT_PREFIX
 from bluer_objects.logger import logger
 
@@ -16,6 +17,9 @@ def get_id(
     object_name: str,
     create: bool = False,
 ) -> Tuple[bool, str]:
+    if env.MLFLOW_IS_SERVERLESS:
+        return True, "serverless-id"
+
     experiment_name = to_experiment_name(object_name)
 
     try:
@@ -38,6 +42,9 @@ def rm(
     object_name: str,
     is_id: bool = False,
 ) -> bool:
+    if env.MLFLOW_IS_SERVERLESS:
+        return True
+
     if is_id:
         experiment_id = object_name
     else:

bluer_objects/mlflow/runs.py

@@ -5,10 +5,10 @@ from mlflow.tracking import MlflowClient
 from mlflow.entities import ViewType
 
 from blueness import module
-from bluer_options import string
 from bluer_options.logger import crash_report
 
 from bluer_objects import NAME
+from bluer_objects import env
 from bluer_objects.mlflow.objects import get_id
 from bluer_objects.mlflow.tags import get_tags
 from bluer_objects.logger import logger
@@ -19,6 +19,9 @@ NAME = module.name(__file__, NAME)
 def end_run(
     object_name: str,
 ) -> bool:
+    if env.MLFLOW_IS_SERVERLESS:
+        return True
+
     try:
         mlflow.end_run()
         logger.info("⏹️  {}".format(object_name))
@@ -36,6 +39,9 @@ def get_run_id(
     create: bool = False,
     is_id: bool = False,
 ) -> Tuple[bool, List[str]]:
+    if env.MLFLOW_IS_SERVERLESS:
+        return True, []
+
     if is_id:
         experiment_id = object_name
     else:
@@ -62,6 +68,9 @@ def get_run_id(
 def start_run(
     object_name: str,
 ) -> bool:
+    if env.MLFLOW_IS_SERVERLESS:
+        return True
+
     success, experiment_id = get_id(object_name, create=True)
     if not success:
         return False

bluer_objects/mlflow/serverless/__init__.py

@@ -0,0 +1,3 @@
+from bluer_objects.mlflow.serverless.read import get_tags
+from bluer_objects.mlflow.serverless.search import search
+from bluer_objects.mlflow.serverless.write import set_tags

bluer_objects/mlflow/serverless/api.py

@@ -0,0 +1,88 @@
+from typing import Dict, Tuple
+
+from blueness import module
+
+from bluer_objects import NAME
+from bluer_objects import file
+from bluer_objects import objects
+from bluer_objects import storage
+from bluer_objects.logger import logger
+
+NAME = module.name(__file__, NAME)
+
+
+def write(
+    object_name: str,
+    filename: str,
+    data: Dict,
+    log: bool = False,
+) -> bool:
+    if log:
+        logger.info(f"{NAME}.update({object_name}/{filename})")
+
+    if not storage.download(
+        object_name=object_name,
+        filename=filename,
+        log=log,
+    ):
+        return False
+
+    full_filename = objects.path_of(
+        object_name=object_name,
+        filename=filename,
+    )
+
+    _, current_data = file.load_yaml(
+        full_filename,
+        ignore_error=True,
+        default={},
+    )
+    if not isinstance(current_data, dict):
+        logger.error(
+            "dict expected, {} received".format(
+                current_data.__class__.__name__,
+            )
+        )
+        return False
+
+    current_data.update(data)
+
+    if not file.save_yaml(
+        full_filename,
+        current_data,
+        log=log,
+    ):
+        return False
+
+    if not storage.upload(
+        object_name=object_name,
+        filename=filename,
+        log=log,
+    ):
+        return False
+
+    return True
+
+
+def read(
+    object_name: str,
+    filename: str,
+    verbose: bool = False,
+) -> Tuple[bool, Dict]:
+    if not storage.download(
+        object_name=object_name,
+        filename=filename,
+        log=verbose,
+    ):
+        return True, {}
+
+    _, data = file.load_yaml(
+        objects.path_of(
+            object_name=object_name,
+            filename=filename,
+        ),
+        ignore_error=True,
+        default={},
+    )
+
+    return True, data

bluer_objects/mlflow/serverless/read.py

@@ -0,0 +1,19 @@
+from typing import Tuple, Dict
+
+from blueness import module
+
+from bluer_objects import NAME
+from bluer_objects.mlflow.serverless import api
+
+NAME = module.name(__file__, NAME)
+
+
+def get_tags(
+    object_name: str,
+    verbose: bool = False,
+) -> Tuple[bool, Dict[str, str]]:
+    return api.read(
+        object_name="_serverless_objects",
+        filename=f"{object_name}.yaml",
+        verbose=verbose,
+    )

bluer_objects/mlflow/serverless/search.py

@@ -0,0 +1,35 @@
+from typing import List, Tuple, Union
+
+from bluer_options.options import Options
+
+from bluer_objects.mlflow.serverless import api
+from bluer_objects.logger import logger
+
+
+def search(
+    filter_string: Union[str, dict],
+    log: bool = False,
+) -> Tuple[bool, List[str]]:
+    query = Options(filter_string)
+
+    output: Union[List[str], None] = None
+    for key, value in query.items():
+        success, dict_of_objects = api.read(
+            object_name="_serverless_keys",
+            filename=f"{key}.yaml",
+            verbose=log,
+        )
+        if not success:
+            return False, []
+
+        output = [
+            object_name
+            for object_name in (dict_of_objects if output is None else output)
+            if dict_of_objects.get(
+                object_name,
+                False if isinstance(value, bool) else None,
+            )
+            == value
+        ]
+
+    return True, [] if output is None else output