From 6817e7215b58704905d7d5f972d3b49ba65b28ea Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 11 Dec 2024 21:31:15 +0000 Subject: [PATCH] feat(pagerules): rename namespace to page_rules --- api.md | 20 +- src/cloudflare/_client.py | 38 +-- .../resources/{pagerules.py => page_rules.py} | 161 +++++----- src/cloudflare/types/page_rules/__init__.py | 13 + .../{pagerules => page_rules}/page_rule.py | 0 .../page_rule_create_params.py} | 4 +- .../page_rule_delete_response.py} | 4 +- .../page_rule_edit_params.py} | 4 +- .../page_rule_list_params.py} | 4 +- .../page_rule_list_response.py} | 4 +- .../page_rule_update_params.py} | 4 +- .../types/{pagerules => page_rules}/target.py | 0 .../{pagerules => page_rules}/target_param.py | 0 src/cloudflare/types/pagerules/__init__.py | 13 - .../{test_pagerules.py => test_page_rules.py} | 274 +++++++++--------- 15 files changed, 274 insertions(+), 269 deletions(-) rename src/cloudflare/resources/{pagerules.py => page_rules.py} (88%) create mode 100644 src/cloudflare/types/page_rules/__init__.py rename src/cloudflare/types/{pagerules => page_rules}/page_rule.py (100%) rename src/cloudflare/types/{pagerules/pagerule_update_params.py => page_rules/page_rule_create_params.py} (99%) rename src/cloudflare/types/{pagerules/pagerule_delete_response.py => page_rules/page_rule_delete_response.py} (66%) rename src/cloudflare/types/{pagerules/pagerule_edit_params.py => page_rules/page_rule_edit_params.py} (99%) rename src/cloudflare/types/{pagerules/pagerule_list_params.py => page_rules/page_rule_list_params.py} (89%) rename src/cloudflare/types/{pagerules/pagerule_list_response.py => page_rules/page_rule_list_response.py} (68%) rename src/cloudflare/types/{pagerules/pagerule_create_params.py => page_rules/page_rule_update_params.py} (99%) rename src/cloudflare/types/{pagerules => page_rules}/target.py (100%) rename src/cloudflare/types/{pagerules => page_rules}/target_param.py (100%) delete mode 100644 src/cloudflare/types/pagerules/__init__.py rename tests/api_resources/{test_pagerules.py => test_page_rules.py} (75%) diff --git a/api.md b/api.md index 6ddbb1f9f9e..a7c4dcff441 100644 --- a/api.md +++ b/api.md @@ -2050,27 +2050,27 @@ Methods: - client.origin_tls_client_auth.settings.update(\*, zone_id, \*\*params) -> Optional[SettingUpdateResponse] - client.origin_tls_client_auth.settings.get(\*, zone_id) -> Optional[SettingGetResponse] -# Pagerules +# PageRules Types: ```python -from cloudflare.types.pagerules import ( +from cloudflare.types.page_rules import ( PageRule, Target, - PageruleListResponse, - PageruleDeleteResponse, + PageRuleListResponse, + PageRuleDeleteResponse, ) ``` Methods: -- client.pagerules.create(\*, zone_id, \*\*params) -> Optional[PageRule] -- client.pagerules.update(pagerule_id, \*, zone_id, \*\*params) -> Optional[PageRule] -- client.pagerules.list(\*, zone_id, \*\*params) -> Optional[PageruleListResponse] -- client.pagerules.delete(pagerule_id, \*, zone_id) -> Optional[PageruleDeleteResponse] -- client.pagerules.edit(pagerule_id, \*, zone_id, \*\*params) -> Optional[PageRule] -- client.pagerules.get(pagerule_id, \*, zone_id) -> Optional[PageRule] +- client.page_rules.create(\*, zone_id, \*\*params) -> Optional[PageRule] +- client.page_rules.update(pagerule_id, \*, zone_id, \*\*params) -> Optional[PageRule] +- client.page_rules.list(\*, zone_id, \*\*params) -> Optional[PageRuleListResponse] +- client.page_rules.delete(pagerule_id, \*, zone_id) -> Optional[PageRuleDeleteResponse] +- client.page_rules.edit(pagerule_id, \*, zone_id, \*\*params) -> Optional[PageRule] +- client.page_rules.get(pagerule_id, \*, zone_id) -> Optional[PageRule] # RateLimits diff --git a/src/cloudflare/_client.py b/src/cloudflare/_client.py index 8e6dd6070e4..ec966ca654c 100644 --- a/src/cloudflare/_client.py +++ b/src/cloudflare/_client.py @@ -71,7 +71,6 @@ snippets, spectrum, hostnames, - pagerules, registrar, turnstile, vectorize, @@ -80,6 +79,7 @@ ai_gateway, audit_logs, hyperdrive, + page_rules, zero_trust, api_gateway, botnet_feed, @@ -370,10 +370,10 @@ def origin_tls_client_auth(self) -> origin_tls_client_auth.OriginTLSClientAuthRe return OriginTLSClientAuthResource(self) @cached_property - def pagerules(self) -> pagerules.PagerulesResource: - from .resources.pagerules import PagerulesResource + def page_rules(self) -> page_rules.PageRulesResource: + from .resources.page_rules import PageRulesResource - return PagerulesResource(self) + return PageRulesResource(self) @cached_property def rate_limits(self) -> rate_limits.RateLimitsResource: @@ -1129,10 +1129,10 @@ def origin_tls_client_auth(self) -> origin_tls_client_auth.AsyncOriginTLSClientA return AsyncOriginTLSClientAuthResource(self) @cached_property - def pagerules(self) -> pagerules.AsyncPagerulesResource: - from .resources.pagerules import AsyncPagerulesResource + def page_rules(self) -> page_rules.AsyncPageRulesResource: + from .resources.page_rules import AsyncPageRulesResource - return AsyncPagerulesResource(self) + return AsyncPageRulesResource(self) @cached_property def rate_limits(self) -> rate_limits.AsyncRateLimitsResource: @@ -1821,10 +1821,10 @@ def origin_tls_client_auth(self) -> origin_tls_client_auth.OriginTLSClientAuthRe return OriginTLSClientAuthResourceWithRawResponse(self._client.origin_tls_client_auth) @cached_property - def pagerules(self) -> pagerules.PagerulesResourceWithRawResponse: - from .resources.pagerules import PagerulesResourceWithRawResponse + def page_rules(self) -> page_rules.PageRulesResourceWithRawResponse: + from .resources.page_rules import PageRulesResourceWithRawResponse - return PagerulesResourceWithRawResponse(self._client.pagerules) + return PageRulesResourceWithRawResponse(self._client.page_rules) @cached_property def rate_limits(self) -> rate_limits.RateLimitsResourceWithRawResponse: @@ -2334,10 +2334,10 @@ def origin_tls_client_auth(self) -> origin_tls_client_auth.AsyncOriginTLSClientA return AsyncOriginTLSClientAuthResourceWithRawResponse(self._client.origin_tls_client_auth) @cached_property - def pagerules(self) -> pagerules.AsyncPagerulesResourceWithRawResponse: - from .resources.pagerules import AsyncPagerulesResourceWithRawResponse + def page_rules(self) -> page_rules.AsyncPageRulesResourceWithRawResponse: + from .resources.page_rules import AsyncPageRulesResourceWithRawResponse - return AsyncPagerulesResourceWithRawResponse(self._client.pagerules) + return AsyncPageRulesResourceWithRawResponse(self._client.page_rules) @cached_property def rate_limits(self) -> rate_limits.AsyncRateLimitsResourceWithRawResponse: @@ -2847,10 +2847,10 @@ def origin_tls_client_auth(self) -> origin_tls_client_auth.OriginTLSClientAuthRe return OriginTLSClientAuthResourceWithStreamingResponse(self._client.origin_tls_client_auth) @cached_property - def pagerules(self) -> pagerules.PagerulesResourceWithStreamingResponse: - from .resources.pagerules import PagerulesResourceWithStreamingResponse + def page_rules(self) -> page_rules.PageRulesResourceWithStreamingResponse: + from .resources.page_rules import PageRulesResourceWithStreamingResponse - return PagerulesResourceWithStreamingResponse(self._client.pagerules) + return PageRulesResourceWithStreamingResponse(self._client.page_rules) @cached_property def rate_limits(self) -> rate_limits.RateLimitsResourceWithStreamingResponse: @@ -3362,10 +3362,10 @@ def origin_tls_client_auth(self) -> origin_tls_client_auth.AsyncOriginTLSClientA return AsyncOriginTLSClientAuthResourceWithStreamingResponse(self._client.origin_tls_client_auth) @cached_property - def pagerules(self) -> pagerules.AsyncPagerulesResourceWithStreamingResponse: - from .resources.pagerules import AsyncPagerulesResourceWithStreamingResponse + def page_rules(self) -> page_rules.AsyncPageRulesResourceWithStreamingResponse: + from .resources.page_rules import AsyncPageRulesResourceWithStreamingResponse - return AsyncPagerulesResourceWithStreamingResponse(self._client.pagerules) + return AsyncPageRulesResourceWithStreamingResponse(self._client.page_rules) @cached_property def rate_limits(self) -> rate_limits.AsyncRateLimitsResourceWithStreamingResponse: diff --git a/src/cloudflare/resources/pagerules.py b/src/cloudflare/resources/page_rules.py similarity index 88% rename from src/cloudflare/resources/pagerules.py rename to src/cloudflare/resources/page_rules.py index 3297f84978a..669798161c2 100644 --- a/src/cloudflare/resources/pagerules.py +++ b/src/cloudflare/resources/page_rules.py @@ -22,40 +22,45 @@ ) from .._wrappers import ResultWrapper from .._base_client import make_request_options -from ..types.pagerules import pagerule_edit_params, pagerule_list_params, pagerule_create_params, pagerule_update_params -from ..types.pagerules.page_rule import PageRule -from ..types.pagerules.target_param import TargetParam -from ..types.pagerules.pagerule_list_response import PageruleListResponse -from ..types.pagerules.pagerule_delete_response import PageruleDeleteResponse +from ..types.page_rules import ( + page_rule_edit_params, + page_rule_list_params, + page_rule_create_params, + page_rule_update_params, +) +from ..types.page_rules.page_rule import PageRule +from ..types.page_rules.target_param import TargetParam +from ..types.page_rules.page_rule_list_response import PageRuleListResponse +from ..types.page_rules.page_rule_delete_response import PageRuleDeleteResponse -__all__ = ["PagerulesResource", "AsyncPagerulesResource"] +__all__ = ["PageRulesResource", "AsyncPageRulesResource"] -class PagerulesResource(SyncAPIResource): +class PageRulesResource(SyncAPIResource): @cached_property - def with_raw_response(self) -> PagerulesResourceWithRawResponse: + def with_raw_response(self) -> PageRulesResourceWithRawResponse: """ This property can be used as a prefix for any HTTP method call to return the the raw response object instead of the parsed content. For more information, see https://www.github.com/cloudflare/cloudflare-python#accessing-raw-response-data-eg-headers """ - return PagerulesResourceWithRawResponse(self) + return PageRulesResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> PagerulesResourceWithStreamingResponse: + def with_streaming_response(self) -> PageRulesResourceWithStreamingResponse: """ An alternative to `.with_raw_response` that doesn't eagerly read the response body. For more information, see https://www.github.com/cloudflare/cloudflare-python#with_streaming_response """ - return PagerulesResourceWithStreamingResponse(self) + return PageRulesResourceWithStreamingResponse(self) def create( self, *, zone_id: str, - actions: Iterable[pagerule_create_params.Action], + actions: Iterable[page_rule_create_params.Action], targets: Iterable[TargetParam], priority: int | NotGiven = NOT_GIVEN, status: Literal["active", "disabled"] | NotGiven = NOT_GIVEN, @@ -104,7 +109,7 @@ def create( "priority": priority, "status": status, }, - pagerule_create_params.PageruleCreateParams, + page_rule_create_params.PageRuleCreateParams, ), options=make_request_options( extra_headers=extra_headers, @@ -121,7 +126,7 @@ def update( pagerule_id: str, *, zone_id: str, - actions: Iterable[pagerule_update_params.Action], + actions: Iterable[page_rule_update_params.Action], targets: Iterable[TargetParam], priority: int | NotGiven = NOT_GIVEN, status: Literal["active", "disabled"] | NotGiven = NOT_GIVEN, @@ -176,7 +181,7 @@ def update( "priority": priority, "status": status, }, - pagerule_update_params.PageruleUpdateParams, + page_rule_update_params.PageRuleUpdateParams, ), options=make_request_options( extra_headers=extra_headers, @@ -202,7 +207,7 @@ def list( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[PageruleListResponse]: + ) -> Optional[PageRuleListResponse]: """ Fetches Page Rules in a zone. @@ -242,11 +247,11 @@ def list( "order": order, "status": status, }, - pagerule_list_params.PageruleListParams, + page_rule_list_params.PageRuleListParams, ), - post_parser=ResultWrapper[Optional[PageruleListResponse]]._unwrapper, + post_parser=ResultWrapper[Optional[PageRuleListResponse]]._unwrapper, ), - cast_to=cast(Type[Optional[PageruleListResponse]], ResultWrapper[PageruleListResponse]), + cast_to=cast(Type[Optional[PageRuleListResponse]], ResultWrapper[PageRuleListResponse]), ) def delete( @@ -260,7 +265,7 @@ def delete( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[PageruleDeleteResponse]: + ) -> Optional[PageRuleDeleteResponse]: """ Deletes an existing Page Rule. @@ -288,9 +293,9 @@ def delete( extra_query=extra_query, extra_body=extra_body, timeout=timeout, - post_parser=ResultWrapper[Optional[PageruleDeleteResponse]]._unwrapper, + post_parser=ResultWrapper[Optional[PageRuleDeleteResponse]]._unwrapper, ), - cast_to=cast(Type[Optional[PageruleDeleteResponse]], ResultWrapper[PageruleDeleteResponse]), + cast_to=cast(Type[Optional[PageRuleDeleteResponse]], ResultWrapper[PageRuleDeleteResponse]), ) def edit( @@ -298,7 +303,7 @@ def edit( pagerule_id: str, *, zone_id: str, - actions: Iterable[pagerule_edit_params.Action] | NotGiven = NOT_GIVEN, + actions: Iterable[page_rule_edit_params.Action] | NotGiven = NOT_GIVEN, priority: int | NotGiven = NOT_GIVEN, status: Literal["active", "disabled"] | NotGiven = NOT_GIVEN, targets: Iterable[TargetParam] | NotGiven = NOT_GIVEN, @@ -351,7 +356,7 @@ def edit( "status": status, "targets": targets, }, - pagerule_edit_params.PageruleEditParams, + page_rule_edit_params.PageRuleEditParams, ), options=make_request_options( extra_headers=extra_headers, @@ -408,31 +413,31 @@ def get( ) -class AsyncPagerulesResource(AsyncAPIResource): +class AsyncPageRulesResource(AsyncAPIResource): @cached_property - def with_raw_response(self) -> AsyncPagerulesResourceWithRawResponse: + def with_raw_response(self) -> AsyncPageRulesResourceWithRawResponse: """ This property can be used as a prefix for any HTTP method call to return the the raw response object instead of the parsed content. For more information, see https://www.github.com/cloudflare/cloudflare-python#accessing-raw-response-data-eg-headers """ - return AsyncPagerulesResourceWithRawResponse(self) + return AsyncPageRulesResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> AsyncPagerulesResourceWithStreamingResponse: + def with_streaming_response(self) -> AsyncPageRulesResourceWithStreamingResponse: """ An alternative to `.with_raw_response` that doesn't eagerly read the response body. For more information, see https://www.github.com/cloudflare/cloudflare-python#with_streaming_response """ - return AsyncPagerulesResourceWithStreamingResponse(self) + return AsyncPageRulesResourceWithStreamingResponse(self) async def create( self, *, zone_id: str, - actions: Iterable[pagerule_create_params.Action], + actions: Iterable[page_rule_create_params.Action], targets: Iterable[TargetParam], priority: int | NotGiven = NOT_GIVEN, status: Literal["active", "disabled"] | NotGiven = NOT_GIVEN, @@ -481,7 +486,7 @@ async def create( "priority": priority, "status": status, }, - pagerule_create_params.PageruleCreateParams, + page_rule_create_params.PageRuleCreateParams, ), options=make_request_options( extra_headers=extra_headers, @@ -498,7 +503,7 @@ async def update( pagerule_id: str, *, zone_id: str, - actions: Iterable[pagerule_update_params.Action], + actions: Iterable[page_rule_update_params.Action], targets: Iterable[TargetParam], priority: int | NotGiven = NOT_GIVEN, status: Literal["active", "disabled"] | NotGiven = NOT_GIVEN, @@ -553,7 +558,7 @@ async def update( "priority": priority, "status": status, }, - pagerule_update_params.PageruleUpdateParams, + page_rule_update_params.PageRuleUpdateParams, ), options=make_request_options( extra_headers=extra_headers, @@ -579,7 +584,7 @@ async def list( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[PageruleListResponse]: + ) -> Optional[PageRuleListResponse]: """ Fetches Page Rules in a zone. @@ -619,11 +624,11 @@ async def list( "order": order, "status": status, }, - pagerule_list_params.PageruleListParams, + page_rule_list_params.PageRuleListParams, ), - post_parser=ResultWrapper[Optional[PageruleListResponse]]._unwrapper, + post_parser=ResultWrapper[Optional[PageRuleListResponse]]._unwrapper, ), - cast_to=cast(Type[Optional[PageruleListResponse]], ResultWrapper[PageruleListResponse]), + cast_to=cast(Type[Optional[PageRuleListResponse]], ResultWrapper[PageRuleListResponse]), ) async def delete( @@ -637,7 +642,7 @@ async def delete( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[PageruleDeleteResponse]: + ) -> Optional[PageRuleDeleteResponse]: """ Deletes an existing Page Rule. @@ -665,9 +670,9 @@ async def delete( extra_query=extra_query, extra_body=extra_body, timeout=timeout, - post_parser=ResultWrapper[Optional[PageruleDeleteResponse]]._unwrapper, + post_parser=ResultWrapper[Optional[PageRuleDeleteResponse]]._unwrapper, ), - cast_to=cast(Type[Optional[PageruleDeleteResponse]], ResultWrapper[PageruleDeleteResponse]), + cast_to=cast(Type[Optional[PageRuleDeleteResponse]], ResultWrapper[PageRuleDeleteResponse]), ) async def edit( @@ -675,7 +680,7 @@ async def edit( pagerule_id: str, *, zone_id: str, - actions: Iterable[pagerule_edit_params.Action] | NotGiven = NOT_GIVEN, + actions: Iterable[page_rule_edit_params.Action] | NotGiven = NOT_GIVEN, priority: int | NotGiven = NOT_GIVEN, status: Literal["active", "disabled"] | NotGiven = NOT_GIVEN, targets: Iterable[TargetParam] | NotGiven = NOT_GIVEN, @@ -728,7 +733,7 @@ async def edit( "status": status, "targets": targets, }, - pagerule_edit_params.PageruleEditParams, + page_rule_edit_params.PageRuleEditParams, ), options=make_request_options( extra_headers=extra_headers, @@ -785,97 +790,97 @@ async def get( ) -class PagerulesResourceWithRawResponse: - def __init__(self, pagerules: PagerulesResource) -> None: - self._pagerules = pagerules +class PageRulesResourceWithRawResponse: + def __init__(self, page_rules: PageRulesResource) -> None: + self._page_rules = page_rules self.create = to_raw_response_wrapper( - pagerules.create, + page_rules.create, ) self.update = to_raw_response_wrapper( - pagerules.update, + page_rules.update, ) self.list = to_raw_response_wrapper( - pagerules.list, + page_rules.list, ) self.delete = to_raw_response_wrapper( - pagerules.delete, + page_rules.delete, ) self.edit = to_raw_response_wrapper( - pagerules.edit, + page_rules.edit, ) self.get = to_raw_response_wrapper( - pagerules.get, + page_rules.get, ) -class AsyncPagerulesResourceWithRawResponse: - def __init__(self, pagerules: AsyncPagerulesResource) -> None: - self._pagerules = pagerules +class AsyncPageRulesResourceWithRawResponse: + def __init__(self, page_rules: AsyncPageRulesResource) -> None: + self._page_rules = page_rules self.create = async_to_raw_response_wrapper( - pagerules.create, + page_rules.create, ) self.update = async_to_raw_response_wrapper( - pagerules.update, + page_rules.update, ) self.list = async_to_raw_response_wrapper( - pagerules.list, + page_rules.list, ) self.delete = async_to_raw_response_wrapper( - pagerules.delete, + page_rules.delete, ) self.edit = async_to_raw_response_wrapper( - pagerules.edit, + page_rules.edit, ) self.get = async_to_raw_response_wrapper( - pagerules.get, + page_rules.get, ) -class PagerulesResourceWithStreamingResponse: - def __init__(self, pagerules: PagerulesResource) -> None: - self._pagerules = pagerules +class PageRulesResourceWithStreamingResponse: + def __init__(self, page_rules: PageRulesResource) -> None: + self._page_rules = page_rules self.create = to_streamed_response_wrapper( - pagerules.create, + page_rules.create, ) self.update = to_streamed_response_wrapper( - pagerules.update, + page_rules.update, ) self.list = to_streamed_response_wrapper( - pagerules.list, + page_rules.list, ) self.delete = to_streamed_response_wrapper( - pagerules.delete, + page_rules.delete, ) self.edit = to_streamed_response_wrapper( - pagerules.edit, + page_rules.edit, ) self.get = to_streamed_response_wrapper( - pagerules.get, + page_rules.get, ) -class AsyncPagerulesResourceWithStreamingResponse: - def __init__(self, pagerules: AsyncPagerulesResource) -> None: - self._pagerules = pagerules +class AsyncPageRulesResourceWithStreamingResponse: + def __init__(self, page_rules: AsyncPageRulesResource) -> None: + self._page_rules = page_rules self.create = async_to_streamed_response_wrapper( - pagerules.create, + page_rules.create, ) self.update = async_to_streamed_response_wrapper( - pagerules.update, + page_rules.update, ) self.list = async_to_streamed_response_wrapper( - pagerules.list, + page_rules.list, ) self.delete = async_to_streamed_response_wrapper( - pagerules.delete, + page_rules.delete, ) self.edit = async_to_streamed_response_wrapper( - pagerules.edit, + page_rules.edit, ) self.get = async_to_streamed_response_wrapper( - pagerules.get, + page_rules.get, ) diff --git a/src/cloudflare/types/page_rules/__init__.py b/src/cloudflare/types/page_rules/__init__.py new file mode 100644 index 00000000000..d85830d5966 --- /dev/null +++ b/src/cloudflare/types/page_rules/__init__.py @@ -0,0 +1,13 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from .target import Target as Target +from .page_rule import PageRule as PageRule +from .target_param import TargetParam as TargetParam +from .page_rule_edit_params import PageRuleEditParams as PageRuleEditParams +from .page_rule_list_params import PageRuleListParams as PageRuleListParams +from .page_rule_create_params import PageRuleCreateParams as PageRuleCreateParams +from .page_rule_list_response import PageRuleListResponse as PageRuleListResponse +from .page_rule_update_params import PageRuleUpdateParams as PageRuleUpdateParams +from .page_rule_delete_response import PageRuleDeleteResponse as PageRuleDeleteResponse diff --git a/src/cloudflare/types/pagerules/page_rule.py b/src/cloudflare/types/page_rules/page_rule.py similarity index 100% rename from src/cloudflare/types/pagerules/page_rule.py rename to src/cloudflare/types/page_rules/page_rule.py diff --git a/src/cloudflare/types/pagerules/pagerule_update_params.py b/src/cloudflare/types/page_rules/page_rule_create_params.py similarity index 99% rename from src/cloudflare/types/pagerules/pagerule_update_params.py rename to src/cloudflare/types/page_rules/page_rule_create_params.py index 7b5245c39f8..7a3dbc4fcf9 100644 --- a/src/cloudflare/types/pagerules/pagerule_update_params.py +++ b/src/cloudflare/types/page_rules/page_rule_create_params.py @@ -26,7 +26,7 @@ from ..zones.sort_query_string_for_cache_param import SortQueryStringForCacheParam __all__ = [ - "PageruleUpdateParams", + "PageRuleCreateParams", "Action", "ActionBypassCacheOnCookie", "ActionCacheByDeviceType", @@ -53,7 +53,7 @@ ] -class PageruleUpdateParams(TypedDict, total=False): +class PageRuleCreateParams(TypedDict, total=False): zone_id: Required[str] """Identifier""" diff --git a/src/cloudflare/types/pagerules/pagerule_delete_response.py b/src/cloudflare/types/page_rules/page_rule_delete_response.py similarity index 66% rename from src/cloudflare/types/pagerules/pagerule_delete_response.py rename to src/cloudflare/types/page_rules/page_rule_delete_response.py index d90b3c2a02b..a7dc5a5e36a 100644 --- a/src/cloudflare/types/pagerules/pagerule_delete_response.py +++ b/src/cloudflare/types/page_rules/page_rule_delete_response.py @@ -3,9 +3,9 @@ from ..._models import BaseModel -__all__ = ["PageruleDeleteResponse"] +__all__ = ["PageRuleDeleteResponse"] -class PageruleDeleteResponse(BaseModel): +class PageRuleDeleteResponse(BaseModel): id: str """Identifier""" diff --git a/src/cloudflare/types/pagerules/pagerule_edit_params.py b/src/cloudflare/types/page_rules/page_rule_edit_params.py similarity index 99% rename from src/cloudflare/types/pagerules/pagerule_edit_params.py rename to src/cloudflare/types/page_rules/page_rule_edit_params.py index 2130f00d83d..fe7c599ea02 100644 --- a/src/cloudflare/types/pagerules/pagerule_edit_params.py +++ b/src/cloudflare/types/page_rules/page_rule_edit_params.py @@ -26,7 +26,7 @@ from ..zones.sort_query_string_for_cache_param import SortQueryStringForCacheParam __all__ = [ - "PageruleEditParams", + "PageRuleEditParams", "Action", "ActionBypassCacheOnCookie", "ActionCacheByDeviceType", @@ -53,7 +53,7 @@ ] -class PageruleEditParams(TypedDict, total=False): +class PageRuleEditParams(TypedDict, total=False): zone_id: Required[str] """Identifier""" diff --git a/src/cloudflare/types/pagerules/pagerule_list_params.py b/src/cloudflare/types/page_rules/page_rule_list_params.py similarity index 89% rename from src/cloudflare/types/pagerules/pagerule_list_params.py rename to src/cloudflare/types/page_rules/page_rule_list_params.py index f243c08faba..6ead32d68b8 100644 --- a/src/cloudflare/types/pagerules/pagerule_list_params.py +++ b/src/cloudflare/types/page_rules/page_rule_list_params.py @@ -4,10 +4,10 @@ from typing_extensions import Literal, Required, TypedDict -__all__ = ["PageruleListParams"] +__all__ = ["PageRuleListParams"] -class PageruleListParams(TypedDict, total=False): +class PageRuleListParams(TypedDict, total=False): zone_id: Required[str] """Identifier""" diff --git a/src/cloudflare/types/pagerules/pagerule_list_response.py b/src/cloudflare/types/page_rules/page_rule_list_response.py similarity index 68% rename from src/cloudflare/types/pagerules/pagerule_list_response.py rename to src/cloudflare/types/page_rules/page_rule_list_response.py index b2992e28bbd..ef7956e70e5 100644 --- a/src/cloudflare/types/pagerules/pagerule_list_response.py +++ b/src/cloudflare/types/page_rules/page_rule_list_response.py @@ -5,6 +5,6 @@ from .page_rule import PageRule -__all__ = ["PageruleListResponse"] +__all__ = ["PageRuleListResponse"] -PageruleListResponse: TypeAlias = List[PageRule] +PageRuleListResponse: TypeAlias = List[PageRule] diff --git a/src/cloudflare/types/pagerules/pagerule_create_params.py b/src/cloudflare/types/page_rules/page_rule_update_params.py similarity index 99% rename from src/cloudflare/types/pagerules/pagerule_create_params.py rename to src/cloudflare/types/page_rules/page_rule_update_params.py index 2fe0781abfa..ceff13a48fe 100644 --- a/src/cloudflare/types/pagerules/pagerule_create_params.py +++ b/src/cloudflare/types/page_rules/page_rule_update_params.py @@ -26,7 +26,7 @@ from ..zones.sort_query_string_for_cache_param import SortQueryStringForCacheParam __all__ = [ - "PageruleCreateParams", + "PageRuleUpdateParams", "Action", "ActionBypassCacheOnCookie", "ActionCacheByDeviceType", @@ -53,7 +53,7 @@ ] -class PageruleCreateParams(TypedDict, total=False): +class PageRuleUpdateParams(TypedDict, total=False): zone_id: Required[str] """Identifier""" diff --git a/src/cloudflare/types/pagerules/target.py b/src/cloudflare/types/page_rules/target.py similarity index 100% rename from src/cloudflare/types/pagerules/target.py rename to src/cloudflare/types/page_rules/target.py diff --git a/src/cloudflare/types/pagerules/target_param.py b/src/cloudflare/types/page_rules/target_param.py similarity index 100% rename from src/cloudflare/types/pagerules/target_param.py rename to src/cloudflare/types/page_rules/target_param.py diff --git a/src/cloudflare/types/pagerules/__init__.py b/src/cloudflare/types/pagerules/__init__.py deleted file mode 100644 index a023afa9b37..00000000000 --- a/src/cloudflare/types/pagerules/__init__.py +++ /dev/null @@ -1,13 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from __future__ import annotations - -from .target import Target as Target -from .page_rule import PageRule as PageRule -from .target_param import TargetParam as TargetParam -from .pagerule_edit_params import PageruleEditParams as PageruleEditParams -from .pagerule_list_params import PageruleListParams as PageruleListParams -from .pagerule_create_params import PageruleCreateParams as PageruleCreateParams -from .pagerule_list_response import PageruleListResponse as PageruleListResponse -from .pagerule_update_params import PageruleUpdateParams as PageruleUpdateParams -from .pagerule_delete_response import PageruleDeleteResponse as PageruleDeleteResponse diff --git a/tests/api_resources/test_pagerules.py b/tests/api_resources/test_page_rules.py similarity index 75% rename from tests/api_resources/test_pagerules.py rename to tests/api_resources/test_page_rules.py index 68a6822ba59..8e39d596f5f 100644 --- a/tests/api_resources/test_pagerules.py +++ b/tests/api_resources/test_page_rules.py @@ -9,21 +9,21 @@ from cloudflare import Cloudflare, AsyncCloudflare from tests.utils import assert_matches_type -from cloudflare.types.pagerules import ( +from cloudflare.types.page_rules import ( PageRule, - PageruleListResponse, - PageruleDeleteResponse, + PageRuleListResponse, + PageRuleDeleteResponse, ) base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") -class TestPagerules: +class TestPageRules: parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) @parametrize def test_method_create(self, client: Cloudflare) -> None: - pagerule = client.pagerules.create( + page_rule = client.page_rules.create( zone_id="023e105f4ecef8ad9ca31a8372d0c353", actions=[{}], targets=[ @@ -36,11 +36,11 @@ def test_method_create(self, client: Cloudflare) -> None: } ], ) - assert_matches_type(Optional[PageRule], pagerule, path=["response"]) + assert_matches_type(Optional[PageRule], page_rule, path=["response"]) @parametrize def test_method_create_with_all_params(self, client: Cloudflare) -> None: - pagerule = client.pagerules.create( + page_rule = client.page_rules.create( zone_id="023e105f4ecef8ad9ca31a8372d0c353", actions=[ { @@ -60,11 +60,11 @@ def test_method_create_with_all_params(self, client: Cloudflare) -> None: priority=0, status="active", ) - assert_matches_type(Optional[PageRule], pagerule, path=["response"]) + assert_matches_type(Optional[PageRule], page_rule, path=["response"]) @parametrize def test_raw_response_create(self, client: Cloudflare) -> None: - response = client.pagerules.with_raw_response.create( + response = client.page_rules.with_raw_response.create( zone_id="023e105f4ecef8ad9ca31a8372d0c353", actions=[{}], targets=[ @@ -80,12 +80,12 @@ def test_raw_response_create(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" - pagerule = response.parse() - assert_matches_type(Optional[PageRule], pagerule, path=["response"]) + page_rule = response.parse() + assert_matches_type(Optional[PageRule], page_rule, path=["response"]) @parametrize def test_streaming_response_create(self, client: Cloudflare) -> None: - with client.pagerules.with_streaming_response.create( + with client.page_rules.with_streaming_response.create( zone_id="023e105f4ecef8ad9ca31a8372d0c353", actions=[{}], targets=[ @@ -101,15 +101,15 @@ def test_streaming_response_create(self, client: Cloudflare) -> None: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" - pagerule = response.parse() - assert_matches_type(Optional[PageRule], pagerule, path=["response"]) + page_rule = response.parse() + assert_matches_type(Optional[PageRule], page_rule, path=["response"]) assert cast(Any, response.is_closed) is True @parametrize def test_path_params_create(self, client: Cloudflare) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `zone_id` but received ''"): - client.pagerules.with_raw_response.create( + client.page_rules.with_raw_response.create( zone_id="", actions=[{}], targets=[ @@ -125,7 +125,7 @@ def test_path_params_create(self, client: Cloudflare) -> None: @parametrize def test_method_update(self, client: Cloudflare) -> None: - pagerule = client.pagerules.update( + page_rule = client.page_rules.update( pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", zone_id="023e105f4ecef8ad9ca31a8372d0c353", actions=[{}], @@ -139,11 +139,11 @@ def test_method_update(self, client: Cloudflare) -> None: } ], ) - assert_matches_type(Optional[PageRule], pagerule, path=["response"]) + assert_matches_type(Optional[PageRule], page_rule, path=["response"]) @parametrize def test_method_update_with_all_params(self, client: Cloudflare) -> None: - pagerule = client.pagerules.update( + page_rule = client.page_rules.update( pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", zone_id="023e105f4ecef8ad9ca31a8372d0c353", actions=[ @@ -164,11 +164,11 @@ def test_method_update_with_all_params(self, client: Cloudflare) -> None: priority=0, status="active", ) - assert_matches_type(Optional[PageRule], pagerule, path=["response"]) + assert_matches_type(Optional[PageRule], page_rule, path=["response"]) @parametrize def test_raw_response_update(self, client: Cloudflare) -> None: - response = client.pagerules.with_raw_response.update( + response = client.page_rules.with_raw_response.update( pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", zone_id="023e105f4ecef8ad9ca31a8372d0c353", actions=[{}], @@ -185,12 +185,12 @@ def test_raw_response_update(self, client: Cloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" - pagerule = response.parse() - assert_matches_type(Optional[PageRule], pagerule, path=["response"]) + page_rule = response.parse() + assert_matches_type(Optional[PageRule], page_rule, path=["response"]) @parametrize def test_streaming_response_update(self, client: Cloudflare) -> None: - with client.pagerules.with_streaming_response.update( + with client.page_rules.with_streaming_response.update( pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", zone_id="023e105f4ecef8ad9ca31a8372d0c353", actions=[{}], @@ -207,15 +207,15 @@ def test_streaming_response_update(self, client: Cloudflare) -> None: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" - pagerule = response.parse() - assert_matches_type(Optional[PageRule], pagerule, path=["response"]) + page_rule = response.parse() + assert_matches_type(Optional[PageRule], page_rule, path=["response"]) assert cast(Any, response.is_closed) is True @parametrize def test_path_params_update(self, client: Cloudflare) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `zone_id` but received ''"): - client.pagerules.with_raw_response.update( + client.page_rules.with_raw_response.update( pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", zone_id="", actions=[{}], @@ -231,7 +231,7 @@ def test_path_params_update(self, client: Cloudflare) -> None: ) with pytest.raises(ValueError, match=r"Expected a non-empty value for `pagerule_id` but received ''"): - client.pagerules.with_raw_response.update( + client.page_rules.with_raw_response.update( pagerule_id="", zone_id="023e105f4ecef8ad9ca31a8372d0c353", actions=[{}], @@ -248,112 +248,112 @@ def test_path_params_update(self, client: Cloudflare) -> None: @parametrize def test_method_list(self, client: Cloudflare) -> None: - pagerule = client.pagerules.list( + page_rule = client.page_rules.list( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[PageruleListResponse], pagerule, path=["response"]) + assert_matches_type(Optional[PageRuleListResponse], page_rule, path=["response"]) @parametrize def test_method_list_with_all_params(self, client: Cloudflare) -> None: - pagerule = client.pagerules.list( + page_rule = client.page_rules.list( zone_id="023e105f4ecef8ad9ca31a8372d0c353", direction="asc", match="any", order="status", status="active", ) - assert_matches_type(Optional[PageruleListResponse], pagerule, path=["response"]) + assert_matches_type(Optional[PageRuleListResponse], page_rule, path=["response"]) @parametrize def test_raw_response_list(self, client: Cloudflare) -> None: - response = client.pagerules.with_raw_response.list( + response = client.page_rules.with_raw_response.list( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" - pagerule = response.parse() - assert_matches_type(Optional[PageruleListResponse], pagerule, path=["response"]) + page_rule = response.parse() + assert_matches_type(Optional[PageRuleListResponse], page_rule, path=["response"]) @parametrize def test_streaming_response_list(self, client: Cloudflare) -> None: - with client.pagerules.with_streaming_response.list( + with client.page_rules.with_streaming_response.list( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" - pagerule = response.parse() - assert_matches_type(Optional[PageruleListResponse], pagerule, path=["response"]) + page_rule = response.parse() + assert_matches_type(Optional[PageRuleListResponse], page_rule, path=["response"]) assert cast(Any, response.is_closed) is True @parametrize def test_path_params_list(self, client: Cloudflare) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `zone_id` but received ''"): - client.pagerules.with_raw_response.list( + client.page_rules.with_raw_response.list( zone_id="", ) @parametrize def test_method_delete(self, client: Cloudflare) -> None: - pagerule = client.pagerules.delete( + page_rule = client.page_rules.delete( pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[PageruleDeleteResponse], pagerule, path=["response"]) + assert_matches_type(Optional[PageRuleDeleteResponse], page_rule, path=["response"]) @parametrize def test_raw_response_delete(self, client: Cloudflare) -> None: - response = client.pagerules.with_raw_response.delete( + response = client.page_rules.with_raw_response.delete( pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" - pagerule = response.parse() - assert_matches_type(Optional[PageruleDeleteResponse], pagerule, path=["response"]) + page_rule = response.parse() + assert_matches_type(Optional[PageRuleDeleteResponse], page_rule, path=["response"]) @parametrize def test_streaming_response_delete(self, client: Cloudflare) -> None: - with client.pagerules.with_streaming_response.delete( + with client.page_rules.with_streaming_response.delete( pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" - pagerule = response.parse() - assert_matches_type(Optional[PageruleDeleteResponse], pagerule, path=["response"]) + page_rule = response.parse() + assert_matches_type(Optional[PageRuleDeleteResponse], page_rule, path=["response"]) assert cast(Any, response.is_closed) is True @parametrize def test_path_params_delete(self, client: Cloudflare) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `zone_id` but received ''"): - client.pagerules.with_raw_response.delete( + client.page_rules.with_raw_response.delete( pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", zone_id="", ) with pytest.raises(ValueError, match=r"Expected a non-empty value for `pagerule_id` but received ''"): - client.pagerules.with_raw_response.delete( + client.page_rules.with_raw_response.delete( pagerule_id="", zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) @parametrize def test_method_edit(self, client: Cloudflare) -> None: - pagerule = client.pagerules.edit( + page_rule = client.page_rules.edit( pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[PageRule], pagerule, path=["response"]) + assert_matches_type(Optional[PageRule], page_rule, path=["response"]) @parametrize def test_method_edit_with_all_params(self, client: Cloudflare) -> None: - pagerule = client.pagerules.edit( + page_rule = client.page_rules.edit( pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", zone_id="023e105f4ecef8ad9ca31a8372d0c353", actions=[ @@ -374,103 +374,103 @@ def test_method_edit_with_all_params(self, client: Cloudflare) -> None: } ], ) - assert_matches_type(Optional[PageRule], pagerule, path=["response"]) + assert_matches_type(Optional[PageRule], page_rule, path=["response"]) @parametrize def test_raw_response_edit(self, client: Cloudflare) -> None: - response = client.pagerules.with_raw_response.edit( + response = client.page_rules.with_raw_response.edit( pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" - pagerule = response.parse() - assert_matches_type(Optional[PageRule], pagerule, path=["response"]) + page_rule = response.parse() + assert_matches_type(Optional[PageRule], page_rule, path=["response"]) @parametrize def test_streaming_response_edit(self, client: Cloudflare) -> None: - with client.pagerules.with_streaming_response.edit( + with client.page_rules.with_streaming_response.edit( pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" - pagerule = response.parse() - assert_matches_type(Optional[PageRule], pagerule, path=["response"]) + page_rule = response.parse() + assert_matches_type(Optional[PageRule], page_rule, path=["response"]) assert cast(Any, response.is_closed) is True @parametrize def test_path_params_edit(self, client: Cloudflare) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `zone_id` but received ''"): - client.pagerules.with_raw_response.edit( + client.page_rules.with_raw_response.edit( pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", zone_id="", ) with pytest.raises(ValueError, match=r"Expected a non-empty value for `pagerule_id` but received ''"): - client.pagerules.with_raw_response.edit( + client.page_rules.with_raw_response.edit( pagerule_id="", zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) @parametrize def test_method_get(self, client: Cloudflare) -> None: - pagerule = client.pagerules.get( + page_rule = client.page_rules.get( pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[PageRule], pagerule, path=["response"]) + assert_matches_type(Optional[PageRule], page_rule, path=["response"]) @parametrize def test_raw_response_get(self, client: Cloudflare) -> None: - response = client.pagerules.with_raw_response.get( + response = client.page_rules.with_raw_response.get( pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" - pagerule = response.parse() - assert_matches_type(Optional[PageRule], pagerule, path=["response"]) + page_rule = response.parse() + assert_matches_type(Optional[PageRule], page_rule, path=["response"]) @parametrize def test_streaming_response_get(self, client: Cloudflare) -> None: - with client.pagerules.with_streaming_response.get( + with client.page_rules.with_streaming_response.get( pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" - pagerule = response.parse() - assert_matches_type(Optional[PageRule], pagerule, path=["response"]) + page_rule = response.parse() + assert_matches_type(Optional[PageRule], page_rule, path=["response"]) assert cast(Any, response.is_closed) is True @parametrize def test_path_params_get(self, client: Cloudflare) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `zone_id` but received ''"): - client.pagerules.with_raw_response.get( + client.page_rules.with_raw_response.get( pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", zone_id="", ) with pytest.raises(ValueError, match=r"Expected a non-empty value for `pagerule_id` but received ''"): - client.pagerules.with_raw_response.get( + client.page_rules.with_raw_response.get( pagerule_id="", zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) -class TestAsyncPagerules: +class TestAsyncPageRules: parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"]) @parametrize async def test_method_create(self, async_client: AsyncCloudflare) -> None: - pagerule = await async_client.pagerules.create( + page_rule = await async_client.page_rules.create( zone_id="023e105f4ecef8ad9ca31a8372d0c353", actions=[{}], targets=[ @@ -483,11 +483,11 @@ async def test_method_create(self, async_client: AsyncCloudflare) -> None: } ], ) - assert_matches_type(Optional[PageRule], pagerule, path=["response"]) + assert_matches_type(Optional[PageRule], page_rule, path=["response"]) @parametrize async def test_method_create_with_all_params(self, async_client: AsyncCloudflare) -> None: - pagerule = await async_client.pagerules.create( + page_rule = await async_client.page_rules.create( zone_id="023e105f4ecef8ad9ca31a8372d0c353", actions=[ { @@ -507,11 +507,11 @@ async def test_method_create_with_all_params(self, async_client: AsyncCloudflare priority=0, status="active", ) - assert_matches_type(Optional[PageRule], pagerule, path=["response"]) + assert_matches_type(Optional[PageRule], page_rule, path=["response"]) @parametrize async def test_raw_response_create(self, async_client: AsyncCloudflare) -> None: - response = await async_client.pagerules.with_raw_response.create( + response = await async_client.page_rules.with_raw_response.create( zone_id="023e105f4ecef8ad9ca31a8372d0c353", actions=[{}], targets=[ @@ -527,12 +527,12 @@ async def test_raw_response_create(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" - pagerule = await response.parse() - assert_matches_type(Optional[PageRule], pagerule, path=["response"]) + page_rule = await response.parse() + assert_matches_type(Optional[PageRule], page_rule, path=["response"]) @parametrize async def test_streaming_response_create(self, async_client: AsyncCloudflare) -> None: - async with async_client.pagerules.with_streaming_response.create( + async with async_client.page_rules.with_streaming_response.create( zone_id="023e105f4ecef8ad9ca31a8372d0c353", actions=[{}], targets=[ @@ -548,15 +548,15 @@ async def test_streaming_response_create(self, async_client: AsyncCloudflare) -> assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" - pagerule = await response.parse() - assert_matches_type(Optional[PageRule], pagerule, path=["response"]) + page_rule = await response.parse() + assert_matches_type(Optional[PageRule], page_rule, path=["response"]) assert cast(Any, response.is_closed) is True @parametrize async def test_path_params_create(self, async_client: AsyncCloudflare) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `zone_id` but received ''"): - await async_client.pagerules.with_raw_response.create( + await async_client.page_rules.with_raw_response.create( zone_id="", actions=[{}], targets=[ @@ -572,7 +572,7 @@ async def test_path_params_create(self, async_client: AsyncCloudflare) -> None: @parametrize async def test_method_update(self, async_client: AsyncCloudflare) -> None: - pagerule = await async_client.pagerules.update( + page_rule = await async_client.page_rules.update( pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", zone_id="023e105f4ecef8ad9ca31a8372d0c353", actions=[{}], @@ -586,11 +586,11 @@ async def test_method_update(self, async_client: AsyncCloudflare) -> None: } ], ) - assert_matches_type(Optional[PageRule], pagerule, path=["response"]) + assert_matches_type(Optional[PageRule], page_rule, path=["response"]) @parametrize async def test_method_update_with_all_params(self, async_client: AsyncCloudflare) -> None: - pagerule = await async_client.pagerules.update( + page_rule = await async_client.page_rules.update( pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", zone_id="023e105f4ecef8ad9ca31a8372d0c353", actions=[ @@ -611,11 +611,11 @@ async def test_method_update_with_all_params(self, async_client: AsyncCloudflare priority=0, status="active", ) - assert_matches_type(Optional[PageRule], pagerule, path=["response"]) + assert_matches_type(Optional[PageRule], page_rule, path=["response"]) @parametrize async def test_raw_response_update(self, async_client: AsyncCloudflare) -> None: - response = await async_client.pagerules.with_raw_response.update( + response = await async_client.page_rules.with_raw_response.update( pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", zone_id="023e105f4ecef8ad9ca31a8372d0c353", actions=[{}], @@ -632,12 +632,12 @@ async def test_raw_response_update(self, async_client: AsyncCloudflare) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" - pagerule = await response.parse() - assert_matches_type(Optional[PageRule], pagerule, path=["response"]) + page_rule = await response.parse() + assert_matches_type(Optional[PageRule], page_rule, path=["response"]) @parametrize async def test_streaming_response_update(self, async_client: AsyncCloudflare) -> None: - async with async_client.pagerules.with_streaming_response.update( + async with async_client.page_rules.with_streaming_response.update( pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", zone_id="023e105f4ecef8ad9ca31a8372d0c353", actions=[{}], @@ -654,15 +654,15 @@ async def test_streaming_response_update(self, async_client: AsyncCloudflare) -> assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" - pagerule = await response.parse() - assert_matches_type(Optional[PageRule], pagerule, path=["response"]) + page_rule = await response.parse() + assert_matches_type(Optional[PageRule], page_rule, path=["response"]) assert cast(Any, response.is_closed) is True @parametrize async def test_path_params_update(self, async_client: AsyncCloudflare) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `zone_id` but received ''"): - await async_client.pagerules.with_raw_response.update( + await async_client.page_rules.with_raw_response.update( pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", zone_id="", actions=[{}], @@ -678,7 +678,7 @@ async def test_path_params_update(self, async_client: AsyncCloudflare) -> None: ) with pytest.raises(ValueError, match=r"Expected a non-empty value for `pagerule_id` but received ''"): - await async_client.pagerules.with_raw_response.update( + await async_client.page_rules.with_raw_response.update( pagerule_id="", zone_id="023e105f4ecef8ad9ca31a8372d0c353", actions=[{}], @@ -695,112 +695,112 @@ async def test_path_params_update(self, async_client: AsyncCloudflare) -> None: @parametrize async def test_method_list(self, async_client: AsyncCloudflare) -> None: - pagerule = await async_client.pagerules.list( + page_rule = await async_client.page_rules.list( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[PageruleListResponse], pagerule, path=["response"]) + assert_matches_type(Optional[PageRuleListResponse], page_rule, path=["response"]) @parametrize async def test_method_list_with_all_params(self, async_client: AsyncCloudflare) -> None: - pagerule = await async_client.pagerules.list( + page_rule = await async_client.page_rules.list( zone_id="023e105f4ecef8ad9ca31a8372d0c353", direction="asc", match="any", order="status", status="active", ) - assert_matches_type(Optional[PageruleListResponse], pagerule, path=["response"]) + assert_matches_type(Optional[PageRuleListResponse], page_rule, path=["response"]) @parametrize async def test_raw_response_list(self, async_client: AsyncCloudflare) -> None: - response = await async_client.pagerules.with_raw_response.list( + response = await async_client.page_rules.with_raw_response.list( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" - pagerule = await response.parse() - assert_matches_type(Optional[PageruleListResponse], pagerule, path=["response"]) + page_rule = await response.parse() + assert_matches_type(Optional[PageRuleListResponse], page_rule, path=["response"]) @parametrize async def test_streaming_response_list(self, async_client: AsyncCloudflare) -> None: - async with async_client.pagerules.with_streaming_response.list( + async with async_client.page_rules.with_streaming_response.list( zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" - pagerule = await response.parse() - assert_matches_type(Optional[PageruleListResponse], pagerule, path=["response"]) + page_rule = await response.parse() + assert_matches_type(Optional[PageRuleListResponse], page_rule, path=["response"]) assert cast(Any, response.is_closed) is True @parametrize async def test_path_params_list(self, async_client: AsyncCloudflare) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `zone_id` but received ''"): - await async_client.pagerules.with_raw_response.list( + await async_client.page_rules.with_raw_response.list( zone_id="", ) @parametrize async def test_method_delete(self, async_client: AsyncCloudflare) -> None: - pagerule = await async_client.pagerules.delete( + page_rule = await async_client.page_rules.delete( pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[PageruleDeleteResponse], pagerule, path=["response"]) + assert_matches_type(Optional[PageRuleDeleteResponse], page_rule, path=["response"]) @parametrize async def test_raw_response_delete(self, async_client: AsyncCloudflare) -> None: - response = await async_client.pagerules.with_raw_response.delete( + response = await async_client.page_rules.with_raw_response.delete( pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" - pagerule = await response.parse() - assert_matches_type(Optional[PageruleDeleteResponse], pagerule, path=["response"]) + page_rule = await response.parse() + assert_matches_type(Optional[PageRuleDeleteResponse], page_rule, path=["response"]) @parametrize async def test_streaming_response_delete(self, async_client: AsyncCloudflare) -> None: - async with async_client.pagerules.with_streaming_response.delete( + async with async_client.page_rules.with_streaming_response.delete( pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" - pagerule = await response.parse() - assert_matches_type(Optional[PageruleDeleteResponse], pagerule, path=["response"]) + page_rule = await response.parse() + assert_matches_type(Optional[PageRuleDeleteResponse], page_rule, path=["response"]) assert cast(Any, response.is_closed) is True @parametrize async def test_path_params_delete(self, async_client: AsyncCloudflare) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `zone_id` but received ''"): - await async_client.pagerules.with_raw_response.delete( + await async_client.page_rules.with_raw_response.delete( pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", zone_id="", ) with pytest.raises(ValueError, match=r"Expected a non-empty value for `pagerule_id` but received ''"): - await async_client.pagerules.with_raw_response.delete( + await async_client.page_rules.with_raw_response.delete( pagerule_id="", zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) @parametrize async def test_method_edit(self, async_client: AsyncCloudflare) -> None: - pagerule = await async_client.pagerules.edit( + page_rule = await async_client.page_rules.edit( pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[PageRule], pagerule, path=["response"]) + assert_matches_type(Optional[PageRule], page_rule, path=["response"]) @parametrize async def test_method_edit_with_all_params(self, async_client: AsyncCloudflare) -> None: - pagerule = await async_client.pagerules.edit( + page_rule = await async_client.page_rules.edit( pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", zone_id="023e105f4ecef8ad9ca31a8372d0c353", actions=[ @@ -821,92 +821,92 @@ async def test_method_edit_with_all_params(self, async_client: AsyncCloudflare) } ], ) - assert_matches_type(Optional[PageRule], pagerule, path=["response"]) + assert_matches_type(Optional[PageRule], page_rule, path=["response"]) @parametrize async def test_raw_response_edit(self, async_client: AsyncCloudflare) -> None: - response = await async_client.pagerules.with_raw_response.edit( + response = await async_client.page_rules.with_raw_response.edit( pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" - pagerule = await response.parse() - assert_matches_type(Optional[PageRule], pagerule, path=["response"]) + page_rule = await response.parse() + assert_matches_type(Optional[PageRule], page_rule, path=["response"]) @parametrize async def test_streaming_response_edit(self, async_client: AsyncCloudflare) -> None: - async with async_client.pagerules.with_streaming_response.edit( + async with async_client.page_rules.with_streaming_response.edit( pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" - pagerule = await response.parse() - assert_matches_type(Optional[PageRule], pagerule, path=["response"]) + page_rule = await response.parse() + assert_matches_type(Optional[PageRule], page_rule, path=["response"]) assert cast(Any, response.is_closed) is True @parametrize async def test_path_params_edit(self, async_client: AsyncCloudflare) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `zone_id` but received ''"): - await async_client.pagerules.with_raw_response.edit( + await async_client.page_rules.with_raw_response.edit( pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", zone_id="", ) with pytest.raises(ValueError, match=r"Expected a non-empty value for `pagerule_id` but received ''"): - await async_client.pagerules.with_raw_response.edit( + await async_client.page_rules.with_raw_response.edit( pagerule_id="", zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) @parametrize async def test_method_get(self, async_client: AsyncCloudflare) -> None: - pagerule = await async_client.pagerules.get( + page_rule = await async_client.page_rules.get( pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) - assert_matches_type(Optional[PageRule], pagerule, path=["response"]) + assert_matches_type(Optional[PageRule], page_rule, path=["response"]) @parametrize async def test_raw_response_get(self, async_client: AsyncCloudflare) -> None: - response = await async_client.pagerules.with_raw_response.get( + response = await async_client.page_rules.with_raw_response.get( pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" - pagerule = await response.parse() - assert_matches_type(Optional[PageRule], pagerule, path=["response"]) + page_rule = await response.parse() + assert_matches_type(Optional[PageRule], page_rule, path=["response"]) @parametrize async def test_streaming_response_get(self, async_client: AsyncCloudflare) -> None: - async with async_client.pagerules.with_streaming_response.get( + async with async_client.page_rules.with_streaming_response.get( pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" - pagerule = await response.parse() - assert_matches_type(Optional[PageRule], pagerule, path=["response"]) + page_rule = await response.parse() + assert_matches_type(Optional[PageRule], page_rule, path=["response"]) assert cast(Any, response.is_closed) is True @parametrize async def test_path_params_get(self, async_client: AsyncCloudflare) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `zone_id` but received ''"): - await async_client.pagerules.with_raw_response.get( + await async_client.page_rules.with_raw_response.get( pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", zone_id="", ) with pytest.raises(ValueError, match=r"Expected a non-empty value for `pagerule_id` but received ''"): - await async_client.pagerules.with_raw_response.get( + await async_client.page_rules.with_raw_response.get( pagerule_id="", zone_id="023e105f4ecef8ad9ca31a8372d0c353", )