gcore 0.3.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

gcore/types/cloud/inference/deployment_create_params.py

@@ -6,9 +6,7 @@ from typing import Dict, List, Iterable, Optional
 from typing_extensions import Required, Annotated, TypedDict
 
 from ...._utils import PropertyInfo
-from ..ingress_opts_param import IngressOptsParam
 from ..laas_index_retention_policy_param import LaasIndexRetentionPolicyParam
-from ..container_probe_config_create_param import ContainerProbeConfigCreateParam
 
 __all__ = [
     "DeploymentCreateParams",
@@ -21,8 +19,24 @@ __all__ = [
     "ContainerScaleTriggersHTTP",
     "ContainerScaleTriggersMemory",
     "ContainerScaleTriggersSqs",
+    "IngressOpts",
     "Logging",
     "Probes",
+    "ProbesLivenessProbe",
+    "ProbesLivenessProbeProbe",
+    "ProbesLivenessProbeProbeExec",
+    "ProbesLivenessProbeProbeHTTPGet",
+    "ProbesLivenessProbeProbeTcpSocket",
+    "ProbesReadinessProbe",
+    "ProbesReadinessProbeProbe",
+    "ProbesReadinessProbeProbeExec",
+    "ProbesReadinessProbeProbeHTTPGet",
+    "ProbesReadinessProbeProbeTcpSocket",
+    "ProbesStartupProbe",
+    "ProbesStartupProbeProbe",
+    "ProbesStartupProbeProbeExec",
+    "ProbesStartupProbeProbeHTTPGet",
+    "ProbesStartupProbeProbeTcpSocket",
 ]
 
 
@@ -50,11 +64,20 @@ class DeploymentCreateParams(TypedDict, total=False):
     name: Required[str]
     """Inference instance name."""
 
+    api_keys: List[str]
+    """List of API keys for the inference instance.
+
+    Multiple keys can be attached to one deployment.If `auth_enabled` and `api_keys`
+    are both specified, a ValidationError will be raised.
+    """
+
     auth_enabled: bool
     """Set to `true` to enable API key authentication for the inference instance.
 
     `"Authorization": "Bearer ****\\**"` or `"X-Api-Key": "****\\**"` header is required
-    for the requests to the instance if enabled
+    for the requests to the instance if enabled. This field is deprecated and will
+    be removed in the future. Use `api_keys` field instead.If `auth_enabled` and
+    `api_keys` are both specified, a ValidationError will be raised.
     """
 
     command: Optional[List[str]]
@@ -69,7 +92,7 @@ class DeploymentCreateParams(TypedDict, total=False):
     envs: Dict[str, str]
     """Environment variables for the inference instance."""
 
-    ingress_opts: Optional[IngressOptsParam]
+    ingress_opts: Optional[IngressOpts]
     """Ingress options for the inference instance"""
 
     logging: Optional[Logging]
@@ -197,6 +220,17 @@ class Container(TypedDict, total=False):
     """Scale for the container"""
 
 
+class IngressOpts(TypedDict, total=False):
+    disable_response_buffering: bool
+    """Disable response buffering if true.
+
+    A client usually has a much slower connection and can not consume the response
+    data as fast as it is produced by an upstream application. Ingress tries to
+    buffer the whole response in order to release the upstream application as soon
+    as possible.By default, the response buffering is enabled.
+    """
+
+
 class Logging(TypedDict, total=False):
     destination_region_id: Optional[int]
     """ID of the region in which the logs will be stored"""
@@ -211,12 +245,195 @@ class Logging(TypedDict, total=False):
     """The topic name to stream logs to"""
 
 
+class ProbesLivenessProbeProbeExec(TypedDict, total=False):
+    command: Required[List[str]]
+    """Command to be executed inside the running container."""
+
+
+class ProbesLivenessProbeProbeHTTPGet(TypedDict, total=False):
+    port: Required[int]
+    """Port number the probe should connect to."""
+
+    headers: Dict[str, str]
+    """HTTP headers to be sent with the request."""
+
+    host: Optional[str]
+    """Host name to send HTTP request to."""
+
+    path: str
+    """The endpoint to send the HTTP request to."""
+
+    schema: str
+    """Schema to use for the HTTP request."""
+
+
+class ProbesLivenessProbeProbeTcpSocket(TypedDict, total=False):
+    port: Required[int]
+    """Port number to check if it's open."""
+
+
+class ProbesLivenessProbeProbe(TypedDict, total=False):
+    exec: Optional[ProbesLivenessProbeProbeExec]
+    """Exec probe configuration"""
+
+    failure_threshold: int
+    """The number of consecutive probe failures that mark the container as unhealthy."""
+
+    http_get: Optional[ProbesLivenessProbeProbeHTTPGet]
+    """HTTP GET probe configuration"""
+
+    initial_delay_seconds: int
+    """The initial delay before starting the first probe."""
+
+    period_seconds: int
+    """How often (in seconds) to perform the probe."""
+
+    success_threshold: int
+    """The number of consecutive successful probes that mark the container as healthy."""
+
+    tcp_socket: Optional[ProbesLivenessProbeProbeTcpSocket]
+    """TCP socket probe configuration"""
+
+    timeout_seconds: int
+    """The timeout for each probe."""
+
+
+class ProbesLivenessProbe(TypedDict, total=False):
+    enabled: Required[bool]
+    """Whether the probe is enabled or not."""
+
+    probe: ProbesLivenessProbeProbe
+    """Probe configuration (exec, `http_get` or `tcp_socket`)"""
+
+
+class ProbesReadinessProbeProbeExec(TypedDict, total=False):
+    command: Required[List[str]]
+    """Command to be executed inside the running container."""
+
+
+class ProbesReadinessProbeProbeHTTPGet(TypedDict, total=False):
+    port: Required[int]
+    """Port number the probe should connect to."""
+
+    headers: Dict[str, str]
+    """HTTP headers to be sent with the request."""
+
+    host: Optional[str]
+    """Host name to send HTTP request to."""
+
+    path: str
+    """The endpoint to send the HTTP request to."""
+
+    schema: str
+    """Schema to use for the HTTP request."""
+
+
+class ProbesReadinessProbeProbeTcpSocket(TypedDict, total=False):
+    port: Required[int]
+    """Port number to check if it's open."""
+
+
+class ProbesReadinessProbeProbe(TypedDict, total=False):
+    exec: Optional[ProbesReadinessProbeProbeExec]
+    """Exec probe configuration"""
+
+    failure_threshold: int
+    """The number of consecutive probe failures that mark the container as unhealthy."""
+
+    http_get: Optional[ProbesReadinessProbeProbeHTTPGet]
+    """HTTP GET probe configuration"""
+
+    initial_delay_seconds: int
+    """The initial delay before starting the first probe."""
+
+    period_seconds: int
+    """How often (in seconds) to perform the probe."""
+
+    success_threshold: int
+    """The number of consecutive successful probes that mark the container as healthy."""
+
+    tcp_socket: Optional[ProbesReadinessProbeProbeTcpSocket]
+    """TCP socket probe configuration"""
+
+    timeout_seconds: int
+    """The timeout for each probe."""
+
+
+class ProbesReadinessProbe(TypedDict, total=False):
+    enabled: Required[bool]
+    """Whether the probe is enabled or not."""
+
+    probe: ProbesReadinessProbeProbe
+    """Probe configuration (exec, `http_get` or `tcp_socket`)"""
+
+
+class ProbesStartupProbeProbeExec(TypedDict, total=False):
+    command: Required[List[str]]
+    """Command to be executed inside the running container."""
+
+
+class ProbesStartupProbeProbeHTTPGet(TypedDict, total=False):
+    port: Required[int]
+    """Port number the probe should connect to."""
+
+    headers: Dict[str, str]
+    """HTTP headers to be sent with the request."""
+
+    host: Optional[str]
+    """Host name to send HTTP request to."""
+
+    path: str
+    """The endpoint to send the HTTP request to."""
+
+    schema: str
+    """Schema to use for the HTTP request."""
+
+
+class ProbesStartupProbeProbeTcpSocket(TypedDict, total=False):
+    port: Required[int]
+    """Port number to check if it's open."""
+
+
+class ProbesStartupProbeProbe(TypedDict, total=False):
+    exec: Optional[ProbesStartupProbeProbeExec]
+    """Exec probe configuration"""
+
+    failure_threshold: int
+    """The number of consecutive probe failures that mark the container as unhealthy."""
+
+    http_get: Optional[ProbesStartupProbeProbeHTTPGet]
+    """HTTP GET probe configuration"""
+
+    initial_delay_seconds: int
+    """The initial delay before starting the first probe."""
+
+    period_seconds: int
+    """How often (in seconds) to perform the probe."""
+
+    success_threshold: int
+    """The number of consecutive successful probes that mark the container as healthy."""
+
+    tcp_socket: Optional[ProbesStartupProbeProbeTcpSocket]
+    """TCP socket probe configuration"""
+
+    timeout_seconds: int
+    """The timeout for each probe."""
+
+
+class ProbesStartupProbe(TypedDict, total=False):
+    enabled: Required[bool]
+    """Whether the probe is enabled or not."""
+
+    probe: ProbesStartupProbeProbe
+    """Probe configuration (exec, `http_get` or `tcp_socket`)"""
+
+
 class Probes(TypedDict, total=False):
-    liveness_probe: Optional[ContainerProbeConfigCreateParam]
+    liveness_probe: Optional[ProbesLivenessProbe]
     """Liveness probe configuration"""
 
-    readiness_probe: Optional[ContainerProbeConfigCreateParam]
+    readiness_probe: Optional[ProbesReadinessProbe]
     """Readiness probe configuration"""
 
-    startup_probe: Optional[ContainerProbeConfigCreateParam]
+    startup_probe: Optional[ProbesStartupProbe]
     """Startup probe configuration"""

gcore/types/cloud/inference/deployment_update_params.py

@@ -6,7 +6,6 @@ from typing import Dict, List, Iterable, Optional
 from typing_extensions import Required, Annotated, TypedDict
 
 from ...._utils import PropertyInfo
-from ..ingress_opts_param import IngressOptsParam
 from ..laas_index_retention_policy_param import LaasIndexRetentionPolicyParam
 
 __all__ = [
@@ -20,6 +19,7 @@ __all__ = [
     "ContainerScaleTriggersHTTP",
     "ContainerScaleTriggersMemory",
     "ContainerScaleTriggersSqs",
+    "IngressOpts",
     "Logging",
     "Probes",
     "ProbesLivenessProbe",
@@ -44,11 +44,21 @@ class DeploymentUpdateParams(TypedDict, total=False):
     project_id: int
     """Project ID"""
 
+    api_keys: Optional[List[str]]
+    """List of API keys for the inference instance.
+
+    Multiple keys can be attached to one deployment.If `auth_enabled` and `api_keys`
+    are both specified, a ValidationError will be raised.If `[]` is provided, the
+    API keys will be removed and auth will be disabled on the deployment.
+    """
+
     auth_enabled: bool
     """Set to `true` to enable API key authentication for the inference instance.
 
     `"Authorization": "Bearer ****\\**"` or `"X-Api-Key": "****\\**"` header is required
-    for the requests to the instance if enabled
+    for the requests to the instance if enabled. This field is deprecated and will
+    be removed in the future. Use `api_keys` field instead.If `auth_enabled` and
+    `api_keys` are both specified, a ValidationError will be raised.
     """
 
     command: Optional[List[str]]
@@ -77,7 +87,7 @@ class DeploymentUpdateParams(TypedDict, total=False):
     accessible Docker image URL can be specified.
     """
 
-    ingress_opts: Optional[IngressOptsParam]
+    ingress_opts: Optional[IngressOpts]
     """Ingress options for the inference instance"""
 
     listening_port: Optional[int]
@@ -204,6 +214,17 @@ class Container(TypedDict, total=False):
     """Scale for the container"""
 
 
+class IngressOpts(TypedDict, total=False):
+    disable_response_buffering: bool
+    """Disable response buffering if true.
+
+    A client usually has a much slower connection and can not consume the response
+    data as fast as it is produced by an upstream application. Ingress tries to
+    buffer the whole response in order to release the upstream application as soon
+    as possible.By default, the response buffering is enabled.
+    """
+
+
 class Logging(TypedDict, total=False):
     destination_region_id: Optional[int]
     """ID of the region in which the logs will be stored"""

gcore/types/cloud/inference/deployments/__init__.py

@@ -3,3 +3,4 @@
 from __future__ import annotations
 
 from .log_list_params import LogListParams as LogListParams
+from .inference_deployment_log import InferenceDeploymentLog as InferenceDeploymentLog

gcore/types/cloud/inference/{inference_log.py → deployments/inference_deployment_log.py}

@@ -2,12 +2,12 @@
 
 from datetime import datetime
 
-from ...._models import BaseModel
+from ....._models import BaseModel
 
-__all__ = ["InferenceLog"]
+__all__ = ["InferenceDeploymentLog"]
 
 
-class InferenceLog(BaseModel):
+class InferenceDeploymentLog(BaseModel):
     message: str
     """Log message."""
 

gcore/types/cloud/inference/inference_deployment.py

@@ -0,0 +1,266 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, List, Optional
+from typing_extensions import Literal
+
+from ..logging import Logging
+from ...._models import BaseModel
+from .probe_config import ProbeConfig
+
+__all__ = [
+    "InferenceDeployment",
+    "Container",
+    "ContainerDeployStatus",
+    "ContainerScale",
+    "ContainerScaleTriggers",
+    "ContainerScaleTriggersCPU",
+    "ContainerScaleTriggersGPUMemory",
+    "ContainerScaleTriggersGPUUtilization",
+    "ContainerScaleTriggersHTTP",
+    "ContainerScaleTriggersMemory",
+    "ContainerScaleTriggersSqs",
+    "IngressOpts",
+    "ObjectReference",
+    "Probes",
+]
+
+
+class ContainerDeployStatus(BaseModel):
+    ready: int
+    """Number of ready instances"""
+
+    total: int
+    """Total number of instances"""
+
+
+class ContainerScaleTriggersCPU(BaseModel):
+    threshold: int
+    """Threshold value for the trigger in percentage"""
+
+
+class ContainerScaleTriggersGPUMemory(BaseModel):
+    threshold: int
+    """Threshold value for the trigger in percentage"""
+
+
+class ContainerScaleTriggersGPUUtilization(BaseModel):
+    threshold: int
+    """Threshold value for the trigger in percentage"""
+
+
+class ContainerScaleTriggersHTTP(BaseModel):
+    rate: int
+    """Request count per 'window' seconds for the http trigger"""
+
+    window: int
+    """Time window for rate calculation in seconds"""
+
+
+class ContainerScaleTriggersMemory(BaseModel):
+    threshold: int
+    """Threshold value for the trigger in percentage"""
+
+
+class ContainerScaleTriggersSqs(BaseModel):
+    activation_queue_length: int
+    """Number of messages for activation"""
+
+    aws_endpoint: Optional[str] = None
+    """Custom AWS endpoint"""
+
+    aws_region: str
+    """AWS region"""
+
+    queue_length: int
+    """Number of messages for one replica"""
+
+    queue_url: str
+    """SQS queue URL"""
+
+    scale_on_delayed: bool
+    """Scale on delayed messages"""
+
+    scale_on_flight: bool
+    """Scale on in-flight messages"""
+
+    secret_name: str
+    """Auth secret name"""
+
+
+class ContainerScaleTriggers(BaseModel):
+    cpu: Optional[ContainerScaleTriggersCPU] = None
+    """CPU trigger configuration"""
+
+    gpu_memory: Optional[ContainerScaleTriggersGPUMemory] = None
+    """GPU memory trigger configuration.
+
+    Calculated by `DCGM_FI_DEV_MEM_COPY_UTIL` metric
+    """
+
+    gpu_utilization: Optional[ContainerScaleTriggersGPUUtilization] = None
+    """GPU utilization trigger configuration.
+
+    Calculated by `DCGM_FI_DEV_GPU_UTIL` metric
+    """
+
+    http: Optional[ContainerScaleTriggersHTTP] = None
+    """HTTP trigger configuration"""
+
+    memory: Optional[ContainerScaleTriggersMemory] = None
+    """Memory trigger configuration"""
+
+    sqs: Optional[ContainerScaleTriggersSqs] = None
+    """SQS trigger configuration"""
+
+
+class ContainerScale(BaseModel):
+    cooldown_period: Optional[int] = None
+    """Cooldown period between scaling actions in seconds"""
+
+    max: int
+    """Maximum scale for the container"""
+
+    min: int
+    """Minimum scale for the container"""
+
+    polling_interval: Optional[int] = None
+    """Polling interval for scaling triggers in seconds"""
+
+    triggers: ContainerScaleTriggers
+    """Triggers for scaling actions"""
+
+
+class Container(BaseModel):
+    address: Optional[str] = None
+    """Address of the inference instance"""
+
+    deploy_status: ContainerDeployStatus
+    """Status of the containers deployment"""
+
+    error_message: Optional[str] = None
+    """Error message if the container deployment failed"""
+
+    region_id: int
+    """Region name for the container"""
+
+    scale: ContainerScale
+    """Scale for the container"""
+
+
+class IngressOpts(BaseModel):
+    disable_response_buffering: bool
+    """Disable response buffering if true.
+
+    A client usually has a much slower connection and can not consume the response
+    data as fast as it is produced by an upstream application. Ingress tries to
+    buffer the whole response in order to release the upstream application as soon
+    as possible.By default, the response buffering is enabled.
+    """
+
+
+class ObjectReference(BaseModel):
+    kind: Literal["AppDeployment"]
+    """Kind of the inference object to be referenced"""
+
+    name: str
+    """Name of the inference object to be referenced"""
+
+
+class Probes(BaseModel):
+    liveness_probe: Optional[ProbeConfig] = None
+    """Liveness probe configuration"""
+
+    readiness_probe: Optional[ProbeConfig] = None
+    """Readiness probe configuration"""
+
+    startup_probe: Optional[ProbeConfig] = None
+    """Startup probe configuration"""
+
+
+class InferenceDeployment(BaseModel):
+    address: Optional[str] = None
+    """Address of the inference instance"""
+
+    auth_enabled: bool
+    """`true` if instance uses API key authentication.
+
+    `"Authorization": "Bearer ****\\**"` or `"X-Api-Key": "****\\**"` header is required
+    for the requests to the instance if enabled.
+    """
+
+    command: Optional[str] = None
+    """Command to be executed when running a container from an image."""
+
+    containers: List[Container]
+    """List of containers for the inference instance"""
+
+    created_at: Optional[str] = None
+    """Inference instance creation date in ISO 8601 format."""
+
+    credentials_name: str
+    """Registry credentials name"""
+
+    description: str
+    """Inference instance description."""
+
+    envs: Optional[Dict[str, str]] = None
+    """Environment variables for the inference instance"""
+
+    flavor_name: str
+    """Flavor name for the inference instance"""
+
+    image: str
+    """Docker image for the inference instance.
+
+    This field should contain the image name and tag in the format 'name:tag', e.g.,
+    'nginx:latest'. It defaults to Docker Hub as the image registry, but any
+    accessible Docker image URL can be specified.
+    """
+
+    ingress_opts: Optional[IngressOpts] = None
+    """Ingress options for the inference instance"""
+
+    listening_port: int
+    """Listening port for the inference instance."""
+
+    logging: Optional[Logging] = None
+    """Logging configuration for the inference instance"""
+
+    name: str
+    """Inference instance name."""
+
+    object_references: List[ObjectReference]
+    """Indicates to which parent object this inference belongs to."""
+
+    probes: Optional[Probes] = None
+    """Probes configured for all containers of the inference instance."""
+
+    project_id: int
+    """Project ID. If not provided, your default project ID will be used."""
+
+    status: Literal["ACTIVE", "DELETING", "DEPLOYING", "DISABLED", "PARTIALLYDEPLOYED", "PENDING"]
+    """Inference instance status. Value can be one of the following:
+
+    - `DEPLOYING` - The instance is being deployed. Containers are not yet created.
+    - `PARTIALLYDEPLOYED` - All containers have been created, but some may not be
+      ready yet. Instances stuck in this state typically indicate either image being
+      pulled, or a failure of some kind. In the latter case, the `error_message`
+      field of the respective container object in the `containers` collection
+      explains the failure reason.
+    - `ACTIVE` - The instance is running and ready to accept requests.
+    - `DISABLED` - The instance is disabled and not accepting any requests.
+    - `PENDING` - The instance is running but scaled to zero. It will be
+      automatically scaled up when a request is made.
+    - `DELETING` - The instance is being deleted.
+    """
+
+    timeout: Optional[int] = None
+    """
+    Specifies the duration in seconds without any requests after which the
+    containers will be downscaled to their minimum scale value as defined by
+    `scale.min`. If set, this helps in optimizing resource usage by reducing the
+    number of container instances during periods of inactivity.
+    """
+
+    api_keys: Optional[List[str]] = None
+    """List of API keys for the inference instance"""

gcore/types/cloud/inference/{inference_apikey_secret.py → inference_deployment_api_key.py}

@@ -4,10 +4,10 @@ from typing_extensions import Literal
 
 from ...._models import BaseModel
 
-__all__ = ["InferenceApikeySecret"]
+__all__ = ["InferenceDeploymentAPIKey"]
 
 
-class InferenceApikeySecret(BaseModel):
+class InferenceDeploymentAPIKey(BaseModel):
     secret: str
     """API key secret"""
 

gcore/types/cloud/inference/{mlcatalog_model_card.py → inference_model.py}

@@ -6,10 +6,10 @@ from pydantic import Field as FieldInfo
 
 from ...._models import BaseModel
 
-__all__ = ["MlcatalogModelCard"]
+__all__ = ["InferenceModel"]
 
 
-class MlcatalogModelCard(BaseModel):
+class InferenceModel(BaseModel):
     id: str
     """Model ID."""
 

gcore/types/cloud/inference/{inference_registry_credential.py → inference_registry_credentials.py}

@@ -2,10 +2,10 @@
 
 from ...._models import BaseModel
 
-__all__ = ["InferenceRegistryCredential"]
+__all__ = ["InferenceRegistryCredentials"]
 
 
-class InferenceRegistryCredential(BaseModel):
+class InferenceRegistryCredentials(BaseModel):
     name: str
     """Registry credential name."""
 

gcore/types/cloud/inference/{inference_registry_credential_full.py → inference_registry_credentials_create.py}

@@ -2,10 +2,10 @@
 
 from ...._models import BaseModel
 
-__all__ = ["InferenceRegistryCredentialFull"]
+__all__ = ["InferenceRegistryCredentialsCreate"]
 
 
-class InferenceRegistryCredentialFull(BaseModel):
+class InferenceRegistryCredentialsCreate(BaseModel):
     name: str
     """Registry credential name."""