gcore 0.6.0__py3-none-any.whl → 0.8.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.6.0"  # x-release-please-version
+__version__ = "0.8.0"  # x-release-please-version

gcore/pagination.py

@@ -1,23 +1,31 @@
 # 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__ = [
     "SyncOffsetPage",
     "AsyncOffsetPage",
-    "SyncOffsetPageIam",
-    "AsyncOffsetPageIam",
     "SyncOffsetPageFastedgeApps",
     "AsyncOffsetPageFastedgeApps",
     "SyncOffsetPageFastedgeTemplates",
     "AsyncOffsetPageFastedgeTemplates",
     "SyncOffsetPageFastedgeAppLogs",
     "AsyncOffsetPageFastedgeAppLogs",
+    "SyncPageStreamingAI",
+    "AsyncPageStreamingAI",
+    "SyncPageStreaming",
+    "AsyncPageStreaming",
 ]
 
+_BaseModelT = TypeVar("_BaseModelT", bound=BaseModel)
+
 _T = TypeVar("_T")
 
 
@@ -81,66 +89,6 @@ class AsyncOffsetPage(BaseAsyncPage[_T], BasePage[_T], Generic[_T]):
         return None
 
 
-class SyncOffsetPageIam(BaseSyncPage[_T], BasePage[_T], Generic[_T]):
-    result: List[_T]
-    count: Optional[int] = None
-
-    @override
-    def _get_page_items(self) -> List[_T]:
-        result = self.result
-        if not result:
-            return []
-        return result
-
-    @override
-    def next_page_info(self) -> Optional[PageInfo]:
-        offset = self._options.params.get("offset") or 0
-        if not isinstance(offset, int):
-            raise ValueError(f'Expected "offset" param to be an integer but got {offset}')
-
-        length = len(self._get_page_items())
-        current_count = offset + length
-
-        count = self.count
-        if count is None:
-            return None
-
-        if current_count < count:
-            return PageInfo(params={"offset": current_count})
-
-        return None
-
-
-class AsyncOffsetPageIam(BaseAsyncPage[_T], BasePage[_T], Generic[_T]):
-    result: List[_T]
-    count: Optional[int] = None
-
-    @override
-    def _get_page_items(self) -> List[_T]:
-        result = self.result
-        if not result:
-            return []
-        return result
-
-    @override
-    def next_page_info(self) -> Optional[PageInfo]:
-        offset = self._options.params.get("offset") or 0
-        if not isinstance(offset, int):
-            raise ValueError(f'Expected "offset" param to be an integer but got {offset}')
-
-        length = len(self._get_page_items())
-        current_count = offset + length
-
-        count = self.count
-        if count is None:
-            return None
-
-        if current_count < count:
-            return PageInfo(params={"offset": current_count})
-
-        return None
-
-
 class SyncOffsetPageFastedgeApps(BaseSyncPage[_T], BasePage[_T], Generic[_T]):
     apps: List[_T]
     count: Optional[int] = None
@@ -319,3 +267,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

@@ -136,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,
@@ -144,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,
@@ -332,6 +348,18 @@ __all__ = [
     "AsyncAuditLogsResourceWithRawResponse",
     "AuditLogsResourceWithStreamingResponse",
     "AsyncAuditLogsResourceWithStreamingResponse",
+    "CostReportsResource",
+    "AsyncCostReportsResource",
+    "CostReportsResourceWithRawResponse",
+    "AsyncCostReportsResourceWithRawResponse",
+    "CostReportsResourceWithStreamingResponse",
+    "AsyncCostReportsResourceWithStreamingResponse",
+    "UsageReportsResource",
+    "AsyncUsageReportsResource",
+    "UsageReportsResourceWithRawResponse",
+    "AsyncUsageReportsResourceWithRawResponse",
+    "UsageReportsResourceWithStreamingResponse",
+    "AsyncUsageReportsResourceWithStreamingResponse",
     "CloudResource",
     "AsyncCloudResource",
     "CloudResourceWithRawResponse",

gcore/resources/cloud/cloud.py

@@ -76,6 +76,14 @@ from .users.users import (
     UsersResourceWithStreamingResponse,
     AsyncUsersResourceWithStreamingResponse,
 )
+from .cost_reports import (
+    CostReportsResource,
+    AsyncCostReportsResource,
+    CostReportsResourceWithRawResponse,
+    AsyncCostReportsResourceWithRawResponse,
+    CostReportsResourceWithStreamingResponse,
+    AsyncCostReportsResourceWithStreamingResponse,
+)
 from .floating_ips import (
     FloatingIPsResource,
     AsyncFloatingIPsResource,
@@ -92,6 +100,14 @@ from .quotas.quotas import (
     QuotasResourceWithStreamingResponse,
     AsyncQuotasResourceWithStreamingResponse,
 )
+from .usage_reports import (
+    UsageReportsResource,
+    AsyncUsageReportsResource,
+    UsageReportsResourceWithRawResponse,
+    AsyncUsageReportsResourceWithRawResponse,
+    UsageReportsResourceWithStreamingResponse,
+    AsyncUsageReportsResourceWithStreamingResponse,
+)
 from .placement_groups import (
     PlacementGroupsResource,
     AsyncPlacementGroupsResource,
@@ -285,6 +301,14 @@ class CloudResource(SyncAPIResource):
     def audit_logs(self) -> AuditLogsResource:
         return AuditLogsResource(self._client)
 
+    @cached_property
+    def cost_reports(self) -> CostReportsResource:
+        return CostReportsResource(self._client)
+
+    @cached_property
+    def usage_reports(self) -> UsageReportsResource:
+        return UsageReportsResource(self._client)
+
     @cached_property
     def with_raw_response(self) -> CloudResourceWithRawResponse:
         """
@@ -398,6 +422,14 @@ class AsyncCloudResource(AsyncAPIResource):
     def audit_logs(self) -> AsyncAuditLogsResource:
         return AsyncAuditLogsResource(self._client)
 
+    @cached_property
+    def cost_reports(self) -> AsyncCostReportsResource:
+        return AsyncCostReportsResource(self._client)
+
+    @cached_property
+    def usage_reports(self) -> AsyncUsageReportsResource:
+        return AsyncUsageReportsResource(self._client)
+
     @cached_property
     def with_raw_response(self) -> AsyncCloudResourceWithRawResponse:
         """
@@ -514,6 +546,14 @@ class CloudResourceWithRawResponse:
     def audit_logs(self) -> AuditLogsResourceWithRawResponse:
         return AuditLogsResourceWithRawResponse(self._cloud.audit_logs)
 
+    @cached_property
+    def cost_reports(self) -> CostReportsResourceWithRawResponse:
+        return CostReportsResourceWithRawResponse(self._cloud.cost_reports)
+
+    @cached_property
+    def usage_reports(self) -> UsageReportsResourceWithRawResponse:
+        return UsageReportsResourceWithRawResponse(self._cloud.usage_reports)
+
 
 class AsyncCloudResourceWithRawResponse:
     def __init__(self, cloud: AsyncCloudResource) -> None:
@@ -611,6 +651,14 @@ class AsyncCloudResourceWithRawResponse:
     def audit_logs(self) -> AsyncAuditLogsResourceWithRawResponse:
         return AsyncAuditLogsResourceWithRawResponse(self._cloud.audit_logs)
 
+    @cached_property
+    def cost_reports(self) -> AsyncCostReportsResourceWithRawResponse:
+        return AsyncCostReportsResourceWithRawResponse(self._cloud.cost_reports)
+
+    @cached_property
+    def usage_reports(self) -> AsyncUsageReportsResourceWithRawResponse:
+        return AsyncUsageReportsResourceWithRawResponse(self._cloud.usage_reports)
+
 
 class CloudResourceWithStreamingResponse:
     def __init__(self, cloud: CloudResource) -> None:
@@ -708,6 +756,14 @@ class CloudResourceWithStreamingResponse:
     def audit_logs(self) -> AuditLogsResourceWithStreamingResponse:
         return AuditLogsResourceWithStreamingResponse(self._cloud.audit_logs)
 
+    @cached_property
+    def cost_reports(self) -> CostReportsResourceWithStreamingResponse:
+        return CostReportsResourceWithStreamingResponse(self._cloud.cost_reports)
+
+    @cached_property
+    def usage_reports(self) -> UsageReportsResourceWithStreamingResponse:
+        return UsageReportsResourceWithStreamingResponse(self._cloud.usage_reports)
+
 
 class AsyncCloudResourceWithStreamingResponse:
     def __init__(self, cloud: AsyncCloudResource) -> None:
@@ -804,3 +860,11 @@ class AsyncCloudResourceWithStreamingResponse:
     @cached_property
     def audit_logs(self) -> AsyncAuditLogsResourceWithStreamingResponse:
         return AsyncAuditLogsResourceWithStreamingResponse(self._cloud.audit_logs)
+
+    @cached_property
+    def cost_reports(self) -> AsyncCostReportsResourceWithStreamingResponse:
+        return AsyncCostReportsResourceWithStreamingResponse(self._cloud.cost_reports)
+
+    @cached_property
+    def usage_reports(self) -> AsyncUsageReportsResourceWithStreamingResponse:
+        return AsyncUsageReportsResourceWithStreamingResponse(self._cloud.usage_reports)