generate client via 'make generate-openapi-client'

Author: ks6088ts

client/api_client.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+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, Callable, Dict, List, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .azure_openai.azure_openai_request_builder import Azure_openaiRequestBuilder
+    from .document_intelligence.document_intelligence_request_builder import Document_intelligenceRequestBuilder
+
+class ApiClient(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 ApiClient and sets the default values.
+        param request_adapter: The request adapter to use to execute the requests.
+        Returns: None
+        """
+        if not request_adapter:
+            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)
+        if not self.request_adapter.base_url:
+            self.request_adapter.base_url = "http://localhost:8000"
+        self.path_parameters["base_url"] = self.request_adapter.base_url
+    
+    @property
+    def azure_openai(self) -> Azure_openaiRequestBuilder:
+        """
+        The azure_openai property
+        """
+        from .azure_openai.azure_openai_request_builder import Azure_openaiRequestBuilder
+
+        return Azure_openaiRequestBuilder(self.request_adapter, self.path_parameters)
+    
+    @property
+    def document_intelligence(self) -> Document_intelligenceRequestBuilder:
+        """
+        The document_intelligence property
+        """
+        from .document_intelligence.document_intelligence_request_builder import Document_intelligenceRequestBuilder
+
+        return Document_intelligenceRequestBuilder(self.request_adapter, self.path_parameters)
+    
+

client/azure_openai/azure_openai_request_builder.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+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, Callable, Dict, List, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .chat_completions.chat_completions_request_builder import Chat_completionsRequestBuilder
+
+class Azure_openaiRequestBuilder(BaseRequestBuilder):
+    """
+    Builds and executes requests for operations under /azure_openai
+    """
+    def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, Dict[str, Any]]) -> None:
+        """
+        Instantiates a new Azure_openaiRequestBuilder 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}/azure_openai", path_parameters)
+    
+    @property
+    def chat_completions(self) -> Chat_completionsRequestBuilder:
+        """
+        The chat_completions property
+        """
+        from .chat_completions.chat_completions_request_builder import Chat_completionsRequestBuilder
+
+        return Chat_completionsRequestBuilder(self.request_adapter, self.path_parameters)
+    
+

client/azure_openai/chat_completions/chat_completions_request_builder.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+from kiota_abstractions.base_request_builder import BaseRequestBuilder
+from kiota_abstractions.base_request_configuration import RequestConfiguration
+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, Callable, Dict, List, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from ...models.chat_completion_request import ChatCompletionRequest
+    from ...models.chat_completion_response import ChatCompletionResponse
+    from ...models.h_t_t_p_validation_error import HTTPValidationError
+
+class Chat_completionsRequestBuilder(BaseRequestBuilder):
+    """
+    Builds and executes requests for operations under /azure_openai/chat_completions
+    """
+    def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, Dict[str, Any]]) -> None:
+        """
+        Instantiates a new Chat_completionsRequestBuilder 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}/azure_openai/chat_completions", path_parameters)
+    
+    async def post(self,body: Optional[ChatCompletionRequest] = None, request_configuration: Optional[RequestConfiguration] = None) -> Optional[ChatCompletionResponse]:
+        """
+        Create Chat Completions
+        param body: The request body
+        param request_configuration: Configuration for the request such as headers, query parameters, and middleware options.
+        Returns: Optional[ChatCompletionResponse]
+        """
+        if not body:
+            raise TypeError("body cannot be null.")
+        request_info = self.to_post_request_information(
+            body, request_configuration
+        )
+        from ...models.h_t_t_p_validation_error import HTTPValidationError
+
+        error_mapping: Dict[str, ParsableFactory] = {
+            "422": HTTPValidationError,
+        }
+        if not self.request_adapter:
+            raise Exception("Http core is null") 
+        from ...models.chat_completion_response import ChatCompletionResponse
+
+        return await self.request_adapter.send_async(request_info, ChatCompletionResponse, error_mapping)
+    
+    def to_post_request_information(self,body: Optional[ChatCompletionRequest] = None, request_configuration: Optional[RequestConfiguration] = None) -> RequestInformation:
+        """
+        Create Chat Completions
+        param body: The request body
+        param request_configuration: Configuration for the request such as headers, query parameters, and middleware options.
+        Returns: RequestInformation
+        """
+        if not body:
+            raise TypeError("body cannot be null.")
+        request_info = RequestInformation(Method.POST, self.url_template, 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: Optional[str] = None) -> Chat_completionsRequestBuilder:
+        """
+        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: Chat_completionsRequestBuilder
+        """
+        if not raw_url:
+            raise TypeError("raw_url cannot be null.")
+        return Chat_completionsRequestBuilder(self.request_adapter, raw_url)
+    
+

client/document_intelligence/analyze_document/analyze_document_request_builder.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+from kiota_abstractions.base_request_builder import BaseRequestBuilder
+from kiota_abstractions.base_request_configuration import RequestConfiguration
+from kiota_abstractions.get_path_parameters import get_path_parameters
+from kiota_abstractions.method import Method
+from kiota_abstractions.multipart_body import MultipartBody
+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, Callable, Dict, List, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from ...models.analyze_document_response import AnalyzeDocumentResponse
+    from ...models.h_t_t_p_validation_error import HTTPValidationError
+
+class Analyze_documentRequestBuilder(BaseRequestBuilder):
+    """
+    Builds and executes requests for operations under /document_intelligence/analyze_document
+    """
+    def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, Dict[str, Any]]) -> None:
+        """
+        Instantiates a new Analyze_documentRequestBuilder 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}/document_intelligence/analyze_document", path_parameters)
+    
+    async def post(self,body: Optional[MultipartBody] = None, request_configuration: Optional[RequestConfiguration] = None) -> Optional[AnalyzeDocumentResponse]:
+        """
+        Analyze Document
+        param body: The request body
+        param request_configuration: Configuration for the request such as headers, query parameters, and middleware options.
+        Returns: Optional[AnalyzeDocumentResponse]
+        """
+        if not body:
+            raise TypeError("body cannot be null.")
+        request_info = self.to_post_request_information(
+            body, request_configuration
+        )
+        from ...models.h_t_t_p_validation_error import HTTPValidationError
+
+        error_mapping: Dict[str, ParsableFactory] = {
+            "422": HTTPValidationError,
+        }
+        if not self.request_adapter:
+            raise Exception("Http core is null") 
+        from ...models.analyze_document_response import AnalyzeDocumentResponse
+
+        return await self.request_adapter.send_async(request_info, AnalyzeDocumentResponse, error_mapping)
+    
+    def to_post_request_information(self,body: Optional[MultipartBody] = None, request_configuration: Optional[RequestConfiguration] = None) -> RequestInformation:
+        """
+        Analyze Document
+        param body: The request body
+        param request_configuration: Configuration for the request such as headers, query parameters, and middleware options.
+        Returns: RequestInformation
+        """
+        if not body:
+            raise TypeError("body cannot be null.")
+        request_info = RequestInformation(Method.POST, self.url_template, 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, "multipart/form-data", body)
+        return request_info
+    
+    def with_url(self,raw_url: Optional[str] = None) -> Analyze_documentRequestBuilder:
+        """
+        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: Analyze_documentRequestBuilder
+        """
+        if not raw_url:
+            raise TypeError("raw_url cannot be null.")
+        return Analyze_documentRequestBuilder(self.request_adapter, raw_url)
+    
+

client/document_intelligence/document_intelligence_request_builder.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+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, Callable, Dict, List, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .analyze_document.analyze_document_request_builder import Analyze_documentRequestBuilder
+
+class Document_intelligenceRequestBuilder(BaseRequestBuilder):
+    """
+    Builds and executes requests for operations under /document_intelligence
+    """
+    def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, Dict[str, Any]]) -> None:
+        """
+        Instantiates a new Document_intelligenceRequestBuilder 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}/document_intelligence", path_parameters)
+    
+    @property
+    def analyze_document(self) -> Analyze_documentRequestBuilder:
+        """
+        The analyze_document property
+        """
+        from .analyze_document.analyze_document_request_builder import Analyze_documentRequestBuilder
+
+        return Analyze_documentRequestBuilder(self.request_adapter, self.path_parameters)
+    
+

client/kiota-lock.json

@@ -0,0 +1,32 @@
+{
+  "descriptionHash": "F3B49DC82AFDA0E7C058BDB4EF5B2D13AB357D868E809192EFFE49859B73397348D63687480E60656459D9212EF3A84EED183E4AEF12B22D592E74885ED7444A",
+  "descriptionLocation": "../specs/openapi.json",
+  "lockFileVersion": "1.0.0",
+  "kiotaVersion": "1.13.0",
+  "clientClassName": "ApiClient",
+  "clientNamespaceName": "client",
+  "language": "Python",
+  "usesBackingStore": false,
+  "excludeBackwardCompatible": false,
+  "includeAdditionalData": true,
+  "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": [],
+  "disabledValidationRules": []
+}

client/models/analyze_document_response.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import AdditionalDataHolder, Parsable, ParseNode, SerializationWriter
+from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union
+
+@dataclass
+class AnalyzeDocumentResponse(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 content property
+    content: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: Optional[ParseNode] = None) -> AnalyzeDocumentResponse:
+        """
+        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: AnalyzeDocumentResponse
+        """
+        if not parse_node:
+            raise TypeError("parse_node cannot be null.")
+        return AnalyzeDocumentResponse()
+    
+    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]] = {
+            "content": lambda n : setattr(self, 'content', 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 not writer:
+            raise TypeError("writer cannot be null.")
+        writer.write_str_value("content", self.content)
+        writer.write_additional_data_value(self.additional_data)
+    
+