gcore 0.1.0a2__py3-none-any.whl → 0.2.0__py3-none-any.whl

gcore/types/cloud/inference/deployment_update_params.py

@@ -8,7 +8,6 @@ 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__ = [
     "DeploymentUpdateParams",
@@ -23,6 +22,21 @@ __all__ = [
     "ContainerScaleTriggersSqs",
     "Logging",
     "Probes",
+    "ProbesLivenessProbe",
+    "ProbesLivenessProbeProbe",
+    "ProbesLivenessProbeProbeExec",
+    "ProbesLivenessProbeProbeHTTPGet",
+    "ProbesLivenessProbeProbeTcpSocket",
+    "ProbesReadinessProbe",
+    "ProbesReadinessProbeProbe",
+    "ProbesReadinessProbeProbeExec",
+    "ProbesReadinessProbeProbeHTTPGet",
+    "ProbesReadinessProbeProbeTcpSocket",
+    "ProbesStartupProbe",
+    "ProbesStartupProbeProbe",
+    "ProbesStartupProbeProbeExec",
+    "ProbesStartupProbeProbeHTTPGet",
+    "ProbesStartupProbeProbeTcpSocket",
 ]
 
 
@@ -30,7 +44,7 @@ class DeploymentUpdateParams(TypedDict, total=False):
     project_id: int
     """Project ID"""
 
-    auth_enabled: Optional[bool]
+    auth_enabled: bool
     """Set to `true` to enable API key authentication for the inference instance.
 
     `"Authorization": "Bearer *****"` or `"X-Api-Key": "*****"` header is required
@@ -52,7 +66,7 @@ class DeploymentUpdateParams(TypedDict, total=False):
     envs: Optional[Dict[str, str]]
     """Environment variables for the inference instance."""
 
-    flavor_name: Optional[str]
+    flavor_name: str
     """Flavor name for the inference instance."""
 
     image: Optional[str]
@@ -204,12 +218,195 @@ class Logging(TypedDict, total=False):
     """The topic name to stream logs to"""
 
 
+class ProbesLivenessProbeProbeExec(TypedDict, total=False):
+    command: List[str]
+    """Command to be executed inside the running container."""
+
+
+class ProbesLivenessProbeProbeHTTPGet(TypedDict, total=False):
+    headers: Dict[str, str]
+    """HTTP headers to be sent with the request."""
+
+    host: str
+    """Host name to send HTTP request to."""
+
+    path: str
+    """The endpoint to send the HTTP request to."""
+
+    port: int
+    """Port number the probe should connect to."""
+
+    schema: str
+    """Schema to use for the HTTP request."""
+
+
+class ProbesLivenessProbeProbeTcpSocket(TypedDict, total=False):
+    port: 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: bool
+    """Whether the probe is enabled or not."""
+
+    probe: ProbesLivenessProbeProbe
+    """Probe configuration (exec, http_get or tcp_socket)"""
+
+
+class ProbesReadinessProbeProbeExec(TypedDict, total=False):
+    command: List[str]
+    """Command to be executed inside the running container."""
+
+
+class ProbesReadinessProbeProbeHTTPGet(TypedDict, total=False):
+    headers: Dict[str, str]
+    """HTTP headers to be sent with the request."""
+
+    host: str
+    """Host name to send HTTP request to."""
+
+    path: str
+    """The endpoint to send the HTTP request to."""
+
+    port: int
+    """Port number the probe should connect to."""
+
+    schema: str
+    """Schema to use for the HTTP request."""
+
+
+class ProbesReadinessProbeProbeTcpSocket(TypedDict, total=False):
+    port: 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: bool
+    """Whether the probe is enabled or not."""
+
+    probe: ProbesReadinessProbeProbe
+    """Probe configuration (exec, http_get or tcp_socket)"""
+
+
+class ProbesStartupProbeProbeExec(TypedDict, total=False):
+    command: List[str]
+    """Command to be executed inside the running container."""
+
+
+class ProbesStartupProbeProbeHTTPGet(TypedDict, total=False):
+    headers: Dict[str, str]
+    """HTTP headers to be sent with the request."""
+
+    host: str
+    """Host name to send HTTP request to."""
+
+    path: str
+    """The endpoint to send the HTTP request to."""
+
+    port: int
+    """Port number the probe should connect to."""
+
+    schema: str
+    """Schema to use for the HTTP request."""
+
+
+class ProbesStartupProbeProbeTcpSocket(TypedDict, total=False):
+    port: 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: 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/inference.py

@@ -70,7 +70,7 @@ class Inference(BaseModel):
     project_id: int
     """Project ID. If not provided, your default project ID will be used."""
 
-    status: Literal["ACTIVE", "DELETING", "DEPLOYING", "DISABLED", "PARTIALLYDEPLOYED"]
+    status: Literal["ACTIVE", "DELETING", "DEPLOYING", "DISABLED", "PARTIALLYDEPLOYED", "PENDING"]
     """Inference instance status.
 
     Value can be one of the following:
@@ -83,6 +83,8 @@ class Inference(BaseModel):
       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.
     """
 

gcore/types/cloud/load_balancer_listener_detail.py

@@ -23,21 +23,33 @@ class LoadBalancerListenerDetail(BaseModel):
     id: str
     """Load balancer listener ID"""
 
+    allowed_cidrs: Optional[List[str]] = None
+    """Network CIDRs from which service will be accessible"""
+
     connection_limit: int
     """Limit of simultaneous connections"""
 
+    creator_task_id: Optional[str] = None
+    """Task that created this entity"""
+
     insert_headers: object
     """Dictionary of additional header insertion into HTTP headers.
 
     Only used with HTTP and TERMINATED_HTTPS protocols.
     """
 
+    loadbalancer_id: Optional[str] = None
+    """Load balancer ID"""
+
     name: str
     """Load balancer listener name"""
 
     operating_status: LoadBalancerOperatingStatus
     """Listener operating status"""
 
+    pool_count: Optional[int] = None
+    """Number of pools (for UI)"""
+
     protocol: LbListenerProtocol
     """Load balancer protocol"""
 
@@ -47,18 +59,6 @@ class LoadBalancerListenerDetail(BaseModel):
     provisioning_status: ProvisioningStatus
     """Listener lifecycle status"""
 
-    allowed_cidrs: Optional[List[str]] = None
-    """Network CIDRs from which service will be accessible"""
-
-    creator_task_id: Optional[str] = None
-    """Task that created this entity"""
-
-    loadbalancer_id: Optional[str] = None
-    """Load balancer ID"""
-
-    pool_count: Optional[int] = None
-    """Number of pools (for UI)"""
-
     secret_id: Optional[str] = None
     """
     ID of the secret where PKCS12 file is stored for TERMINATED_HTTPS or PROMETHEUS
@@ -93,5 +93,5 @@ class LoadBalancerListenerDetail(BaseModel):
     timeout_member_data: Optional[int] = None
     """Backend member inactivity timeout in milliseconds"""
 
-    user_list: Optional[List[UserList]] = None
+    user_list: List[UserList]
     """Load balancer listener users list"""

gcore/types/cloud/load_balancer_pool.py

@@ -31,9 +31,15 @@ class LoadBalancerPool(BaseModel):
     ca_secret_id: Optional[str] = None
     """Secret ID of CA certificate bundle"""
 
+    creator_task_id: Optional[str] = None
+    """Task that created this entity"""
+
     crl_secret_id: Optional[str] = None
     """Secret ID of CA revocation list file"""
 
+    healthmonitor: Optional[HealthMonitor] = None
+    """Health monitor parameters"""
+
     lb_algorithm: LbAlgorithm
     """Load balancer algorithm"""
 
@@ -64,6 +70,13 @@ class LoadBalancerPool(BaseModel):
     session_persistence: Optional[SessionPersistence] = None
     """Session persistence parameters"""
 
+    task_id: Optional[str] = None
+    """The UUID of the active task that currently holds a lock on the resource.
+
+    This lock prevents concurrent modifications to ensure consistency. If `null`,
+    the resource is not locked.
+    """
+
     timeout_client_data: Optional[int] = None
     """Frontend client inactivity timeout in milliseconds"""
 
@@ -72,16 +85,3 @@ class LoadBalancerPool(BaseModel):
 
     timeout_member_data: Optional[int] = None
     """Backend member inactivity timeout in milliseconds"""
-
-    creator_task_id: Optional[str] = None
-    """Task that created this entity"""
-
-    healthmonitor: Optional[HealthMonitor] = None
-    """Health monitor parameters"""
-
-    task_id: Optional[str] = None
-    """The UUID of the active task that currently holds a lock on the resource.
-
-    This lock prevents concurrent modifications to ensure consistency. If `null`,
-    the resource is not locked.
-    """

gcore/types/cloud/load_balancer_pool_list.py

@@ -1,16 +1,111 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-from typing import List
+from typing import List, Union, Optional
+from typing_extensions import TypeAlias
 
+from .member import Member
 from ..._models import BaseModel
-from .load_balancer_pool import LoadBalancerPool
+from .lb_algorithm import LbAlgorithm
+from .health_monitor import HealthMonitor
+from .lb_pool_protocol import LbPoolProtocol
+from .provisioning_status import ProvisioningStatus
+from .session_persistence import SessionPersistence
+from .load_balancer_operating_status import LoadBalancerOperatingStatus
 
-__all__ = ["LoadBalancerPoolList"]
+__all__ = [
+    "LoadBalancerPoolList",
+    "Result",
+    "ResultListener",
+    "ResultLoadbalancer",
+    "ResultMember",
+    "ResultMemberLbPoolMemberSerializer",
+]
+
+
+class ResultListener(BaseModel):
+    id: str
+    """Resource ID"""
+
+
+class ResultLoadbalancer(BaseModel):
+    id: str
+    """Resource ID"""
+
+
+class ResultMemberLbPoolMemberSerializer(BaseModel):
+    id: str
+    """Member ID must be provided if an existing member is being updated"""
+
+
+ResultMember: TypeAlias = Union[ResultMemberLbPoolMemberSerializer, Member]
+
+
+class Result(BaseModel):
+    id: str
+    """Pool ID"""
+
+    ca_secret_id: Optional[str] = None
+    """Secret ID of CA certificate bundle"""
+
+    creator_task_id: Optional[str] = None
+    """Task that created this entity"""
+
+    crl_secret_id: Optional[str] = None
+    """Secret ID of CA revocation list file"""
+
+    healthmonitor: Optional[HealthMonitor] = None
+    """Health monitor parameters"""
+
+    lb_algorithm: LbAlgorithm
+    """Load balancer algorithm"""
+
+    listeners: List[ResultListener]
+    """Listeners IDs"""
+
+    loadbalancers: List[ResultLoadbalancer]
+    """Load balancers IDs"""
+
+    members: List[ResultMember]
+    """Pool members"""
+
+    name: str
+    """Pool name"""
+
+    operating_status: LoadBalancerOperatingStatus
+    """Pool operating status"""
+
+    protocol: LbPoolProtocol
+    """Protocol"""
+
+    provisioning_status: ProvisioningStatus
+    """Pool lifecycle status"""
+
+    secret_id: Optional[str] = None
+    """Secret ID for TLS client authentication to the member servers"""
+
+    session_persistence: Optional[SessionPersistence] = None
+    """Session persistence parameters"""
+
+    task_id: Optional[str] = None
+    """The UUID of the active task that currently holds a lock on the resource.
+
+    This lock prevents concurrent modifications to ensure consistency. If `null`,
+    the resource is not locked.
+    """
+
+    timeout_client_data: Optional[int] = None
+    """Frontend client inactivity timeout in milliseconds"""
+
+    timeout_member_connect: Optional[int] = None
+    """Backend member connection timeout in milliseconds"""
+
+    timeout_member_data: Optional[int] = None
+    """Backend member inactivity timeout in milliseconds"""
 
 
 class LoadBalancerPoolList(BaseModel):
     count: int
     """Number of objects"""
 
-    results: List[LoadBalancerPool]
+    results: List[Result]
     """Objects"""

gcore/types/cloud/load_balancers/listener_create_params.py

@@ -12,8 +12,10 @@ __all__ = ["ListenerCreateParams", "UserList"]
 
 class ListenerCreateParams(TypedDict, total=False):
     project_id: int
+    """Project ID"""
 
     region_id: int
+    """Region ID"""
 
     loadbalancer_id: Required[str]
     """Load balancer ID"""

gcore/types/cloud/load_balancers/listener_get_params.py

@@ -9,8 +9,10 @@ __all__ = ["ListenerGetParams"]
 
 class ListenerGetParams(TypedDict, total=False):
     project_id: int
+    """Project ID"""
 
     region_id: int
+    """Region ID"""
 
     show_stats: bool
-    """Show statistics"""
+    """Show stats"""

gcore/types/cloud/load_balancers/listener_list_params.py

@@ -9,11 +9,13 @@ __all__ = ["ListenerListParams"]
 
 class ListenerListParams(TypedDict, total=False):
     project_id: int
+    """Project ID"""
 
     region_id: int
+    """Region ID"""
 
     loadbalancer_id: str
-    """Load balancer ID"""
+    """Load Balancer ID"""
 
     show_stats: bool
-    """Show statistics"""
+    """Show stats"""

gcore/types/cloud/load_balancers/listener_update_params.py

@@ -10,8 +10,10 @@ __all__ = ["ListenerUpdateParams", "UserList"]
 
 class ListenerUpdateParams(TypedDict, total=False):
     project_id: int
+    """Project ID"""
 
     region_id: int
+    """Region ID"""
 
     allowed_cidrs: Optional[List[str]]
     """Network CIDRs from which service will be accessible"""

gcore/types/cloud/load_balancers/pool_create_params.py

@@ -16,8 +16,10 @@ __all__ = ["PoolCreateParams", "Healthmonitor", "Member", "SessionPersistence"]
 
 class PoolCreateParams(TypedDict, total=False):
     project_id: int
+    """Project ID"""
 
     region_id: int
+    """Region ID"""
 
     lb_algorithm: Required[LbAlgorithm]
     """Load balancer algorithm"""

gcore/types/cloud/load_balancers/pool_list_params.py

@@ -9,17 +9,16 @@ __all__ = ["PoolListParams"]
 
 class PoolListParams(TypedDict, total=False):
     project_id: int
+    """Project ID"""
 
     region_id: int
+    """Region ID"""
 
     details: bool
-    """
-    If true, show member and healthmonitor details of each pool (increases request
-    time)
-    """
+    """Show members and Health Monitor details"""
 
     listener_id: str
-    """Load balancer listener ID"""
+    """Listener ID"""
 
     loadbalancer_id: str
-    """Load balancer ID"""
+    """Load Balancer ID"""

gcore/types/cloud/load_balancers/pool_update_params.py

@@ -16,8 +16,10 @@ __all__ = ["PoolUpdateParams", "Healthmonitor", "Member", "SessionPersistence"]
 
 class PoolUpdateParams(TypedDict, total=False):
     project_id: int
+    """Project ID"""
 
     region_id: int
+    """Region ID"""
 
     ca_secret_id: Optional[str]
     """Secret ID of CA certificate bundle"""

gcore/types/cloud/load_balancers/pools/health_monitor_create_params.py

@@ -14,8 +14,10 @@ __all__ = ["HealthMonitorCreateParams"]
 
 class HealthMonitorCreateParams(TypedDict, total=False):
     project_id: int
+    """Project ID"""
 
     region_id: int
+    """Region ID"""
 
     delay: Required[int]
     """The time, in seconds, between sending probes to members"""

gcore/types/cloud/load_balancers/pools/member_add_params.py

@@ -10,8 +10,10 @@ __all__ = ["MemberAddParams"]
 
 class MemberAddParams(TypedDict, total=False):
     project_id: int
+    """Project ID"""
 
     region_id: int
+    """Region ID"""
 
     address: Required[str]
     """Member IP address"""

gcore/types/cloud/network.py

@@ -16,9 +16,18 @@ class Network(BaseModel):
     created_at: datetime
     """Datetime when the network was created"""
 
+    creator_task_id: Optional[str] = None
+    """Task that created this entity"""
+
+    default: Optional[bool] = None
+    """True if network has is_default attribute"""
+
     external: bool
     """True if the network `router:external` attribute"""
 
+    mtu: int
+    """MTU (maximum transmission unit). Default value is 1450"""
+
     name: str
     """Network name"""
 
@@ -28,12 +37,18 @@ class Network(BaseModel):
     ports.
     """
 
+    project_id: Optional[int] = None
+    """Project ID"""
+
     region: str
     """Region name"""
 
     region_id: int
     """Region ID"""
 
+    segmentation_id: Optional[int] = None
+    """Id of network segment"""
+
     shared: bool
     """True when the network is shared with your project by external owner"""
 
@@ -50,30 +65,15 @@ class Network(BaseModel):
     values.
     """
 
-    type: str
-    """Network type (vlan, vxlan)"""
-
-    updated_at: datetime
-    """Datetime when the network was last updated"""
-
-    creator_task_id: Optional[str] = None
-    """Task that created this entity"""
-
-    default: Optional[bool] = None
-    """True if network has is_default attribute"""
-
-    mtu: Optional[int] = None
-    """MTU (maximum transmission unit). Default value is 1450"""
-
-    project_id: Optional[int] = None
-    """Project ID"""
-
-    segmentation_id: Optional[int] = None
-    """Id of network segment"""
-
     task_id: Optional[str] = None
     """The UUID of the active task that currently holds a lock on the resource.
 
     This lock prevents concurrent modifications to ensure consistency. If `null`,
     the resource is not locked.
     """
+
+    type: str
+    """Network type (vlan, vxlan)"""
+
+    updated_at: datetime
+    """Datetime when the network was last updated"""