ml-management 0.5.1rc6__tar.gz → 0.5.1rc8__tar.gz

{ml-management-0.5.1rc6 → ml-management-0.5.1rc8}/ML_management/dataset_loader/dataset_loader_pattern.py

@@ -1,10 +1,8 @@
 """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):
+class DatasetLoaderPattern(ABC):
     """Define dataset loader.
 
     Attributes

{ml-management-0.5.1rc6 → ml-management-0.5.1rc8}/ML_management/executor/base_executor.py

@@ -14,12 +14,11 @@ from ML_management.executor.patterns import (
 )
 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
 
 default_dataset_loader_pattern = OneDatasetLoaderPattern()
 
 
-class BaseExecutor(RichPythonModel, ABC):
+class BaseExecutor(ABC):
     """Define custom job executor."""
 
     DEFAULT_ROLE = DEFAULT_ROLE

{ml-management-0.5.1rc6 → ml-management-0.5.1rc8}/ML_management/mlmanagement/jsonschema_inference.py

@@ -28,7 +28,15 @@ type_map = {
 
 
 class SkipJsonSchema:
-    """Annotation wrapper for system parameters to skip them in JSON schema."""
+    """
+    Annotation wrapper for system parameters to skip them in JSON schema.
+
+    Usage example::
+
+        def my_function(arg: Annotated[SkipJsonSchema, np.ndarray]) -> None:
+            print(arg)
+
+    """
 
     def __class_getitem__(cls, _type):  # for backward compatibility with older models
         return cls()

{ml-management-0.5.1rc6 → ml-management-0.5.1rc8}/ML_management/mlmanagement/load_api.py

@@ -16,12 +16,14 @@ 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.model import MLMODEL_FILE_NAME
-from mlflow.pyfunc import DATA, FLAVOR_NAME
-from mlflow.pyfunc.model import CONFIG_KEY_ARTIFACTS
-
-MLCONFIG = "MLConfig.yaml"
+from ML_management.mlmanagement.variables import (
+    CONFIG_KEY_ARTIFACTS,
+    DATA,
+    FLAVOR_NAME,
+    MLCONFIG,
+    MLMODEL_FILE_NAME,
+    get_log_service_url,
+)
 
 
 def download_artifacts_by_name_version(
@@ -106,6 +108,7 @@ def _set_model_version_requirements(local_path) -> None:
             subprocess.check_call(
                 [sys.executable, "-m", "pip", "install", "--no-cache-dir", "--default-timeout=100", *requirements]
             )
+
     except Exception:
         print(traceback.format_exc())
 

{ml-management-0.5.1rc6 → ml-management-0.5.1rc8}/ML_management/mlmanagement/log_api.py

@@ -2,31 +2,21 @@ import importlib
 import json
 import os
 import posixpath
-import subprocess
 import sys
 import tarfile
 import threading
 import warnings
 from contextlib import _GeneratorContextManager
 from pathlib import Path
-from tempfile import TemporaryDirectory
 from typing import Dict, List, Optional, Union
 
-import cloudpickle
 import httpx
-import numpy
-import pandas
 import yaml
-from scipy.sparse import csc_matrix, csr_matrix
 
-import mlflow
 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
+from ML_management.mlmanagement.base_exceptions import MLMClientError, MLMServerError
 from ML_management.mlmanagement.jsonschema_inference import infer_jsonschema
-from ML_management.mlmanagement.mlmanager import set_experiment, start_run, start_run_if_not_exist
 from ML_management.mlmanagement.model_type import ModelType
-from ML_management.mlmanagement.module_finder import ModuleFinder
 from ML_management.mlmanagement.server_mlmanager_exceptions import *  # noqa: F403
 from ML_management.mlmanagement.server_mlmanager_exceptions import (
     AuthError,
@@ -36,155 +26,23 @@ from ML_management.mlmanagement.server_mlmanager_exceptions import (
 from ML_management.mlmanagement.session import AuthSession
 from ML_management.mlmanagement.utils import INIT_FUNCTION_NAME, is_model_name_valid, validate_predict_config
 from ML_management.mlmanagement.variables import (
+    CONFIG_KEY_ARTIFACTS,
+    DATA,
+    DEFAULT_EXPERIMENT,
     EXPERIMENT_NAME_FOR_DATASET_LOADER,
     EXPERIMENT_NAME_FOR_EXECUTOR,
     FILENAME_FOR_INFERENCE_CONFIG,
-    active_run_stack,
     get_log_service_url,
     get_server_ml_api,
 )
 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,
-    description: Optional[str],
-    model_version_tags: Optional[Dict[str, str]] = None,
-    code_path=None,
-    conda_env=None,
-    python_model=None,
-    artifacts: Optional[dict] = 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,
-    source_executor_version=None,
-    source_executor_role=None,
-    upload_model_mode=None,
-    visibility=None,
-    extra_modules_names: Optional[list] = None,
-    used_modules_names: Optional[list] = None,
-    root_module_name: str = "__main__",
-    linter_check: bool = True,
-    start_build: bool = True,
-    create_venv_pack: bool = False,
-):
-    """
-    Log a Pyfunc model with custom inference logic and optional data dependencies as an MLflow artifact.
-
-    Current run is using.
-    Parameter registered_model_name must be not empty string,
-        consist of alphanumeric characters, '_'
-        and must start and end with an alphanumeric character.
-        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:
-        raise RuntimeError("Parameters 'extra_modules_names' and 'used_modules_names' cannot be used at the same time.")
-    if upload_model_mode == UploadModelMode.none:
-        raise RuntimeError("You can't log a model using the 'upload_model_mode' parameter set to none.")
-    if not is_model_name_valid(registered_model_name):
-        raise RuntimeError(
-            "Parameter 'registered_model_name' must be not empty string, "
-            "consist of alphanumeric characters, '_' "
-            "and must start and end with an alphanumeric character."
-            "Validation regexp: '(([A-Za-z0-9][A-Za-z0-9_]*)?[A-Za-z0-9])+'"
-        )
-    del UploadModelMode  # need to delete this because it is not JSON serializable
-    if create_venv_pack:
-        if not isinstance(artifacts, dict):
-            raise RuntimeError("You must provide config for model serving in artifacts, if create_venv_pack=True")
-        validate_predict_config(path=artifacts.get(FILENAME_FOR_INFERENCE_CONFIG))
-    start_run_if_not_exist()
-    if used_modules_names is not None:
-        submodules = set(used_modules_names)
-        ModuleFinder.import_modules_by_name(submodules)
-    else:
-        submodules = ModuleFinder().find_root_submodules(root_name=root_module_name)
-        if linter_check:
-            for module_name in submodules:
-                if hasattr(sys.modules[module_name], "__file__"):
-                    # pylint check what would fall on any error except when abstract method is not implemented (E0110)
-                    # and when pylint has been unable to import a module (E0401)
-                    linter_output = subprocess.run(
-                        [
-                            sys.executable,
-                            "-m",
-                            "pylint",
-                            "{}".format(sys.modules[module_name].__file__),
-                            "--clear-cache-post-run=True",
-                            "--disable=all",
-                            "--enable=E",
-                            "--disable=E0401, E1101",
-                            "--fail-on=E",
-                            "--reports=n",
-                            "--score=n",
-                            "-j 0",
-                        ],
-                        check=False,
-                        stdout=subprocess.PIPE,
-                        text=True,
-                    )
-                    if linter_output.stdout:  # if linter has output when something wrong with code
-                        raise PylintError(linter_output.stdout)
-                    del linter_output
-        if extra_modules_names:
-            extra_set = set(extra_modules_names)
-            ModuleFinder.import_modules_by_name(extra_set)
-            submodules = submodules.union(extra_set)
-    try:
-        for module_name in submodules:
-            cloudpickle.register_pickle_by_value(sys.modules[module_name])
-        kwargs = {
-            "artifact_path": artifact_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,
-            "source_executor_version": source_executor_version,
-            "source_executor_role": source_executor_role,
-            "upload_model_mode": upload_model_mode,
-            "visibility": visibility,
-            "start_build": start_build,
-            "create_venv_pack": create_venv_pack,
-        }
-        response = _request_log_model("log_model", kwargs)
-        return _raise_error(response)
-    finally:
-        for module_name in submodules:
-            cloudpickle.unregister_pickle_by_value(sys.modules[module_name])
 
 
 def _log_object_src(
     artifact_path,
     model_path: str,
     description: str,
+    experiment_name: str,
     model_type: ModelType = ModelType.MODEL,
     model_version_tags: Optional[Dict[str, str]] = None,
     registered_model_name: str = "default_name",
@@ -200,7 +58,7 @@ def _log_object_src(
     additional_local_packages: Optional[Union[List[str], str]] = None,
 ):
     """
-    Log a Pyfunc model with custom inference logic and optional data dependencies as an MLflow artifact.
+    Log a src model with custom inference logic and optional data dependencies as an artifact.
 
     Current run is using.
     Parameter registered_model_name must be not empty string,
@@ -235,7 +93,6 @@ def _log_object_src(
     del UploadModelMode  # need to delete this because it is not JSON serializable
     if create_venv_pack:
         validate_predict_config(path=os.path.join(f"{model_path}", "artifacts", f"{FILENAME_FOR_INFERENCE_CONFIG}"))
-    start_run_if_not_exist()
     old_python_path = sys.path.copy()
     old_sys_modules = sys.modules.copy()
     try:
@@ -262,8 +119,9 @@ def _log_object_src(
             "create_venv_pack": create_venv_pack,
             "additional_local_packages": additional_local_packages,
             "get_object_func": get_object_func,
+            "experiment_name": experiment_name,
         }
-        response = _request_log_model("log_object_src", kwargs)
+        response = _request_log_model(kwargs)
         result = _raise_error(response)
     except Exception as err:
         raise err
@@ -275,13 +133,15 @@ def _log_object_src(
                     sys.modules.pop(module)
 
     if additional_local_packages:
-        if isinstance(additional_local_packages, list):
-            for package in additional_local_packages:
-                response = _request_log_artifacts(package, DATA, model_type)
-                _raise_error(response)
-        else:
-            response = _request_log_artifacts(additional_local_packages, DATA, model_type)
+        name_version = json.loads(response.content.decode("utf-8"))
+        if not isinstance(additional_local_packages, list):
+            additional_local_packages = [additional_local_packages]
+        for package in additional_local_packages:
+            response = _request_log_artifacts(
+                package, DATA, name_version["name"], int(name_version["version"]), model_type
+            )
             _raise_error(response)
+
     return result
 
 
@@ -325,27 +185,17 @@ def log_executor_src(
     None
 
     """
-    old_experiment_name = variables.active_experiment
-
-    try:
-        set_experiment(EXPERIMENT_NAME_FOR_EXECUTOR, visibility=VisibilityOptions.PUBLIC)
-
-        with start_run(nested=True):
-            _log_object_src(
-                artifact_path="",
-                description=description,
-                registered_model_name=registered_name,
-                start_build=start_build,
-                model_path=model_path,
-                visibility=visibility,
-                additional_local_packages=additional_local_packages,
-                model_type=ModelType.EXECUTOR,
-            )
-
-    except Exception as err:
-        raise err
-    finally:
-        variables.active_experiment = old_experiment_name
+    _log_object_src(
+        artifact_path="",
+        description=description,
+        registered_model_name=registered_name,
+        start_build=start_build,
+        model_path=model_path,
+        visibility=visibility,
+        additional_local_packages=additional_local_packages,
+        model_type=ModelType.EXECUTOR,
+        experiment_name=EXPERIMENT_NAME_FOR_EXECUTOR,
+    )
 
 
 def log_dataset_loader_src(
@@ -385,23 +235,16 @@ def log_dataset_loader_src(
     None
 
     """
-    old_experiment_name = variables.active_experiment
-    try:
-        set_experiment(EXPERIMENT_NAME_FOR_DATASET_LOADER, visibility=VisibilityOptions.PUBLIC)
-        with start_run(nested=True):
-            _log_object_src(
-                artifact_path="",
-                description=description,
-                registered_model_name=registered_name,
-                model_path=model_path,
-                visibility=visibility,
-                additional_local_packages=additional_local_packages,
-                model_type=ModelType.DATASET_LOADER,
-            )
-    except Exception as err:
-        raise err
-    finally:
-        variables.active_experiment = old_experiment_name
+    _log_object_src(
+        artifact_path="",
+        description=description,
+        registered_model_name=registered_name,
+        model_path=model_path,
+        visibility=visibility,
+        additional_local_packages=additional_local_packages,
+        model_type=ModelType.DATASET_LOADER,
+        experiment_name=EXPERIMENT_NAME_FOR_DATASET_LOADER,
+    )
 
 
 def log_model_src(
@@ -410,7 +253,7 @@ def log_model_src(
     description: str,
     start_build: bool = True,
     model_version_tags: Optional[Dict[str, str]] = None,
-    experiment_name: Optional[str] = None,
+    experiment_name: str = DEFAULT_EXPERIMENT,
     create_venv_pack: bool = False,
     visibility: VisibilityOptions = VisibilityOptions.PRIVATE,
     additional_local_packages: Optional[Union[List[str], str]] = None,
@@ -445,27 +288,19 @@ def log_model_src(
     =======
     None
     """
-    old_experiment_name = variables.active_experiment
-    try:
-        if experiment_name:
-            set_experiment(experiment_name, visibility=VisibilityOptions.PUBLIC)
-        with start_run(nested=True):
-            _log_object_src(
-                artifact_path="",
-                description=description,
-                registered_model_name=registered_name,
-                model_path=model_path,
-                start_build=start_build,
-                model_version_tags=model_version_tags,
-                create_venv_pack=create_venv_pack,
-                visibility=visibility,
-                additional_local_packages=additional_local_packages,
-                model_type=ModelType.MODEL,
-            )
-    except Exception as err:
-        raise err
-    finally:
-        variables.active_experiment = old_experiment_name
+    _log_object_src(
+        artifact_path="",
+        description=description,
+        registered_model_name=registered_name,
+        model_path=model_path,
+        start_build=start_build,
+        model_version_tags=model_version_tags,
+        create_venv_pack=create_venv_pack,
+        visibility=visibility,
+        additional_local_packages=additional_local_packages,
+        model_type=ModelType.MODEL,
+        experiment_name=experiment_name,
+    )
 
 
 def log_artifact(local_path: str, artifact_path: Optional[str] = None) -> None:
@@ -610,14 +445,14 @@ def log_metrics(metrics: Dict[str, float], step: int = 0) -> None:
     return _request_log_metric(metrics_to_log, step)
 
 
-def _request_log_model(function_name: str, kwargs: dict):
+def _request_log_model(kwargs: dict):
     """
     Send request for log_model function.
 
     Steps for log model:
     0) Infer jsonschema, raise if it is invalid
     1) open temporary directory
-    2) Do mlflow.save_model() locally
+    2) Do init model locally
     3) Pack it to tar file
     4) Send it to server to log model there.
     """
@@ -677,7 +512,7 @@ def _request_log_model(function_name: str, kwargs: dict):
     from ML_management.model.model_type_to_methods_map import model_pattern_to_methods
     from ML_management.model.patterns.model_pattern import Model
 
-    experiment_name = variables.active_experiment.get("experiment_name")
+    experiment_name = kwargs.get("experiment_name", DEFAULT_EXPERIMENT)
 
     if python_model is not None:
         if isinstance(python_model, Model):
@@ -721,42 +556,38 @@ def _request_log_model(function_name: str, kwargs: dict):
             kwargs.pop(delete_arg, None)
 
         log_request = {
-            "function_name": function_name,
-            "active_experiment": variables.active_experiment,
-            "active_run_ids": [run.info.run_id for run in active_run_stack],
+            "job_run_id": variables.job_run_id,
         }
 
-        if function_name == "log_model":
-            kwargs["loader_module"] = mlflow.pyfunc.model.__name__
-            with TemporaryDirectory() as temp_dir:
-                model_folder = "model"
-                path_for_model_folder = os.path.join(temp_dir, model_folder)
-                mlflow.pyfunc.save_model(path=path_for_model_folder, **kwargs_for_save_model)
-                model_folder = path_for_model_folder
-                log_request["kwargs"] = kwargs
-                return _open_pipe_send_request(model_folder, log_request, url=get_log_service_url("log_model"))
-        else:
-            artifacts_path = os.path.join(kwargs["model_path"], CONFIG_KEY_ARTIFACTS)
-            if os.path.isfile(artifacts_path):
-                raise Exception(f"The artifact file {artifacts_path} is invalid. The artifact must be a directory.")
+        artifacts_path = os.path.join(kwargs["model_path"], CONFIG_KEY_ARTIFACTS)
+        if os.path.isfile(artifacts_path):
+            raise Exception(f"The artifact file {artifacts_path} is invalid. The artifact must be a directory.")
 
-            model_folder = kwargs["model_path"]
+        model_folder = kwargs["model_path"]
 
-            del kwargs["model_path"]
-            kwargs["loader_module"] = "ML_management.loader.loader"
-            log_request["kwargs"] = kwargs
-            return _open_pipe_send_request(model_folder, log_request, url=get_log_service_url("log_model"))
+        del kwargs["model_path"]
+        kwargs["loader_module"] = "ML_management.loader.loader"
+        log_request["kwargs"] = kwargs
+        return _open_pipe_send_request(model_folder, log_request, url=get_log_service_url("log_model"))
 
     else:
         raise Exception("python_model parameter must be specified")
 
 
-def _request_log_artifacts(local_path, artifact_path, model_type: Optional[ModelType] = None):
+def _request_log_artifacts(
+    local_path,
+    artifact_path,
+    name: Optional[str] = None,
+    version: Optional[int] = None,
+    model_type: Optional[ModelType] = None,
+):
     """Send request for log artifact."""
     log_artifact_request = {
-        "kwargs": {"local_path": local_path, "artifact_path": artifact_path},
-        "active_run_ids": [run.info.run_id for run in active_run_stack],
+        "artifact_path": artifact_path,
+        "job_run_id": variables.job_run_id,
         "model_type": model_type,
+        "name": name,
+        "version": version,
     }
     if not os.path.exists(local_path):
         raise FileNotFoundError(f"Path: {local_path} does not exist.")
@@ -766,7 +597,7 @@ def _request_log_artifacts(local_path, artifact_path, model_type: Optional[Model
             url = get_log_service_url("log_artifact")
 
             # upload multipart
-            data = {"mlflow_request": json.dumps(log_artifact_request)}
+            data = {"log_request": json.dumps(log_artifact_request)}
             headers = {"Transfer-Encoding": "chunked"}
 
             file_content_type = "application/octet-stream"
@@ -836,12 +667,12 @@ def _request(
     is_tar=False,
     stream=False,
 ) -> _GeneratorContextManager:
-    """Create mlflow_request and send it to server."""
+    """Create log request and send it to server."""
     if not file:
         return AuthSession().post(url=url, stream=stream, json=request_dict)
 
     # upload multipart
-    data = {"mlflow_request": json.dumps(request_dict)}
+    data = {"log_request": json.dumps(request_dict)}
     headers = {"Transfer-Encoding": "chunked"}
 
     file_content_type = "application/octet-stream"
@@ -869,11 +700,10 @@ def _tar_folder(w, model_folder):
 
 
 def _request_log_metric(metrics: Dict[str, float], step: Optional[int] = None):
-    if not active_run_stack:
+    if not variables.job_run_id:
         raise MLMClientError("The log_metric function must be called from the active job.")
-    run_id = active_run_stack[0].info.run_id
 
-    request_dict = {"metrics": metrics, "step": step, "run_id": run_id}
+    request_dict = {"metrics": metrics, "step": step, "run_id": variables.job_run_id}
 
     url = posixpath.join(get_server_ml_api(), "log-metric")
 
@@ -881,11 +711,10 @@ def _request_log_metric(metrics: Dict[str, float], step: Optional[int] = None):
 
 
 def _request_log_params(params: Dict[str, str]):
-    if not active_run_stack:
+    if not variables.job_run_id:
         raise MLMClientError("The log_params function must be called from the active job.")
-    run_id = active_run_stack[0].info.run_id
 
-    request_dict = {"params": params, "run_id": run_id}
+    request_dict = {"params": params, "run_id": variables.job_run_id}
 
     url = posixpath.join(get_server_ml_api(), "log-params")
 

{ml-management-0.5.1rc6 → ml-management-0.5.1rc8}/ML_management/mlmanagement/server_mlmanager_exceptions.py

@@ -1,4 +1,4 @@
-"""Custom exception definition for server mlflow manager graph."""
+"""Custom exception definition for server manager graph."""
 
 from typing import Any, Optional, Tuple
 

{ml-management-0.5.1rc6 → ml-management-0.5.1rc8}/ML_management/mlmanagement/variables.py

@@ -10,8 +10,15 @@ s3_password = "PLACEHOLDER"
 mlm_login = None
 mlm_password = None
 
-active_run_stack = []
-active_experiment: dict = {}
+job_run_id = None
+
+CONFIG_KEY_ARTIFACTS = "artifacts"
+DEFAULT_EXPERIMENT = "Default"
+MLCONFIG = "MLConfig.yaml"
+MLMODEL_FILE_NAME = "MLmodel"
+DATA = "data"
+FLAVOR_NAME = "python_function"
+
 
 EXPERIMENT_NAME_FOR_EXECUTOR = "executors"
 EXPERIMENT_NAME_FOR_DATASET_LOADER = "dataset_loaders"
@@ -20,8 +27,8 @@ SERVER_META = posixpath.join("bff", "meta.json")
 
 
 def get_server_ml_api() -> str:
-    """Get server '/mlflow' endpoint URL."""
-    return posixpath.join(get_server_url(), "mlflow")
+    """Get server '/api' endpoint URL."""
+    return posixpath.join(get_server_url(), "api")
 
 
 def get_log_service_url(function_name: str) -> str:

{ml-management-0.5.1rc6 → ml-management-0.5.1rc8}/ML_management/model/patterns/model_pattern.py

@@ -4,24 +4,25 @@ 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
+from ML_management.mlmanagement.variables import CONFIG_KEY_ARTIFACTS
 
 
-class Model(RichPythonModel, ABC):
-    """Abstract class for model that Job will use."""
+class Model(ABC):
+    """
+    Abstract class for model that Job will use.
 
-    def __new__(cls, *args, **kwargs):  # noqa: ARG003
-        """Get object of Model class.
-
-        Attributes
-        ----------
+    Attributes
+    ----------
         self.artifacts: str
             Local path to artifacts.
 
         self.dataset: DatasetLoader object
             Instance of user's dataset.
-        """
+
+    """
+
+    def __new__(cls, *args, **kwargs):  # noqa: ARG003
+        """Get object of Model class."""
         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.
@@ -40,7 +41,7 @@ class Model(RichPythonModel, ABC):
         """Every model should make predictions."""
         raise NotImplementedError
 
-    def to_device(self, device: str) -> None:
+    def to_device(self, device: str) -> None:  # noqa: B027
         """
         Define model migration to specific device.