ml-management 0.5.1rc0__tar.gz → 0.5.1rc1__tar.gz

ml-management-0.5.1rc1/ML_management/dataset_loader/dataset_loader_pattern.py

@@ -0,0 +1,34 @@
+"""Dataset loader template for custom dataset loader."""
+from abc import ABC, abstractmethod
+
+from ML_management.model.patterns.rich_python_model import RichPythonModel
+
+
+class DatasetLoaderPattern(RichPythonModel, ABC):
+    """Define dataset loader.
+
+    Attributes
+    ----------
+    artifacts : str
+        Local path to artifacts.
+        That parameters will be set automatically in job before the 'get_dataset' func would be executed.
+    data_path: str
+        A path to data to be loaded.
+
+    """
+
+    def __init__(self):
+        """Init dataset loader class."""
+        self.artifacts: str
+        self.data_path = None
+
+    @abstractmethod
+    def get_dataset(self, **dataset_params):
+        """
+        Return dataset.
+
+        To get data_path use self.data_path parameter, which also will be set in the job.
+        'dataset_params' are dataset_loader parameters. One has to define it as ordinary kwargs
+        with type annotation.
+        """
+        raise NotImplementedError

{ml-management-0.5.1rc0 → ml-management-0.5.1rc1}/ML_management/executor/base_executor.py

@@ -1,10 +1,8 @@
 """Executor template for custom executor."""
 
 from abc import ABC, abstractmethod
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, Union
 
-import ML_management.mlmanagement.log_api
-import ML_management.mlmanagement.mlmanager
 from ML_management.dataset_loader import DatasetLoaderPattern
 from ML_management.dataset_loader.dataset_loader_pattern_to_methods_map import DatasetLoaderMethodName
 from ML_management.executor.patterns import (
@@ -14,9 +12,6 @@ from ML_management.executor.patterns import (
     OneDatasetLoaderPattern,
     OneModelPattern,
 )
-from ML_management.mlmanagement import variables
-from ML_management.mlmanagement.module_finder import ModuleFinder
-from ML_management.mlmanagement.visibility_options import VisibilityOptions
 from ML_management.model.model_type_to_methods_map import ModelMethodName
 from ML_management.model.patterns.model_pattern import Model
 from ML_management.model.patterns.rich_python_model import RichPythonModel
@@ -140,91 +135,6 @@ class BaseExecutor(RichPythonModel, ABC):
         """
         raise NotImplementedError
 
-    def upload_executor(
-        self,
-        executor_name: str,
-        pip_requirements=None,
-        description: Optional[str] = None,
-        extra_pip_requirements=None,
-        conda_env=None,
-        artifacts: Optional[dict] = None,
-        visibility: VisibilityOptions = VisibilityOptions.PRIVATE,
-        extra_modules_names: Optional[List[str]] = None,
-        used_modules_names: Optional[List[str]] = None,
-        linter_check: bool = True,
-        start_build: bool = False,
-    ) -> None:
-        """
-        Upload wrapper to MLmanagement server.
-
-        :param pip_requirements: {{ pip_requirements }}
-
-        :param extra_pip_requirements: {{ extra_pip_requirements }}
-        `pip_requirements` and 'extra_pip_requirements' must be either a string path to a pip requirements file on the
-            local filesystem or an iterable of pip requirement strings.
-
-        :param conda_env: {{ conda_env }}
-        'conda_env' must be a dict specifying the conda environment for this model.
-
-        :param artifacts: A dictionary containing ``<name, artifact_uri>`` entries. Remote artifact URIs
-                          are resolved to absolute filesystem paths, producing a dictionary of
-                          ``<name, absolute_path>`` entries. ``python_model`` can reference these
-                          resolved entries as the ``artifacts`` property of the ``context`` parameter
-                          in :func:`PythonModel.load_context() <mlflow.pyfunc.PythonModel.load_context>`
-                          and :func:`PythonModel.predict() <mlflow.pyfunc.PythonModel.predict>`.
-                          For example, consider the following ``artifacts`` dictionary::
-
-                            {
-                                "my_file": "s3://my-bucket/path/to/my/file"
-                            }
-
-                          In this case, the ``"my_file"`` artifact is downloaded from S3. The
-                          ``python_model`` can then refer to ``"my_file"`` as an absolute filesystem
-                          path via ``context.artifacts["my_file"]``.
-
-                          If ``None``, no artifacts are added to the executor.
-
-        :param visibility: either a private or public executor.
-
-        :param extra_modules_names: names of modules that should be pickled by value
-            in addition to auto-detected modules.
-
-        :param used_modules_names: modules that should be pickled by value, disables the auto-detection of modules.
-
-        :param linter_check: if True, check code of the executor by linter.
-
-        :param start_build: if set to True, start job to create docker image.
-            This parameter may be True only if there is no models for executor.
-        """
-        old_experiment_name = variables.active_experiment
-        if (self.desired_model_methods or self.upload_model_modes) and start_build:
-            raise RuntimeError("Parameter start_build=True is acceptable only if there is no models for executor.")
-        ML_management.mlmanagement.mlmanager.set_experiment(
-            variables.EXPERIMENT_NAME_FOR_EXECUTOR, visibility=VisibilityOptions.PUBLIC
-        )
-        try:
-            with ML_management.mlmanagement.mlmanager.start_run(nested=True):
-                ML_management.mlmanagement.log_api._log_model(
-                    artifact_path="",
-                    description=description,
-                    artifacts=artifacts,
-                    python_model=self,
-                    registered_model_name=executor_name,
-                    pip_requirements=pip_requirements,
-                    extra_pip_requirements=extra_pip_requirements,
-                    conda_env=conda_env,
-                    visibility=visibility,
-                    extra_modules_names=extra_modules_names,
-                    used_modules_names=used_modules_names,
-                    root_module_name=ModuleFinder.get_my_caller_module_name(),
-                    linter_check=linter_check,
-                    start_build=start_build,
-                )
-        except Exception as err:
-            raise err
-        finally:
-            variables.active_experiment = old_experiment_name
-
     @property
     def model(self) -> Model:
         """Property returning a single model.

{ml-management-0.5.1rc0 → ml-management-0.5.1rc1}/ML_management/mlmanagement/jsonschema_inference.py

@@ -1,8 +1,8 @@
 """Module for automatic jsonschema inference."""
+import typing
 import warnings
 from copy import copy
 from inspect import formatannotation, getfullargspec
-from typing import Generic, TypeVar
 
 from jsonschema import SchemaError
 from jsonschema.validators import Draft4Validator
@@ -28,14 +28,10 @@ type_map = {
 }
 
 
-T = TypeVar("T")
-
-
-class SkipJsonSchema(Generic[T]):
+class SkipJsonSchema:
     """Annotation wrapper for system parameters to skip them in JSON schema."""
 
-    def __class_getitem__(cls, _type):
-        return cls()
+    pass
 
 
 def __get_or_raise(type_name, from_optional: bool = False):
@@ -168,7 +164,11 @@ def infer_jsonschema(func, get_object_func):
             raise NoAnnotationError(arg=arg)
 
         # skip system parameters
-        if isinstance(spec.annotations[arg], SkipJsonSchema):
+        if (
+            typing.get_origin(spec.annotations[arg]) is typing.Annotated
+            and spec.annotations[arg].__metadata__
+            and spec.annotations[arg].__metadata__[0] is SkipJsonSchema
+        ):
             continue
 
         schema["properties"][arg] = __get_json_schema_from_annotation(spec.annotations[arg])

{ml-management-0.5.1rc0 → ml-management-0.5.1rc1}/ML_management/mlmanagement/load_api.py

@@ -7,29 +7,19 @@ import tarfile
 import tempfile
 import threading
 import traceback
+from pathlib import Path
 from typing import Optional
 
+import yaml
+
 from ML_management.mlmanagement.base_exceptions import MLMClientError
 from ML_management.mlmanagement.log_api import _raise_error
 from ML_management.mlmanagement.model_type import ModelType
 from ML_management.mlmanagement.session import AuthSession
 from ML_management.mlmanagement.variables import get_log_service_url
-from mlflow.models import Model
-from mlflow.pyfunc import (
-    CODE,
-    DATA,
-    FLAVOR_NAME,
-    MAIN,
-    MLMODEL_FILE_NAME,
-    PY_VERSION,
-    RESOURCE_DOES_NOT_EXIST,
-    MlflowException,
-    PyFuncModel,
-    _add_code_from_conf_to_system_path,
-    _download_artifact_from_uri,
-    _warn_dependency_requirement_mismatches,
-    _warn_potentially_incompatible_py_version_if_necessary,
-)
+from mlflow.pyfunc.model import CONFIG_KEY_ARTIFACTS
+
+MLCONFIG = "MLConfig.yaml"
 
 
 def download_artifacts_by_name_version(
@@ -57,7 +47,6 @@ def _load_model_type(
     name: str,
     version: Optional[int],
     model_type: ModelType,
-    unwrap: bool = True,
     install_requirements: bool = False,
     dst_path: Optional[str] = None,
     kwargs_for_init=None,
@@ -68,12 +57,7 @@ def _load_model_type(
     )
     if install_requirements:
         _set_model_version_requirements(local_path)
-    model_load_dict = {"model_path": local_path, "kwargs_for_init": kwargs_for_init}
-    loaded_model = _load_model_mflow(model_data=model_load_dict, suppress_warnings=True)
-    if unwrap:
-        artifacts_path = loaded_model._model_impl.context._artifacts
-        loaded_model = loaded_model.unwrap_python_model()
-        loaded_model.artifacts = artifacts_path
+    loaded_model = _load_model_src(local_path, kwargs_for_init)
     return loaded_model
 
 
@@ -81,7 +65,6 @@ def load_dataset(
     name: str,
     version: Optional[int] = None,
     install_requirements: bool = False,
-    unwrap: bool = True,
     dst_path: Optional[str] = None,
     kwargs_for_init: Optional[dict] = None,
 ):
@@ -95,8 +78,6 @@ def load_dataset(
         Version of the dataset. Default: None, "latest" version is used.
     install_requirements: bool = False
         Whether to install dataset requirements. Default: False.
-    unwrap: bool = True
-        Whether to unwrap dataset. Default: True.
     dst_path: Optional[str]: None
         Destination path. Default: None.
     kwargs_for_init: Optional[dict]: None
@@ -106,16 +87,17 @@ def load_dataset(
     DatasetLoaderPattern
         The object of the dataset to use.
     """
-    return _load_model_type(
-        name, version, ModelType.DATASET_LOADER, unwrap, install_requirements, dst_path, kwargs_for_init
-    )
+    return _load_model_type(name, version, ModelType.DATASET_LOADER, install_requirements, dst_path, kwargs_for_init)
 
 
 def _set_model_version_requirements(local_path) -> None:
     """Installing requirements of the model locally."""
     with open(os.path.join(local_path, "requirements.txt")) as req:
         requirements = list(
-            filter(lambda x: "ml-management" not in x.lower() and "mlflow" not in x.lower(), req.read().split("\n"))
+            filter(
+                lambda x: "ml-management" not in x.lower() and "mlflow" not in x.lower() and len(x),
+                req.read().split("\n"),
+            )
         )
     try:
         if requirements:
@@ -130,7 +112,6 @@ def load_model(
     name: str,
     version: Optional[int] = None,
     install_requirements: bool = False,
-    unwrap: bool = True,
     dst_path: Optional[str] = None,
     kwargs_for_init=None,
 ):
@@ -144,8 +125,6 @@ def load_model(
         Version of the model. Default: None, "latest" version is used.
     install_requirements: bool = False
         Whether to install model requirements. Default: False.
-    unwrap: bool = True
-        Whether to unwrap model. Default: True.
     dst_path: Optional[str]: None
         Destination path. Default: None.
     kwargs_for_init: Optional[dict]: None
@@ -155,14 +134,13 @@ def load_model(
     Model
         The object of the model to use.
     """
-    return _load_model_type(name, version, ModelType.MODEL, unwrap, install_requirements, dst_path, kwargs_for_init)
+    return _load_model_type(name, version, ModelType.MODEL, install_requirements, dst_path, kwargs_for_init)
 
 
 def load_executor(
     name: str,
     version: Optional[int] = None,
     install_requirements: bool = False,
-    unwrap: bool = True,
     dst_path: Optional[str] = None,
 ):
     """Download all model's files for loading model locally.
@@ -175,8 +153,6 @@ def load_executor(
         Version of the executor. Default: None, "latest" version is used.
     install_requirements: bool = False
         Whether to install executor requirements. Default: False.
-    unwrap: bool = True
-        Whether to unwrap executor. Default: True.
     dst_path: Optional[str]: None
         Destination path. Default: None.
     Returns
@@ -184,7 +160,7 @@ def load_executor(
     BaseExecutor
         The object of the executor to use.
     """
-    return _load_model_type(name, version, ModelType.EXECUTOR, unwrap, install_requirements, dst_path)
+    return _load_model_type(name, version, ModelType.EXECUTOR, install_requirements, dst_path)
 
 
 def _untar_folder(buff, to_folder):
@@ -230,39 +206,25 @@ def _request_download_artifacts(url, params: dict, dst_path: Optional[str] = Non
             return local_path
 
 
-def _load_model_mflow(
-    model_data: dict,
-    suppress_warnings: bool = False,
-    dst_path: Optional[str] = None,
-) -> PyFuncModel:
-    """Load model function from mlflow with custom arguments for our loader of a model."""
-    # Mflow checks type of arguments so we need to use json as str.
-    model_args = model_data
-    model_uri = model_args["model_path"]
-    local_path = _download_artifact_from_uri(artifact_uri=model_uri, output_path=dst_path)
-
-    if not suppress_warnings:
-        _warn_dependency_requirement_mismatches(local_path)
-
-    model_meta = Model.load(os.path.join(local_path, MLMODEL_FILE_NAME))
-
-    conf = model_meta.flavors.get(FLAVOR_NAME)
-    if conf is None:
-        raise MlflowException(
-            f'Model does not have the "{FLAVOR_NAME}" flavor',
-            RESOURCE_DOES_NOT_EXIST,
-        )
-    model_py_version = conf.get(PY_VERSION)
-    if not suppress_warnings:
-        _warn_potentially_incompatible_py_version_if_necessary(model_py_version=model_py_version)
-
-    _add_code_from_conf_to_system_path(local_path, conf, code_key=CODE)
-    data_path = os.path.join(local_path, conf[DATA]) if (DATA in conf) else local_path
-    model_args["model_path"] = data_path
-    if importlib.import_module(conf[MAIN]).__name__ == "ML_management.loader.loader":
-        model_data = model_args
-    else:
-        model_data = data_path
-    model_impl = importlib.import_module(conf[MAIN])._load_pyfunc(model_data)
-    predict_fn = conf.get("predict_fn", "predict")
-    return PyFuncModel(model_meta=model_meta, model_impl=model_impl, predict_fn=predict_fn)
+def _load_model_src(local_path: str, kwargs_for_init: Optional[dict]):
+    if not kwargs_for_init:
+        kwargs_for_init = {}
+    config_path = os.path.join(local_path, MLCONFIG)
+    with open(config_path) as file:
+        conf = yaml.safe_load(file)
+
+    load_model_path = os.path.join(local_path, conf["load_model_path"])
+
+    from ML_management.mlmanagement.utils import INIT_FUNCTION_NAME  # circular import
+
+    parts = Path(load_model_path).parts
+    if str(Path(*parts[:2])) not in sys.path:
+        sys.path.append(str(Path(*parts[:2])))
+    python_model = getattr(importlib.import_module(".".join(parts[2:])), INIT_FUNCTION_NAME)(**kwargs_for_init)
+    artifacts = Path(load_model_path) / CONFIG_KEY_ARTIFACTS
+    if not artifacts.exists():
+        artifacts.mkdir()
+
+    python_model.artifacts = str(artifacts)
+
+    return python_model

{ml-management-0.5.1rc0 → ml-management-0.5.1rc1}/ML_management/mlmanagement/log_api.py

@@ -20,7 +20,6 @@ import yaml
 from scipy.sparse import csc_matrix, csr_matrix
 
 import mlflow
-from ML_management.loader.loader import CONFIG_KEY_ARTIFACTS
 from ML_management.mlmanagement import variables
 from ML_management.mlmanagement.base_exceptions import *  # noqa: F403
 from ML_management.mlmanagement.base_exceptions import MLMClientError, MLMServerError, PylintError
@@ -48,6 +47,8 @@ from ML_management.mlmanagement.visibility_options import VisibilityOptions
 from ML_management.registry.exceptions import *  # noqa: F403
 from mlflow.pyfunc import DATA
 
+CONFIG_KEY_ARTIFACTS = "artifacts"
+
 
 def _log_model(
     artifact_path,
@@ -90,6 +91,7 @@ def _log_model(
         Validation regexp: "(([A-Za-z0-9][A-Za-z0-9_]*)?[A-Za-z0-9])+"
     You cannot specify the parameters: loader_module, data_path and the parameters: python_model, artifacts together.
     """
+    raise DeprecationWarning("The function '_log_model' is deprecated.")
     from ML_management.executor.upload_model_mode import UploadModelMode  # circular import
 
     if extra_modules_names and used_modules_names:
@@ -185,18 +187,7 @@ def _log_object_src(
     description: str,
     model_type: ModelType = ModelType.MODEL,
     model_version_tags: Optional[Dict[str, str]] = None,
-    code_path=None,
-    conda_env=None,
-    python_model=None,
     registered_model_name: str = "default_name",
-    signature: mlflow.models.signature.ModelSignature = None,
-    input_example: Union[
-        pandas.core.frame.DataFrame, numpy.ndarray, dict, list, csr_matrix, csc_matrix, str, bytes
-    ] = None,
-    await_registration_for: int = 300,
-    pip_requirements=None,
-    extra_pip_requirements=None,
-    metadata=None,
     source_model_name=None,
     source_model_version=None,
     source_executor_name=None,
@@ -257,16 +248,8 @@ def _log_object_src(
             "model_path": model_path,
             "description": description,
             "model_version_tags": model_version_tags,
-            "code_path": code_path,
-            "conda_env": conda_env,
             "python_model": python_model,
             "registered_model_name": registered_model_name,
-            "signature": signature,
-            "input_example": input_example,
-            "await_registration_for": await_registration_for,
-            "pip_requirements": pip_requirements,
-            "extra_pip_requirements": extra_pip_requirements,
-            "metadata": metadata,
             "source_model_name": source_model_name,
             "source_model_version": source_model_version,
             "source_executor_name": source_executor_name,

{ml-management-0.5.1rc0 → ml-management-0.5.1rc1}/ML_management/model/patterns/gradient_model.py

@@ -1,6 +1,6 @@
 """Class inherits from base class of Model with a specific method for obtaining gradients."""
 from abc import ABC, abstractmethod
-from typing import Callable
+from typing import Annotated, Callable
 
 import numpy as np
 
@@ -12,6 +12,8 @@ class GradientModel(model_pattern.Model, ABC):
     """Implementation of gradient model."""
 
     @abstractmethod
-    def get_grad(self, loss_fn: SkipJsonSchema[Callable], input_batch: SkipJsonSchema[np.ndarray]) -> np.ndarray:
+    def get_grad(
+        self, loss_fn: Annotated[Callable, SkipJsonSchema], input_batch: Annotated[np.ndarray, SkipJsonSchema]
+    ) -> np.ndarray:
         """Define get_grad function."""
         raise NotImplementedError

ml-management-0.5.1rc1/ML_management/model/patterns/model_pattern.py

@@ -0,0 +1,53 @@
+"""Define Abstract class for Model with necessary methods and methods to implement."""
+import inspect
+import os
+from abc import ABC, abstractmethod
+from pathlib import Path
+
+from ML_management.mlmanagement.log_api import CONFIG_KEY_ARTIFACTS
+from ML_management.model.patterns.rich_python_model import RichPythonModel
+
+
+class Model(RichPythonModel, ABC):
+    """Abstract class for model that Job will use."""
+
+    def __new__(cls, *args, **kwargs):  # noqa: ARG003
+        """Get object of Model class.
+
+        Attributes
+        ----------
+        self.artifacts: str
+            Local path to artifacts.
+
+        self.dataset: DatasetLoader object
+            Instance of user's dataset.
+        """
+        self = super().__new__(cls)
+        # For now it was impossible to set self.artifacts before init func of model,
+        # so it was impossible to use it inside init.
+        # Because inside the job container code we have a fixed folder and file structure,
+        # we can predetermine artifacts path.
+        # It has to be beside file __init__.py  with get_object function.
+        self.artifacts = str(
+            Path(os.path.dirname(inspect.getframeinfo(inspect.currentframe().f_back)[0])) / CONFIG_KEY_ARTIFACTS
+        )
+        self.dataset = None
+
+        return self
+
+    @abstractmethod
+    def predict_function(self, **kwargs):
+        """Every model should make predictions."""
+        raise NotImplementedError
+
+    def to_device(self, device: str) -> None:
+        """
+        Define model migration to specific device.
+
+        Devices are marked with following notation:
+
+        cpu - CPU instance
+
+        cuda:<number: int> - GPU instance
+        """
+        pass

{ml-management-0.5.1rc0 → ml-management-0.5.1rc1}/ML_management/model/patterns/model_with_metrics.py

@@ -1,10 +1,12 @@
 """Class inherits from base class of Model with a specific method for updating and computing metrics."""
 from abc import ABC, abstractmethod
-from typing import Dict
+from typing import Annotated, Any, Dict
 
 from ML_management.mlmanagement.jsonschema_inference import SkipJsonSchema
 from ML_management.model.patterns.model_pattern import Model
 
+Tensor = Any
+
 
 class ModelWithMetrics(Model, ABC):
     """Implementation of model with specific methods for reseting, updating and computing metrics."""
@@ -18,7 +20,9 @@ class ModelWithMetrics(Model, ABC):
         raise NotImplementedError
 
     @abstractmethod
-    def update_metrics(self, outputs_batch: SkipJsonSchema["tensor"], targets: SkipJsonSchema["tensor"], **kwargs) -> None:  # type: ignore # noqa
+    def update_metrics(
+        self, outputs_batch: Annotated[Tensor, SkipJsonSchema], targets: Annotated[Tensor, SkipJsonSchema], **kwargs
+    ) -> None:
         """Define function to update internal variables with provided (outputs_batch, targets)."""
         raise NotImplementedError
 

{ml-management-0.5.1rc0 → ml-management-0.5.1rc1}/ML_management/model/patterns/preprocessor.py

@@ -1,17 +1,20 @@
 """Abstract base class for preprocessing methods."""
 from abc import ABC, abstractmethod
+from typing import Annotated, Any
 
 from ML_management.mlmanagement.jsonschema_inference import SkipJsonSchema
 from ML_management.model.patterns.model_pattern import Model
 
+Tensor = Any
+
 
 class Preprocessor(Model, ABC):
     """Abstract class for model that performs preprocessing."""
 
     @abstractmethod
-    def preprocess(self, input_batch: SkipJsonSchema["tensor"], **kwargs) -> "tensor":  # type: ignore # noqa
+    def preprocess(self, input_batch: Annotated[Tensor, SkipJsonSchema], **kwargs) -> Tensor:
         """Perform data preprocessing."""
         raise NotImplementedError
 
-    def predict_function(self, input_batch: SkipJsonSchema["tensor"]):  # type: ignore # noqa
+    def predict_function(self, input_batch: Annotated[Tensor, SkipJsonSchema]):
         return self.preprocess(input_batch)

{ml-management-0.5.1rc0 → ml-management-0.5.1rc1}/ML_management/model/patterns/transformer.py

@@ -1,6 +1,6 @@
 """Abstract base class for model transformation methods."""
 from abc import ABC, abstractmethod
-from typing import Callable
+from typing import Annotated, Callable
 
 from ML_management.mlmanagement.jsonschema_inference import SkipJsonSchema
 from ML_management.model.patterns.model_pattern import Model
@@ -10,7 +10,7 @@ class Transformer(Model, ABC):
     """Abstract class for model that performs transformations."""
 
     @abstractmethod
-    def transform(self, model_fn: SkipJsonSchema[Callable], **kwargs) -> Callable:
+    def transform(self, model_fn: Annotated[Callable, SkipJsonSchema], **kwargs) -> Callable:
         """Perform model transformation.
 
         :param model_fn: takes a batch of input tensors and produces a final prediction tensor.

{ml-management-0.5.1rc0 → ml-management-0.5.1rc1}/ML_management/sdk/model.py

@@ -171,6 +171,7 @@ def get_model_version(name: str, version: Optional[int] = None) -> ModelVersionI
     base_query = op.model_version_from_name_version(model_version=_model_version)
     base_query.name()
     base_query.tags()
+    base_query.source_path()
     base_query.run.run_id()
     base_query.version()
     base_query.build_job.status()

{ml-management-0.5.1rc0 → ml-management-0.5.1rc1}/ML_management/sdk/schema.py

@@ -34,9 +34,10 @@ class JobStatus(sgqlc.types.Enum):
     * `PLANNED`None
     * `RUNNING`None
     * `SUCCESSFUL`None
+    * `UNKNOWN`None
     '''
     __schema__ = schema
-    __choices__ = ('CANCELED', 'FAILED', 'PLANNED', 'RUNNING', 'SUCCESSFUL')
+    __choices__ = ('CANCELED', 'FAILED', 'PLANNED', 'RUNNING', 'SUCCESSFUL', 'UNKNOWN')
 
 
 class JobsSortBy(sgqlc.types.Enum):
@@ -222,15 +223,11 @@ class ModelServingInput(sgqlc.types.Input):
 
 class ModelVersionChoice(sgqlc.types.Input):
     __schema__ = schema
-    __field_names__ = ('choice_criteria', 'metric_name', 'name', 'optimal_min', 'version')
+    __field_names__ = ('choice_criteria', 'name', 'version')
     choice_criteria = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name='choiceCriteria')
 
-    metric_name = sgqlc.types.Field(String, graphql_name='metricName')
-
     name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name='name')
 
-    optimal_min = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name='optimalMin')
-
     version = sgqlc.types.Field(Int, graphql_name='version')
 
 

{ml-management-0.5.1rc0 → ml-management-0.5.1rc1}/PKG-INFO

@@ -1,17 +1,13 @@
 Metadata-Version: 2.1
 Name: ml-management
-Version: 0.5.1rc0
+Version: 0.5.1rc1
 Summary: Python implementation of model pattern, dataset
-Home-page: UNKNOWN
 Author: ISPRAS MODIS
 Author-email: modis@ispras.ru
 Maintainer: Maxim Ryndin
-License: UNKNOWN
-Platform: UNKNOWN
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 
 # mlmanagement
 
 implementation of model pattern, dataset
-

ml-management-0.5.1rc1/VERSION

@@ -0,0 +1 @@
+0.5.1rc1