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

gcore/_client.py

@@ -32,6 +32,7 @@ from .resources.iam import iam
 from .resources.waap import waap
 from .resources.cloud import cloud
 from .resources.fastedge import fastedge
+from .resources.streaming import streaming
 
 __all__ = ["Timeout", "Transport", "ProxiesTypes", "RequestOptions", "Gcore", "AsyncGcore", "Client", "AsyncClient"]
 
@@ -41,6 +42,7 @@ class Gcore(SyncAPIClient):
     waap: waap.WaapResource
     iam: iam.IamResource
     fastedge: fastedge.FastedgeResource
+    streaming: streaming.StreamingResource
     with_raw_response: GcoreWithRawResponse
     with_streaming_response: GcoreWithStreamedResponse
 
@@ -123,6 +125,7 @@ class Gcore(SyncAPIClient):
         self.waap = waap.WaapResource(self)
         self.iam = iam.IamResource(self)
         self.fastedge = fastedge.FastedgeResource(self)
+        self.streaming = streaming.StreamingResource(self)
         self.with_raw_response = GcoreWithRawResponse(self)
         self.with_streaming_response = GcoreWithStreamedResponse(self)
 
@@ -260,6 +263,7 @@ class AsyncGcore(AsyncAPIClient):
     waap: waap.AsyncWaapResource
     iam: iam.AsyncIamResource
     fastedge: fastedge.AsyncFastedgeResource
+    streaming: streaming.AsyncStreamingResource
     with_raw_response: AsyncGcoreWithRawResponse
     with_streaming_response: AsyncGcoreWithStreamedResponse
 
@@ -342,6 +346,7 @@ class AsyncGcore(AsyncAPIClient):
         self.waap = waap.AsyncWaapResource(self)
         self.iam = iam.AsyncIamResource(self)
         self.fastedge = fastedge.AsyncFastedgeResource(self)
+        self.streaming = streaming.AsyncStreamingResource(self)
         self.with_raw_response = AsyncGcoreWithRawResponse(self)
         self.with_streaming_response = AsyncGcoreWithStreamedResponse(self)
 
@@ -480,6 +485,7 @@ class GcoreWithRawResponse:
         self.waap = waap.WaapResourceWithRawResponse(client.waap)
         self.iam = iam.IamResourceWithRawResponse(client.iam)
         self.fastedge = fastedge.FastedgeResourceWithRawResponse(client.fastedge)
+        self.streaming = streaming.StreamingResourceWithRawResponse(client.streaming)
 
 
 class AsyncGcoreWithRawResponse:
@@ -488,6 +494,7 @@ class AsyncGcoreWithRawResponse:
         self.waap = waap.AsyncWaapResourceWithRawResponse(client.waap)
         self.iam = iam.AsyncIamResourceWithRawResponse(client.iam)
         self.fastedge = fastedge.AsyncFastedgeResourceWithRawResponse(client.fastedge)
+        self.streaming = streaming.AsyncStreamingResourceWithRawResponse(client.streaming)
 
 
 class GcoreWithStreamedResponse:
@@ -496,6 +503,7 @@ class GcoreWithStreamedResponse:
         self.waap = waap.WaapResourceWithStreamingResponse(client.waap)
         self.iam = iam.IamResourceWithStreamingResponse(client.iam)
         self.fastedge = fastedge.FastedgeResourceWithStreamingResponse(client.fastedge)
+        self.streaming = streaming.StreamingResourceWithStreamingResponse(client.streaming)
 
 
 class AsyncGcoreWithStreamedResponse:
@@ -504,6 +512,7 @@ class AsyncGcoreWithStreamedResponse:
         self.waap = waap.AsyncWaapResourceWithStreamingResponse(client.waap)
         self.iam = iam.AsyncIamResourceWithStreamingResponse(client.iam)
         self.fastedge = fastedge.AsyncFastedgeResourceWithStreamingResponse(client.fastedge)
+        self.streaming = streaming.AsyncStreamingResourceWithStreamingResponse(client.streaming)
 
 
 Client = Gcore

gcore/_models.py

@@ -208,14 +208,18 @@ class BaseModel(pydantic.BaseModel):
             else:
                 fields_values[name] = field_get_default(field)
 
+        extra_field_type = _get_extra_fields_type(__cls)
+
         _extra = {}
         for key, value in values.items():
             if key not in model_fields:
+                parsed = construct_type(value=value, type_=extra_field_type) if extra_field_type is not None else value
+
                 if PYDANTIC_V2:
-                    _extra[key] = value
+                    _extra[key] = parsed
                 else:
                     _fields_set.add(key)
-                    fields_values[key] = value
+                    fields_values[key] = parsed
 
         object.__setattr__(m, "__dict__", fields_values)
 
@@ -370,6 +374,23 @@ def _construct_field(value: object, field: FieldInfo, key: str) -> object:
     return construct_type(value=value, type_=type_, metadata=getattr(field, "metadata", None))
 
 
+def _get_extra_fields_type(cls: type[pydantic.BaseModel]) -> type | None:
+    if not PYDANTIC_V2:
+        # TODO
+        return None
+
+    schema = cls.__pydantic_core_schema__
+    if schema["type"] == "model":
+        fields = schema["schema"]
+        if fields["type"] == "model-fields":
+            extras = fields.get("extras_schema")
+            if extras and "cls" in extras:
+                # mypy can't narrow the type
+                return extras["cls"]  # type: ignore[no-any-return]
+
+    return None
+
+
 def is_basemodel(type_: type) -> bool:
     """Returns whether or not the given type is either a `BaseModel` or a union of `BaseModel`"""
     if is_union(type_):
@@ -439,7 +460,7 @@ def construct_type(*, value: object, type_: object, metadata: Optional[List[Any]
         type_ = type_.__value__  # type: ignore[unreachable]
 
     # unwrap `Annotated[T, ...]` -> `T`
-    if metadata is not None:
+    if metadata is not None and len(metadata) > 0:
         meta: tuple[Any, ...] = tuple(metadata)
     elif is_annotated_type(type_):
         meta = get_args(type_)[1:]

gcore/_version.py

@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "gcore"
-__version__ = "0.5.0"  # x-release-please-version
+__version__ = "0.7.0"  # x-release-please-version

gcore/pagination.py

@@ -1,8 +1,12 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-from typing import List, Generic, TypeVar, Optional
+from typing import Any, List, Type, Generic, Mapping, TypeVar, Optional, cast
 from typing_extensions import override
 
+from httpx import Response
+
+from ._utils import is_mapping
+from ._models import BaseModel
 from ._base_client import BasePage, PageInfo, BaseSyncPage, BaseAsyncPage
 
 __all__ = [
@@ -16,8 +20,14 @@ __all__ = [
     "AsyncOffsetPageFastedgeTemplates",
     "SyncOffsetPageFastedgeAppLogs",
     "AsyncOffsetPageFastedgeAppLogs",
+    "SyncPageStreamingAI",
+    "AsyncPageStreamingAI",
+    "SyncPageStreaming",
+    "AsyncPageStreaming",
 ]
 
+_BaseModelT = TypeVar("_BaseModelT", bound=BaseModel)
+
 _T = TypeVar("_T")
 
 
@@ -319,3 +329,93 @@ class AsyncOffsetPageFastedgeAppLogs(BaseAsyncPage[_T], BasePage[_T], Generic[_T
             return PageInfo(params={"offset": current_count})
 
         return None
+
+
+class SyncPageStreamingAI(BaseSyncPage[_T], BasePage[_T], Generic[_T]):
+    results: List[_T]
+
+    @override
+    def _get_page_items(self) -> List[_T]:
+        results = self.results
+        if not results:
+            return []
+        return results
+
+    @override
+    def next_page_info(self) -> Optional[PageInfo]:
+        last_page = cast("int | None", self._options.params.get("page")) or 1
+
+        return PageInfo(params={"page": last_page + 1})
+
+
+class AsyncPageStreamingAI(BaseAsyncPage[_T], BasePage[_T], Generic[_T]):
+    results: List[_T]
+
+    @override
+    def _get_page_items(self) -> List[_T]:
+        results = self.results
+        if not results:
+            return []
+        return results
+
+    @override
+    def next_page_info(self) -> Optional[PageInfo]:
+        last_page = cast("int | None", self._options.params.get("page")) or 1
+
+        return PageInfo(params={"page": last_page + 1})
+
+
+class SyncPageStreaming(BaseSyncPage[_T], BasePage[_T], Generic[_T]):
+    items: List[_T]
+
+    @override
+    def _get_page_items(self) -> List[_T]:
+        items = self.items
+        if not items:
+            return []
+        return items
+
+    @override
+    def next_page_info(self) -> None:
+        """
+        This page represents a response that isn't actually paginated at the API level
+        so there will never be a next page.
+        """
+        return None
+
+    @classmethod
+    def build(cls: Type[_BaseModelT], *, response: Response, data: object) -> _BaseModelT:  # noqa: ARG003
+        return cls.construct(
+            None,
+            **{
+                **(cast(Mapping[str, Any], data) if is_mapping(data) else {"items": data}),
+            },
+        )
+
+
+class AsyncPageStreaming(BaseAsyncPage[_T], BasePage[_T], Generic[_T]):
+    items: List[_T]
+
+    @override
+    def _get_page_items(self) -> List[_T]:
+        items = self.items
+        if not items:
+            return []
+        return items
+
+    @override
+    def next_page_info(self) -> None:
+        """
+        This page represents a response that isn't actually paginated at the API level
+        so there will never be a next page.
+        """
+        return None
+
+    @classmethod
+    def build(cls: Type[_BaseModelT], *, response: Response, data: object) -> _BaseModelT:  # noqa: ARG003
+        return cls.construct(
+            None,
+            **{
+                **(cast(Mapping[str, Any], data) if is_mapping(data) else {"items": data}),
+            },
+        )

gcore/resources/__init__.py

@@ -32,6 +32,14 @@ from .fastedge import (
     FastedgeResourceWithStreamingResponse,
     AsyncFastedgeResourceWithStreamingResponse,
 )
+from .streaming import (
+    StreamingResource,
+    AsyncStreamingResource,
+    StreamingResourceWithRawResponse,
+    AsyncStreamingResourceWithRawResponse,
+    StreamingResourceWithStreamingResponse,
+    AsyncStreamingResourceWithStreamingResponse,
+)
 
 __all__ = [
     "CloudResource",
@@ -58,4 +66,10 @@ __all__ = [
     "AsyncFastedgeResourceWithRawResponse",
     "FastedgeResourceWithStreamingResponse",
     "AsyncFastedgeResourceWithStreamingResponse",
+    "StreamingResource",
+    "AsyncStreamingResource",
+    "StreamingResourceWithRawResponse",
+    "AsyncStreamingResourceWithRawResponse",
+    "StreamingResourceWithStreamingResponse",
+    "AsyncStreamingResourceWithStreamingResponse",
 ]

gcore/resources/cloud/__init__.py

@@ -112,6 +112,14 @@ from .ip_ranges import (
     IPRangesResourceWithStreamingResponse,
     AsyncIPRangesResourceWithStreamingResponse,
 )
+from .audit_logs import (
+    AuditLogsResource,
+    AsyncAuditLogsResource,
+    AuditLogsResourceWithRawResponse,
+    AsyncAuditLogsResourceWithRawResponse,
+    AuditLogsResourceWithStreamingResponse,
+    AsyncAuditLogsResourceWithStreamingResponse,
+)
 from .registries import (
     RegistriesResource,
     AsyncRegistriesResource,
@@ -128,6 +136,14 @@ from .file_shares import (
     FileSharesResourceWithStreamingResponse,
     AsyncFileSharesResourceWithStreamingResponse,
 )
+from .cost_reports import (
+    CostReportsResource,
+    AsyncCostReportsResource,
+    CostReportsResourceWithRawResponse,
+    AsyncCostReportsResourceWithRawResponse,
+    CostReportsResourceWithStreamingResponse,
+    AsyncCostReportsResourceWithStreamingResponse,
+)
 from .floating_ips import (
     FloatingIPsResource,
     AsyncFloatingIPsResource,
@@ -136,6 +152,14 @@ from .floating_ips import (
     FloatingIPsResourceWithStreamingResponse,
     AsyncFloatingIPsResourceWithStreamingResponse,
 )
+from .usage_reports import (
+    UsageReportsResource,
+    AsyncUsageReportsResource,
+    UsageReportsResourceWithRawResponse,
+    AsyncUsageReportsResourceWithRawResponse,
+    UsageReportsResourceWithStreamingResponse,
+    AsyncUsageReportsResourceWithStreamingResponse,
+)
 from .load_balancers import (
     LoadBalancersResource,
     AsyncLoadBalancersResource,
@@ -318,6 +342,24 @@ __all__ = [
     "AsyncInstancesResourceWithRawResponse",
     "InstancesResourceWithStreamingResponse",
     "AsyncInstancesResourceWithStreamingResponse",
+    "AuditLogsResource",
+    "AsyncAuditLogsResource",
+    "AuditLogsResourceWithRawResponse",
+    "AsyncAuditLogsResourceWithRawResponse",
+    "AuditLogsResourceWithStreamingResponse",
+    "AsyncAuditLogsResourceWithStreamingResponse",
+    "CostReportsResource",
+    "AsyncCostReportsResource",
+    "CostReportsResourceWithRawResponse",
+    "AsyncCostReportsResourceWithRawResponse",
+    "CostReportsResourceWithStreamingResponse",
+    "AsyncCostReportsResourceWithStreamingResponse",
+    "UsageReportsResource",
+    "AsyncUsageReportsResource",
+    "UsageReportsResourceWithRawResponse",
+    "AsyncUsageReportsResourceWithRawResponse",
+    "UsageReportsResourceWithStreamingResponse",
+    "AsyncUsageReportsResourceWithStreamingResponse",
     "CloudResource",
     "AsyncCloudResource",
     "CloudResourceWithRawResponse",