diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml new file mode 100644 index 0000000..48e61dd --- /dev/null +++ b/.github/workflows/build.yml @@ -0,0 +1,34 @@ +name: Build and test + +on: + push: + pull_request: + +jobs: + build: + runs-on: ubuntu-latest + + strategy: + matrix: + python-version: ["3.13"] + fail-fast: false + + steps: + - uses: actions/checkout@v4 + + - name: Install uv + uses: astral-sh/setup-uv@v5 + with: + python-version: ${{ matrix.python-version }} + + - name: Install dependencies + run: uv sync + + - name: Lint (ruff) + run: uv run ruff check src/ tests/ + + - name: Type check (mypy) + run: uv run mypy src/ + + - name: Test (pytest) + run: uv run pytest --cov=src --cov-report=term-missing diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml new file mode 100644 index 0000000..66d5ff0 --- /dev/null +++ b/.github/workflows/publish.yml @@ -0,0 +1,29 @@ +name: Publish to PyPI + +on: + release: + types: [published] + +jobs: + publish: + runs-on: ubuntu-latest + + permissions: + id-token: write # required for OIDC trusted publisher + + steps: + - uses: actions/checkout@v4 + + - name: Install uv + uses: astral-sh/setup-uv@v5 + with: + python-version: "3.13" + + - name: Install dependencies + run: uv sync + + - name: Build wheel and sdist + run: uv build + + - name: Publish to PyPI + uses: pypa/gh-action-pypi-publish@release/v1 diff --git a/CITATION.cff b/CITATION.cff index 9563f95..052b929 100644 --- a/CITATION.cff +++ b/CITATION.cff @@ -5,8 +5,8 @@ abstract: "Python client for Puzzel SMS Gateway." authors: - family-names: "Lie Uberg" given-names: Lewi -version: 2.0.4 -date-released: 2024-03-06 +version: 3.0.0 +date-released: 2026-04-13 repository-code: "https://github.com/PuzzelSolutions/smsgw-client-python" license: MIT keywords: diff --git a/pyproject.toml b/pyproject.toml index 4ba05e2..4a62c8b 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "puzzel-sms-gateway-client" -version = "2.0.4" +version = "3.0.0" description = "Puzzel SMS Gateway Python Client (Kiota-generated)" requires-python = ">=3.13" license = {text = "MIT"} diff --git a/src/gw/gw_request_builder.py b/src/gw/gw_request_builder.py new file mode 100644 index 0000000..816b62c --- /dev/null +++ b/src/gw/gw_request_builder.py @@ -0,0 +1,33 @@ +from __future__ import annotations +from collections.abc import Callable +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.request_adapter import RequestAdapter +from typing import Any, Optional, TYPE_CHECKING, Union + +if TYPE_CHECKING: + from .rs.rs_request_builder import RsRequestBuilder + +class GwRequestBuilder(BaseRequestBuilder): + """ + Builds and executes requests for operations under /gw + """ + def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, dict[str, Any]]) -> None: + """ + Instantiates a new GwRequestBuilder and sets the default values. + param path_parameters: The raw url or the url-template parameters for the request. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + super().__init__(request_adapter, "{+baseurl}/gw", path_parameters) + + @property + def rs(self) -> RsRequestBuilder: + """ + The rs property + """ + from .rs.rs_request_builder import RsRequestBuilder + + return RsRequestBuilder(self.request_adapter, self.path_parameters) + + diff --git a/src/gw/rs/rs_request_builder.py b/src/gw/rs/rs_request_builder.py new file mode 100644 index 0000000..b8a806d --- /dev/null +++ b/src/gw/rs/rs_request_builder.py @@ -0,0 +1,33 @@ +from __future__ import annotations +from collections.abc import Callable +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.request_adapter import RequestAdapter +from typing import Any, Optional, TYPE_CHECKING, Union + +if TYPE_CHECKING: + from .send_messages.send_messages_request_builder import SendMessagesRequestBuilder + +class RsRequestBuilder(BaseRequestBuilder): + """ + Builds and executes requests for operations under /gw/rs + """ + def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, dict[str, Any]]) -> None: + """ + Instantiates a new RsRequestBuilder and sets the default values. + param path_parameters: The raw url or the url-template parameters for the request. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + super().__init__(request_adapter, "{+baseurl}/gw/rs", path_parameters) + + @property + def send_messages(self) -> SendMessagesRequestBuilder: + """ + The sendMessages property + """ + from .send_messages.send_messages_request_builder import SendMessagesRequestBuilder + + return SendMessagesRequestBuilder(self.request_adapter, self.path_parameters) + + diff --git a/src/gw/rs/send_messages/send_messages_request_builder.py b/src/gw/rs/send_messages/send_messages_request_builder.py new file mode 100644 index 0000000..8896d66 --- /dev/null +++ b/src/gw/rs/send_messages/send_messages_request_builder.py @@ -0,0 +1,148 @@ +from __future__ import annotations +from collections.abc import Callable +from dataclasses import dataclass, field +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.base_request_configuration import RequestConfiguration +from kiota_abstractions.default_query_parameters import QueryParameters +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.method import Method +from kiota_abstractions.request_adapter import RequestAdapter +from kiota_abstractions.request_information import RequestInformation +from kiota_abstractions.request_option import RequestOption +from kiota_abstractions.serialization import Parsable, ParsableFactory +from typing import Any, Optional, TYPE_CHECKING, Union +from warnings import warn + +if TYPE_CHECKING: + from ....models.gateway_request import GatewayRequest + from ....models.gateway_response import GatewayResponse + from ....models.problem_details import ProblemDetails + +class SendMessagesRequestBuilder(BaseRequestBuilder): + """ + Builds and executes requests for operations under /gw/rs/sendMessages + """ + def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, dict[str, Any]]) -> None: + """ + Instantiates a new SendMessagesRequestBuilder and sets the default values. + param path_parameters: The raw url or the url-template parameters for the request. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + super().__init__(request_adapter, "{+baseurl}/gw/rs/sendMessages?Message={Message}&Password={Password}&Username={Username}{&BatchReference*,ServiceId*}", path_parameters) + + async def get(self,request_configuration: Optional[RequestConfiguration[SendMessagesRequestBuilderGetQueryParameters]] = None) -> Optional[bytes]: + """ + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: bytes + """ + request_info = self.to_get_request_information( + request_configuration + ) + if not self.request_adapter: + raise Exception("Http core is null") + return await self.request_adapter.send_primitive_async(request_info, "bytes", None) + + async def post(self,body: GatewayRequest, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[GatewayResponse]: + """ + param body: The request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[GatewayResponse] + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = self.to_post_request_information( + body, request_configuration + ) + from ....models.problem_details import ProblemDetails + + error_mapping: dict[str, type[ParsableFactory]] = { + "401": ProblemDetails, + } + if not self.request_adapter: + raise Exception("Http core is null") + from ....models.gateway_response import GatewayResponse + + return await self.request_adapter.send_async(request_info, GatewayResponse, error_mapping) + + def to_get_request_information(self,request_configuration: Optional[RequestConfiguration[SendMessagesRequestBuilderGetQueryParameters]] = None) -> RequestInformation: + """ + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.GET, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + return request_info + + def to_post_request_information(self,body: GatewayRequest, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation: + """ + param body: The request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = RequestInformation(Method.POST, '{+baseurl}/gw/rs/sendMessages', self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + request_info.set_content_from_parsable(self.request_adapter, "application/json", body) + return request_info + + def with_url(self,raw_url: str) -> SendMessagesRequestBuilder: + """ + Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored. + param raw_url: The raw URL to use for the request builder. + Returns: SendMessagesRequestBuilder + """ + if raw_url is None: + raise TypeError("raw_url cannot be null.") + return SendMessagesRequestBuilder(self.request_adapter, raw_url) + + @dataclass + class SendMessagesRequestBuilderGetQueryParameters(): + def get_query_parameter(self,original_name: str) -> str: + """ + Maps the query parameters names to their encoded names for the URI template parsing. + param original_name: The original query parameter name in the class. + Returns: str + """ + if original_name is None: + raise TypeError("original_name cannot be null.") + if original_name == "batch_reference": + return "BatchReference" + if original_name == "message": + return "Message" + if original_name == "password": + return "Password" + if original_name == "service_id": + return "ServiceId" + if original_name == "username": + return "Username" + return original_name + + batch_reference: Optional[str] = None + + message: Optional[list[str]] = None + + password: Optional[str] = None + + service_id: Optional[int] = None + + username: Optional[str] = None + + + @dataclass + class SendMessagesRequestBuilderGetRequestConfiguration(RequestConfiguration[SendMessagesRequestBuilderGetQueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + @dataclass + class SendMessagesRequestBuilderPostRequestConfiguration(RequestConfiguration[QueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + diff --git a/src/kiota-lock.json b/src/kiota-lock.json new file mode 100644 index 0000000..896bbd7 --- /dev/null +++ b/src/kiota-lock.json @@ -0,0 +1,39 @@ +{ + "descriptionHash": "5269EB413FDAB685C5F9A1648ECEDC5DE1ECA2E7A96AD20E95A0228BD8A43C50637B565F8218237F045B6EFBC307B8ECB1D11194478A84638417F7B1DB0B3414", + "descriptionLocation": "../../../source-generator/swagger.json", + "lockFileVersion": "1.0.0", + "kiotaVersion": "1.31.0", + "clientClassName": "MtHttpClient", + "typeAccessModifier": "Public", + "clientNamespaceName": "Puzzel.SmsGateway.Clients.MtHttp", + "language": "Python", + "usesBackingStore": false, + "excludeBackwardCompatible": false, + "includeAdditionalData": true, + "disableSSLValidation": false, + "serializers": [ + "Microsoft.Kiota.Serialization.Json.JsonSerializationWriterFactory", + "Microsoft.Kiota.Serialization.Text.TextSerializationWriterFactory", + "Microsoft.Kiota.Serialization.Form.FormSerializationWriterFactory", + "Microsoft.Kiota.Serialization.Multipart.MultipartSerializationWriterFactory" + ], + "deserializers": [ + "Microsoft.Kiota.Serialization.Json.JsonParseNodeFactory", + "Microsoft.Kiota.Serialization.Text.TextParseNodeFactory", + "Microsoft.Kiota.Serialization.Form.FormParseNodeFactory" + ], + "structuredMimeTypes": [ + "application/json", + "text/plain;q=0.9", + "application/x-www-form-urlencoded;q=0.2", + "multipart/form-data;q=0.1" + ], + "includePatterns": [], + "excludePatterns": [ + "/v4/**", + "/mgmt/**", + "/chimera/**", + "/smsgw/**" + ], + "disabledValidationRules": [] +} \ No newline at end of file diff --git a/src/management/item/batch/batch_request_builder.py b/src/management/item/batch/batch_request_builder.py new file mode 100644 index 0000000..d89d800 --- /dev/null +++ b/src/management/item/batch/batch_request_builder.py @@ -0,0 +1,88 @@ +from __future__ import annotations +from collections.abc import Callable +from dataclasses import dataclass, field +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.base_request_configuration import RequestConfiguration +from kiota_abstractions.default_query_parameters import QueryParameters +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.method import Method +from kiota_abstractions.request_adapter import RequestAdapter +from kiota_abstractions.request_information import RequestInformation +from kiota_abstractions.request_option import RequestOption +from kiota_abstractions.serialization import Parsable, ParsableFactory +from typing import Any, Optional, TYPE_CHECKING, Union +from warnings import warn + +if TYPE_CHECKING: + from ....models.batch_list_response import BatchListResponse + from .item.with_client_batch_reference_item_request_builder import WithClientBatchReferenceItemRequestBuilder + +class BatchRequestBuilder(BaseRequestBuilder): + """ + Builds and executes requests for operations under /management/{serviceId}/batch + """ + def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, dict[str, Any]]) -> None: + """ + Instantiates a new BatchRequestBuilder and sets the default values. + param path_parameters: The raw url or the url-template parameters for the request. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + super().__init__(request_adapter, "{+baseurl}/management/{serviceId}/batch", path_parameters) + + def by_client_batch_reference(self,client_batch_reference: str) -> WithClientBatchReferenceItemRequestBuilder: + """ + Gets an item from the Puzzel.SmsGateway.Clients.MtHttp.management.item.batch.item collection + param client_batch_reference: Unique identifier of the item + Returns: WithClientBatchReferenceItemRequestBuilder + """ + if client_batch_reference is None: + raise TypeError("client_batch_reference cannot be null.") + from .item.with_client_batch_reference_item_request_builder import WithClientBatchReferenceItemRequestBuilder + + url_tpl_params = get_path_parameters(self.path_parameters) + url_tpl_params["clientBatchReference"] = client_batch_reference + return WithClientBatchReferenceItemRequestBuilder(self.request_adapter, url_tpl_params) + + async def get(self,request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[BatchListResponse]: + """ + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[BatchListResponse] + """ + request_info = self.to_get_request_information( + request_configuration + ) + if not self.request_adapter: + raise Exception("Http core is null") + from ....models.batch_list_response import BatchListResponse + + return await self.request_adapter.send_async(request_info, BatchListResponse, None) + + def to_get_request_information(self,request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation: + """ + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.GET, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + return request_info + + def with_url(self,raw_url: str) -> BatchRequestBuilder: + """ + Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored. + param raw_url: The raw URL to use for the request builder. + Returns: BatchRequestBuilder + """ + if raw_url is None: + raise TypeError("raw_url cannot be null.") + return BatchRequestBuilder(self.request_adapter, raw_url) + + @dataclass + class BatchRequestBuilderGetRequestConfiguration(RequestConfiguration[QueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + diff --git a/src/management/item/batch/item/with_client_batch_reference_item_request_builder.py b/src/management/item/batch/item/with_client_batch_reference_item_request_builder.py new file mode 100644 index 0000000..f79f228 --- /dev/null +++ b/src/management/item/batch/item/with_client_batch_reference_item_request_builder.py @@ -0,0 +1,116 @@ +from __future__ import annotations +from collections.abc import Callable +from dataclasses import dataclass, field +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.base_request_configuration import RequestConfiguration +from kiota_abstractions.default_query_parameters import QueryParameters +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.method import Method +from kiota_abstractions.request_adapter import RequestAdapter +from kiota_abstractions.request_information import RequestInformation +from kiota_abstractions.request_option import RequestOption +from kiota_abstractions.serialization import Parsable, ParsableFactory +from typing import Any, Optional, TYPE_CHECKING, Union +from warnings import warn + +if TYPE_CHECKING: + from .....models.batch_single_response import BatchSingleResponse + from .....models.problem_details import ProblemDetails + from .....models.stop_batch_response import StopBatchResponse + +class WithClientBatchReferenceItemRequestBuilder(BaseRequestBuilder): + """ + Builds and executes requests for operations under /management/{serviceId}/batch/{clientBatchReference} + """ + def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, dict[str, Any]]) -> None: + """ + Instantiates a new WithClientBatchReferenceItemRequestBuilder and sets the default values. + param path_parameters: The raw url or the url-template parameters for the request. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + super().__init__(request_adapter, "{+baseurl}/management/{serviceId}/batch/{clientBatchReference}", path_parameters) + + async def delete(self,request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[StopBatchResponse]: + """ + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[StopBatchResponse] + """ + request_info = self.to_delete_request_information( + request_configuration + ) + from .....models.problem_details import ProblemDetails + + error_mapping: dict[str, type[ParsableFactory]] = { + "404": ProblemDetails, + } + if not self.request_adapter: + raise Exception("Http core is null") + from .....models.stop_batch_response import StopBatchResponse + + return await self.request_adapter.send_async(request_info, StopBatchResponse, error_mapping) + + async def get(self,request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[BatchSingleResponse]: + """ + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[BatchSingleResponse] + """ + request_info = self.to_get_request_information( + request_configuration + ) + from .....models.problem_details import ProblemDetails + + error_mapping: dict[str, type[ParsableFactory]] = { + "404": ProblemDetails, + } + if not self.request_adapter: + raise Exception("Http core is null") + from .....models.batch_single_response import BatchSingleResponse + + return await self.request_adapter.send_async(request_info, BatchSingleResponse, error_mapping) + + def to_delete_request_information(self,request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation: + """ + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.DELETE, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + return request_info + + def to_get_request_information(self,request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation: + """ + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.GET, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + return request_info + + def with_url(self,raw_url: str) -> WithClientBatchReferenceItemRequestBuilder: + """ + Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored. + param raw_url: The raw URL to use for the request builder. + Returns: WithClientBatchReferenceItemRequestBuilder + """ + if raw_url is None: + raise TypeError("raw_url cannot be null.") + return WithClientBatchReferenceItemRequestBuilder(self.request_adapter, raw_url) + + @dataclass + class WithClientBatchReferenceItemRequestBuilderDeleteRequestConfiguration(RequestConfiguration[QueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + @dataclass + class WithClientBatchReferenceItemRequestBuilderGetRequestConfiguration(RequestConfiguration[QueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + diff --git a/src/management/item/with_service_item_request_builder.py b/src/management/item/with_service_item_request_builder.py new file mode 100644 index 0000000..89e51c0 --- /dev/null +++ b/src/management/item/with_service_item_request_builder.py @@ -0,0 +1,33 @@ +from __future__ import annotations +from collections.abc import Callable +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.request_adapter import RequestAdapter +from typing import Any, Optional, TYPE_CHECKING, Union + +if TYPE_CHECKING: + from .batch.batch_request_builder import BatchRequestBuilder + +class WithServiceItemRequestBuilder(BaseRequestBuilder): + """ + Builds and executes requests for operations under /management/{serviceId} + """ + def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, dict[str, Any]]) -> None: + """ + Instantiates a new WithServiceItemRequestBuilder and sets the default values. + param path_parameters: The raw url or the url-template parameters for the request. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + super().__init__(request_adapter, "{+baseurl}/management/{serviceId}", path_parameters) + + @property + def batch(self) -> BatchRequestBuilder: + """ + The batch property + """ + from .batch.batch_request_builder import BatchRequestBuilder + + return BatchRequestBuilder(self.request_adapter, self.path_parameters) + + diff --git a/src/management/management_request_builder.py b/src/management/management_request_builder.py new file mode 100644 index 0000000..7e68317 --- /dev/null +++ b/src/management/management_request_builder.py @@ -0,0 +1,38 @@ +from __future__ import annotations +from collections.abc import Callable +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.request_adapter import RequestAdapter +from typing import Any, Optional, TYPE_CHECKING, Union + +if TYPE_CHECKING: + from .item.with_service_item_request_builder import WithServiceItemRequestBuilder + +class ManagementRequestBuilder(BaseRequestBuilder): + """ + Builds and executes requests for operations under /management + """ + def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, dict[str, Any]]) -> None: + """ + Instantiates a new ManagementRequestBuilder and sets the default values. + param path_parameters: The raw url or the url-template parameters for the request. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + super().__init__(request_adapter, "{+baseurl}/management", path_parameters) + + def by_service_id(self,service_id: int) -> WithServiceItemRequestBuilder: + """ + Gets an item from the Puzzel.SmsGateway.Clients.MtHttp.management.item collection + param service_id: Unique identifier of the item + Returns: WithServiceItemRequestBuilder + """ + if service_id is None: + raise TypeError("service_id cannot be null.") + from .item.with_service_item_request_builder import WithServiceItemRequestBuilder + + url_tpl_params = get_path_parameters(self.path_parameters) + url_tpl_params["serviceId"] = service_id + return WithServiceItemRequestBuilder(self.request_adapter, url_tpl_params) + + diff --git a/src/models/batch_list_response.py b/src/models/batch_list_response.py new file mode 100644 index 0000000..7df9e61 --- /dev/null +++ b/src/models/batch_list_response.py @@ -0,0 +1,50 @@ +from __future__ import annotations +from collections.abc import Callable +from dataclasses import dataclass, field +from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter +from typing import Any, Optional, TYPE_CHECKING, Union + +if TYPE_CHECKING: + from .batch_response import BatchResponse + +@dataclass +class BatchListResponse(Parsable): + # The messageBatch property + message_batch: Optional[list[BatchResponse]] = None + + @staticmethod + def create_from_discriminator_value(parse_node: ParseNode) -> BatchListResponse: + """ + Creates a new instance of the appropriate class based on discriminator value + param parse_node: The parse node to use to read the discriminator value and create the object + Returns: BatchListResponse + """ + if parse_node is None: + raise TypeError("parse_node cannot be null.") + return BatchListResponse() + + def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]: + """ + The deserialization information for the current model + Returns: dict[str, Callable[[ParseNode], None]] + """ + from .batch_response import BatchResponse + + from .batch_response import BatchResponse + + fields: dict[str, Callable[[Any], None]] = { + "messageBatch": lambda n : setattr(self, 'message_batch', n.get_collection_of_object_values(BatchResponse)), + } + return fields + + def serialize(self,writer: SerializationWriter) -> None: + """ + Serializes information the current object + param writer: Serialization writer to use to serialize this model + Returns: None + """ + if writer is None: + raise TypeError("writer cannot be null.") + writer.write_collection_of_object_values("messageBatch", self.message_batch) + + diff --git a/src/models/batch_response.py b/src/models/batch_response.py new file mode 100644 index 0000000..33ba4aa --- /dev/null +++ b/src/models/batch_response.py @@ -0,0 +1,51 @@ +from __future__ import annotations +from collections.abc import Callable +from dataclasses import dataclass, field +from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter +from typing import Any, Optional, TYPE_CHECKING, Union + +@dataclass +class BatchResponse(Parsable): + # The clientBatchReference property + client_batch_reference: Optional[str] = None + # The onHold property + on_hold: Optional[int] = None + # The totalSize property + total_size: Optional[int] = None + + @staticmethod + def create_from_discriminator_value(parse_node: ParseNode) -> BatchResponse: + """ + Creates a new instance of the appropriate class based on discriminator value + param parse_node: The parse node to use to read the discriminator value and create the object + Returns: BatchResponse + """ + if parse_node is None: + raise TypeError("parse_node cannot be null.") + return BatchResponse() + + def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]: + """ + The deserialization information for the current model + Returns: dict[str, Callable[[ParseNode], None]] + """ + fields: dict[str, Callable[[Any], None]] = { + "clientBatchReference": lambda n : setattr(self, 'client_batch_reference', n.get_str_value()), + "onHold": lambda n : setattr(self, 'on_hold', n.get_int_value()), + "totalSize": lambda n : setattr(self, 'total_size', n.get_int_value()), + } + return fields + + def serialize(self,writer: SerializationWriter) -> None: + """ + Serializes information the current object + param writer: Serialization writer to use to serialize this model + Returns: None + """ + if writer is None: + raise TypeError("writer cannot be null.") + writer.write_str_value("clientBatchReference", self.client_batch_reference) + writer.write_int_value("onHold", self.on_hold) + writer.write_int_value("totalSize", self.total_size) + + diff --git a/src/models/batch_single_response.py b/src/models/batch_single_response.py new file mode 100644 index 0000000..f714d14 --- /dev/null +++ b/src/models/batch_single_response.py @@ -0,0 +1,50 @@ +from __future__ import annotations +from collections.abc import Callable +from dataclasses import dataclass, field +from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter +from typing import Any, Optional, TYPE_CHECKING, Union + +if TYPE_CHECKING: + from .batch_response import BatchResponse + +@dataclass +class BatchSingleResponse(Parsable): + # The messageBatch property + message_batch: Optional[BatchResponse] = None + + @staticmethod + def create_from_discriminator_value(parse_node: ParseNode) -> BatchSingleResponse: + """ + Creates a new instance of the appropriate class based on discriminator value + param parse_node: The parse node to use to read the discriminator value and create the object + Returns: BatchSingleResponse + """ + if parse_node is None: + raise TypeError("parse_node cannot be null.") + return BatchSingleResponse() + + def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]: + """ + The deserialization information for the current model + Returns: dict[str, Callable[[ParseNode], None]] + """ + from .batch_response import BatchResponse + + from .batch_response import BatchResponse + + fields: dict[str, Callable[[Any], None]] = { + "messageBatch": lambda n : setattr(self, 'message_batch', n.get_object_value(BatchResponse)), + } + return fields + + def serialize(self,writer: SerializationWriter) -> None: + """ + Serializes information the current object + param writer: Serialization writer to use to serialize this model + Returns: None + """ + if writer is None: + raise TypeError("writer cannot be null.") + writer.write_object_value("messageBatch", self.message_batch) + + diff --git a/src/models/gas_settings.py b/src/models/gas_settings.py new file mode 100644 index 0000000..66ca087 --- /dev/null +++ b/src/models/gas_settings.py @@ -0,0 +1,47 @@ +from __future__ import annotations +from collections.abc import Callable +from dataclasses import dataclass, field +from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter +from typing import Any, Optional, TYPE_CHECKING, Union + +@dataclass +class GasSettings(Parsable): + # The description property + description: Optional[str] = None + # The serviceCode property + service_code: Optional[str] = None + + @staticmethod + def create_from_discriminator_value(parse_node: ParseNode) -> GasSettings: + """ + Creates a new instance of the appropriate class based on discriminator value + param parse_node: The parse node to use to read the discriminator value and create the object + Returns: GasSettings + """ + if parse_node is None: + raise TypeError("parse_node cannot be null.") + return GasSettings() + + def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]: + """ + The deserialization information for the current model + Returns: dict[str, Callable[[ParseNode], None]] + """ + fields: dict[str, Callable[[Any], None]] = { + "description": lambda n : setattr(self, 'description', n.get_str_value()), + "serviceCode": lambda n : setattr(self, 'service_code', n.get_str_value()), + } + return fields + + def serialize(self,writer: SerializationWriter) -> None: + """ + Serializes information the current object + param writer: Serialization writer to use to serialize this model + Returns: None + """ + if writer is None: + raise TypeError("writer cannot be null.") + writer.write_str_value("description", self.description) + writer.write_str_value("serviceCode", self.service_code) + + diff --git a/src/models/gateway_request.py b/src/models/gateway_request.py new file mode 100644 index 0000000..dc454c0 --- /dev/null +++ b/src/models/gateway_request.py @@ -0,0 +1,66 @@ +from __future__ import annotations +from collections.abc import Callable +from dataclasses import dataclass, field +from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter +from typing import Any, Optional, TYPE_CHECKING, Union + +if TYPE_CHECKING: + from .message import Message + +@dataclass +class GatewayRequest(Parsable): + # The batchReference property + batch_reference: Optional[str] = None + # The message property + message: Optional[list[Message]] = None + # The password property + password: Optional[str] = None + # The serviceId property + service_id: Optional[int] = None + # The username property + username: Optional[str] = None + + @staticmethod + def create_from_discriminator_value(parse_node: ParseNode) -> GatewayRequest: + """ + Creates a new instance of the appropriate class based on discriminator value + param parse_node: The parse node to use to read the discriminator value and create the object + Returns: GatewayRequest + """ + if parse_node is None: + raise TypeError("parse_node cannot be null.") + return GatewayRequest() + + def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]: + """ + The deserialization information for the current model + Returns: dict[str, Callable[[ParseNode], None]] + """ + from .message import Message + + from .message import Message + + fields: dict[str, Callable[[Any], None]] = { + "batchReference": lambda n : setattr(self, 'batch_reference', n.get_str_value()), + "message": lambda n : setattr(self, 'message', n.get_collection_of_object_values(Message)), + "password": lambda n : setattr(self, 'password', n.get_str_value()), + "serviceId": lambda n : setattr(self, 'service_id', n.get_int_value()), + "username": lambda n : setattr(self, 'username', n.get_str_value()), + } + return fields + + def serialize(self,writer: SerializationWriter) -> None: + """ + Serializes information the current object + param writer: Serialization writer to use to serialize this model + Returns: None + """ + if writer is None: + raise TypeError("writer cannot be null.") + writer.write_str_value("batchReference", self.batch_reference) + writer.write_collection_of_object_values("message", self.message) + writer.write_str_value("password", self.password) + writer.write_int_value("serviceId", self.service_id) + writer.write_str_value("username", self.username) + + diff --git a/src/models/gateway_response.py b/src/models/gateway_response.py new file mode 100644 index 0000000..7dc0801 --- /dev/null +++ b/src/models/gateway_response.py @@ -0,0 +1,54 @@ +from __future__ import annotations +from collections.abc import Callable +from dataclasses import dataclass, field +from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter +from typing import Any, Optional, TYPE_CHECKING, Union + +if TYPE_CHECKING: + from .message_status import MessageStatus + +@dataclass +class GatewayResponse(Parsable): + # The batchReference property + batch_reference: Optional[str] = None + # The messageStatus property + message_status: Optional[list[MessageStatus]] = None + + @staticmethod + def create_from_discriminator_value(parse_node: ParseNode) -> GatewayResponse: + """ + Creates a new instance of the appropriate class based on discriminator value + param parse_node: The parse node to use to read the discriminator value and create the object + Returns: GatewayResponse + """ + if parse_node is None: + raise TypeError("parse_node cannot be null.") + return GatewayResponse() + + def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]: + """ + The deserialization information for the current model + Returns: dict[str, Callable[[ParseNode], None]] + """ + from .message_status import MessageStatus + + from .message_status import MessageStatus + + fields: dict[str, Callable[[Any], None]] = { + "batchReference": lambda n : setattr(self, 'batch_reference', n.get_str_value()), + "messageStatus": lambda n : setattr(self, 'message_status', n.get_collection_of_object_values(MessageStatus)), + } + return fields + + def serialize(self,writer: SerializationWriter) -> None: + """ + Serializes information the current object + param writer: Serialization writer to use to serialize this model + Returns: None + """ + if writer is None: + raise TypeError("writer cannot be null.") + writer.write_str_value("batchReference", self.batch_reference) + writer.write_collection_of_object_values("messageStatus", self.message_status) + + diff --git a/src/models/message.py b/src/models/message.py new file mode 100644 index 0000000..74cdd70 --- /dev/null +++ b/src/models/message.py @@ -0,0 +1,70 @@ +from __future__ import annotations +from collections.abc import Callable +from dataclasses import dataclass, field +from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter +from typing import Any, Optional, TYPE_CHECKING, Union + +if TYPE_CHECKING: + from .settings import Settings + +@dataclass +class Message(Parsable): + # The clientReference property + client_reference: Optional[str] = None + # The content property + content: Optional[str] = None + # The price property + price: Optional[int] = None + # The priceXml property + price_xml: Optional[str] = None + # The recipient property + recipient: Optional[str] = None + # The settings property + settings: Optional[Settings] = None + + @staticmethod + def create_from_discriminator_value(parse_node: ParseNode) -> Message: + """ + Creates a new instance of the appropriate class based on discriminator value + param parse_node: The parse node to use to read the discriminator value and create the object + Returns: Message + """ + if parse_node is None: + raise TypeError("parse_node cannot be null.") + return Message() + + def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]: + """ + The deserialization information for the current model + Returns: dict[str, Callable[[ParseNode], None]] + """ + from .settings import Settings + + from .settings import Settings + + fields: dict[str, Callable[[Any], None]] = { + "clientReference": lambda n : setattr(self, 'client_reference', n.get_str_value()), + "content": lambda n : setattr(self, 'content', n.get_str_value()), + "price": lambda n : setattr(self, 'price', n.get_int_value()), + "priceXml": lambda n : setattr(self, 'price_xml', n.get_str_value()), + "recipient": lambda n : setattr(self, 'recipient', n.get_str_value()), + "settings": lambda n : setattr(self, 'settings', n.get_object_value(Settings)), + } + return fields + + def serialize(self,writer: SerializationWriter) -> None: + """ + Serializes information the current object + param writer: Serialization writer to use to serialize this model + Returns: None + """ + if writer is None: + raise TypeError("writer cannot be null.") + writer.write_str_value("clientReference", self.client_reference) + writer.write_str_value("content", self.content) + writer.write_int_value("price", self.price) + writer.write_str_value("priceXml", self.price_xml) + writer.write_str_value("recipient", self.recipient) + writer.write_object_value("settings", self.settings) + + diff --git a/src/models/message_status.py b/src/models/message_status.py new file mode 100644 index 0000000..0a57cbc --- /dev/null +++ b/src/models/message_status.py @@ -0,0 +1,67 @@ +from __future__ import annotations +from collections.abc import Callable +from dataclasses import dataclass, field +from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter +from typing import Any, Optional, TYPE_CHECKING, Union + +@dataclass +class MessageStatus(Parsable): + # The clientReference property + client_reference: Optional[str] = None + # The messageId property + message_id: Optional[str] = None + # The recipient property + recipient: Optional[str] = None + # The sequenceIndex property + sequence_index: Optional[int] = None + # The sessionId property + session_id: Optional[str] = None + # The statusCode property + status_code: Optional[int] = None + # The statusMessage property + status_message: Optional[str] = None + + @staticmethod + def create_from_discriminator_value(parse_node: ParseNode) -> MessageStatus: + """ + Creates a new instance of the appropriate class based on discriminator value + param parse_node: The parse node to use to read the discriminator value and create the object + Returns: MessageStatus + """ + if parse_node is None: + raise TypeError("parse_node cannot be null.") + return MessageStatus() + + def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]: + """ + The deserialization information for the current model + Returns: dict[str, Callable[[ParseNode], None]] + """ + fields: dict[str, Callable[[Any], None]] = { + "clientReference": lambda n : setattr(self, 'client_reference', n.get_str_value()), + "messageId": lambda n : setattr(self, 'message_id', n.get_str_value()), + "recipient": lambda n : setattr(self, 'recipient', n.get_str_value()), + "sequenceIndex": lambda n : setattr(self, 'sequence_index', n.get_int_value()), + "sessionId": lambda n : setattr(self, 'session_id', n.get_str_value()), + "statusCode": lambda n : setattr(self, 'status_code', n.get_int_value()), + "statusMessage": lambda n : setattr(self, 'status_message', n.get_str_value()), + } + return fields + + def serialize(self,writer: SerializationWriter) -> None: + """ + Serializes information the current object + param writer: Serialization writer to use to serialize this model + Returns: None + """ + if writer is None: + raise TypeError("writer cannot be null.") + writer.write_str_value("clientReference", self.client_reference) + writer.write_str_value("messageId", self.message_id) + writer.write_str_value("recipient", self.recipient) + writer.write_int_value("sequenceIndex", self.sequence_index) + writer.write_str_value("sessionId", self.session_id) + writer.write_int_value("statusCode", self.status_code) + writer.write_str_value("statusMessage", self.status_message) + + diff --git a/src/models/originator_settings.py b/src/models/originator_settings.py new file mode 100644 index 0000000..69c98c3 --- /dev/null +++ b/src/models/originator_settings.py @@ -0,0 +1,54 @@ +from __future__ import annotations +from collections.abc import Callable +from dataclasses import dataclass, field +from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter +from typing import Any, Optional, TYPE_CHECKING, Union + +if TYPE_CHECKING: + from .originator_type import OriginatorType + +@dataclass +class OriginatorSettings(Parsable): + # The originator property + originator: Optional[str] = None + # The originatorType property + originator_type: Optional[OriginatorType] = None + + @staticmethod + def create_from_discriminator_value(parse_node: ParseNode) -> OriginatorSettings: + """ + Creates a new instance of the appropriate class based on discriminator value + param parse_node: The parse node to use to read the discriminator value and create the object + Returns: OriginatorSettings + """ + if parse_node is None: + raise TypeError("parse_node cannot be null.") + return OriginatorSettings() + + def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]: + """ + The deserialization information for the current model + Returns: dict[str, Callable[[ParseNode], None]] + """ + from .originator_type import OriginatorType + + from .originator_type import OriginatorType + + fields: dict[str, Callable[[Any], None]] = { + "originator": lambda n : setattr(self, 'originator', n.get_str_value()), + "originatorType": lambda n : setattr(self, 'originator_type', n.get_enum_value(OriginatorType)), + } + return fields + + def serialize(self,writer: SerializationWriter) -> None: + """ + Serializes information the current object + param writer: Serialization writer to use to serialize this model + Returns: None + """ + if writer is None: + raise TypeError("writer cannot be null.") + writer.write_str_value("originator", self.originator) + writer.write_enum_value("originatorType", self.originator_type) + + diff --git a/src/models/originator_type.py b/src/models/originator_type.py new file mode 100644 index 0000000..9564f34 --- /dev/null +++ b/src/models/originator_type.py @@ -0,0 +1,7 @@ +from enum import Enum + +class OriginatorType(str, Enum): + International = "International", + Alphanumeric = "Alphanumeric", + Network = "Network", + diff --git a/src/models/parameter.py b/src/models/parameter.py new file mode 100644 index 0000000..46107f4 --- /dev/null +++ b/src/models/parameter.py @@ -0,0 +1,47 @@ +from __future__ import annotations +from collections.abc import Callable +from dataclasses import dataclass, field +from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter +from typing import Any, Optional, TYPE_CHECKING, Union + +@dataclass +class Parameter(Parsable): + # The key property + key: Optional[str] = None + # The value property + value: Optional[str] = None + + @staticmethod + def create_from_discriminator_value(parse_node: ParseNode) -> Parameter: + """ + Creates a new instance of the appropriate class based on discriminator value + param parse_node: The parse node to use to read the discriminator value and create the object + Returns: Parameter + """ + if parse_node is None: + raise TypeError("parse_node cannot be null.") + return Parameter() + + def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]: + """ + The deserialization information for the current model + Returns: dict[str, Callable[[ParseNode], None]] + """ + fields: dict[str, Callable[[Any], None]] = { + "key": lambda n : setattr(self, 'key', n.get_str_value()), + "value": lambda n : setattr(self, 'value', n.get_str_value()), + } + return fields + + def serialize(self,writer: SerializationWriter) -> None: + """ + Serializes information the current object + param writer: Serialization writer to use to serialize this model + Returns: None + """ + if writer is None: + raise TypeError("writer cannot be null.") + writer.write_str_value("key", self.key) + writer.write_str_value("value", self.value) + + diff --git a/src/models/problem_details.py b/src/models/problem_details.py new file mode 100644 index 0000000..fbf5678 --- /dev/null +++ b/src/models/problem_details.py @@ -0,0 +1,70 @@ +from __future__ import annotations +from collections.abc import Callable +from dataclasses import dataclass, field +from kiota_abstractions.api_error import APIError +from kiota_abstractions.serialization import AdditionalDataHolder, Parsable, ParseNode, SerializationWriter +from typing import Any, Optional, TYPE_CHECKING, Union + +@dataclass +class ProblemDetails(APIError, AdditionalDataHolder, Parsable): + # Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well. + additional_data: dict[str, Any] = field(default_factory=dict) + + # The detail property + detail: Optional[str] = None + # The instance property + instance: Optional[str] = None + # The status property + status: Optional[int] = None + # The title property + title: Optional[str] = None + # The type property + type: Optional[str] = None + + @staticmethod + def create_from_discriminator_value(parse_node: ParseNode) -> ProblemDetails: + """ + Creates a new instance of the appropriate class based on discriminator value + param parse_node: The parse node to use to read the discriminator value and create the object + Returns: ProblemDetails + """ + if parse_node is None: + raise TypeError("parse_node cannot be null.") + return ProblemDetails() + + def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]: + """ + The deserialization information for the current model + Returns: dict[str, Callable[[ParseNode], None]] + """ + fields: dict[str, Callable[[Any], None]] = { + "detail": lambda n : setattr(self, 'detail', n.get_str_value()), + "instance": lambda n : setattr(self, 'instance', n.get_str_value()), + "status": lambda n : setattr(self, 'status', n.get_int_value()), + "title": lambda n : setattr(self, 'title', n.get_str_value()), + "type": lambda n : setattr(self, 'type', n.get_str_value()), + } + return fields + + def serialize(self,writer: SerializationWriter) -> None: + """ + Serializes information the current object + param writer: Serialization writer to use to serialize this model + Returns: None + """ + if writer is None: + raise TypeError("writer cannot be null.") + writer.write_str_value("detail", self.detail) + writer.write_str_value("instance", self.instance) + writer.write_int_value("status", self.status) + writer.write_str_value("title", self.title) + writer.write_str_value("type", self.type) + writer.write_additional_data_value(self.additional_data) + + @property + def primary_message(self) -> Optional[str]: + """ + The primary error message. + """ + return super().message + diff --git a/src/models/send_window.py b/src/models/send_window.py new file mode 100644 index 0000000..d5b1f98 --- /dev/null +++ b/src/models/send_window.py @@ -0,0 +1,55 @@ +from __future__ import annotations +from collections.abc import Callable +from dataclasses import dataclass, field +from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter +from typing import Any, Optional, TYPE_CHECKING, Union + +@dataclass +class SendWindow(Parsable): + # The startDate property + start_date: Optional[str] = None + # The startTime property + start_time: Optional[str] = None + # The stopDate property + stop_date: Optional[str] = None + # The stopTime property + stop_time: Optional[str] = None + + @staticmethod + def create_from_discriminator_value(parse_node: ParseNode) -> SendWindow: + """ + Creates a new instance of the appropriate class based on discriminator value + param parse_node: The parse node to use to read the discriminator value and create the object + Returns: SendWindow + """ + if parse_node is None: + raise TypeError("parse_node cannot be null.") + return SendWindow() + + def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]: + """ + The deserialization information for the current model + Returns: dict[str, Callable[[ParseNode], None]] + """ + fields: dict[str, Callable[[Any], None]] = { + "startDate": lambda n : setattr(self, 'start_date', n.get_str_value()), + "startTime": lambda n : setattr(self, 'start_time', n.get_str_value()), + "stopDate": lambda n : setattr(self, 'stop_date', n.get_str_value()), + "stopTime": lambda n : setattr(self, 'stop_time', n.get_str_value()), + } + return fields + + def serialize(self,writer: SerializationWriter) -> None: + """ + Serializes information the current object + param writer: Serialization writer to use to serialize this model + Returns: None + """ + if writer is None: + raise TypeError("writer cannot be null.") + writer.write_str_value("startDate", self.start_date) + writer.write_str_value("startTime", self.start_time) + writer.write_str_value("stopDate", self.stop_date) + writer.write_str_value("stopTime", self.stop_time) + + diff --git a/src/models/settings.py b/src/models/settings.py new file mode 100644 index 0000000..02b36c0 --- /dev/null +++ b/src/models/settings.py @@ -0,0 +1,103 @@ +from __future__ import annotations +from collections.abc import Callable +from dataclasses import dataclass, field +from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter +from typing import Any, Optional, TYPE_CHECKING, Union + +if TYPE_CHECKING: + from .gas_settings import GasSettings + from .originator_settings import OriginatorSettings + from .parameter import Parameter + from .send_window import SendWindow + +@dataclass +class Settings(Parsable): + # The age property + age: Optional[int] = None + # The autoDetectEncoding property + auto_detect_encoding: Optional[bool] = None + # The differentiator property + differentiator: Optional[str] = None + # The gasSettings property + gas_settings: Optional[GasSettings] = None + # The invoiceNode property + invoice_node: Optional[str] = None + # The newSession property + new_session: Optional[bool] = None + # The originatorSettings property + originator_settings: Optional[OriginatorSettings] = None + # The parameter property + parameter: Optional[list[Parameter]] = None + # The priority property + priority: Optional[int] = None + # The sendWindow property + send_window: Optional[SendWindow] = None + # The sessionId property + session_id: Optional[str] = None + # The validity property + validity: Optional[int] = None + + @staticmethod + def create_from_discriminator_value(parse_node: ParseNode) -> Settings: + """ + Creates a new instance of the appropriate class based on discriminator value + param parse_node: The parse node to use to read the discriminator value and create the object + Returns: Settings + """ + if parse_node is None: + raise TypeError("parse_node cannot be null.") + return Settings() + + def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]: + """ + The deserialization information for the current model + Returns: dict[str, Callable[[ParseNode], None]] + """ + from .gas_settings import GasSettings + from .originator_settings import OriginatorSettings + from .parameter import Parameter + from .send_window import SendWindow + + from .gas_settings import GasSettings + from .originator_settings import OriginatorSettings + from .parameter import Parameter + from .send_window import SendWindow + + fields: dict[str, Callable[[Any], None]] = { + "age": lambda n : setattr(self, 'age', n.get_int_value()), + "autoDetectEncoding": lambda n : setattr(self, 'auto_detect_encoding', n.get_bool_value()), + "differentiator": lambda n : setattr(self, 'differentiator', n.get_str_value()), + "gasSettings": lambda n : setattr(self, 'gas_settings', n.get_object_value(GasSettings)), + "invoiceNode": lambda n : setattr(self, 'invoice_node', n.get_str_value()), + "newSession": lambda n : setattr(self, 'new_session', n.get_bool_value()), + "originatorSettings": lambda n : setattr(self, 'originator_settings', n.get_object_value(OriginatorSettings)), + "parameter": lambda n : setattr(self, 'parameter', n.get_collection_of_object_values(Parameter)), + "priority": lambda n : setattr(self, 'priority', n.get_int_value()), + "sendWindow": lambda n : setattr(self, 'send_window', n.get_object_value(SendWindow)), + "sessionId": lambda n : setattr(self, 'session_id', n.get_str_value()), + "validity": lambda n : setattr(self, 'validity', n.get_int_value()), + } + return fields + + def serialize(self,writer: SerializationWriter) -> None: + """ + Serializes information the current object + param writer: Serialization writer to use to serialize this model + Returns: None + """ + if writer is None: + raise TypeError("writer cannot be null.") + writer.write_int_value("age", self.age) + writer.write_bool_value("autoDetectEncoding", self.auto_detect_encoding) + writer.write_str_value("differentiator", self.differentiator) + writer.write_object_value("gasSettings", self.gas_settings) + writer.write_str_value("invoiceNode", self.invoice_node) + writer.write_bool_value("newSession", self.new_session) + writer.write_object_value("originatorSettings", self.originator_settings) + writer.write_collection_of_object_values("parameter", self.parameter) + writer.write_int_value("priority", self.priority) + writer.write_object_value("sendWindow", self.send_window) + writer.write_str_value("sessionId", self.session_id) + writer.write_int_value("validity", self.validity) + + diff --git a/src/models/stop_batch_response.py b/src/models/stop_batch_response.py new file mode 100644 index 0000000..9af4818 --- /dev/null +++ b/src/models/stop_batch_response.py @@ -0,0 +1,58 @@ +from __future__ import annotations +from collections.abc import Callable +from dataclasses import dataclass, field +from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter +from typing import Any, Optional, TYPE_CHECKING, Union + +if TYPE_CHECKING: + from .stopped_message_response import StoppedMessageResponse + +@dataclass +class StopBatchResponse(Parsable): + # The clientBatchReference property + client_batch_reference: Optional[str] = None + # The serviceId property + service_id: Optional[int] = None + # The stoppedMessages property + stopped_messages: Optional[list[StoppedMessageResponse]] = None + + @staticmethod + def create_from_discriminator_value(parse_node: ParseNode) -> StopBatchResponse: + """ + Creates a new instance of the appropriate class based on discriminator value + param parse_node: The parse node to use to read the discriminator value and create the object + Returns: StopBatchResponse + """ + if parse_node is None: + raise TypeError("parse_node cannot be null.") + return StopBatchResponse() + + def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]: + """ + The deserialization information for the current model + Returns: dict[str, Callable[[ParseNode], None]] + """ + from .stopped_message_response import StoppedMessageResponse + + from .stopped_message_response import StoppedMessageResponse + + fields: dict[str, Callable[[Any], None]] = { + "clientBatchReference": lambda n : setattr(self, 'client_batch_reference', n.get_str_value()), + "serviceId": lambda n : setattr(self, 'service_id', n.get_int_value()), + "stoppedMessages": lambda n : setattr(self, 'stopped_messages', n.get_collection_of_object_values(StoppedMessageResponse)), + } + return fields + + def serialize(self,writer: SerializationWriter) -> None: + """ + Serializes information the current object + param writer: Serialization writer to use to serialize this model + Returns: None + """ + if writer is None: + raise TypeError("writer cannot be null.") + writer.write_str_value("clientBatchReference", self.client_batch_reference) + writer.write_int_value("serviceId", self.service_id) + writer.write_collection_of_object_values("stoppedMessages", self.stopped_messages) + + diff --git a/src/models/stopped_message_response.py b/src/models/stopped_message_response.py new file mode 100644 index 0000000..9e504bc --- /dev/null +++ b/src/models/stopped_message_response.py @@ -0,0 +1,47 @@ +from __future__ import annotations +from collections.abc import Callable +from dataclasses import dataclass, field +from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter +from typing import Any, Optional, TYPE_CHECKING, Union + +@dataclass +class StoppedMessageResponse(Parsable): + # The clientMessageReference property + client_message_reference: Optional[str] = None + # The messageId property + message_id: Optional[str] = None + + @staticmethod + def create_from_discriminator_value(parse_node: ParseNode) -> StoppedMessageResponse: + """ + Creates a new instance of the appropriate class based on discriminator value + param parse_node: The parse node to use to read the discriminator value and create the object + Returns: StoppedMessageResponse + """ + if parse_node is None: + raise TypeError("parse_node cannot be null.") + return StoppedMessageResponse() + + def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]: + """ + The deserialization information for the current model + Returns: dict[str, Callable[[ParseNode], None]] + """ + fields: dict[str, Callable[[Any], None]] = { + "clientMessageReference": lambda n : setattr(self, 'client_message_reference', n.get_str_value()), + "messageId": lambda n : setattr(self, 'message_id', n.get_str_value()), + } + return fields + + def serialize(self,writer: SerializationWriter) -> None: + """ + Serializes information the current object + param writer: Serialization writer to use to serialize this model + Returns: None + """ + if writer is None: + raise TypeError("writer cannot be null.") + writer.write_str_value("clientMessageReference", self.client_message_reference) + writer.write_str_value("messageId", self.message_id) + + diff --git a/src/mt_http_client.py b/src/mt_http_client.py new file mode 100644 index 0000000..f403880 --- /dev/null +++ b/src/mt_http_client.py @@ -0,0 +1,60 @@ +from __future__ import annotations +from collections.abc import Callable +from kiota_abstractions.api_client_builder import enable_backing_store_for_serialization_writer_factory, register_default_deserializer, register_default_serializer +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.request_adapter import RequestAdapter +from kiota_abstractions.serialization import ParseNodeFactoryRegistry, SerializationWriterFactoryRegistry +from kiota_serialization_form.form_parse_node_factory import FormParseNodeFactory +from kiota_serialization_form.form_serialization_writer_factory import FormSerializationWriterFactory +from kiota_serialization_json.json_parse_node_factory import JsonParseNodeFactory +from kiota_serialization_json.json_serialization_writer_factory import JsonSerializationWriterFactory +from kiota_serialization_multipart.multipart_serialization_writer_factory import MultipartSerializationWriterFactory +from kiota_serialization_text.text_parse_node_factory import TextParseNodeFactory +from kiota_serialization_text.text_serialization_writer_factory import TextSerializationWriterFactory +from typing import Any, Optional, TYPE_CHECKING, Union + +if TYPE_CHECKING: + from .gw.gw_request_builder import GwRequestBuilder + from .management.management_request_builder import ManagementRequestBuilder + +class MtHttpClient(BaseRequestBuilder): + """ + The main entry point of the SDK, exposes the configuration and the fluent API. + """ + def __init__(self,request_adapter: RequestAdapter) -> None: + """ + Instantiates a new MtHttpClient and sets the default values. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + if request_adapter is None: + raise TypeError("request_adapter cannot be null.") + super().__init__(request_adapter, "{+baseurl}", None) + register_default_serializer(JsonSerializationWriterFactory) + register_default_serializer(TextSerializationWriterFactory) + register_default_serializer(FormSerializationWriterFactory) + register_default_serializer(MultipartSerializationWriterFactory) + register_default_deserializer(JsonParseNodeFactory) + register_default_deserializer(TextParseNodeFactory) + register_default_deserializer(FormParseNodeFactory) + + @property + def gw(self) -> GwRequestBuilder: + """ + The gw property + """ + from .gw.gw_request_builder import GwRequestBuilder + + return GwRequestBuilder(self.request_adapter, self.path_parameters) + + @property + def management(self) -> ManagementRequestBuilder: + """ + The management property + """ + from .management.management_request_builder import ManagementRequestBuilder + + return ManagementRequestBuilder(self.request_adapter, self.path_parameters) + +