qwak-core 0.4.278__py3-none-any.whl → 0.5.19__py3-none-any.whl

qwak/feature_store/online/client.py

@@ -1,6 +1,5 @@
 import logging
 import math
-from io import StringIO
 from typing import TYPE_CHECKING, List, Optional, Sequence, Tuple
 
 from _qwak_proto.qwak.ecosystem.v0.ecosystem_pb2 import AuthenticatedUnifiedUserContext
@@ -205,9 +204,26 @@ class OnlineClient:
                 response_df_json, _ = self._serving_client.GetMultiFeatures.with_call(
                     request, metadata=self._metadata
                 )
-                features_df: pd.DataFrame = pd.read_json(
-                    StringIO(response_df_json.pandas_df_as_json), orient="split"
-                )
+                try:
+                    # Try orjson first (fastest - 6x speedup)
+                    import orjson
+
+                    parsed_data = orjson.loads(response_df_json.pandas_df_as_json)
+                    features_df: pd.DataFrame = pd.DataFrame(
+                        data=parsed_data["data"],
+                        columns=parsed_data["columns"],
+                        index=parsed_data["index"],
+                    )
+                except ImportError:
+                    # Fallback: Direct json.loads + DataFrame (2x speedup, no deps)
+                    import json
+
+                    parsed_data = json.loads(response_df_json.pandas_df_as_json)
+                    features_df: pd.DataFrame = pd.DataFrame(
+                        data=parsed_data["data"],
+                        columns=parsed_data["columns"],
+                        index=parsed_data["index"],
+                    )
                 results.append(
                     pd.concat(
                         [population_df.reset_index(drop=True), features_df],

qwak/feature_store/validations/validation_decorators.py

@@ -0,0 +1,70 @@
+from functools import wraps
+
+from qwak.exceptions import QwakException
+from qwak.feature_store.validations.validation_response import SuccessValidationResponse
+
+
+def silence_backend_specific_validation_exceptions(*error_messages_to_silence):
+    """
+    A decorator that catches specific backend validation exceptions and returns a standardized
+    validation success response encapsulating the exception details. Used to skip the validation
+    process for certain backend exceptions. hopefully will be removed soon after validations will be supported on
+    all environment types.
+
+    Parameters:
+        *error_messages_to_silence: Variable length argument list
+            Messages that, if present in the exception message, should trigger the
+            standardized validation success response instead of propagating the exception.
+
+    Returns:
+        function
+            The wrapped function that will catch specified backend validation exceptions
+            and return a standardized validation success response if any of the specified
+            error messages are found in the exception message.
+
+    Usage:
+    ------
+    @silence_backend_specific_validation_exceptions(
+        "Validating DataSource is not supported for self-hosted environments",
+        "Validating DataSource is not supported for SAAS environments"
+    )
+    def validate_data_source():
+        # Your function implementation
+
+    When 'validate_data_source_blocking' raises a QwakException containing one of the specified error messages,
+    it will return a SuccessValidationResponse, including the
+    exception's representation in stderr and in the sample as a dataframe with a warning column.
+    If the exception message does not contain any of the specified error messages, the exception is raised normally.
+    """
+
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, silence_specific_exceptions: bool = True, **kwargs):
+            try:
+                return func(*args, **kwargs)
+            except QwakException as e:
+                is_to_silent_error = silence_specific_exceptions and any(
+                    error_message in repr(e)
+                    for error_message in error_messages_to_silence
+                )
+                if not is_to_silent_error:
+                    raise e
+
+                try:
+                    import pandas as pd
+                except ImportError as exc:
+                    raise QwakException("Missing required Pandas dependency") from exc
+
+                return (
+                    SuccessValidationResponse(
+                        sample=pd.DataFrame({"errors": [repr(e)]}),
+                        features=[],
+                        stdout="",
+                        stderr=repr(e),
+                    ),
+                    None,
+                )
+
+        return wrapper
+
+    return decorator

qwak/feature_store/validations/validation_response.py

@@ -1,6 +1,7 @@
 import ast
 from abc import ABC
 from dataclasses import dataclass
+from io import StringIO
 from typing import TYPE_CHECKING, List
 
 from _qwak_proto.qwak.feature_store.features.feature_set_pb2 import (
@@ -87,8 +88,9 @@ class ValidationResponseFactory:
             success: ProtoValidationSuccessResponse = (
                 validation_response.success_response
             )
+
             pd_sample: pd.DataFrame = pd.read_json(
-                path_or_buf=ast.literal_eval(success.sample),
+                path_or_buf=StringIO(ast.literal_eval(success.sample)),
                 dtype=success.spark_column_description,
             )
 

qwak/feature_store/validations/validator.py

@@ -9,6 +9,9 @@ from qwak.clients.feature_store.operator_client import FeaturesOperatorClient
 from qwak.exceptions import QwakException
 from qwak.feature_store.data_sources.base import BaseSource
 from qwak.feature_store.feature_sets.base_feature_set import BaseFeatureSet
+from qwak.feature_store.validations.validation_decorators import (
+    silence_backend_specific_validation_exceptions,
+)
 from qwak.feature_store.validations.validation_options import (
     DataSourceValidationOptions,
     FeatureSetValidationOptions,
@@ -52,13 +55,16 @@ class FeaturesOperatorValidator(Validator):
         self._operator_client = FeaturesOperatorClient()
         self._registry_client = FeatureRegistryClient()
 
+    @silence_backend_specific_validation_exceptions(
+        "Validating DataSource is not supported for self-hosted environments"
+    )
     def validate_data_source(
         self,
         data_source: BaseSource,
         sample_size: int = 10,
         validation_options: Optional[DataSourceValidationOptions] = None,
     ) -> Tuple[ValidationResponse, Optional[str]]:
-        if 0 >= sample_size > 1000:
+        if sample_size <= 0 or 1_000 < sample_size:
             raise ValueError(
                 f"sample_size must be under 1000 and positive, got: {sample_size}"
             )
@@ -76,18 +82,20 @@ class FeaturesOperatorValidator(Validator):
 
         return ValidationResponseFactory.from_proto(proto_response), artifact_url
 
+    @silence_backend_specific_validation_exceptions(
+        "Validating FeatureSet is not supported for self-hosted environments"
+    )
     def validate_featureset(
         self,
         featureset: BaseFeatureSet,
         sample_size: int = 10,
         validation_options: Optional[FeatureSetValidationOptions] = None,
     ) -> Tuple[ValidationResponse, Optional[str]]:
-        if 0 >= sample_size > 1000:
+        if sample_size <= 0 or 1_000 < sample_size:
             raise ValueError(
                 f"sample_size must be under 1000 and positive, got: {sample_size}"
             )
         artifact_url: Optional[str] = None
-
         featureset_spec, artifact_url = featureset._to_proto(
             feature_registry=self._registry_client, features=None, git_commit=None
         )

qwak/inner/build_logic/interface/context_interface.py

@@ -60,3 +60,7 @@ class Context(metaclass=ABCMeta):
     # Upload Custom Wheels
     custom_runtime_wheel: Optional[Path] = field(default=None)
     custom_core_wheel: Optional[Path] = field(default=None)
+
+    platform_url: Optional[str] = field(
+        default_factory=UserAccountConfiguration().retrieve_platform_url
+    )

qwak/inner/build_logic/phases/phase_010_fetch_model/post_fetch_validation_step.py

@@ -104,7 +104,7 @@ class PostFetchValidationStep(Step):
     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", "install"], cwd=package_dir)  # nosec
+        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

qwak/inner/const.py

@@ -33,10 +33,6 @@ class QwakConstants:
 
     TOKEN_AUDIENCE: str = "https://auth-token.qwak.ai/"  # nosec B105
 
-    QWAK_AUTHENTICATION_URL = "https://grpc.qwak.ai/api/v1/authentication/qwak-api-key"
+    QWAK_APP_URL: str = "https://app.qwak.ai"
 
-    QWAK_AUTHENTICATED_USER_ENDPOINT: str = (
-        "https://grpc.qwak.ai/api/v0/runtime/get-authenticated-user-context"
-    )
-
-    JFROG_TENANT_HEADER_KEY = "X-JFrog-Tenant-Id"
+    CONTROL_PLANE_GRPC_ADDRESS_ENVAR_NAME: str = "CONTROL_PLANE_GRPC_ADDRESS"

qwak/inner/di_configuration/__init__.py

@@ -1,71 +1,3 @@
-import os
-
 from .account import UserAccountConfiguration
 from .containers import QwakContainer
-
-
-def wire_dependencies():
-    container = QwakContainer()
-
-    default_config_file = os.path.join(os.path.dirname(__file__), "config.yml")
-    container.config.from_yaml(default_config_file)
-
-    from qwak.clients import (
-        administration,
-        alert_management,
-        alerts_registry,
-        analytics,
-        audience,
-        automation_management,
-        autoscaling,
-        batch_job_management,
-        build_management,
-        build_orchestrator,
-        data_versioning,
-        deployment,
-        feature_store,
-        file_versioning,
-        instance_template,
-        integration_management,
-        kube_deployment_captain,
-        logging_client,
-        model_management,
-        project,
-        prompt_manager,
-        system_secret,
-        user_application_instance,
-        vector_store,
-        workspace_manager,
-    )
-
-    container.wire(
-        packages=[
-            administration,
-            alert_management,
-            audience,
-            automation_management,
-            autoscaling,
-            analytics,
-            batch_job_management,
-            build_management,
-            build_orchestrator,
-            data_versioning,
-            deployment,
-            file_versioning,
-            instance_template,
-            kube_deployment_captain,
-            logging_client,
-            model_management,
-            project,
-            feature_store,
-            user_application_instance,
-            alerts_registry,
-            workspace_manager,
-            vector_store,
-            integration_management,
-            system_secret,
-            prompt_manager,
-        ]
-    )
-
-    return container
+from .dependency_wiring import wire_dependencies

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)
@@ -202,3 +145,15 @@ class UserAccountConfiguration:
                 f"Environment {self._environment} has not be configured."
                 f"Please ensure it is configured using the `qwak configure` command."
             )
+
+    def retrieve_platform_url(self) -> str:
+        """
+        Retrieve the platform URL based on the configured authentication client.
+
+        Returns:
+            str: The platform URL.
+        """
+        auth_client_instance = self._auth_client()
+        base_url = auth_client_instance.get_base_url()
+
+        return base_url

qwak/inner/di_configuration/containers.py

@@ -22,6 +22,7 @@ class QwakContainer(containers.DeclarativeContainer):
         status_for_retry=(
             grpc.StatusCode.UNAVAILABLE,
             grpc.StatusCode.CANCELLED,
+            grpc.StatusCode.DEADLINE_EXCEEDED,
         ),
     )
 
@@ -37,5 +38,8 @@ class QwakContainer(containers.DeclarativeContainer):
         url=config.grpc.builds.internal_address,
         enable_ssl=config.grpc.builds.enable_ssl,
         enable_auth=False,
-        status_for_retry=(grpc.StatusCode.UNAVAILABLE,),
+        status_for_retry=(
+            grpc.StatusCode.UNAVAILABLE,
+            grpc.StatusCode.DEADLINE_EXCEEDED,
+        ),
     )

qwak/inner/di_configuration/dependency_wiring.py

@@ -0,0 +1,98 @@
+import os
+from pathlib import Path
+from typing import Optional
+
+from qwak.inner.const import QwakConstants
+from qwak.inner.di_configuration import QwakContainer
+from qwak.inner.tool.grpc.grpc_tools import validate_grpc_address
+from qwak.tools.logger import get_qwak_logger
+
+
+logger = get_qwak_logger()
+
+__DEFAULT_CONFIG_FILE_PATH: Path = Path(__file__).parent / "config.yml"
+
+
+def wire_dependencies():
+    container = QwakContainer()
+
+    container.config.from_yaml(__DEFAULT_CONFIG_FILE_PATH)
+    control_plane_grpc_address_override: Optional[str] = os.getenv(
+        QwakConstants.CONTROL_PLANE_GRPC_ADDRESS_ENVAR_NAME
+    )
+
+    if control_plane_grpc_address_override:
+        validate_grpc_address(control_plane_grpc_address_override)
+        __override_control_plane_grpc_address(
+            container, control_plane_grpc_address_override
+        )
+
+    from qwak.clients import (
+        administration,
+        alert_management,
+        alerts_registry,
+        analytics,
+        audience,
+        automation_management,
+        autoscaling,
+        batch_job_management,
+        build_orchestrator,
+        data_versioning,
+        deployment,
+        feature_store,
+        file_versioning,
+        instance_template,
+        integration_management,
+        kube_deployment_captain,
+        logging_client,
+        model_management,
+        project,
+        prompt_manager,
+        system_secret,
+        user_application_instance,
+        vector_store,
+        workspace_manager,
+    )
+
+    container.wire(
+        packages=[
+            administration,
+            alert_management,
+            audience,
+            automation_management,
+            autoscaling,
+            analytics,
+            batch_job_management,
+            build_orchestrator,
+            data_versioning,
+            deployment,
+            file_versioning,
+            instance_template,
+            kube_deployment_captain,
+            logging_client,
+            model_management,
+            project,
+            feature_store,
+            user_application_instance,
+            alerts_registry,
+            workspace_manager,
+            vector_store,
+            integration_management,
+            system_secret,
+            prompt_manager,
+        ]
+    )
+
+    return container
+
+
+def __override_control_plane_grpc_address(
+    container: "QwakContainer", control_plane_grpc_address_override: str
+):
+    logger.debug(
+        "Overriding control plane gRPC address from environment variable to %s.",
+        control_plane_grpc_address_override,
+    )
+    container.config.grpc.core.address.from_value(
+        control_plane_grpc_address_override.strip()
+    )

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.*")
 
@@ -28,6 +25,13 @@ class BaseAuthClient(ABC):
     def login(self) -> None:
         pass
 
+    @abstractmethod
+    def get_base_url(self) -> str:
+        """
+        Returns the base URL for the authentication service.
+        """
+        return ""
+
 
 class Auth0ClientBase(BaseAuthClient):
     _TOKENS_FIELD = "TOKENS"
@@ -46,6 +50,9 @@ class Auth0ClientBase(BaseAuthClient):
         self.audience = audience
         self.api_key = api_key
 
+    def get_base_url(self) -> str:
+        return QwakConstants.QWAK_APP_URL
+
     # Returns Non if token is expired
     def get_token(self):
         if self._environment != Session().get_environment():
@@ -130,80 +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 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()
-
-        # Remove '/artifactory/' from the URL
-        if "/artifactory" in artifactory_url:
-            base_url = artifactory_url.replace("/artifactory", "")
-        else:
-            # Remove trailing slash if exists
-            base_url = artifactory_url.rstrip("/")
-        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."
-            )