qwak-core 0.4.366__py3-none-any.whl → 0.4.392__py3-none-any.whl

qwak/clients/project/client.py

@@ -1,5 +1,3 @@
-from typing import Optional
-
 import grpc
 from _qwak_proto.qwak.projects.projects_pb2 import (
     CreateProjectRequest,
@@ -8,7 +6,6 @@ from _qwak_proto.qwak.projects.projects_pb2 import (
     ListProjectsRequest,
 )
 from _qwak_proto.qwak.projects.projects_pb2_grpc import ProjectsManagementServiceStub
-from _qwak_proto.qwak.projects.jfrog_project_spec_pb2 import ModelRepositoryJFrogSpec
 from dependency_injector.wiring import Provide, inject
 from qwak.exceptions import QwakException
 from qwak.inner.di_configuration import QwakContainer
@@ -34,16 +31,12 @@ class ProjectsManagementClient:
         self,
         project_name,
         project_description,
-        jfrog_project_key: Optional[str] = None,
     ):
         try:
             return self._projects_management_service.CreateProject(
                 CreateProjectRequest(
                     project_name=project_name,
                     project_description=project_description,
-                    jfrog_spec=ModelRepositoryJFrogSpec(
-                        jfrog_project_key=jfrog_project_key
-                    ),
                 )
             )
 

qwak/feature_store/_common/packaging.py

@@ -16,6 +16,7 @@ from qwak.feature_store._common.value import (
     UPDATE_QWAK_SDK_WITH_FEATURE_STORE_EXTRA_MSG,
 )
 from requests import HTTPError, Response
+from urllib.parse import urlparse, ParseResult
 
 ZIP_FUNCTION_CONTENT_TYPE = "text/plain"
 
@@ -220,17 +221,22 @@ def put_files_content(
 
 
 def upload_to_s3(presign_url: str, in_memory_zip: bytes, content_type: str) -> str:
+    parsed_url: ParseResult = urlparse(presign_url)
+    extra_headers: Dict[str, str] = (
+        {"x-ms-blob-type": "BlockBlob"}
+        if parsed_url.hostname.endswith(".blob.core.windows.net")
+        else None
+    )
     put_files_content(
         url=presign_url,
         content=in_memory_zip,
         content_type=content_type,
+        extra_headers=extra_headers,
     )
-    from urllib.parse import urlparse
 
-    parsed_url = urlparse(presign_url)
-    postfix = parsed_url.path
-    bucket = parsed_url.hostname.split(".s3.")[0]
-    s3_path = f"s3://{bucket}{postfix}"  # noqa: E231
+    postfix: str = parsed_url.path
+    bucket: str = parsed_url.hostname.split(".s3.")[0]
+    s3_path: str = f"s3://{bucket}{postfix}"  # noqa: E231
     return s3_path
 
 

qwak/inner/const.py

@@ -39,6 +39,4 @@ class QwakConstants:
         "https://grpc.qwak.ai/api/v0/runtime/get-authenticated-user-context"
     )
 
-    JFROG_TENANT_HEADER_KEY = "X-JFrog-Tenant-Id"
-
     QWAK_APP_URL: str = "https://app.qwak.ai"

qwak/inner/di_configuration/account.py

@@ -2,13 +2,12 @@ import configparser
 import errno
 import os
 from dataclasses import dataclass
-from typing import Optional, Type, Union
+from typing import Optional, Type
 
 from qwak.exceptions import QwakLoginException
 from qwak.inner.const import QwakConstants
 from qwak.inner.di_configuration.session import Session
-from qwak.inner.tool.auth import Auth0ClientBase, FrogMLAuthClient
-from frogml_storage.authentication.login import frogml_login
+from qwak.inner.tool.auth import Auth0ClientBase
 
 
 @dataclass
@@ -23,18 +22,6 @@ class UserAccount:
     # Assigned username
     username: Optional[str] = None
 
-    # Assigned password
-    password: Optional[str] = None
-
-    # Assigned URL
-    url: Optional[str] = None
-
-    # Anonymous login
-    anonymous: bool = False
-
-    # Interactive login
-    is_interactive: bool = False
-
 
 class UserAccountConfiguration:
     USER_FIELD = "user"
@@ -43,9 +30,9 @@ class UserAccountConfiguration:
 
     def __init__(
         self,
-        config_file=QwakConstants.QWAK_CONFIG_FILE,
-        auth_file=QwakConstants.QWAK_AUTHORIZATION_FILE,
-        auth_client: Union[Type[Auth0ClientBase], Type[FrogMLAuthClient]] = None,
+        config_file: str = QwakConstants.QWAK_CONFIG_FILE,
+        auth_file: str = QwakConstants.QWAK_AUTHORIZATION_FILE,
+        auth_client: Type[Auth0ClientBase] = Auth0ClientBase,
     ):
         self._config_file = config_file
         self._auth_file = auth_file
@@ -53,52 +40,12 @@ class UserAccountConfiguration:
         self._auth = configparser.ConfigParser()
         self._environment = Session().get_environment()
         self._auth_client = auth_client
-        self._force_qwak_auth = os.getenv("FORCE_QWAK_AUTH", "False") == "True"
-
-        if not self._auth_client:
-            # Determine auth client based on FrogML configuration
-            try:
-                from frogml_storage.authentication.utils import (
-                    get_frogml_configuration,
-                )
-
-                if (
-                    get_frogml_configuration() or os.getenv("JF_URL")
-                ) and not self._force_qwak_auth:
-                    self._auth_client = FrogMLAuthClient
-                else:
-                    self._auth_client = Auth0ClientBase
-            except (ImportError, Exception):
-                self._auth_client = Auth0ClientBase
 
     def configure_user(self, user_account: UserAccount):
         """
         Configure user authentication based on the authentication client type
         """
-        if issubclass(self._auth_client, Auth0ClientBase):
-            # Existing Qwak authentication flow
-            self.__qwak_login(user_account)
-
-        elif issubclass(self._auth_client, FrogMLAuthClient):
-            # Use FrogML's login flow
-            success = frogml_login(
-                url=user_account.url,
-                username=user_account.username,
-                password=user_account.password,
-                token=user_account.api_key,
-                anonymous=user_account.anonymous,
-                is_interactive=user_account.is_interactive,
-            )
-
-            if not success:
-                raise QwakLoginException("Failed to authenticate with JFrog")
-            # Validate access token
-            # TODO: Remove once we support reference token
-            token = self._auth_client().get_token()
-            if not token or len(token) <= 64:
-                raise QwakLoginException(
-                    "Authentication with JFrog failed: Only Access Tokens are supported. Please ensure you are using a valid Access Token."
-                )
+        self.__qwak_login(user_account)
 
     def __qwak_login(self, user_account: UserAccount):
         self._auth.read(self._auth_file)
@@ -139,8 +86,6 @@ class UserAccountConfiguration:
         :return:
         """
         try:
-            if issubclass(self._auth_client, FrogMLAuthClient):
-                return UserAccount()
             username = os.environ.get("QWAK_USERNAME")
             api_key = os.environ.get("QWAK_API_KEY")
             if not api_key and (
@@ -179,8 +124,6 @@ class UserAccountConfiguration:
         :return:
         """
         try:
-            if issubclass(self._auth_client, FrogMLAuthClient):
-                return ""
             api_key = os.environ.get("QWAK_API_KEY")
             if api_key:
                 Session().set_environment(api_key)
@@ -213,7 +156,4 @@ class UserAccountConfiguration:
         auth_client_instance = self._auth_client()
         base_url = auth_client_instance.get_base_url()
 
-        if issubclass(self._auth_client, FrogMLAuthClient):
-            return f"{base_url}/ui/ml"
-
         return base_url

qwak/inner/tool/auth.py

@@ -1,12 +1,9 @@
 import warnings
 from filelock import FileLock
-from typing_extensions import Self
 
 from qwak.inner.di_configuration.session import Session
 from abc import ABC, abstractmethod
 from typing import Optional
-from frogml_storage.authentication.utils import get_credentials
-from frogml_storage.authentication.models import AuthConfig
 
 warnings.filterwarnings(action="ignore", module=".*jose.*")
 
@@ -140,86 +137,3 @@ class Auth0ClientBase(BaseAuthClient):
             raise e
         except Exception:
             raise QwakLoginException()
-
-
-class FrogMLAuthClient(BaseAuthClient):
-    __MIN_TOKEN_LENGTH: int = 64
-
-    def __init__(self, auth_config: Optional[AuthConfig] = None):
-        self.auth_config = auth_config
-        self._token = None
-        self._tenant_id = None
-
-    def get_token(self) -> Optional[str]:
-        if not self._token:
-            self.login()
-        return self._token
-
-    def get_tenant_id(self) -> Optional[str]:
-        if not self._tenant_id:
-            self.login()
-        return self._tenant_id
-
-    def get_base_url(self) -> str:
-        artifactory_url, _ = get_credentials(self.auth_config)
-        return self.__format_artifactory_url(artifactory_url)
-
-    def login(self) -> None:
-        artifactory_url, auth = get_credentials(self.auth_config)
-        # For now, we only support Bearer token authentication
-        if not hasattr(auth, "token"):
-            return
-
-        # noinspection PyUnresolvedReferences
-        self._token = auth.token
-        self.__validate_token()
-
-        base_url = self.__format_artifactory_url(artifactory_url)
-        try:
-            response = requests.get(
-                f"{base_url}/ui/api/v1/system/auth/screen/footer",
-                headers={"Authorization": f"Bearer {self._token}"},
-                timeout=60,
-            )
-            response.raise_for_status()  # Raises an HTTPError for bad responses
-            response_data = response.json()
-            if "serverId" not in response_data:
-                response = requests.get(
-                    f"{base_url}/jfconnect/api/v1/system/jpd_id",
-                    headers={"Authorization": f"Bearer {self._token}"},
-                    timeout=60,
-                )
-                if response.status_code == 200:
-                    self._tenant_id = response.text
-                elif response.status_code == 401:
-                    raise QwakLoginException(
-                        "Failed to authenticate with JFrog. Please check your credentials"
-                    )
-                else:
-                    raise QwakLoginException(
-                        "Failed to authenticate with JFrog. Please check your artifactory configuration"
-                    )
-            else:
-                self._tenant_id = response_data["serverId"]
-        except requests.exceptions.RequestException:
-            raise QwakLoginException(
-                "Failed to authenticate with JFrog. Please check your artifactory configuration"
-            )
-        except ValueError:  # This catches JSON decode errors
-            raise QwakLoginException(
-                "Failed to authenticate with JFrog. Please check your artifactory configuration"
-            )
-
-    def __validate_token(self: Self):
-        if self._token is None or len(self._token) <= self.__MIN_TOKEN_LENGTH:
-            raise QwakLoginException(
-                "Authentication with JFrog failed: Only JWT Access Tokens are supported. "
-                "Please ensure you are using a valid JWT Access Token."
-            )
-
-    @staticmethod
-    def __format_artifactory_url(artifactory_url: str) -> str:
-        # Remove '/artifactory' from the URL
-        base_url: str = artifactory_url.replace("/artifactory", "")
-        # Remove trailing slash if exists
-        return base_url.rstrip("/")

qwak/inner/tool/grpc/grpc_auth.py

@@ -1,7 +1,6 @@
 from typing import Callable, Tuple
 
 import grpc
-from qwak.inner.const import QwakConstants
 
 _SIGNATURE_HEADER_KEY = "authorization"
 
@@ -35,34 +34,3 @@ class Auth0Client(grpc.AuthMetadataPlugin):
 
             self._auth_client = Auth0ClientBase()
         return self._auth_client.get_token()
-
-
-class FrogMLGrpcClient(grpc.AuthMetadataPlugin):
-    def __init__(self):
-        self._auth_client = None
-
-    def __call__(
-        self,
-        context: grpc.AuthMetadataContext,
-        callback: Callable[[Tuple[Tuple[str, str]], None], None],
-    ):
-        """Implements authentication by passing metadata to a callback.
-
-        Args:
-            context: An AuthMetadataContext providing information on the RPC that
-                the plugin is being called to authenticate.
-            callback: A callback that accepts a tuple of metadata key/value pairs and a None
-                parameter.
-        """
-        # Get token from FrogML client
-        if not self._auth_client:
-            from qwak.inner.tool.auth import FrogMLAuthClient
-
-            self._auth_client = FrogMLAuthClient()
-        token = self._auth_client.get_token()
-        jfrog_tenant_id = self._auth_client.get_tenant_id()
-        metadata = (
-            (_SIGNATURE_HEADER_KEY, f"Bearer {token}"),
-            (QwakConstants.JFROG_TENANT_HEADER_KEY.lower(), jfrog_tenant_id),
-        )
-        callback(metadata, None)

qwak/inner/tool/grpc/grpc_tools.py

@@ -6,10 +6,8 @@ from typing import Callable, Optional, Tuple
 
 import grpc
 from qwak.exceptions import QwakException
-from qwak.inner.di_configuration.account import UserAccountConfiguration
-from qwak.inner.tool.auth import Auth0ClientBase
 
-from .grpc_auth import Auth0Client, FrogMLGrpcClient
+from .grpc_auth import Auth0Client
 
 logger = logging.getLogger()
 
@@ -49,11 +47,7 @@ def create_grpc_channel(
         credentials = grpc.ssl_channel_credentials()
         if enable_auth:
             if auth_metadata_plugin is None:
-                user_config = UserAccountConfiguration()
-                if issubclass(user_config._auth_client, Auth0ClientBase):
-                    auth_metadata_plugin = Auth0Client()
-                else:
-                    auth_metadata_plugin = FrogMLGrpcClient()
+                auth_metadata_plugin = Auth0Client()
             credentials = grpc.composite_channel_credentials(
                 credentials, grpc.metadata_call_credentials(auth_metadata_plugin)
             )

qwak/inner/tool/grpc/grpc_try_wrapping.py

@@ -1,12 +1,14 @@
+import logging
 import functools
 import inspect
 from inspect import BoundArguments, Signature
 from typing import Any, Callable, Optional
 
 import grpc
-from frogml_storage.logging import logger
 from qwak.exceptions import QwakException
 
+logger = logging.getLogger()
+
 
 def grpc_try_catch_wrapper(
     exception_message: str,

qwak/qwak_client/client.py

@@ -238,8 +238,8 @@ class QwakClient:
         model = self._get_model_management().get_model(model_id=model_id)
         model_uuid = model.uuid
 
-        metric_filters = list()
-        parameter_filters = list()
+        metric_filters = []
+        parameter_filters = []
 
         for build_filter in filters:
             if isinstance(build_filter, MetricFilter):
@@ -356,7 +356,6 @@ class QwakClient:
         self,
         project_name: str,
         project_description: str,
-        jfrog_project_key: Optional[str] = None,
     ) -> str:
         """
         Create project
@@ -364,7 +363,6 @@ class QwakClient:
         Args:
             project_name (str): The requested name
             project_description (str): The requested description
-            jfrog_project_key (Optional[str]): The requested jfrog project key
 
         Returns:
              str: The project ID of the newly created project
@@ -373,7 +371,6 @@ class QwakClient:
         project = self._get_project_management().create_project(
             project_name=project_name,
             project_description=project_description,
-            jfrog_project_key=jfrog_project_key,
         )
 
         return project.project.project_id
@@ -419,7 +416,6 @@ class QwakClient:
         project_id: str,
         model_name: str,
         model_description: str,
-        jfrog_project_key: Optional[str] = None,
     ) -> str:
         """
         Create model
@@ -428,7 +424,6 @@ class QwakClient:
             project_id (str): The project ID to associate the model
             model_name (str): The requested name
             model_description (str): The requested description
-            jfrog_project_key (Optional[str]): The jfrog project key
 
         Returns:
              str: The model ID of the newly created project
@@ -438,7 +433,6 @@ class QwakClient:
             project_id=project_id,
             model_name=model_name,
             model_description=model_description,
-            jfrog_project_key=jfrog_project_key,
         )
 
         return model.model_id

qwak/vector_store/rest_helpers.py

@@ -4,25 +4,16 @@ import socket
 from datetime import datetime
 
 import requests
-from qwak.inner.di_configuration.account import UserAccountConfiguration
-from qwak.inner.tool.auth import Auth0ClientBase, FrogMLAuthClient
-from qwak.inner.const import QwakConstants
+from qwak.inner.tool.auth import Auth0ClientBase
 
 
 def _get_authorization():
-    user_account_configuration = UserAccountConfiguration()
-    if issubclass(user_account_configuration._auth_client, Auth0ClientBase):
-        auth_client = Auth0ClientBase()
-        tenant_id = None
-    else:
-        auth_client = FrogMLAuthClient()
-        tenant_id = auth_client.get_tenant_id()
-
+    auth_client = Auth0ClientBase()
     token = auth_client.get_token()
     token_split = token.split(".")
     decoded_token = json.loads(_base64url_decode(token_split[1]).decode("utf-8"))
     token_expiration = datetime.fromtimestamp(decoded_token["exp"])
-    return f"Bearer {token}", token_expiration, tenant_id
+    return f"Bearer {token}", token_expiration
 
 
 def _base64url_decode(input):
@@ -77,8 +68,5 @@ class RestSession(requests.Session):
         return super().prepare_request(request)
 
     def prepare_request_token(self):
-        auth_token, self.jwt_expiration, tenant_id = _get_authorization()
+        auth_token, self.jwt_expiration = _get_authorization()
         self.headers["Authorization"] = auth_token
-
-        if tenant_id:
-            self.headers[QwakConstants.JFROG_TENANT_HEADER_KEY] = tenant_id

qwak_core-0.4.392.dist-info/METADATA

@@ -0,0 +1,50 @@
+Metadata-Version: 2.3
+Name: qwak-core
+Version: 0.4.392
+Summary: Qwak Core contains the necessary objects and communication tools for using the Qwak Platform
+License: Apache-2.0
+Keywords: mlops,ml,deployment,serving,model
+Author: Qwak
+Author-email: info@qwak.com
+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 :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+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.71.2)
+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,<5)
+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)
+Requires-Dist: typer
+Project-URL: Home page, https://www.qwak.com/
+Description-Content-Type: text/markdown
+
+# Qwak Core
+
+Qwak 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.
+Qwak Core contains all the objects and tools necessary to use the Qwak Platform
+