exist-client 0.1.0__tar.gz → 0.1.2.dev2__tar.gz

{exist_client-0.1.0 → exist_client-0.1.2.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: exist-client
-Version: 0.1.0
+Version: 0.1.2.dev2
 Summary: 
 Author: Ilya Nekhay
 Author-email: nekhayiv@gmail.com
@@ -9,6 +9,9 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: attrs (>=23.1.0,<24.0.0)
+Requires-Dist: loguru
+Requires-Dist: pytilz (>=0.1.0,<0.2.0)
 Description-Content-Type: text/markdown
 
 # Setting up a new project

exist_client-0.1.2.dev2/pyproject.toml

@@ -0,0 +1,77 @@
+[tool.poetry]
+name = "exist-client"
+version = "0.1.2.dev2"
+description = ""
+authors = ["Ilya Nekhay <nekhayiv@gmail.com>"]
+readme = "README.md"
+packages = [{include = "exist_client", from = "src"}]
+
+
+[tool.poetry.dependencies]
+python = "^3.10"
+attrs = "^23.1.0"
+loguru = "*"
+pytilz = "^0.1.0"
+
+
+[tool.poetry.group.dev.dependencies]
+# Code generation
+openapi-python-client = "^0.16.1"
+
+# Code management
+pre-commit = "*"
+commitizen = "*"
+
+# Testing
+pytest = "*"
+pytest-cov = "*"
+mypy = "*"
+respx = "*"
+flask = "^3.0.0"
+flask-httpauth = "^4.8.0"
+flask-httpauth-stubs = "^0.1.6"
+syrupy = "^4.6.0"
+
+
+[build-system]
+requires = ["poetry-core", "poetry-dynamic-versioning"]
+build-backend = "poetry_dynamic_versioning.backend"
+
+
+[tool.pytest.ini_options]
+addopts = "--cov=src --cov-report html --cov-report xml --cov-config=.coveragerc"
+pythonpath = ["src"]
+testpaths = ["tests"]
+
+
+[tool.isort]
+profile = "black"
+
+
+[tool.ruff]
+select = ["F", "I"]
+line-length = 120
+
+
+[tool.commitizen]
+name = "cz_conventional_commits"
+tag_format = "v$version"
+version_type = "pep440"
+version_provider = "poetry"
+update_changelog_on_bump = true
+major_version_zero = true
+
+
+[tool.poetry-dynamic-versioning]
+enable = false
+# TODO: extract version from `cz bump` so that when there's a MINOR/MAJOR change coming, the dev version corresponds
+#  to the next MINOR/MAJOR version
+format-jinja = """
+    {%- if distance == 0 -%}
+        {{ serialize_pep440(base, stage, revision) }}
+    {%- elif revision is not none -%}
+        {{ serialize_pep440(base, stage, revision + 1, dev=distance) }}
+    {%- else -%}
+        {{ serialize_pep440(bump_version(base), stage, revision, dev=distance) }}
+    {%- endif -%}
+"""

exist_client-0.1.2.dev2/src/exist_client/__init__.py

@@ -0,0 +1,3 @@
+from .client import ExistClient
+
+__all__ = ["ExistClient"]

exist_client-0.1.2.dev2/src/exist_client/_exist_io_client/__init__.py

@@ -0,0 +1,7 @@
+""" A client library for accessing Exist.io """
+from .client import AuthenticatedClient, Client
+
+__all__ = (
+    "AuthenticatedClient",
+    "Client",
+)

exist_client-0.1.2.dev2/src/exist_client/_exist_io_client/api/__init__.py

@@ -0,0 +1 @@
+""" Contains methods for accessing the API """

exist_client-0.1.2.dev2/src/exist_client/_exist_io_client/api/default/access_token.py

@@ -0,0 +1,134 @@
+from http import HTTPStatus
+from typing import Any, Dict, Optional, Union
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.access_token_data import AccessTokenData
+from ...models.tokens import Tokens
+from ...types import Response
+
+
+def _get_kwargs(
+    form_data: AccessTokenData,
+) -> Dict[str, Any]:
+    return {
+        "method": "post",
+        "url": "/oauth2/access_token",
+        "data": form_data.to_dict(),
+    }
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Tokens]:
+    if response.status_code == HTTPStatus.OK:
+        response_200 = Tokens.from_dict(response.json())
+
+        return response_200
+    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[Tokens]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: Union[AuthenticatedClient, Client],
+    form_data: AccessTokenData,
+) -> Response[Tokens]:
+    """
+    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[Tokens]
+    """
+
+    kwargs = _get_kwargs(
+        form_data=form_data,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    *,
+    client: Union[AuthenticatedClient, Client],
+    form_data: AccessTokenData,
+) -> Optional[Tokens]:
+    """
+    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:
+        Tokens
+    """
+
+    return sync_detailed(
+        client=client,
+        form_data=form_data,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: Union[AuthenticatedClient, Client],
+    form_data: AccessTokenData,
+) -> Response[Tokens]:
+    """
+    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[Tokens]
+    """
+
+    kwargs = _get_kwargs(
+        form_data=form_data,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    *,
+    client: Union[AuthenticatedClient, Client],
+    form_data: AccessTokenData,
+) -> Optional[Tokens]:
+    """
+    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:
+        Tokens
+    """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+            form_data=form_data,
+        )
+    ).parsed

exist_client-0.1.2.dev2/src/exist_client/_exist_io_client/api/default/accounts_profile.py

@@ -0,0 +1,120 @@
+from http import HTTPStatus
+from typing import Any, Dict, Optional, Union
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.user_profile import UserProfile
+from ...types import Response
+
+
+def _get_kwargs() -> Dict[str, Any]:
+    return {
+        "method": "get",
+        "url": "/api/2/accounts/profile/",
+    }
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[UserProfile]:
+    if response.status_code == HTTPStatus.OK:
+        response_200 = UserProfile.from_dict(response.json())
+
+        return response_200
+    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[UserProfile]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient,
+) -> Response[UserProfile]:
+    """
+    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[UserProfile]
+    """
+
+    kwargs = _get_kwargs()
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    *,
+    client: AuthenticatedClient,
+) -> Optional[UserProfile]:
+    """
+    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:
+        UserProfile
+    """
+
+    return sync_detailed(
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient,
+) -> Response[UserProfile]:
+    """
+    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[UserProfile]
+    """
+
+    kwargs = _get_kwargs()
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient,
+) -> Optional[UserProfile]:
+    """
+    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:
+        UserProfile
+    """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+        )
+    ).parsed

exist_client-0.1.2.dev2/src/exist_client/_exist_io_client/api/default/attribute_values_get.py

@@ -0,0 +1,166 @@
+from http import HTTPStatus
+from typing import Any, Dict, Optional, Union
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.attribute_values_get_result import AttributeValuesGetResult
+from ...types import UNSET, Response, Unset
+
+
+def _get_kwargs(
+    *,
+    attribute: str,
+    page: Union[Unset, None, int] = UNSET,
+) -> Dict[str, Any]:
+    params: Dict[str, Any] = {}
+    params["attribute"] = attribute
+
+    params["page"] = page
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+    return {
+        "method": "get",
+        "url": "/api/2/attributes/values/",
+        "params": params,
+    }
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[AttributeValuesGetResult]:
+    if response.status_code == HTTPStatus.OK:
+        response_200 = AttributeValuesGetResult.from_dict(response.json())
+
+        return response_200
+    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[AttributeValuesGetResult]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: Union[AuthenticatedClient, Client],
+    attribute: str,
+    page: Union[Unset, None, int] = UNSET,
+) -> Response[AttributeValuesGetResult]:
+    """
+    Args:
+        attribute (str):
+        page (Union[Unset, None, int]):
+
+    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[AttributeValuesGetResult]
+    """
+
+    kwargs = _get_kwargs(
+        attribute=attribute,
+        page=page,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    *,
+    client: Union[AuthenticatedClient, Client],
+    attribute: str,
+    page: Union[Unset, None, int] = UNSET,
+) -> Optional[AttributeValuesGetResult]:
+    """
+    Args:
+        attribute (str):
+        page (Union[Unset, None, int]):
+
+    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:
+        AttributeValuesGetResult
+    """
+
+    return sync_detailed(
+        client=client,
+        attribute=attribute,
+        page=page,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: Union[AuthenticatedClient, Client],
+    attribute: str,
+    page: Union[Unset, None, int] = UNSET,
+) -> Response[AttributeValuesGetResult]:
+    """
+    Args:
+        attribute (str):
+        page (Union[Unset, None, int]):
+
+    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[AttributeValuesGetResult]
+    """
+
+    kwargs = _get_kwargs(
+        attribute=attribute,
+        page=page,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    *,
+    client: Union[AuthenticatedClient, Client],
+    attribute: str,
+    page: Union[Unset, None, int] = UNSET,
+) -> Optional[AttributeValuesGetResult]:
+    """
+    Args:
+        attribute (str):
+        page (Union[Unset, None, int]):
+
+    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:
+        AttributeValuesGetResult
+    """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+            attribute=attribute,
+            page=page,
+        )
+    ).parsed

exist_client-0.1.2.dev2/src/exist_client/_exist_io_client/api/default/attributes_acquire.py

@@ -0,0 +1,164 @@
+from http import HTTPStatus
+from typing import Any, Dict, List, Optional, Union
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.attribute_by_name import AttributeByName
+from ...models.attribute_by_template import AttributeByTemplate
+from ...models.attributes_acquire_result import AttributesAcquireResult
+from ...types import Response
+
+
+def _get_kwargs(
+    *,
+    json_body: List[Union["AttributeByName", "AttributeByTemplate"]],
+) -> Dict[str, Any]:
+    json_json_body = []
+    for json_body_item_data in json_body:
+        json_body_item: Dict[str, Any]
+
+        if isinstance(json_body_item_data, AttributeByTemplate):
+            json_body_item = json_body_item_data.to_dict()
+
+        else:
+            json_body_item = json_body_item_data.to_dict()
+
+        json_json_body.append(json_body_item)
+
+    return {
+        "method": "post",
+        "url": "/api/2/attributes/acquire/",
+        "json": json_json_body,
+    }
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[AttributesAcquireResult]:
+    if response.status_code == HTTPStatus.OK:
+        response_200 = AttributesAcquireResult.from_dict(response.json())
+
+        return response_200
+    if response.status_code == HTTPStatus.ACCEPTED:
+        response_202 = AttributesAcquireResult.from_dict(response.json())
+
+        return response_202
+    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[AttributesAcquireResult]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient,
+    json_body: List[Union["AttributeByName", "AttributeByTemplate"]],
+) -> Response[AttributesAcquireResult]:
+    """
+    Args:
+        json_body (List[Union['AttributeByName', 'AttributeByTemplate']]):
+
+    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[AttributesAcquireResult]
+    """
+
+    kwargs = _get_kwargs(
+        json_body=json_body,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    *,
+    client: AuthenticatedClient,
+    json_body: List[Union["AttributeByName", "AttributeByTemplate"]],
+) -> Optional[AttributesAcquireResult]:
+    """
+    Args:
+        json_body (List[Union['AttributeByName', 'AttributeByTemplate']]):
+
+    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:
+        AttributesAcquireResult
+    """
+
+    return sync_detailed(
+        client=client,
+        json_body=json_body,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient,
+    json_body: List[Union["AttributeByName", "AttributeByTemplate"]],
+) -> Response[AttributesAcquireResult]:
+    """
+    Args:
+        json_body (List[Union['AttributeByName', 'AttributeByTemplate']]):
+
+    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[AttributesAcquireResult]
+    """
+
+    kwargs = _get_kwargs(
+        json_body=json_body,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient,
+    json_body: List[Union["AttributeByName", "AttributeByTemplate"]],
+) -> Optional[AttributesAcquireResult]:
+    """
+    Args:
+        json_body (List[Union['AttributeByName', 'AttributeByTemplate']]):
+
+    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:
+        AttributesAcquireResult
+    """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+            json_body=json_body,
+        )
+    ).parsed