robosystems-client 0.1.9__py3-none-any.whl

robosystems_client/api/user_subscriptions/upgrade_shared_repository_subscription.py

@@ -0,0 +1,228 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union, cast
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.http_validation_error import HTTPValidationError
+from ...models.tier_upgrade_request import TierUpgradeRequest
+from ...types import UNSET, Response, Unset
+
+
+def _get_kwargs(
+  subscription_id: str,
+  *,
+  body: TierUpgradeRequest,
+  authorization: Union[None, Unset, str] = UNSET,
+  auth_token: Union[None, Unset, str] = UNSET,
+) -> dict[str, Any]:
+  headers: dict[str, Any] = {}
+  if not isinstance(authorization, Unset):
+    headers["authorization"] = authorization
+
+  cookies = {}
+  if auth_token is not UNSET:
+    cookies["auth-token"] = auth_token
+
+  _kwargs: dict[str, Any] = {
+    "method": "put",
+    "url": f"/v1/user/subscriptions/shared-repositories/{subscription_id}/upgrade",
+    "cookies": cookies,
+  }
+
+  _kwargs["json"] = body.to_dict()
+
+  headers["Content-Type"] = "application/json"
+
+  _kwargs["headers"] = headers
+  return _kwargs
+
+
+def _parse_response(
+  *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Union[Any, HTTPValidationError]]:
+  if response.status_code == 200:
+    response_200 = response.json()
+    return response_200
+  if response.status_code == 400:
+    response_400 = cast(Any, None)
+    return response_400
+  if response.status_code == 404:
+    response_404 = cast(Any, None)
+    return response_404
+  if response.status_code == 401:
+    response_401 = cast(Any, None)
+    return response_401
+  if response.status_code == 500:
+    response_500 = cast(Any, None)
+    return response_500
+  if response.status_code == 422:
+    response_422 = HTTPValidationError.from_dict(response.json())
+
+    return response_422
+  if client.raise_on_unexpected_status:
+    raise errors.UnexpectedStatus(response.status_code, response.content)
+  else:
+    return None
+
+
+def _build_response(
+  *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[Union[Any, HTTPValidationError]]:
+  return Response(
+    status_code=HTTPStatus(response.status_code),
+    content=response.content,
+    headers=response.headers,
+    parsed=_parse_response(client=client, response=response),
+  )
+
+
+def sync_detailed(
+  subscription_id: str,
+  *,
+  client: AuthenticatedClient,
+  body: TierUpgradeRequest,
+  authorization: Union[None, Unset, str] = UNSET,
+  auth_token: Union[None, Unset, str] = UNSET,
+) -> Response[Union[Any, HTTPValidationError]]:
+  """Upgrade Subscription Tier
+
+   Upgrade a subscription to a higher tier with immediate credit adjustment
+
+  Args:
+      subscription_id (str):
+      authorization (Union[None, Unset, str]):
+      auth_token (Union[None, Unset, str]):
+      body (TierUpgradeRequest): Request to upgrade subscription tier.
+
+  Raises:
+      errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+      httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+  Returns:
+      Response[Union[Any, HTTPValidationError]]
+  """
+
+  kwargs = _get_kwargs(
+    subscription_id=subscription_id,
+    body=body,
+    authorization=authorization,
+    auth_token=auth_token,
+  )
+
+  response = client.get_httpx_client().request(
+    **kwargs,
+  )
+
+  return _build_response(client=client, response=response)
+
+
+def sync(
+  subscription_id: str,
+  *,
+  client: AuthenticatedClient,
+  body: TierUpgradeRequest,
+  authorization: Union[None, Unset, str] = UNSET,
+  auth_token: Union[None, Unset, str] = UNSET,
+) -> Optional[Union[Any, HTTPValidationError]]:
+  """Upgrade Subscription Tier
+
+   Upgrade a subscription to a higher tier with immediate credit adjustment
+
+  Args:
+      subscription_id (str):
+      authorization (Union[None, Unset, str]):
+      auth_token (Union[None, Unset, str]):
+      body (TierUpgradeRequest): Request to upgrade subscription tier.
+
+  Raises:
+      errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+      httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+  Returns:
+      Union[Any, HTTPValidationError]
+  """
+
+  return sync_detailed(
+    subscription_id=subscription_id,
+    client=client,
+    body=body,
+    authorization=authorization,
+    auth_token=auth_token,
+  ).parsed
+
+
+async def asyncio_detailed(
+  subscription_id: str,
+  *,
+  client: AuthenticatedClient,
+  body: TierUpgradeRequest,
+  authorization: Union[None, Unset, str] = UNSET,
+  auth_token: Union[None, Unset, str] = UNSET,
+) -> Response[Union[Any, HTTPValidationError]]:
+  """Upgrade Subscription Tier
+
+   Upgrade a subscription to a higher tier with immediate credit adjustment
+
+  Args:
+      subscription_id (str):
+      authorization (Union[None, Unset, str]):
+      auth_token (Union[None, Unset, str]):
+      body (TierUpgradeRequest): Request to upgrade subscription tier.
+
+  Raises:
+      errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+      httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+  Returns:
+      Response[Union[Any, HTTPValidationError]]
+  """
+
+  kwargs = _get_kwargs(
+    subscription_id=subscription_id,
+    body=body,
+    authorization=authorization,
+    auth_token=auth_token,
+  )
+
+  response = await client.get_async_httpx_client().request(**kwargs)
+
+  return _build_response(client=client, response=response)
+
+
+async def asyncio(
+  subscription_id: str,
+  *,
+  client: AuthenticatedClient,
+  body: TierUpgradeRequest,
+  authorization: Union[None, Unset, str] = UNSET,
+  auth_token: Union[None, Unset, str] = UNSET,
+) -> Optional[Union[Any, HTTPValidationError]]:
+  """Upgrade Subscription Tier
+
+   Upgrade a subscription to a higher tier with immediate credit adjustment
+
+  Args:
+      subscription_id (str):
+      authorization (Union[None, Unset, str]):
+      auth_token (Union[None, Unset, str]):
+      body (TierUpgradeRequest): Request to upgrade subscription tier.
+
+  Raises:
+      errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+      httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+  Returns:
+      Union[Any, HTTPValidationError]
+  """
+
+  return (
+    await asyncio_detailed(
+      subscription_id=subscription_id,
+      client=client,
+      body=body,
+      authorization=authorization,
+      auth_token=auth_token,
+    )
+  ).parsed

robosystems_client/client.py

@@ -0,0 +1,278 @@
+import ssl
+from typing import Any, Optional, Union
+
+import httpx
+from attrs import define, evolve, field
+
+
+@define
+class Client:
+  """A class for keeping track of data related to the API
+
+  The following are accepted as keyword arguments and will be used to construct httpx Clients internally:
+
+      ``base_url``: The base URL for the API, all requests are made to a relative path to this URL
+
+      ``cookies``: A dictionary of cookies to be sent with every request
+
+      ``headers``: A dictionary of headers to be sent with every request
+
+      ``timeout``: The maximum amount of a time a request can take. API functions will raise
+      httpx.TimeoutException if this is exceeded.
+
+      ``verify_ssl``: Whether or not to verify the SSL certificate of the API server. This should be True in production,
+      but can be set to False for testing purposes.
+
+      ``follow_redirects``: Whether or not to follow redirects. Default value is False.
+
+      ``httpx_args``: A dictionary of additional arguments to be passed to the ``httpx.Client`` and ``httpx.AsyncClient`` constructor.
+
+
+  Attributes:
+      raise_on_unexpected_status: Whether or not to raise an errors.UnexpectedStatus if the API returns a
+          status code that was not documented in the source OpenAPI document. Can also be provided as a keyword
+          argument to the constructor.
+  """
+
+  raise_on_unexpected_status: bool = field(default=False, kw_only=True)
+  _base_url: str = field(alias="base_url")
+  _cookies: dict[str, str] = field(factory=dict, kw_only=True, alias="cookies")
+  _headers: dict[str, str] = field(factory=dict, kw_only=True, alias="headers")
+  _timeout: Optional[httpx.Timeout] = field(default=None, kw_only=True, alias="timeout")
+  _verify_ssl: Union[str, bool, ssl.SSLContext] = field(
+    default=True, kw_only=True, alias="verify_ssl"
+  )
+  _follow_redirects: bool = field(default=False, kw_only=True, alias="follow_redirects")
+  _httpx_args: dict[str, Any] = field(factory=dict, kw_only=True, alias="httpx_args")
+  _client: Optional[httpx.Client] = field(default=None, init=False)
+  _async_client: Optional[httpx.AsyncClient] = field(default=None, init=False)
+
+  def with_headers(self, headers: dict[str, str]) -> "Client":
+    """Get a new client matching this one with additional headers"""
+    if self._client is not None:
+      self._client.headers.update(headers)
+    if self._async_client is not None:
+      self._async_client.headers.update(headers)
+    return evolve(self, headers={**self._headers, **headers})
+
+  def with_cookies(self, cookies: dict[str, str]) -> "Client":
+    """Get a new client matching this one with additional cookies"""
+    if self._client is not None:
+      self._client.cookies.update(cookies)
+    if self._async_client is not None:
+      self._async_client.cookies.update(cookies)
+    return evolve(self, cookies={**self._cookies, **cookies})
+
+  def with_timeout(self, timeout: httpx.Timeout) -> "Client":
+    """Get a new client matching this one with a new timeout (in seconds)"""
+    if self._client is not None:
+      self._client.timeout = timeout
+    if self._async_client is not None:
+      self._async_client.timeout = timeout
+    return evolve(self, timeout=timeout)
+
+  def set_httpx_client(self, client: httpx.Client) -> "Client":
+    """Manually set the underlying httpx.Client
+
+    **NOTE**: This will override any other settings on the client, including cookies, headers, and timeout.
+    """
+    self._client = client
+    return self
+
+  def get_httpx_client(self) -> httpx.Client:
+    """Get the underlying httpx.Client, constructing a new one if not previously set"""
+    if self._client is None:
+      self._client = httpx.Client(
+        base_url=self._base_url,
+        cookies=self._cookies,
+        headers=self._headers,
+        timeout=self._timeout,
+        verify=self._verify_ssl,
+        follow_redirects=self._follow_redirects,
+        **self._httpx_args,
+      )
+    return self._client
+
+  def __enter__(self) -> "Client":
+    """Enter a context manager for self.client—you cannot enter twice (see httpx docs)"""
+    self.get_httpx_client().__enter__()
+    return self
+
+  def __exit__(self, *args: Any, **kwargs: Any) -> None:
+    """Exit a context manager for internal httpx.Client (see httpx docs)"""
+    self.get_httpx_client().__exit__(*args, **kwargs)
+
+  def set_async_httpx_client(self, async_client: httpx.AsyncClient) -> "Client":
+    """Manually the underlying httpx.AsyncClient
+
+    **NOTE**: This will override any other settings on the client, including cookies, headers, and timeout.
+    """
+    self._async_client = async_client
+    return self
+
+  def get_async_httpx_client(self) -> httpx.AsyncClient:
+    """Get the underlying httpx.AsyncClient, constructing a new one if not previously set"""
+    if self._async_client is None:
+      self._async_client = httpx.AsyncClient(
+        base_url=self._base_url,
+        cookies=self._cookies,
+        headers=self._headers,
+        timeout=self._timeout,
+        verify=self._verify_ssl,
+        follow_redirects=self._follow_redirects,
+        **self._httpx_args,
+      )
+    return self._async_client
+
+  async def __aenter__(self) -> "Client":
+    """Enter a context manager for underlying httpx.AsyncClient—you cannot enter twice (see httpx docs)"""
+    await self.get_async_httpx_client().__aenter__()
+    return self
+
+  async def __aexit__(self, *args: Any, **kwargs: Any) -> None:
+    """Exit a context manager for underlying httpx.AsyncClient (see httpx docs)"""
+    await self.get_async_httpx_client().__aexit__(*args, **kwargs)
+
+
+@define
+class AuthenticatedClient:
+  """A Client which has been authenticated for use on secured endpoints
+
+  The following are accepted as keyword arguments and will be used to construct httpx Clients internally:
+
+      ``base_url``: The base URL for the API, all requests are made to a relative path to this URL
+
+      ``cookies``: A dictionary of cookies to be sent with every request
+
+      ``headers``: A dictionary of headers to be sent with every request
+
+      ``timeout``: The maximum amount of a time a request can take. API functions will raise
+      httpx.TimeoutException if this is exceeded.
+
+      ``verify_ssl``: Whether or not to verify the SSL certificate of the API server. This should be True in production,
+      but can be set to False for testing purposes.
+
+      ``follow_redirects``: Whether or not to follow redirects. Default value is False.
+
+      ``httpx_args``: A dictionary of additional arguments to be passed to the ``httpx.Client`` and ``httpx.AsyncClient`` constructor.
+
+
+  Attributes:
+      raise_on_unexpected_status: Whether or not to raise an errors.UnexpectedStatus if the API returns a
+          status code that was not documented in the source OpenAPI document. Can also be provided as a keyword
+          argument to the constructor.
+      token: The token to use for authentication
+      prefix: The prefix to use for the Authorization header
+      auth_header_name: The name of the Authorization header
+  """
+
+  raise_on_unexpected_status: bool = field(default=False, kw_only=True)
+  _base_url: str = field(alias="base_url")
+  _cookies: dict[str, str] = field(factory=dict, kw_only=True, alias="cookies")
+  _headers: dict[str, str] = field(factory=dict, kw_only=True, alias="headers")
+  _timeout: Optional[httpx.Timeout] = field(default=None, kw_only=True, alias="timeout")
+  _verify_ssl: Union[str, bool, ssl.SSLContext] = field(
+    default=True, kw_only=True, alias="verify_ssl"
+  )
+  _follow_redirects: bool = field(default=False, kw_only=True, alias="follow_redirects")
+  _httpx_args: dict[str, Any] = field(factory=dict, kw_only=True, alias="httpx_args")
+  _client: Optional[httpx.Client] = field(default=None, init=False)
+  _async_client: Optional[httpx.AsyncClient] = field(default=None, init=False)
+
+  token: str
+  prefix: str = "Bearer"
+  auth_header_name: str = "Authorization"
+
+  def with_headers(self, headers: dict[str, str]) -> "AuthenticatedClient":
+    """Get a new client matching this one with additional headers"""
+    if self._client is not None:
+      self._client.headers.update(headers)
+    if self._async_client is not None:
+      self._async_client.headers.update(headers)
+    return evolve(self, headers={**self._headers, **headers})
+
+  def with_cookies(self, cookies: dict[str, str]) -> "AuthenticatedClient":
+    """Get a new client matching this one with additional cookies"""
+    if self._client is not None:
+      self._client.cookies.update(cookies)
+    if self._async_client is not None:
+      self._async_client.cookies.update(cookies)
+    return evolve(self, cookies={**self._cookies, **cookies})
+
+  def with_timeout(self, timeout: httpx.Timeout) -> "AuthenticatedClient":
+    """Get a new client matching this one with a new timeout (in seconds)"""
+    if self._client is not None:
+      self._client.timeout = timeout
+    if self._async_client is not None:
+      self._async_client.timeout = timeout
+    return evolve(self, timeout=timeout)
+
+  def set_httpx_client(self, client: httpx.Client) -> "AuthenticatedClient":
+    """Manually set the underlying httpx.Client
+
+    **NOTE**: This will override any other settings on the client, including cookies, headers, and timeout.
+    """
+    self._client = client
+    return self
+
+  def get_httpx_client(self) -> httpx.Client:
+    """Get the underlying httpx.Client, constructing a new one if not previously set"""
+    if self._client is None:
+      self._headers[self.auth_header_name] = (
+        f"{self.prefix} {self.token}" if self.prefix else self.token
+      )
+      self._client = httpx.Client(
+        base_url=self._base_url,
+        cookies=self._cookies,
+        headers=self._headers,
+        timeout=self._timeout,
+        verify=self._verify_ssl,
+        follow_redirects=self._follow_redirects,
+        **self._httpx_args,
+      )
+    return self._client
+
+  def __enter__(self) -> "AuthenticatedClient":
+    """Enter a context manager for self.client—you cannot enter twice (see httpx docs)"""
+    self.get_httpx_client().__enter__()
+    return self
+
+  def __exit__(self, *args: Any, **kwargs: Any) -> None:
+    """Exit a context manager for internal httpx.Client (see httpx docs)"""
+    self.get_httpx_client().__exit__(*args, **kwargs)
+
+  def set_async_httpx_client(
+    self, async_client: httpx.AsyncClient
+  ) -> "AuthenticatedClient":
+    """Manually the underlying httpx.AsyncClient
+
+    **NOTE**: This will override any other settings on the client, including cookies, headers, and timeout.
+    """
+    self._async_client = async_client
+    return self
+
+  def get_async_httpx_client(self) -> httpx.AsyncClient:
+    """Get the underlying httpx.AsyncClient, constructing a new one if not previously set"""
+    if self._async_client is None:
+      self._headers[self.auth_header_name] = (
+        f"{self.prefix} {self.token}" if self.prefix else self.token
+      )
+      self._async_client = httpx.AsyncClient(
+        base_url=self._base_url,
+        cookies=self._cookies,
+        headers=self._headers,
+        timeout=self._timeout,
+        verify=self._verify_ssl,
+        follow_redirects=self._follow_redirects,
+        **self._httpx_args,
+      )
+    return self._async_client
+
+  async def __aenter__(self) -> "AuthenticatedClient":
+    """Enter a context manager for underlying httpx.AsyncClient—you cannot enter twice (see httpx docs)"""
+    await self.get_async_httpx_client().__aenter__()
+    return self
+
+  async def __aexit__(self, *args: Any, **kwargs: Any) -> None:
+    """Exit a context manager for underlying httpx.AsyncClient (see httpx docs)"""
+    await self.get_async_httpx_client().__aexit__(*args, **kwargs)

robosystems_client/errors.py

@@ -0,0 +1,16 @@
+"""Contains shared errors types that can be raised from API functions"""
+
+
+class UnexpectedStatus(Exception):
+  """Raised by api functions when the response status an undocumented status and Client.raise_on_unexpected_status is True"""
+
+  def __init__(self, status_code: int, content: bytes):
+    self.status_code = status_code
+    self.content = content
+
+    super().__init__(
+      f"Unexpected status code: {status_code}\n\nResponse content:\n{content.decode(errors='ignore')}"
+    )
+
+
+__all__ = ["UnexpectedStatus"]