frogml-core 0.0.108__tar.gz → 0.0.110__tar.gz

frogml_core-0.0.110/PKG-INFO

@@ -0,0 +1,410 @@
+Metadata-Version: 2.3
+Name: frogml-core
+Version: 0.0.110
+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 (>=6.0.2)
+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 (>=4.25.8)
+Requires-Dist: pyarrow (>=20.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
+```

frogml_core-0.0.110/frogml_core/__init__.py

@@ -0,0 +1,25 @@
+"""Top-level package for frogml."""
+
+__author__ = "jfrog"
+__version__ = "0.0.110"
+
+from frogml_core.inner.di_configuration import wire_dependencies
+from frogml_core.model.model_version_tracking import (  # noqa: F401,E501
+    log_metric,
+    log_param,
+)
+from frogml_core.model_loggers.artifact_logger import (  # noqa: F401,E501
+    load_file,
+    log_file,
+)
+from frogml_core.model_loggers.data_logger import load_data, log_data  # noqa: F401
+from frogml_core.model_loggers.model_logger import (  # noqa: F401,E501
+    load_model,
+    log_model,
+)
+
+from .frogml_client.client import FrogMLClient  # noqa: F401
+from .model.decorators.api import api_decorator as api  # noqa: F401
+from .model.decorators.timer import frogml_timer  # noqa: F401
+
+_container = wire_dependencies()

frogml_core-0.0.110/frogml_core/inner/build_logic/phases/phase_010_fetch_model/post_fetch_validation_step.py

@@ -0,0 +1,139 @@
+import importlib.util
+import os
+import shutil
+import subprocess  # nosec
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import List
+
+from frogml_core.exceptions import FrogmlSuggestionException
+from frogml_core.inner.build_logic.constants.temp_dir import TEMP_LOCAL_MODEL_DIR
+from frogml_core.inner.build_logic.dependency_manager_type import DependencyManagerType
+from frogml_core.inner.build_logic.interface.step_inteface import Step
+from frogml_core.inner.build_logic.tools.dependencies_tools import find_dependency_files
+
+TEMP_LOCAL_EDITABLE_FOLDER = "editable"
+
+
+@dataclass
+class DependencyFileObject:
+    dep_file_name: List[str]
+    lock_file_name: str = field(default="")
+
+
+DEPS_MANAGER_FILE_MAP = {
+    DependencyManagerType.PIP: DependencyFileObject(dep_file_name=["requirements.txt"]),
+    DependencyManagerType.POETRY: DependencyFileObject(
+        dep_file_name=["pyproject.toml"], lock_file_name="poetry.lock"
+    ),
+    DependencyManagerType.CONDA: DependencyFileObject(
+        dep_file_name=["conda.yml", "conda.yaml"]
+    ),
+}
+
+
+class PostFetchValidationStep(Step):
+    STEP_DESCRIPTION = "Post model fetch validation"
+
+    def description(self) -> str:
+        return self.STEP_DESCRIPTION
+
+    def execute(self) -> None:
+        self.validate_dependencies()
+        self.configure_base_docker_image()
+        self.create_development_wheels()
+
+    def validate_dependencies(self):
+        if (
+            not Path(self.config.build_properties.model_uri.uri).is_dir()
+            or self.config.build_env.python_env.dependency_file_path
+        ):
+            self.build_logger.debug("Validating dependency file exists")
+            model_uri, main_dir = (
+                self.context.host_temp_local_build_dir / TEMP_LOCAL_MODEL_DIR,
+                self.config.build_properties.model_uri.main_dir,
+            )
+            (
+                self.context.dependency_manager_type,
+                self.context.model_relative_dependency_file,
+                self.context.model_relative_dependency_lock_file,
+            ) = find_dependency_files(model_uri, main_dir, self.build_logger)
+
+            if (
+                self.context.dependency_manager_type
+                and self.context.model_relative_dependency_file
+            ):
+                return
+
+            self.build_logger.error("Dependency file wasn't found, failing...")
+            raise FrogmlSuggestionException(
+                message="Dependency file isn't found",
+                suggestion="Make sure your model include one of dependencies manager: pip/poetry/conda",
+            )
+
+    def configure_base_docker_image(self):
+        base_image = self.config.build_env.docker.base_image
+        if (not base_image) and self.config.build_env.remote.resources.gpu_type:
+            base_image = "frogml/frogml:gpu-py39"  # todo check gpu
+        self.context.base_image = base_image
+
+    def create_development_wheels(self):
+        if not os.getenv("FROGML_DEBUG"):
+            return
+
+        (module_location,) = importlib.util.find_spec(
+            "frogml_sdk"
+        ).submodule_search_locations
+        source_dir = Path(module_location).parent
+        pyproject_toml = source_dir / "pyproject.toml"
+
+        if pyproject_toml.is_file():
+            self.build_logger.info(
+                "Detected non-PyPI-released frogml-sdk installed, creating local frogml-runtime "
+                "and frogml-core wheel files to pass to build process"
+            )
+            runtime_dir = source_dir.parent / "frogml-runtime"
+            core_dir = source_dir.parent / "frogml-core"
+            target_path = self.context.host_temp_local_build_dir
+            self.context.custom_runtime_wheel = self._create_wheel(
+                runtime_dir, target_path
+            )
+            self.context.custom_core_wheel = self._create_wheel(core_dir, target_path)
+
+    def _create_wheel(self, package_dir, target_path):
+        dist_dir = package_dir / "dist"
+        shutil.rmtree(dist_dir, ignore_errors=True)
+        output = subprocess.check_output(["make", "sync"], cwd=package_dir)  # nosec
+        for line in output.decode().split("\n"):
+            self.build_logger.debug(f">>> {line}")
+        output = subprocess.check_output(["poetry", "build"], cwd=package_dir)  # nosec
+        for line in output.decode().split("\n"):
+            self.build_logger.debug(f">>> {line}")
+        wheel_file = next(dist_dir.glob("*.whl"), None)
+        editable_folder = target_path / TEMP_LOCAL_EDITABLE_FOLDER
+        editable_folder.mkdir(exist_ok=True)
+        copied_wheel_file = shutil.move(wheel_file, editable_folder / wheel_file.name)
+        shutil.rmtree(dist_dir, ignore_errors=True)
+        self.build_logger.info(f"Created wheel for {package_dir} successfully")
+        return copied_wheel_file
+
+
+def find_file_location(model_uri, main_dir, filename) -> Path:
+    file_locations: List[Path] = [
+        model_uri / filename,
+        model_uri / main_dir / filename,
+    ]
+    for file in file_locations:
+        if file.is_file():
+            return file
+
+
+def get_possible_dependency_lock_paths(dependency_path: Path):
+    paths = []
+    for _, dependency_file_object in DEPS_MANAGER_FILE_MAP.items():
+        if dependency_file_object.lock_file_name:
+            lock_file_path = (
+                dependency_path.parent / dependency_file_object.lock_file_name
+            )
+            paths.append(lock_file_path)
+    return paths

frogml_core-0.0.110/frogml_proto/jfml/hosting_gateway/v1/build_upload_url_pb2.py

@@ -0,0 +1,29 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: frogml_proto.jfml.hosting_gateway/v1/build_upload_url.proto
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n.jfml/hosting_gateway/v1/build_upload_url.proto\x12\x17jfml.hosting_gateway.v1\"\xd3\x01\n\x18\x42uildUploadUrlParameters\x12\x10\n\x08model_id\x18\x01 \x01(\t\x12\x10\n\x08\x62uild_id\x18\x02 \x01(\t\x12\x11\n\ttag_value\x18\x03 \x01(\t\x12\x41\n\rartifact_type\x18\x04 \x01(\x0e\x32*.jfml.hosting_gateway.v1.BuildArtifactType\x12$\n\x1ause_cloud_provider_storage\x18\x05 \x01(\x08H\x00\x42\x17\n\x15\x63loud_provider_option*v\n\x11\x42uildArtifactType\x12\x19\n\x15INVALID_ARTIFACT_TYPE\x10\x00\x12\x16\n\x12\x44\x41TA_ARTIFACT_TYPE\x10\x01\x12\x16\n\x12\x46ILE_ARTIFACT_TYPE\x10\x02\x12\x16\n\x12\x43ODE_ARTIFACT_TYPE\x10\x03\x42\'\n#com.jfrog.ml.hosting_gateway.api.v1P\x01\x62\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'jfml.hosting_gateway.v1.build_upload_url_pb2', _globals)
+if _descriptor._USE_C_DESCRIPTORS == False:
+
+  DESCRIPTOR._options = None
+  DESCRIPTOR._serialized_options = b'\n#com.jfrog.ml.hosting_gateway.api.v1P\001'
+  _globals['_BUILDARTIFACTTYPE']._serialized_start=289
+  _globals['_BUILDARTIFACTTYPE']._serialized_end=407
+  _globals['_BUILDUPLOADURLPARAMETERS']._serialized_start=76
+  _globals['_BUILDUPLOADURLPARAMETERS']._serialized_end=287
+# @@protoc_insertion_point(module_scope)

frogml_core-0.0.110/frogml_proto/jfml/hosting_gateway/v1/hosting_gateway_service_pb2.py

@@ -0,0 +1,32 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: frogml_proto.jfml.hosting_gateway/v1/hosting_gateway_service.proto
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+from frogml_proto.jfml.hosting_gateway.v1 import build_upload_url_pb2 as jfml_dot_hosting__gateway_dot_v1_dot_build__upload__url__pb2
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n5jfml/hosting_gateway/v1/hosting_gateway_service.proto\x12\x17jfml.hosting_gateway.v1\x1a.jfml/hosting_gateway/v1/build_upload_url.proto\"g\n\"GetBuildVersioningUploadURLRequest\x12\x41\n\x06params\x18\x01 \x01(\x0b\x32\x31.jfml.hosting_gateway.v1.BuildUploadUrlParameters\"9\n#GetBuildVersioningUploadURLResponse\x12\x12\n\nupload_url\x18\x01 \x01(\t2\xb2\x01\n\x15HostingGatewayService\x12\x98\x01\n\x1bGetBuildVersioningUploadURL\x12;.jfml.hosting_gateway.v1.GetBuildVersioningUploadURLRequest\x1a<.jfml.hosting_gateway.v1.GetBuildVersioningUploadURLResponseB\'\n#com.jfrog.ml.hosting_gateway.api.v1P\x01\x62\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'jfml.hosting_gateway.v1.hosting_gateway_service_pb2', _globals)
+if _descriptor._USE_C_DESCRIPTORS == False:
+
+  DESCRIPTOR._options = None
+  DESCRIPTOR._serialized_options = b'\n#com.jfrog.ml.hosting_gateway.api.v1P\001'
+  _globals['_GETBUILDVERSIONINGUPLOADURLREQUEST']._serialized_start=130
+  _globals['_GETBUILDVERSIONINGUPLOADURLREQUEST']._serialized_end=233
+  _globals['_GETBUILDVERSIONINGUPLOADURLRESPONSE']._serialized_start=235
+  _globals['_GETBUILDVERSIONINGUPLOADURLRESPONSE']._serialized_end=292
+  _globals['_HOSTINGGATEWAYSERVICE']._serialized_start=295
+  _globals['_HOSTINGGATEWAYSERVICE']._serialized_end=473
+# @@protoc_insertion_point(module_scope)

frogml_core-0.0.110/frogml_proto/jfml/model_version/v1/artifact_pb2.py

@@ -0,0 +1,29 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: frogml_proto.jfml.model_version/v1/artifact.proto
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n$jfml/model_version/v1/artifact.proto\x12\x15jfml.model_version.v1\"d\n\x08\x41rtifact\x12\x15\n\rartifact_path\x18\x01 \x01(\t\x12\x0c\n\x04size\x18\x02 \x01(\x04\x12\x33\n\tchecksums\x18\x03 \x01(\x0b\x32 .jfml.model_version.v1.Checksums\"\x19\n\tChecksums\x12\x0c\n\x04sha2\x18\x01 \x01(\tB%\n!com.jfrog.ml.model_version.api.v1P\x01\x62\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'jfml.model_version.v1.artifact_pb2', _globals)
+if _descriptor._USE_C_DESCRIPTORS == False:
+
+  DESCRIPTOR._options = None
+  DESCRIPTOR._serialized_options = b'\n!com.jfrog.ml.model_version.api.v1P\001'
+  _globals['_ARTIFACT']._serialized_start=63
+  _globals['_ARTIFACT']._serialized_end=163
+  _globals['_CHECKSUMS']._serialized_start=165
+  _globals['_CHECKSUMS']._serialized_end=190
+# @@protoc_insertion_point(module_scope)