waldur-api-client 7.7.3__py3-none-any.whl → 7.7.5__py3-none-any.whl

waldur_api_client/api/marketplace_maintenance_announcements_template/marketplace_maintenance_announcements_template_destroy.py

@@ -1,89 +0,0 @@
-from http import HTTPStatus
-from typing import Any, Union
-from uuid import UUID
-
-import httpx
-
-from ... import errors
-from ...client import AuthenticatedClient, Client
-from ...types import Response
-
-
-def _get_kwargs(
-    uuid: UUID,
-) -> dict[str, Any]:
-    _kwargs: dict[str, Any] = {
-        "method": "delete",
-        "url": f"/api/marketplace-maintenance-announcements-template/{uuid}/",
-    }
-
-    return _kwargs
-
-
-def _parse_response(*, client: Union[AuthenticatedClient, Client], response: httpx.Response) -> Any:
-    if response.status_code == 204:
-        return None
-    raise errors.UnexpectedStatus(response.status_code, response.content)
-
-
-def _build_response(*, client: Union[AuthenticatedClient, Client], response: httpx.Response) -> Response[Any]:
-    return Response(
-        status_code=HTTPStatus(response.status_code),
-        content=response.content,
-        headers=response.headers,
-        parsed=_parse_response(client=client, response=response),
-    )
-
-
-def sync_detailed(
-    uuid: UUID,
-    *,
-    client: AuthenticatedClient,
-) -> Response[Any]:
-    """
-    Args:
-        uuid (UUID):
-
-    Raises:
-        errors.UnexpectedStatus: If the server returns an undocumented status code.
-        httpx.TimeoutException: If the request takes longer than Client.timeout.
-
-    Returns:
-        Response[Any]
-    """
-
-    kwargs = _get_kwargs(
-        uuid=uuid,
-    )
-
-    response = client.get_httpx_client().request(
-        **kwargs,
-    )
-
-    return _build_response(client=client, response=response)
-
-
-async def asyncio_detailed(
-    uuid: UUID,
-    *,
-    client: AuthenticatedClient,
-) -> Response[Any]:
-    """
-    Args:
-        uuid (UUID):
-
-    Raises:
-        errors.UnexpectedStatus: If the server returns an undocumented status code.
-        httpx.TimeoutException: If the request takes longer than Client.timeout.
-
-    Returns:
-        Response[Any]
-    """
-
-    kwargs = _get_kwargs(
-        uuid=uuid,
-    )
-
-    response = await client.get_async_httpx_client().request(**kwargs)
-
-    return _build_response(client=client, response=response)

waldur_api_client/api/projects/projects_marketplace_checklists_list.py

@@ -1,148 +0,0 @@
-from http import HTTPStatus
-from typing import Any, Union
-
-import httpx
-
-from ... import errors
-from ...client import AuthenticatedClient, Client
-from ...models.project_stats_item import ProjectStatsItem
-from ...types import Response
-
-
-def _get_kwargs(
-    project_uuid: str,
-) -> dict[str, Any]:
-    _kwargs: dict[str, Any] = {
-        "method": "get",
-        "url": f"/api/projects/{project_uuid}/marketplace-checklists/",
-    }
-
-    return _kwargs
-
-
-def _parse_response(
-    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
-) -> list["ProjectStatsItem"]:
-    if response.status_code == 200:
-        response_200 = []
-        _response_200 = response.json()
-        for response_200_item_data in _response_200:
-            response_200_item = ProjectStatsItem.from_dict(response_200_item_data)
-
-            response_200.append(response_200_item)
-
-        return response_200
-    raise errors.UnexpectedStatus(response.status_code, response.content)
-
-
-def _build_response(
-    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
-) -> Response[list["ProjectStatsItem"]]:
-    return Response(
-        status_code=HTTPStatus(response.status_code),
-        content=response.content,
-        headers=response.headers,
-        parsed=_parse_response(client=client, response=response),
-    )
-
-
-def sync_detailed(
-    project_uuid: str,
-    *,
-    client: AuthenticatedClient,
-) -> Response[list["ProjectStatsItem"]]:
-    """
-    Args:
-        project_uuid (str):
-
-    Raises:
-        errors.UnexpectedStatus: If the server returns an undocumented status code.
-        httpx.TimeoutException: If the request takes longer than Client.timeout.
-
-    Returns:
-        Response[list['ProjectStatsItem']]
-    """
-
-    kwargs = _get_kwargs(
-        project_uuid=project_uuid,
-    )
-
-    response = client.get_httpx_client().request(
-        **kwargs,
-    )
-
-    return _build_response(client=client, response=response)
-
-
-def sync(
-    project_uuid: str,
-    *,
-    client: AuthenticatedClient,
-) -> list["ProjectStatsItem"]:
-    """
-    Args:
-        project_uuid (str):
-
-    Raises:
-        errors.UnexpectedStatus: If the server returns an undocumented status code.
-        httpx.TimeoutException: If the request takes longer than Client.timeout.
-
-    Returns:
-        list['ProjectStatsItem']
-    """
-
-    return sync_detailed(
-        project_uuid=project_uuid,
-        client=client,
-    ).parsed
-
-
-async def asyncio_detailed(
-    project_uuid: str,
-    *,
-    client: AuthenticatedClient,
-) -> Response[list["ProjectStatsItem"]]:
-    """
-    Args:
-        project_uuid (str):
-
-    Raises:
-        errors.UnexpectedStatus: If the server returns an undocumented status code.
-        httpx.TimeoutException: If the request takes longer than Client.timeout.
-
-    Returns:
-        Response[list['ProjectStatsItem']]
-    """
-
-    kwargs = _get_kwargs(
-        project_uuid=project_uuid,
-    )
-
-    response = await client.get_async_httpx_client().request(**kwargs)
-
-    return _build_response(client=client, response=response)
-
-
-async def asyncio(
-    project_uuid: str,
-    *,
-    client: AuthenticatedClient,
-) -> list["ProjectStatsItem"]:
-    """
-    Args:
-        project_uuid (str):
-
-    Raises:
-        errors.UnexpectedStatus: If the server returns an undocumented status code.
-        httpx.TimeoutException: If the request takes longer than Client.timeout.
-
-    Returns:
-        list['ProjectStatsItem']
-    """
-
-    return (
-        await asyncio_detailed(
-            project_uuid=project_uuid,
-            client=client,
-        )
-    ).parsed

waldur_api_client/models/checklist_customer_stats.py

@@ -1,92 +0,0 @@
-from collections.abc import Mapping
-from typing import Any, TypeVar
-from uuid import UUID
-
-from attrs import define as _attrs_define
-from attrs import field as _attrs_field
-
-T = TypeVar("T", bound="ChecklistCustomerStats")
-
-
-@_attrs_define
-class ChecklistCustomerStats:
-    """
-    Attributes:
-        name (str):
-        uuid (UUID):
-        latitude (float):
-        longitude (float):
-        score (float):
-    """
-
-    name: str
-    uuid: UUID
-    latitude: float
-    longitude: float
-    score: float
-    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
-
-    def to_dict(self) -> dict[str, Any]:
-        name = self.name
-
-        uuid = str(self.uuid)
-
-        latitude = self.latitude
-
-        longitude = self.longitude
-
-        score = self.score
-
-        field_dict: dict[str, Any] = {}
-        field_dict.update(self.additional_properties)
-        field_dict.update(
-            {
-                "name": name,
-                "uuid": uuid,
-                "latitude": latitude,
-                "longitude": longitude,
-                "score": score,
-            }
-        )
-
-        return field_dict
-
-    @classmethod
-    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
-        d = dict(src_dict)
-        name = d.pop("name")
-
-        uuid = UUID(d.pop("uuid"))
-
-        latitude = d.pop("latitude")
-
-        longitude = d.pop("longitude")
-
-        score = d.pop("score")
-
-        checklist_customer_stats = cls(
-            name=name,
-            uuid=uuid,
-            latitude=latitude,
-            longitude=longitude,
-            score=score,
-        )
-
-        checklist_customer_stats.additional_properties = d
-        return checklist_customer_stats
-
-    @property
-    def additional_keys(self) -> list[str]:
-        return list(self.additional_properties.keys())
-
-    def __getitem__(self, key: str) -> Any:
-        return self.additional_properties[key]
-
-    def __setitem__(self, key: str, value: Any) -> None:
-        self.additional_properties[key] = value
-
-    def __delitem__(self, key: str) -> None:
-        del self.additional_properties[key]
-
-    def __contains__(self, key: str) -> bool:
-        return key in self.additional_properties

waldur_api_client/models/create_checklist.py

@@ -1,131 +0,0 @@
-from collections.abc import Mapping
-from typing import Any, TypeVar, Union, cast
-from uuid import UUID
-
-from attrs import define as _attrs_define
-from attrs import field as _attrs_field
-
-from ..models.checklist_type_enum import ChecklistTypeEnum
-from ..types import UNSET, Unset
-
-T = TypeVar("T", bound="CreateChecklist")
-
-
-@_attrs_define
-class CreateChecklist:
-    """
-    Attributes:
-        uuid (UUID):
-        url (str):
-        name (str):
-        questions_count (int):
-        category_name (str):
-        category_uuid (UUID):
-        checklist_type (ChecklistTypeEnum):
-        description (Union[Unset, str]):
-        roles (Union[Unset, list[str]]):
-    """
-
-    uuid: UUID
-    url: str
-    name: str
-    questions_count: int
-    category_name: str
-    category_uuid: UUID
-    checklist_type: ChecklistTypeEnum
-    description: Union[Unset, str] = UNSET
-    roles: Union[Unset, list[str]] = UNSET
-    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
-
-    def to_dict(self) -> dict[str, Any]:
-        uuid = str(self.uuid)
-
-        url = self.url
-
-        name = self.name
-
-        questions_count = self.questions_count
-
-        category_name = self.category_name
-
-        category_uuid = str(self.category_uuid)
-
-        checklist_type = self.checklist_type.value
-
-        description = self.description
-
-        roles: Union[Unset, list[str]] = UNSET
-        if not isinstance(self.roles, Unset):
-            roles = self.roles
-
-        field_dict: dict[str, Any] = {}
-        field_dict.update(self.additional_properties)
-        field_dict.update(
-            {
-                "uuid": uuid,
-                "url": url,
-                "name": name,
-                "questions_count": questions_count,
-                "category_name": category_name,
-                "category_uuid": category_uuid,
-                "checklist_type": checklist_type,
-            }
-        )
-        if description is not UNSET:
-            field_dict["description"] = description
-        if roles is not UNSET:
-            field_dict["roles"] = roles
-
-        return field_dict
-
-    @classmethod
-    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
-        d = dict(src_dict)
-        uuid = UUID(d.pop("uuid"))
-
-        url = d.pop("url")
-
-        name = d.pop("name")
-
-        questions_count = d.pop("questions_count")
-
-        category_name = d.pop("category_name")
-
-        category_uuid = UUID(d.pop("category_uuid"))
-
-        checklist_type = ChecklistTypeEnum(d.pop("checklist_type"))
-
-        description = d.pop("description", UNSET)
-
-        roles = cast(list[str], d.pop("roles", UNSET))
-
-        create_checklist = cls(
-            uuid=uuid,
-            url=url,
-            name=name,
-            questions_count=questions_count,
-            category_name=category_name,
-            category_uuid=category_uuid,
-            checklist_type=checklist_type,
-            description=description,
-            roles=roles,
-        )
-
-        create_checklist.additional_properties = d
-        return create_checklist
-
-    @property
-    def additional_keys(self) -> list[str]:
-        return list(self.additional_properties.keys())
-
-    def __getitem__(self, key: str) -> Any:
-        return self.additional_properties[key]
-
-    def __setitem__(self, key: str, value: Any) -> None:
-        self.additional_properties[key] = value
-
-    def __delitem__(self, key: str) -> None:
-        del self.additional_properties[key]
-
-    def __contains__(self, key: str) -> bool:
-        return key in self.additional_properties

waldur_api_client/models/project_stats_item.py

@@ -1,100 +0,0 @@
-from collections.abc import Mapping
-from typing import Any, TypeVar
-from uuid import UUID
-
-from attrs import define as _attrs_define
-from attrs import field as _attrs_field
-
-T = TypeVar("T", bound="ProjectStatsItem")
-
-
-@_attrs_define
-class ProjectStatsItem:
-    """
-    Attributes:
-        name (str):
-        uuid (UUID):
-        positive_count (int):
-        negative_count (int):
-        unknown_count (int):
-        score (float):
-    """
-
-    name: str
-    uuid: UUID
-    positive_count: int
-    negative_count: int
-    unknown_count: int
-    score: float
-    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
-
-    def to_dict(self) -> dict[str, Any]:
-        name = self.name
-
-        uuid = str(self.uuid)
-
-        positive_count = self.positive_count
-
-        negative_count = self.negative_count
-
-        unknown_count = self.unknown_count
-
-        score = self.score
-
-        field_dict: dict[str, Any] = {}
-        field_dict.update(self.additional_properties)
-        field_dict.update(
-            {
-                "name": name,
-                "uuid": uuid,
-                "positive_count": positive_count,
-                "negative_count": negative_count,
-                "unknown_count": unknown_count,
-                "score": score,
-            }
-        )
-
-        return field_dict
-
-    @classmethod
-    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
-        d = dict(src_dict)
-        name = d.pop("name")
-
-        uuid = UUID(d.pop("uuid"))
-
-        positive_count = d.pop("positive_count")
-
-        negative_count = d.pop("negative_count")
-
-        unknown_count = d.pop("unknown_count")
-
-        score = d.pop("score")
-
-        project_stats_item = cls(
-            name=name,
-            uuid=uuid,
-            positive_count=positive_count,
-            negative_count=negative_count,
-            unknown_count=unknown_count,
-            score=score,
-        )
-
-        project_stats_item.additional_properties = d
-        return project_stats_item
-
-    @property
-    def additional_keys(self) -> list[str]:
-        return list(self.additional_properties.keys())
-
-    def __getitem__(self, key: str) -> Any:
-        return self.additional_properties[key]
-
-    def __setitem__(self, key: str, value: Any) -> None:
-        self.additional_properties[key] = value
-
-    def __delitem__(self, key: str) -> None:
-        del self.additional_properties[key]
-
-    def __contains__(self, key: str) -> bool:
-        return key in self.additional_properties

waldur_api_client/models/question.py

@@ -1,141 +0,0 @@
-from collections.abc import Mapping
-from typing import TYPE_CHECKING, Any, TypeVar, Union, cast
-from uuid import UUID
-
-from attrs import define as _attrs_define
-from attrs import field as _attrs_field
-
-from ..types import UNSET, Unset
-
-if TYPE_CHECKING:
-    from ..models.question_options import QuestionOptions
-
-
-T = TypeVar("T", bound="Question")
-
-
-@_attrs_define
-class Question:
-    """
-    Attributes:
-        uuid (UUID):
-        category_uuid (UUID):
-        question_options (list['QuestionOptions']):
-        description (Union[Unset, str]):
-        solution (Union[None, Unset, str]): Guidance shown when answer needs clarification
-        image (Union[None, Unset, str]):
-    """
-
-    uuid: UUID
-    category_uuid: UUID
-    question_options: list["QuestionOptions"]
-    description: Union[Unset, str] = UNSET
-    solution: Union[None, Unset, str] = UNSET
-    image: Union[None, Unset, str] = UNSET
-    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
-
-    def to_dict(self) -> dict[str, Any]:
-        uuid = str(self.uuid)
-
-        category_uuid = str(self.category_uuid)
-
-        question_options = []
-        for question_options_item_data in self.question_options:
-            question_options_item = question_options_item_data.to_dict()
-            question_options.append(question_options_item)
-
-        description = self.description
-
-        solution: Union[None, Unset, str]
-        if isinstance(self.solution, Unset):
-            solution = UNSET
-        else:
-            solution = self.solution
-
-        image: Union[None, Unset, str]
-        if isinstance(self.image, Unset):
-            image = UNSET
-        else:
-            image = self.image
-
-        field_dict: dict[str, Any] = {}
-        field_dict.update(self.additional_properties)
-        field_dict.update(
-            {
-                "uuid": uuid,
-                "category_uuid": category_uuid,
-                "question_options": question_options,
-            }
-        )
-        if description is not UNSET:
-            field_dict["description"] = description
-        if solution is not UNSET:
-            field_dict["solution"] = solution
-        if image is not UNSET:
-            field_dict["image"] = image
-
-        return field_dict
-
-    @classmethod
-    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
-        from ..models.question_options import QuestionOptions
-
-        d = dict(src_dict)
-        uuid = UUID(d.pop("uuid"))
-
-        category_uuid = UUID(d.pop("category_uuid"))
-
-        question_options = []
-        _question_options = d.pop("question_options")
-        for question_options_item_data in _question_options:
-            question_options_item = QuestionOptions.from_dict(question_options_item_data)
-
-            question_options.append(question_options_item)
-
-        description = d.pop("description", UNSET)
-
-        def _parse_solution(data: object) -> Union[None, Unset, str]:
-            if data is None:
-                return data
-            if isinstance(data, Unset):
-                return data
-            return cast(Union[None, Unset, str], data)
-
-        solution = _parse_solution(d.pop("solution", UNSET))
-
-        def _parse_image(data: object) -> Union[None, Unset, str]:
-            if data is None:
-                return data
-            if isinstance(data, Unset):
-                return data
-            return cast(Union[None, Unset, str], data)
-
-        image = _parse_image(d.pop("image", UNSET))
-
-        question = cls(
-            uuid=uuid,
-            category_uuid=category_uuid,
-            question_options=question_options,
-            description=description,
-            solution=solution,
-            image=image,
-        )
-
-        question.additional_properties = d
-        return question
-
-    @property
-    def additional_keys(self) -> list[str]:
-        return list(self.additional_properties.keys())
-
-    def __getitem__(self, key: str) -> Any:
-        return self.additional_properties[key]
-
-    def __setitem__(self, key: str, value: Any) -> None:
-        self.additional_properties[key] = value
-
-    def __delitem__(self, key: str) -> None:
-        del self.additional_properties[key]
-
-    def __contains__(self, key: str) -> bool:
-        return key in self.additional_properties