diff --git a/.stats.yml b/.stats.yml index 25f2dbf6793..4ca19da8d57 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,2 +1,2 @@ -configured_endpoints: 1547 +configured_endpoints: 1548 openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/cloudflare%2Fcloudflare-cc9be7885f16989f56e5e015644178eb17b82304fc31f62ed14b7e9a93cab891.yml diff --git a/api.md b/api.md index e6a0e09a3bb..c96e4deaa04 100644 --- a/api.md +++ b/api.md @@ -3951,6 +3951,20 @@ Methods: # MagicNetworkMonitoring +## VpcFlows + +### Tokens + +Types: + +```python +from cloudflare.types.magic_network_monitoring.vpc_flows import TokenCreateResponse +``` + +Methods: + +- client.magic_network_monitoring.vpc_flows.tokens.create(\*, account_id) -> str + ## Configs Types: diff --git a/src/cloudflare/resources/magic_network_monitoring/__init__.py b/src/cloudflare/resources/magic_network_monitoring/__init__.py index ddc8bc54f41..b0bdec4abc5 100644 --- a/src/cloudflare/resources/magic_network_monitoring/__init__.py +++ b/src/cloudflare/resources/magic_network_monitoring/__init__.py @@ -16,6 +16,14 @@ ConfigsResourceWithStreamingResponse, AsyncConfigsResourceWithStreamingResponse, ) +from .vpc_flows import ( + VpcFlowsResource, + AsyncVpcFlowsResource, + VpcFlowsResourceWithRawResponse, + AsyncVpcFlowsResourceWithRawResponse, + VpcFlowsResourceWithStreamingResponse, + AsyncVpcFlowsResourceWithStreamingResponse, +) from .magic_network_monitoring import ( MagicNetworkMonitoringResource, AsyncMagicNetworkMonitoringResource, @@ -26,6 +34,12 @@ ) __all__ = [ + "VpcFlowsResource", + "AsyncVpcFlowsResource", + "VpcFlowsResourceWithRawResponse", + "AsyncVpcFlowsResourceWithRawResponse", + "VpcFlowsResourceWithStreamingResponse", + "AsyncVpcFlowsResourceWithStreamingResponse", "ConfigsResource", "AsyncConfigsResource", "ConfigsResourceWithRawResponse", diff --git a/src/cloudflare/resources/magic_network_monitoring/magic_network_monitoring.py b/src/cloudflare/resources/magic_network_monitoring/magic_network_monitoring.py index 4c11d9c6f8a..f05f0aadded 100644 --- a/src/cloudflare/resources/magic_network_monitoring/magic_network_monitoring.py +++ b/src/cloudflare/resources/magic_network_monitoring/magic_network_monitoring.py @@ -20,11 +20,23 @@ ConfigsResourceWithStreamingResponse, AsyncConfigsResourceWithStreamingResponse, ) +from .vpc_flows.vpc_flows import ( + VpcFlowsResource, + AsyncVpcFlowsResource, + VpcFlowsResourceWithRawResponse, + AsyncVpcFlowsResourceWithRawResponse, + VpcFlowsResourceWithStreamingResponse, + AsyncVpcFlowsResourceWithStreamingResponse, +) __all__ = ["MagicNetworkMonitoringResource", "AsyncMagicNetworkMonitoringResource"] class MagicNetworkMonitoringResource(SyncAPIResource): + @cached_property + def vpc_flows(self) -> VpcFlowsResource: + return VpcFlowsResource(self._client) + @cached_property def configs(self) -> ConfigsResource: return ConfigsResource(self._client) @@ -54,6 +66,10 @@ def with_streaming_response(self) -> MagicNetworkMonitoringResourceWithStreaming class AsyncMagicNetworkMonitoringResource(AsyncAPIResource): + @cached_property + def vpc_flows(self) -> AsyncVpcFlowsResource: + return AsyncVpcFlowsResource(self._client) + @cached_property def configs(self) -> AsyncConfigsResource: return AsyncConfigsResource(self._client) @@ -86,6 +102,10 @@ class MagicNetworkMonitoringResourceWithRawResponse: def __init__(self, magic_network_monitoring: MagicNetworkMonitoringResource) -> None: self._magic_network_monitoring = magic_network_monitoring + @cached_property + def vpc_flows(self) -> VpcFlowsResourceWithRawResponse: + return VpcFlowsResourceWithRawResponse(self._magic_network_monitoring.vpc_flows) + @cached_property def configs(self) -> ConfigsResourceWithRawResponse: return ConfigsResourceWithRawResponse(self._magic_network_monitoring.configs) @@ -99,6 +119,10 @@ class AsyncMagicNetworkMonitoringResourceWithRawResponse: def __init__(self, magic_network_monitoring: AsyncMagicNetworkMonitoringResource) -> None: self._magic_network_monitoring = magic_network_monitoring + @cached_property + def vpc_flows(self) -> AsyncVpcFlowsResourceWithRawResponse: + return AsyncVpcFlowsResourceWithRawResponse(self._magic_network_monitoring.vpc_flows) + @cached_property def configs(self) -> AsyncConfigsResourceWithRawResponse: return AsyncConfigsResourceWithRawResponse(self._magic_network_monitoring.configs) @@ -112,6 +136,10 @@ class MagicNetworkMonitoringResourceWithStreamingResponse: def __init__(self, magic_network_monitoring: MagicNetworkMonitoringResource) -> None: self._magic_network_monitoring = magic_network_monitoring + @cached_property + def vpc_flows(self) -> VpcFlowsResourceWithStreamingResponse: + return VpcFlowsResourceWithStreamingResponse(self._magic_network_monitoring.vpc_flows) + @cached_property def configs(self) -> ConfigsResourceWithStreamingResponse: return ConfigsResourceWithStreamingResponse(self._magic_network_monitoring.configs) @@ -125,6 +153,10 @@ class AsyncMagicNetworkMonitoringResourceWithStreamingResponse: def __init__(self, magic_network_monitoring: AsyncMagicNetworkMonitoringResource) -> None: self._magic_network_monitoring = magic_network_monitoring + @cached_property + def vpc_flows(self) -> AsyncVpcFlowsResourceWithStreamingResponse: + return AsyncVpcFlowsResourceWithStreamingResponse(self._magic_network_monitoring.vpc_flows) + @cached_property def configs(self) -> AsyncConfigsResourceWithStreamingResponse: return AsyncConfigsResourceWithStreamingResponse(self._magic_network_monitoring.configs) diff --git a/src/cloudflare/resources/magic_network_monitoring/vpc_flows/__init__.py b/src/cloudflare/resources/magic_network_monitoring/vpc_flows/__init__.py new file mode 100644 index 00000000000..b7de80f41a1 --- /dev/null +++ b/src/cloudflare/resources/magic_network_monitoring/vpc_flows/__init__.py @@ -0,0 +1,33 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from .tokens import ( + TokensResource, + AsyncTokensResource, + TokensResourceWithRawResponse, + AsyncTokensResourceWithRawResponse, + TokensResourceWithStreamingResponse, + AsyncTokensResourceWithStreamingResponse, +) +from .vpc_flows import ( + VpcFlowsResource, + AsyncVpcFlowsResource, + VpcFlowsResourceWithRawResponse, + AsyncVpcFlowsResourceWithRawResponse, + VpcFlowsResourceWithStreamingResponse, + AsyncVpcFlowsResourceWithStreamingResponse, +) + +__all__ = [ + "TokensResource", + "AsyncTokensResource", + "TokensResourceWithRawResponse", + "AsyncTokensResourceWithRawResponse", + "TokensResourceWithStreamingResponse", + "AsyncTokensResourceWithStreamingResponse", + "VpcFlowsResource", + "AsyncVpcFlowsResource", + "VpcFlowsResourceWithRawResponse", + "AsyncVpcFlowsResourceWithRawResponse", + "VpcFlowsResourceWithStreamingResponse", + "AsyncVpcFlowsResourceWithStreamingResponse", +] diff --git a/src/cloudflare/resources/magic_network_monitoring/vpc_flows/tokens.py b/src/cloudflare/resources/magic_network_monitoring/vpc_flows/tokens.py new file mode 100644 index 00000000000..323c7d893d8 --- /dev/null +++ b/src/cloudflare/resources/magic_network_monitoring/vpc_flows/tokens.py @@ -0,0 +1,174 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Type, cast + +import httpx + +from ...._types import NOT_GIVEN, Body, Query, Headers, NotGiven +from ...._compat import cached_property +from ...._resource import SyncAPIResource, AsyncAPIResource +from ...._response import ( + to_raw_response_wrapper, + to_streamed_response_wrapper, + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, +) +from ...._wrappers import ResultWrapper +from ...._base_client import make_request_options +from ....types.magic_network_monitoring.vpc_flows.token_create_response import TokenCreateResponse + +__all__ = ["TokensResource", "AsyncTokensResource"] + + +class TokensResource(SyncAPIResource): + @cached_property + def with_raw_response(self) -> TokensResourceWithRawResponse: + """ + This property can be used as a prefix for any HTTP method call to return + 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 TokensResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> TokensResourceWithStreamingResponse: + """ + 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 TokensResourceWithStreamingResponse(self) + + def create( + self, + *, + account_id: str, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + ) -> str: + """ + Generate authentication token for VPC flow logs export. + + Args: + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + if not account_id: + raise ValueError(f"Expected a non-empty value for `account_id` but received {account_id!r}") + return self._post( + f"/accounts/{account_id}/mnm/vpc-flows/token", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + post_parser=ResultWrapper[TokenCreateResponse]._unwrapper, + ), + cast_to=cast(Type[str], ResultWrapper[str]), + ) + + +class AsyncTokensResource(AsyncAPIResource): + @cached_property + def with_raw_response(self) -> AsyncTokensResourceWithRawResponse: + """ + This property can be used as a prefix for any HTTP method call to return + 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 AsyncTokensResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncTokensResourceWithStreamingResponse: + """ + 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 AsyncTokensResourceWithStreamingResponse(self) + + async def create( + self, + *, + account_id: str, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, + ) -> str: + """ + Generate authentication token for VPC flow logs export. + + Args: + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + if not account_id: + raise ValueError(f"Expected a non-empty value for `account_id` but received {account_id!r}") + return await self._post( + f"/accounts/{account_id}/mnm/vpc-flows/token", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + post_parser=ResultWrapper[TokenCreateResponse]._unwrapper, + ), + cast_to=cast(Type[str], ResultWrapper[str]), + ) + + +class TokensResourceWithRawResponse: + def __init__(self, tokens: TokensResource) -> None: + self._tokens = tokens + + self.create = to_raw_response_wrapper( + tokens.create, + ) + + +class AsyncTokensResourceWithRawResponse: + def __init__(self, tokens: AsyncTokensResource) -> None: + self._tokens = tokens + + self.create = async_to_raw_response_wrapper( + tokens.create, + ) + + +class TokensResourceWithStreamingResponse: + def __init__(self, tokens: TokensResource) -> None: + self._tokens = tokens + + self.create = to_streamed_response_wrapper( + tokens.create, + ) + + +class AsyncTokensResourceWithStreamingResponse: + def __init__(self, tokens: AsyncTokensResource) -> None: + self._tokens = tokens + + self.create = async_to_streamed_response_wrapper( + tokens.create, + ) diff --git a/src/cloudflare/resources/magic_network_monitoring/vpc_flows/vpc_flows.py b/src/cloudflare/resources/magic_network_monitoring/vpc_flows/vpc_flows.py new file mode 100644 index 00000000000..5537a9b4cdf --- /dev/null +++ b/src/cloudflare/resources/magic_network_monitoring/vpc_flows/vpc_flows.py @@ -0,0 +1,102 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from .tokens import ( + TokensResource, + AsyncTokensResource, + TokensResourceWithRawResponse, + AsyncTokensResourceWithRawResponse, + TokensResourceWithStreamingResponse, + AsyncTokensResourceWithStreamingResponse, +) +from ...._compat import cached_property +from ...._resource import SyncAPIResource, AsyncAPIResource + +__all__ = ["VpcFlowsResource", "AsyncVpcFlowsResource"] + + +class VpcFlowsResource(SyncAPIResource): + @cached_property + def tokens(self) -> TokensResource: + return TokensResource(self._client) + + @cached_property + def with_raw_response(self) -> VpcFlowsResourceWithRawResponse: + """ + This property can be used as a prefix for any HTTP method call to return + 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 VpcFlowsResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> VpcFlowsResourceWithStreamingResponse: + """ + 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 VpcFlowsResourceWithStreamingResponse(self) + + +class AsyncVpcFlowsResource(AsyncAPIResource): + @cached_property + def tokens(self) -> AsyncTokensResource: + return AsyncTokensResource(self._client) + + @cached_property + def with_raw_response(self) -> AsyncVpcFlowsResourceWithRawResponse: + """ + This property can be used as a prefix for any HTTP method call to return + 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 AsyncVpcFlowsResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncVpcFlowsResourceWithStreamingResponse: + """ + 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 AsyncVpcFlowsResourceWithStreamingResponse(self) + + +class VpcFlowsResourceWithRawResponse: + def __init__(self, vpc_flows: VpcFlowsResource) -> None: + self._vpc_flows = vpc_flows + + @cached_property + def tokens(self) -> TokensResourceWithRawResponse: + return TokensResourceWithRawResponse(self._vpc_flows.tokens) + + +class AsyncVpcFlowsResourceWithRawResponse: + def __init__(self, vpc_flows: AsyncVpcFlowsResource) -> None: + self._vpc_flows = vpc_flows + + @cached_property + def tokens(self) -> AsyncTokensResourceWithRawResponse: + return AsyncTokensResourceWithRawResponse(self._vpc_flows.tokens) + + +class VpcFlowsResourceWithStreamingResponse: + def __init__(self, vpc_flows: VpcFlowsResource) -> None: + self._vpc_flows = vpc_flows + + @cached_property + def tokens(self) -> TokensResourceWithStreamingResponse: + return TokensResourceWithStreamingResponse(self._vpc_flows.tokens) + + +class AsyncVpcFlowsResourceWithStreamingResponse: + def __init__(self, vpc_flows: AsyncVpcFlowsResource) -> None: + self._vpc_flows = vpc_flows + + @cached_property + def tokens(self) -> AsyncTokensResourceWithStreamingResponse: + return AsyncTokensResourceWithStreamingResponse(self._vpc_flows.tokens) diff --git a/src/cloudflare/types/magic_network_monitoring/vpc_flows/__init__.py b/src/cloudflare/types/magic_network_monitoring/vpc_flows/__init__.py new file mode 100644 index 00000000000..a50c944db8f --- /dev/null +++ b/src/cloudflare/types/magic_network_monitoring/vpc_flows/__init__.py @@ -0,0 +1,5 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from .token_create_response import TokenCreateResponse as TokenCreateResponse diff --git a/src/cloudflare/types/magic_network_monitoring/vpc_flows/token_create_response.py b/src/cloudflare/types/magic_network_monitoring/vpc_flows/token_create_response.py new file mode 100644 index 00000000000..58d33dba745 --- /dev/null +++ b/src/cloudflare/types/magic_network_monitoring/vpc_flows/token_create_response.py @@ -0,0 +1,7 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing_extensions import TypeAlias + +__all__ = ["TokenCreateResponse"] + +TokenCreateResponse: TypeAlias = str diff --git a/tests/api_resources/magic_network_monitoring/vpc_flows/__init__.py b/tests/api_resources/magic_network_monitoring/vpc_flows/__init__.py new file mode 100644 index 00000000000..fd8019a9a1a --- /dev/null +++ b/tests/api_resources/magic_network_monitoring/vpc_flows/__init__.py @@ -0,0 +1 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. diff --git a/tests/api_resources/magic_network_monitoring/vpc_flows/test_tokens.py b/tests/api_resources/magic_network_monitoring/vpc_flows/test_tokens.py new file mode 100644 index 00000000000..01a029b3b62 --- /dev/null +++ b/tests/api_resources/magic_network_monitoring/vpc_flows/test_tokens.py @@ -0,0 +1,97 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +import os +from typing import Any, cast + +import pytest + +from cloudflare import Cloudflare, AsyncCloudflare +from tests.utils import assert_matches_type + +base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") + + +class TestTokens: + parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) + + @parametrize + def test_method_create(self, client: Cloudflare) -> None: + token = client.magic_network_monitoring.vpc_flows.tokens.create( + account_id="6f91088a406011ed95aed352566e8d4c", + ) + assert_matches_type(str, token, path=["response"]) + + @parametrize + def test_raw_response_create(self, client: Cloudflare) -> None: + response = client.magic_network_monitoring.vpc_flows.tokens.with_raw_response.create( + account_id="6f91088a406011ed95aed352566e8d4c", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + token = response.parse() + assert_matches_type(str, token, path=["response"]) + + @parametrize + def test_streaming_response_create(self, client: Cloudflare) -> None: + with client.magic_network_monitoring.vpc_flows.tokens.with_streaming_response.create( + account_id="6f91088a406011ed95aed352566e8d4c", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + token = response.parse() + assert_matches_type(str, token, 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 `account_id` but received ''"): + client.magic_network_monitoring.vpc_flows.tokens.with_raw_response.create( + account_id="", + ) + + +class TestAsyncTokens: + parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"]) + + @parametrize + async def test_method_create(self, async_client: AsyncCloudflare) -> None: + token = await async_client.magic_network_monitoring.vpc_flows.tokens.create( + account_id="6f91088a406011ed95aed352566e8d4c", + ) + assert_matches_type(str, token, path=["response"]) + + @parametrize + async def test_raw_response_create(self, async_client: AsyncCloudflare) -> None: + response = await async_client.magic_network_monitoring.vpc_flows.tokens.with_raw_response.create( + account_id="6f91088a406011ed95aed352566e8d4c", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + token = await response.parse() + assert_matches_type(str, token, path=["response"]) + + @parametrize + async def test_streaming_response_create(self, async_client: AsyncCloudflare) -> None: + async with async_client.magic_network_monitoring.vpc_flows.tokens.with_streaming_response.create( + account_id="6f91088a406011ed95aed352566e8d4c", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + token = await response.parse() + assert_matches_type(str, token, 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 `account_id` but received ''"): + await async_client.magic_network_monitoring.vpc_flows.tokens.with_raw_response.create( + account_id="", + )