frogml-core 0.0.95__py3-none-any.whl → 0.0.97__py3-none-any.whl

frogml_core/__init__.py

@@ -1,7 +1,7 @@
 """Top-level package for frogml."""
 
 __author__ = "jfrog"
-__version__ = "0.0.95"
+__version__ = "0.0.97"
 
 from frogml_core.inner.di_configuration import wire_dependencies
 from frogml_core.model.model_version_tracking import (  # noqa: F401,E501

frogml_core/clients/instance_template/client.py

@@ -50,10 +50,12 @@ class InstanceTemplateManagementClient:
 
     def list_instance_templates(self) -> List[InstanceTemplateSpec]:
         try:
-            result: ListInstanceTemplatesResponse = self._instance_template_service.ListInstanceTemplates(
-                ListInstanceTemplatesRequest(
-                    optional_instance_filter=InstanceFilter(
-                        instance_type_filter=InstanceTypeFilter.INSTANCE_TYPE_FILTER_ALL
+            result: ListInstanceTemplatesResponse = (
+                self._instance_template_service.ListInstanceTemplates(
+                    ListInstanceTemplatesRequest(
+                        optional_instance_filter=InstanceFilter(
+                            instance_type_filter=InstanceTypeFilter.INSTANCE_TYPE_FILTER_ALL
+                        )
                     )
                 )
             )

frogml_core/clients/model_version_manager/client.py

@@ -2,7 +2,7 @@ from platform import python_version
 from typing import List, Optional, Dict, Union, Tuple
 
 from dependency_injector.wiring import Provide
-from frogml_storage.entity_manifest import Artifact
+from frogml_storage.models.entity_manifest import Artifact
 from grpc import RpcError
 
 from frogml_core.exceptions import FrogmlException
@@ -210,9 +210,9 @@ class ModelVersionManagerClient:
         Optional[List[ArtifactProto]],
         List[ArtifactProto],
     ]:
-        model_artifact_proto: List[
-            ArtifactProto
-        ] = ProtoUtils.convert_artifacts_to_artifacts_proto(model_artifact)
+        model_artifact_proto: List[ArtifactProto] = (
+            ProtoUtils.convert_artifacts_to_artifacts_proto(model_artifact)
+        )
         dependency_artifacts_proto = (
             ProtoUtils.convert_artifacts_to_artifacts_proto(dependency_artifacts)
             if dependency_artifacts

frogml_core/clients/prompt_manager/model_descriptor_mapper.py

@@ -57,10 +57,10 @@ class ModelDescriptorMapper:
         model_id: str, openai_chat_params: ProtoOpenAIChatModelParams
     ) -> OpenAIChat:
         p = openai_chat_params
-        _tool_choice: Union[
-            str, ChatCompletionNamedToolChoiceParam
-        ] = ModelDescriptorMapper._from_tool_choice(
-            openai_chat_params=openai_chat_params
+        _tool_choice: Union[str, ChatCompletionNamedToolChoiceParam] = (
+            ModelDescriptorMapper._from_tool_choice(
+                openai_chat_params=openai_chat_params
+            )
         )
         _tools: List[ChatCompletionToolParam] = []
 

frogml_core/feature_store/_common/artifact_utils.py

@@ -45,9 +45,9 @@ class ArtifactsUploader:
         featureset_name: str,
         __instance_module_path__: str,
     ) -> Optional[ArtifactSpec]:
-        transformation_functions: Optional[
-            List[Callable[..., Any]]
-        ] = transformation.get_functions()
+        transformation_functions: Optional[List[Callable[..., Any]]] = (
+            transformation.get_functions()
+        )
         if transformation_functions is not None and transformation_functions:
             return ArtifactSpec(
                 artifact_name=featureset_name,

frogml_core/feature_store/data_sources/batch/athena.py

@@ -130,9 +130,9 @@ class AthenaSource(JdbcSource):
             )
         )
 
-        time_partition_columns: Optional[
-            TimePartitionColumns
-        ] = AthenaSource._extract_partition_column(proto_athena_source)
+        time_partition_columns: Optional[TimePartitionColumns] = (
+            AthenaSource._extract_partition_column(proto_athena_source)
+        )
         workgroup: Optional[str] = (
             proto_athena_source.workgroup
             if proto_athena_source.HasField("workgroup")

frogml_core/feature_store/feature_sets/context.py

@@ -5,9 +5,5 @@ from typing import Union
 
 @dataclass
 class Context:
-    start_time: Union[
-        str, datetime
-    ] = "${qwak_ingestion_start_timestamp}"  # todo mlops-2312 - rename?
-    end_time: Union[
-        str, datetime
-    ] = "${qwak_ingestion_end_timestamp}"  # todo mlops-2312 - rename?
+    start_time: Union[str, datetime] = "${qwak_ingestion_start_timestamp}"
+    end_time: Union[str, datetime] = "${qwak_ingestion_end_timestamp}"

frogml_core/feature_store/feature_sets/streaming.py

@@ -131,9 +131,9 @@ def feature_set(
             offline_scheduling_policy=offline_scheduling_policy,
         )
 
-        streaming_backfill: Optional[
-            StreamingBackfill
-        ] = StreamingBackfill.get_streaming_backfill_from_function(function=function)
+        streaming_backfill: Optional[StreamingBackfill] = (
+            StreamingBackfill.get_streaming_backfill_from_function(function=function)
+        )
 
         fs_name = name or function.__name__
         streaming_feature_set = StreamingFeatureSet(

frogml_core/feature_store/feature_sets/streaming_backfill.py

@@ -230,7 +230,7 @@ class StreamingBackfill:
 
     @staticmethod
     def _get_normalized_backfill_sources_spec(
-        data_sources: Union[List[str], List[DataSourceBackfillSpec]]
+        data_sources: Union[List[str], List[DataSourceBackfillSpec]],
     ) -> List[DataSourceBackfillSpec]:
         # reformat all data source specs to 'DataSourceBackfillSpec'
         return [

frogml_core/feature_store/online/client.py

@@ -197,12 +197,12 @@ class OnlineClient:
         )
         ordered_entities = [entity[0] for entity in ordered_entities_tuple]
 
-        request_chunks: List[
-            Tuple[RequestedEntitiesMatrix, pd.DataFrame]
-        ] = OnlineClient._split_entities(
-            entity_names=ordered_entities,
-            population_df=df,
-            max_entities_per_split=max_keys_per_request,
+        request_chunks: List[Tuple[RequestedEntitiesMatrix, pd.DataFrame]] = (
+            OnlineClient._split_entities(
+                entity_names=ordered_entities,
+                population_df=df,
+                max_entities_per_split=max_keys_per_request,
+            )
         )
 
         results: List[pd.DataFrame] = []

frogml_core/feature_store/sinks/streaming/factory.py

@@ -25,7 +25,7 @@ class StreamingSinkFactory:
     def get_streaming_sink(proto_streaming_sink: ProtoStreamingSink) -> BaseSink:
         sink_type = proto_streaming_sink.WhichOneof("sink_type")
 
-        auth_conf: BaseAuthentication
+        auth_conf: BaseAuthentication  # noqa: F842
         if sink_type == "kafka_sink":
             proto_kafka_sink: ProtoKafkaSink = proto_streaming_sink.kafka_sink
             auth_configuration: BaseAuthentication = cast(

frogml_core/inner/build_logic/phases/phase_010_fetch_model/fetch_strategy_manager/strategy/git/git_strategy.py

@@ -161,9 +161,9 @@ def make_ssh_key_file(git_ssh_key: str) -> str:
 
 
 def add_ssh_file_to_env(ssh_key_file_path: str) -> None:
-    os.environ[
-        "GIT_SSH_COMMAND"
-    ] = f"ssh -i {ssh_key_file_path} -o StrictHostKeyChecking=no"
+    os.environ["GIT_SSH_COMMAND"] = (
+        f"ssh -i {ssh_key_file_path} -o StrictHostKeyChecking=no"
+    )
     os.environ["GIT_SSH"] = f"ssh -i {ssh_key_file_path} -o StrictHostKeyChecking=no"
 
 

frogml_core/inner/di_configuration/account.py

@@ -3,8 +3,8 @@ import os
 from dataclasses import dataclass
 from typing import Optional
 
-from frogml_storage.authentication._authentication_utils import get_credentials
-from frogml_storage.cli._login_cli import login as frogml_login
+from frogml_storage.authentication.utils import get_credentials
+from frogml_storage.authentication.login import frogml_login
 from frogml_storage.constants import CONFIG_FILE_PATH
 
 from frogml_core.exceptions import FrogmlLoginException

frogml_core/inner/tool/auth.py

@@ -1,9 +1,8 @@
 from typing import Optional, Union, cast
 
 import requests
-from frogml_storage._utils import BearerAuth
-from frogml_storage.authentication._authentication_utils import get_credentials
-from frogml_storage.authentication.models._auth_config import AuthConfig
+from frogml_storage.authentication.models import AuthConfig, BearerAuth
+from frogml_storage.authentication.utils import get_credentials
 from requests.auth import AuthBase
 from typing_extensions import Self
 

frogml_core/llmops/provider/openai/provider.py

@@ -30,9 +30,9 @@ class OpenAIProvider:
         self.client = OpenAIClient()
 
     def _get_random_openai_api_key(self) -> Optional[str]:
-        openai_api_keys: List[
-            OpenAIApiKeySystemSecret
-        ] = IntegrationUtils().get_openai_api_keys()
+        openai_api_keys: List[OpenAIApiKeySystemSecret] = (
+            IntegrationUtils().get_openai_api_keys()
+        )
         if len(openai_api_keys) == 0:
             return None
 

frogml_core/model/tools/adapters/output.py

@@ -46,7 +46,7 @@ def get_output_adapter(
 
             first_result = (
                 return_result[0]
-                if type(return_result) == list and len(return_result) > 0
+                if isinstance(return_result, list) and len(return_result) > 0
                 else return_result
             )
             if issubclass(type(first_result), Message):

frogml_core/tools/logger/logger.py

@@ -276,7 +276,7 @@ def set_file_handler_log_file(
     logger: logging.Logger, handler_name: str, log_file: Path
 ):
     existing_handler = get_handler_from_logger(logger, handler_name)
-    if type(existing_handler) != RotatingFileHandler:
+    if not isinstance(existing_handler, RotatingFileHandler):
         raise FrogmlException(
             f"Error in setting log file. Error message: handler of name {handler_name} is not a file logger handler"
         )

frogml_core/utils/proto_utils.py

@@ -1,6 +1,6 @@
 from typing import List
 
-from frogml_storage.entity_manifest import Artifact
+from frogml_storage.models.entity_manifest import Artifact
 
 from frogml_proto.jfml.model_version.v1.artifact_pb2 import (
     Artifact as ArtifactProto,

frogml_core-0.0.97.dist-info/METADATA

@@ -0,0 +1,411 @@
+Metadata-Version: 2.3
+Name: frogml-core
+Version: 0.0.97
+Summary: frogml Core contains the necessary objects and communication tools for using the Jfrog ml Platform
+License: Apache-2.0
+Keywords: mlops,ml,deployment,serving,model
+Author: Jfrog
+Requires-Python: >=3.9,<3.12
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Provides-Extra: feature-store
+Requires-Dist: PyYAML
+Requires-Dist: cachetools
+Requires-Dist: chevron (==0.14.0)
+Requires-Dist: cloudpickle (==2.2.1) ; extra == "feature-store"
+Requires-Dist: dacite (==1.8.1)
+Requires-Dist: dependency-injector (>=4.0)
+Requires-Dist: filelock
+Requires-Dist: grpcio (>=1.57.0)
+Requires-Dist: joblib (>=1.3.2,<2.0.0)
+Requires-Dist: marshmallow-dataclass (>=8.5.8,<9.0.0)
+Requires-Dist: protobuf (>=3.10,<4) ; python_version < "3.10"
+Requires-Dist: protobuf (>=4.21.6) ; python_version >= "3.10"
+Requires-Dist: pyarrow (>=6.0.0) ; extra == "feature-store"
+Requires-Dist: pyathena (>=2.2.0,!=2.18.0) ; extra == "feature-store"
+Requires-Dist: pydantic
+Requires-Dist: pyspark (==3.4.2) ; extra == "feature-store"
+Requires-Dist: python-jose[cryptography] (>=3.4.0)
+Requires-Dist: python-json-logger (>=2.0.2)
+Requires-Dist: requests
+Requires-Dist: retrying (==1.3.4)
+Requires-Dist: tqdm
+Requires-Dist: typeguard (>=2,<3)
+Project-URL: Home page, https://www.jfrog.com/
+Description-Content-Type: text/markdown
+
+# Frogml Core
+
+Frogml is an end-to-end production ML platform designed to allow data scientists to build, deploy, and monitor their models in production with minimal engineering friction.
+Frogml Core contains all the objects and tools necessary to use the Frogml Platform
+
+# Frog ML Storage
+
+## Table of contents:
+
+- [Overview](#overview)
+- [Working with Artifactory](#Working-with-Artifactory)
+   - [Login by adding authentication details to your python code](#Login-by-adding-authentication-details-to-your-python-code)
+   - [Login via environment variables](#Login-via-environment-variables)
+   - [Login via cli](#Login-via-cli)
+     - [Login by a single command line with options](#Login-by-a-single-command-line-with-options)
+     - [Login by interactive flow in Cli](#Login-by-interactive-flow-in-Cli)
+- [Upload ML model to Artifactory](#Upload-ML-model-to-Artifactory)
+- [Download ML model from Artifactory](#Download-ML-model-from-Artifactory)
+- [Upload ML dataset to Artifactory](#Upload-ML-dataset-to-Artifactory)
+- [Download ML dataset from Artifactory](#Download-ML-dataset-from-Artifactory)
+- [Testing](#Testing)
+  - [Locally run integration tests using local artifactory](#Locally-run-integration-tests-using-artifactory)
+  - [Locally run tests using existing Artifactory](#Locally-run-tests-using-existing-Artifactory)
+- [Packaging](#Packaging)
+- [Linters](#Linters)
+
+## Overview
+
+JFrog ML Storage is a smart python client library providing a simple and efficient method of storing and downloading models, model data and datasets from the JFrog platform, utilizing the advanced capabilities of the JFrog platform.
+
+## Working with Artifactory
+
+FrogML Storage Library support is available from Artifactory version 7.84.x.
+
+To be able to use FrogML Storage with Artifactory, you should authenticate the frogml storage client against Artifactory.
+JFrog implements a credentials provider chain. It sequentially checks each place where you can set the credentials to authenticate with FrogML, and then selects the first one you set.
+
+The credentials retrieval order is as follows:
+
+1. [Login by adding authentication details to your python code](#Login-by-adding-authentication-details-to-your-python-code)
+2. [Login via environment variables](#Login-via-environment-variables)
+3. [Login via cli](#login-via-cli)
+
+
+#### Login by adding authentication details to your python code
+
+---
+**NOTE**
+
+It is strongly discouraged to use credentials in clear text. Use this method for testing purposes only.
+
+---
+
+You can authenticate the FrogML client directly via your Python code, using any of the following credentials (overriding env vars and the credentials in the configuration file):
+- Username and Password
+- Access Token
+
+To log in as an anonymous user, log in first via CLI, and then you will be able to log in via Python using only your JFrog Platform domain.
+
+Authentication by username and password:
+
+```
+from frogml_storage.frog_ml import FrogMLStorage
+from frogml_storage.authentication.models._auth_config import AuthConfig
+
+arti = FrogMLStorage(AuthConfig.by_basic_auth("http://myorg.jfrog.io", <username>, <password>))
+```
+
+Authentication by access token:
+
+```
+from frogml_storage.frog_ml import FrogMLStorage
+from frogml_storage.authentication.models._auth_config import AuthConfig
+
+arti = FrogMLStorage(AuthConfig.by_access_token("http://myorg.jfrog.io", <token>))
+```
+
+#### Login via environment variables
+
+You can also authenticate the frogml client using the following environment variables:
+
+- JF_URL - your JFrog platform domain, for example 'http://myorg.jfrog.io'
+- JF_ACCESS_TOKEN - your artifactory token for this domain. To generate a token, log in to your artifactory, navigate to your FrogML repository and click on "Set Me Up".
+
+After setting the environment variables, you can log in to the frogml client without specifying credentials.
+
+
+```
+from frogml_storage.frog_ml import FrogMLStorage
+from frogml_storage.authentication.models._auth_config import AuthConfig
+
+arti = FrogMLStorage()
+```
+
+
+### Login via cli
+
+It is possible to authenticate the frogml client using any of the following methods:
+
+1. Login by a single CLI command
+2. Interactive flow
+
+After each login attempt, the authentication result (success or failure) is printed on the screen.
+If the login attempt succeeded, the authentication details will be saved as frogml configuration file under the path: ~/.frogml/config.json and from that point you can login again without specifying credentials.
+
+In both interactive flow and the single command flow, it is possible to authenticate the frogml client by:
+
+1. Username and password
+2. Access token
+3. Anonymous authentication
+
+
+
+#### Login by a single command line with options
+
+The below examples show the frogml login options using the cli:
+
+Login using existing jfrog-cli of frogml configuration files (~/.jfrog/jfrog-cli.conf.v6 or ~/.frogml/config.json, respectively):
+
+```
+frogml login
+```
+If no configuration file is found, interactive mode will be triggered.
+
+Login by username and password:
+
+```
+frogml login --url <artifactory_url> --username <username> --password <password>
+```
+
+Where: 
+  - artifactory_url is your JFrog platform domain, for example 'http://myorg.jfrog.io'
+  - username and password are your artifactory credentials for this domain
+
+Login by access token:
+
+```
+frogml login --url <artifactory_url> --token <access_token> 
+```
+
+Where: 
+  - artifactory_url is your JFrog platform domain, for example 'http://myorg.jfrog.io'
+  - token - your artifactory token for this domain. To generate a token, log in to your artifactory and navigate to Administration -> User Management -> Access Tokens. 
+
+Login by anonymous access:
+
+```
+frogml login --url <artifactory_url> --anonymous
+```
+
+#### Login by interactive flow in cli:
+
+To start an interactive flow in the cli, run the command:
+
+```
+frogml login --interactive
+```
+
+After executing the command above, the cli prompts two options as follows:
+
+```
+frogml login --interactive
+Please select from the following options:
+1.Login by jfrog-cli configuration file: ~/.jfrog/jfrog-cli.conf.v6
+2.Connecting to a new server
+```
+
+On choosing the first option, the cli attempts to retrieve your authentication credentials from your JFrog CLI configuration file and sends them to Artifactory.
+
+On choosing the second option, the cli prompts you to input your JFrog platform domain URL. Afterwards, you can select the method you wish to use for authenticating the FrogML library.
+
+```
+Enter artifactory base url: http://myorg.jfrog.io
+Choose your preferred authentication option:
+0: Username and Password
+1: Access Token
+2: Anonymous Access
+```
+
+
+### Upload ML model to Artifactory
+
+You can upload a model to a FrogML repository using the upload_model_version() function. 
+You can upload a single file or an entire folder.
+This function uses checksum upload, assigning a SHA2 value to each model for retrieval from storage. If the binary content cannot be reused, the smart upload mechanism performs regular upload instead.
+After uploading the model, FrogML generates a file named model-info.json which contains the model name and its related files and dependencies.
+
+The version parameter is optional. If not specified, Artifactory will set the version as the timestamp of the time you uploaded the model in your time zone, in UTC format:  yyyy-MM-dd-HH-mm-ss.
+Additionally, you can add properties to the model in Artifactory to categorize and label it.
+The function upload_model_version returns an instance of FrogMlModelVersion, which includes the model's name, version, and namespace.
+
+The below examples show how to upload a model to Artifactory:
+
+---
+**NOTE**
+
+namespace, version, properties, dependencies_files_paths and code_archive_file_path are optional.
+model_path can point to a single file or a directory, in which case the whole directory is uploaded.
+model_type can be written as JSON or as SerializationMetadata object imported from jfrog_ml.serialization_metadata.
+All of SerializationMetadata fields must be populated.
+
+---
+
+
+Upload an entire folder as model:
+
+```
+from frogml_storage.frog_ml import FrogMLStorage
+
+arti = FrogMLStorage()
+arti.upload_model_version(repository=<repository_key>,
+                          namespace=<namespce>,
+                          model_name=<model_name>,
+                          model_path="~/model_to_upload/",
+                          model_type={"framework": "tensorflow", "framework_version": "2.3.0", "serialization_format": "H5", "runtime": "python", "runtime_version": "3.7"},
+                          properties={"model_type": "keras", "experiment": "my-exp"},
+                          dependencies_files_paths=["path/to/req/file1", "path/to/req/file2"],
+                          code_archive_file_path="path/to/code/archieve/file"
+                          )
+```
+
+Upload a model with a specified version, and no dependencies and code archive:
+
+```
+from frogml_storage.frog_ml import FrogMLStorage
+
+arti = FrogMLStorage()
+arti.upload_model_version(repository=<repository_key>,
+                          namespace=<namespce>,
+                          model_name=<model_name>,
+                          version=<version>,
+                          model_path="~/model_to_upload/",
+                          model_type={"framework": "tensorflow", "framework_version": "2.3.0", "serialization_format": "H5", "runtime": "python", "runtime_version": "3.7"}
+                          )
+```
+
+---
+
+#### Download ML model from Artifactory
+
+The below example shows how to download a model from Artifactory:
+
+```
+from frogml_storage.frog_ml import FrogMLStorage
+
+arti = FrogMLStorage()
+
+arti.download_model_version(repository=<repository_key>,
+                            namespace=<namespace>,
+                            model_name=<model_name>,
+                            target_path="~/models",
+                            version=<version>)
+```
+
+---
+**NOTE**
+
+The dependencies and code archive cannot be downloaded.
+
+---
+
+### Upload ML dataset to Artifactory
+
+Upload an entire folder as dataset:
+
+
+```
+from frogml_storage.frog_ml import FrogMLStorage
+
+arti = FrogMLStorage()
+arti.upload_dataset_version(repository=<repository_key>,
+                            namespace=<namespce>, 
+                            dataset_name=<dataset_name>,
+                            source_path="~/dataset_to_upload/",
+                            properties={"dataset_type": "kerras", "experiment": "my-exp"})
+```
+
+Upload a dataset with specified version:
+
+```
+from frogml_storage.frog_ml import FrogMLStorage
+
+arti = FrogMLStorage()
+arti.upload_dataset_version(repository=<repository_key>, 
+                            namespace=<namespce>, 
+                            dataset_name=<dataset_name>, 
+                            version=<version>,
+                            source_path="~/dataset_to_upload/")
+```
+
+Upload a single file as a dataset:
+
+```
+from frogml_storage.frog_ml import FrogMLStorage
+
+arti = FrogMLStorage()
+arti.upload_dataset_version(repository=<repository_key>, 
+                            namespace=<namespce>, 
+                            dataset_name=<dataset_name>, 
+                            version=<version>,
+                            source_path="~/dataset_to_upload/config.json")
+```
+
+ #### Download ML dataset from Artifactory
+
+The below example shows how to download a dataset from Artifactory:
+
+```
+from frogml_storage.frog_ml import FrogMLStorage
+
+arti = FrogMLStorage()
+
+arti.download_dataset_version(repository=<repository_key>, 
+                              namespace=<namespace>, 
+                              dataset_name=<dataset_name>,
+                              target_path="~/datasets", 
+                              version=<version>)
+```
+
+## Testing
+
+### Locally run integration tests using artifactory
+
+Prerequisites:
+-  A user credentials (username, password)
+
+To run the integration tests, use the ```poetry run pytest tests/integrations/test_artifactory_integration.py``` command. 
+In addition, you will need to supply your 
+ARTIFACTORY_URL in a `http(s)://` format (if not supplied, default will be as defined [here](tests/integrations/conftest.py)), ARTIFACTORY_USERNAME, ARTIFACTORY_PASSWORD. 
+the test will create a local repository in RT, will upload and download model and datasets using the provided details,
+and will delete the repository after the test.
+
+example: 
+```
+    export ARTIFACTORY_URL=<artifactory_url>
+    export ARTIFACTORY_USERNAME=<username>
+    export ARTIFACTORY_PASSWORD=<password>
+    
+    poetry run pytest tests/integrations/test_artifactory_integration.py
+ ```
+
+### Locally run tests using existing Artifactory
+
+To run the tests, use the ```pytest``` command pointing it to an existing Artifactory host. 
+Prerequisites:
+-  A generic local repository in the Artifactory instance
+-  A user token or user credentials (username, password)
+
+To run the test:
+
+```
+python3 -m  pytest tests/integrations/test_artifactory_integration.py  --rt_url "<artifactory_url>" --rt_access_token <token> --repo_name <generic-repo-name> -s
+```
+
+## Packaging
+
+```
+poetry build
+```
+
+## Linters
+Fix spaces and linebreaks with:
+```
+make format
+```
+Run linter check:
+```
+make format
+```