qwak-core 0.4.378__py3-none-any.whl → 0.5.4__py3-none-any.whl

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/grpc/grpc_tools.py

@@ -1,15 +1,18 @@
 import logging
+import re
 import time
 from abc import ABC, abstractmethod
 from random import randint
 from typing import Callable, Optional, Tuple
+from urllib.parse import urlparse, ParseResult
 
 import grpc
-from qwak.exceptions import QwakException
 
+from qwak.exceptions import QwakException, QwakGrpcAddressException
 from .grpc_auth import Auth0Client
 
 logger = logging.getLogger()
+HOSTNAME_REGEX: str = r"^(?!-)(?:[A-Za-z0-9-]{1,63}\.)*[A-Za-z0-9-]{1,63}(?<!-)$"
 
 
 def create_grpc_channel(
@@ -19,7 +22,7 @@ def create_grpc_channel(
     auth_metadata_plugin: grpc.AuthMetadataPlugin = None,
     timeout: int = 100,
     options=None,
-    backoff_options={},
+    backoff_options=None,
     max_attempts=4,
     status_for_retry=(grpc.StatusCode.UNAVAILABLE,),
     attempt=0,
@@ -40,6 +43,9 @@ def create_grpc_channel(
         status_for_retry: grpc statuses to retry upon
     Returns: Returns a grpc.Channel
     """
+    if backoff_options is None:
+        backoff_options = {}
+
     if not url:
         raise QwakException("Unable to create gRPC channel. URL has not been defined.")
 
@@ -101,11 +107,14 @@ def create_grpc_channel_or_none(
     auth_metadata_plugin: grpc.AuthMetadataPlugin = None,
     timeout: int = 30,
     options=None,
-    backoff_options={},
+    backoff_options=None,
     max_attempts=2,
     status_for_retry=(grpc.StatusCode.UNAVAILABLE,),
     attempt=0,
 ) -> Callable[[Optional[str], Optional[bool]], Optional[grpc.Channel]]:
+    if backoff_options is None:
+        backoff_options = {}
+
     def deferred_channel(
         url_overwrite: Optional[str] = None, ssl_overwrite: Optional[bool] = None
     ):
@@ -129,6 +138,117 @@ def create_grpc_channel_or_none(
     return deferred_channel
 
 
+def validate_grpc_address(
+    grpc_address: str,
+    is_port_specification_allowed: bool = False,
+    is_url_scheme_allowed: bool = False,
+):
+    """
+    Validate gRPC address format
+    Args:
+        grpc_address (str): gRPC address to validate
+        is_port_specification_allowed (bool): Whether to allow port specification in the address
+        is_url_scheme_allowed (bool): Whether to allow URL scheme in the address
+    Raises:
+        QwakGrpcAddressException: If the gRPC address is invalid
+    """
+    parsed_grpc_address: ParseResult = parse_address(grpc_address)
+    hostname: str = get_hostname_from_address(parsed_grpc_address)
+    validate_paths_are_not_included_in_address(parsed_grpc_address)
+
+    if not is_url_scheme_allowed:
+        __validate_url_scheme_not_included_in_address(parsed_grpc_address)
+
+    if not is_port_specification_allowed:
+        __validate_port_not_included_in_address(parsed_grpc_address)
+
+    if not is_valid_hostname(hostname):
+        raise QwakGrpcAddressException(
+            "gRPC address must be a simple hostname or fully qualified domain name.",
+            parsed_grpc_address,
+        )
+
+
+def validate_paths_are_not_included_in_address(
+    parsed_grpc_address: ParseResult,
+) -> None:
+    has_invalid_path: bool = (
+        parsed_grpc_address.path not in {"", "/"}
+        or parsed_grpc_address.query
+        or parsed_grpc_address.fragment
+    )
+
+    if has_invalid_path:
+        raise QwakGrpcAddressException(
+            "gRPC address must not contain paths, queries, or fragments.",
+            parsed_grpc_address,
+        )
+
+
+def get_hostname_from_address(parsed_grpc_address: ParseResult) -> str:
+    hostname: Optional[str] = parsed_grpc_address.hostname
+    if not hostname:
+        raise QwakGrpcAddressException(
+            "gRPC address must contain a valid hostname.", parsed_grpc_address
+        )
+
+    return hostname
+
+
+def __validate_url_scheme_not_included_in_address(
+    parsed_grpc_address: ParseResult,
+) -> None:
+    if parsed_grpc_address.scheme:
+        raise QwakGrpcAddressException(
+            "URL scheme is not allowed in the gRPC address.", parsed_grpc_address
+        )
+
+
+def __validate_port_not_included_in_address(parsed_grpc_address: ParseResult):
+    try:
+        port: Optional[int] = parsed_grpc_address.port
+    except ValueError as exc:
+        raise QwakGrpcAddressException(
+            "Invalid port specification in the gRPC address.", parsed_grpc_address
+        ) from exc
+
+    if port:
+        raise QwakGrpcAddressException(
+            "Port specification is not allowed in the gRPC address.",
+            parsed_grpc_address,
+        )
+
+
+def parse_address(grpc_address: str) -> ParseResult:
+    if not grpc_address or not grpc_address.strip():
+        raise QwakGrpcAddressException(
+            "gRPC address must not be empty or whitespace.", grpc_address
+        )
+
+    trimmed_address: str = grpc_address.strip()
+    parsed_address: ParseResult = urlparse(
+        trimmed_address if "://" in trimmed_address else f"//{trimmed_address}"
+    )
+
+    return parsed_address
+
+
+def is_valid_hostname(hostname: str) -> bool:
+    """
+    Validate that the supplied hostname conforms to RFC-style label rules:
+    anchored pattern enforces full-string validation, negative lookahead/lookbehind block
+    leading or trailing hyphens per label, and each dot-separated label must be 1-63
+    alphanumeric/hyphen characters.
+
+    Args:
+        hostname (str): The hostname to validate.
+    Returns:
+        bool: True if the hostname is valid, False otherwise.
+    """
+    hostname_pattern: re.Pattern = re.compile(HOSTNAME_REGEX)
+    return bool(hostname_pattern.fullmatch(hostname))
+
+
 class SleepingPolicy(ABC):
     @abstractmethod
     def sleep(self, try_i: int):

qwak/llmops/generation/chat/openai/types/chat/chat_completion.py

@@ -16,8 +16,6 @@
 from dataclasses import dataclass
 from typing import List, Optional
 
-from typing_extensions import Literal
-
 from qwak.llmops.generation.base import ModelResponse
 from .chat_completion_message import ChatCompletionMessage
 from .chat_completion_token_logprob import ChatCompletionTokenLogprob
@@ -34,9 +32,7 @@ class ChoiceLogprobs:
 
 @dataclass
 class Choice:
-    finish_reason: Literal[
-        "stop", "length", "tool_calls", "content_filter", "function_call"
-    ]
+    finish_reason: str
     """The reason the model stopped generating tokens.
 
     This will be `stop` if the model hit a natural stop point or a provided stop
@@ -55,6 +51,21 @@ class Choice:
     logprobs: Optional[ChoiceLogprobs] = None
     """Log probability information for the choice."""
 
+    def __post_init__(self):
+        """Validates that finish_reason is one of the allowed values."""
+        allowed_reasons = {
+            "stop",
+            "length",
+            "tool_calls",
+            "content_filter",
+            "function_call",
+        }
+        if self.finish_reason not in allowed_reasons:
+            raise ValueError(
+                f"Invalid finish_reason: '{self.finish_reason}'. "
+                f"Must be one of {allowed_reasons}"
+            )
+
 
 @dataclass
 class ChatCompletion(ModelResponse):
@@ -73,7 +84,7 @@ class ChatCompletion(ModelResponse):
     model: str
     """The model used for the chat completion."""
 
-    object: Literal["chat.completion"]
+    object: str
     """The object type, which is always `chat.completion`."""
 
     system_fingerprint: Optional[str] = None
@@ -85,3 +96,10 @@ class ChatCompletion(ModelResponse):
 
     usage: Optional[CompletionUsage] = None
     """Usage statistics for the completion request."""
+
+    def __post_init__(self):
+        """Validates that the object type is correct."""
+        if self.object != "chat.completion":
+            raise ValueError(
+                f"Invalid object type: '{self.object}'. Must be 'chat.completion'"
+            )

qwak/llmops/generation/chat/openai/types/chat/chat_completion_chunk.py

@@ -16,8 +16,6 @@
 from dataclasses import dataclass
 from typing import List, Optional
 
-from typing_extensions import Literal
-
 from qwak.llmops.generation.base import ModelResponse
 from .chat_completion_token_logprob import ChatCompletionTokenLogprob
 
@@ -69,9 +67,16 @@ class ChoiceDeltaToolCall:
 
     function: Optional[ChoiceDeltaToolCallFunction] = None
 
-    type: Optional[Literal["function"]] = None
+    type: Optional[str] = None
     """The type of the tool. Currently, only `function` is supported."""
 
+    def __post_init__(self):
+        """Validates that type is 'function' if present."""
+        if self.type is not None and self.type != "function":
+            raise ValueError(
+                f"Invalid type: '{self.type}'. Must be 'function' or None."
+            )
+
 
 @dataclass
 class ChoiceDelta:
@@ -85,11 +90,21 @@ class ChoiceDelta:
     model.
     """
 
-    role: Optional[Literal["system", "user", "assistant", "tool"]] = None
+    role: Optional[str] = None
     """The role of the author of this message."""
 
     tool_calls: Optional[List[ChoiceDeltaToolCall]] = None
 
+    def __post_init__(self):
+        """Validates that role is one of the allowed values if present."""
+        if self.role is not None:
+            allowed_roles = {"system", "user", "assistant", "tool"}
+            if self.role not in allowed_roles:
+                raise ValueError(
+                    f"Invalid role: '{self.role}'. "
+                    f"Must be one of {allowed_roles} or None."
+                )
+
 
 @dataclass
 class ChoiceLogprobs:
@@ -105,9 +120,7 @@ class Choice:
     index: int
     """The index of the choice in the list of choices."""
 
-    finish_reason: Optional[
-        Literal["stop", "length", "tool_calls", "content_filter", "function_call"]
-    ] = None
+    finish_reason: Optional[str] = None
     """The reason the model stopped generating tokens.
 
     This will be `stop` if the model hit a natural stop point or a provided stop
@@ -120,6 +133,22 @@ class Choice:
     logprobs: Optional[ChoiceLogprobs] = None
     """Log probability information for the choice."""
 
+    def __post_init__(self):
+        """Validates that finish_reason is one of the allowed values if present."""
+        if self.finish_reason is not None:
+            allowed_reasons = {
+                "stop",
+                "length",
+                "tool_calls",
+                "content_filter",
+                "function_call",
+            }
+            if self.finish_reason not in allowed_reasons:
+                raise ValueError(
+                    f"Invalid finish_reason: '{self.finish_reason}'. "
+                    f"Must be one of {allowed_reasons} or None."
+                )
+
 
 @dataclass
 class ChatCompletionChunk(ModelResponse):
@@ -141,7 +170,7 @@ class ChatCompletionChunk(ModelResponse):
     model: str
     """The model to generate the completion."""
 
-    object: Literal["chat.completion.chunk"]
+    object: str
     """The object type, which is always `chat.completion.chunk`."""
 
     system_fingerprint: Optional[str] = None
@@ -150,3 +179,10 @@ class ChatCompletionChunk(ModelResponse):
     Can be used in conjunction with the `seed` request parameter to understand when
     backend changes have been made that might impact determinism.
     """
+
+    def __post_init__(self):
+        """Validates that the object type is correct."""
+        if self.object != "chat.completion.chunk":
+            raise ValueError(
+                f"Invalid object type: '{self.object}'. Must be 'chat.completion.chunk'"
+            )

qwak/llmops/generation/chat/openai/types/chat/chat_completion_message.py

@@ -16,8 +16,6 @@
 from dataclasses import dataclass
 from typing import List, Optional
 
-from typing_extensions import Literal
-
 from .chat_completion_message_tool_call import ChatCompletionMessageToolCall
 
 __all__ = ["ChatCompletionMessage", "FunctionCall"]
@@ -39,7 +37,7 @@ class FunctionCall:
 
 @dataclass
 class ChatCompletionMessage:
-    role: Literal["assistant"]
+    role: str
     """The role of the author of this message."""
 
     content: Optional[str] = None
@@ -54,3 +52,8 @@ class ChatCompletionMessage:
 
     tool_calls: Optional[List[ChatCompletionMessageToolCall]] = None
     """The tool calls generated by the model, such as function calls."""
+
+    def __post_init__(self):
+        """Validates that the role type is correct."""
+        if self.role != "assistant":
+            raise ValueError(f"Invalid object type: '{self.role}'. Must be 'assistant'")

{qwak_core-0.4.378.dist-info → qwak_core-0.5.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: qwak-core
-Version: 0.4.378
+Version: 0.5.4
 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
@@ -13,8 +13,6 @@ 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
@@ -22,7 +20,7 @@ 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: dacite (==1.9.2)
 Requires-Dist: dependency-injector (>=4.0)
 Requires-Dist: filelock
 Requires-Dist: grpcio (>=1.71.2)
@@ -32,11 +30,11 @@ 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: pyspark (==3.5.7) ; 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: retrying (==1.4.2)
 Requires-Dist: tqdm
 Requires-Dist: typeguard (>=2,<3)
 Requires-Dist: typer