openapi-httpx-client 0.1.0__tar.gz

openapi_httpx_client-0.1.0/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.2
+Name: openapi-httpx-client
+Version: 0.1.0
+Summary: A Python client for OpenAPI specifications using httpx
+Home-page: https://github.com/lloydzhou/openapiclient
+Author: lloydzhou
+Author-email: lloydzhou@qq.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.23.0
+Requires-Dist: pyyaml>=6.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# OpenAPI Client for Python
+
+A Python implementation inspired by [openapi-client-axios](https://github.com/openapistack/openapi-client-axios) that provides a dynamic client for OpenAPI specifications. This implementation uses httpx for HTTP requests and Python's metaprogramming capabilities to dynamically generate a client.
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+## Usage
+
+```python
+from openapiclient import OpenAPIClient
+import asyncio
+
+async def main():
+    # Initialize the client with the OpenAPI definition
+    api = OpenAPIClient(definition="https://petstore3.swagger.io/api/v3/openapi.json")
+
+    try:
+        # Initialize and get the dynamic client
+        client = await api.init()
+
+        # Call an operation using the generated method
+        response = await client.getPetById(petId=1)
+
+        # Print the response
+        print(f"Status code: {response['status']}")
+        print(f"Pet data: {response['data']}")
+    finally:
+        # Close the HTTP session
+        await api.close()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## Features
+
+- Dynamic client generation using Python metaprogramming
+- Supports OpenAPI 3.0 and 3.1
+- Supports JSON and YAML specification formats
+- Supports specification loading from URL, file, or dictionary
+- Asynchronous API using httpx
+- Response format similar to axios (data, status, headers, config)
+
+## Author
+lloydzhou (2025-02-27)
+
+

openapi_httpx_client-0.1.0/README.md

@@ -0,0 +1,51 @@
+# OpenAPI Client for Python
+
+A Python implementation inspired by [openapi-client-axios](https://github.com/openapistack/openapi-client-axios) that provides a dynamic client for OpenAPI specifications. This implementation uses httpx for HTTP requests and Python's metaprogramming capabilities to dynamically generate a client.
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+## Usage
+
+```python
+from openapiclient import OpenAPIClient
+import asyncio
+
+async def main():
+    # Initialize the client with the OpenAPI definition
+    api = OpenAPIClient(definition="https://petstore3.swagger.io/api/v3/openapi.json")
+
+    try:
+        # Initialize and get the dynamic client
+        client = await api.init()
+
+        # Call an operation using the generated method
+        response = await client.getPetById(petId=1)
+
+        # Print the response
+        print(f"Status code: {response['status']}")
+        print(f"Pet data: {response['data']}")
+    finally:
+        # Close the HTTP session
+        await api.close()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## Features
+
+- Dynamic client generation using Python metaprogramming
+- Supports OpenAPI 3.0 and 3.1
+- Supports JSON and YAML specification formats
+- Supports specification loading from URL, file, or dictionary
+- Asynchronous API using httpx
+- Response format similar to axios (data, status, headers, config)
+
+## Author
+lloydzhou (2025-02-27)
+
+

openapi_httpx_client-0.1.0/openapi_httpx_client.egg-info/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.2
+Name: openapi-httpx-client
+Version: 0.1.0
+Summary: A Python client for OpenAPI specifications using httpx
+Home-page: https://github.com/lloydzhou/openapiclient
+Author: lloydzhou
+Author-email: lloydzhou@qq.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.23.0
+Requires-Dist: pyyaml>=6.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# OpenAPI Client for Python
+
+A Python implementation inspired by [openapi-client-axios](https://github.com/openapistack/openapi-client-axios) that provides a dynamic client for OpenAPI specifications. This implementation uses httpx for HTTP requests and Python's metaprogramming capabilities to dynamically generate a client.
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+## Usage
+
+```python
+from openapiclient import OpenAPIClient
+import asyncio
+
+async def main():
+    # Initialize the client with the OpenAPI definition
+    api = OpenAPIClient(definition="https://petstore3.swagger.io/api/v3/openapi.json")
+
+    try:
+        # Initialize and get the dynamic client
+        client = await api.init()
+
+        # Call an operation using the generated method
+        response = await client.getPetById(petId=1)
+
+        # Print the response
+        print(f"Status code: {response['status']}")
+        print(f"Pet data: {response['data']}")
+    finally:
+        # Close the HTTP session
+        await api.close()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## Features
+
+- Dynamic client generation using Python metaprogramming
+- Supports OpenAPI 3.0 and 3.1
+- Supports JSON and YAML specification formats
+- Supports specification loading from URL, file, or dictionary
+- Asynchronous API using httpx
+- Response format similar to axios (data, status, headers, config)
+
+## Author
+lloydzhou (2025-02-27)
+
+

openapi_httpx_client-0.1.0/openapi_httpx_client.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+README.md
+setup.py
+openapi_httpx_client.egg-info/PKG-INFO
+openapi_httpx_client.egg-info/SOURCES.txt
+openapi_httpx_client.egg-info/dependency_links.txt
+openapi_httpx_client.egg-info/requires.txt
+openapi_httpx_client.egg-info/top_level.txt
+openapiclient/__init__.py
+openapiclient/client.py

openapi_httpx_client-0.1.0/openapi_httpx_client.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

openapi_httpx_client-0.1.0/openapi_httpx_client.egg-info/requires.txt

@@ -0,0 +1,2 @@
+httpx>=0.23.0
+pyyaml>=6.0

openapi_httpx_client-0.1.0/openapi_httpx_client.egg-info/top_level.txt

@@ -0,0 +1 @@
+openapiclient

openapi_httpx_client-0.1.0/openapiclient/__init__.py

@@ -0,0 +1,3 @@
+from .client import OpenAPIClient
+
+__all__ = ['OpenAPIClient']

openapi_httpx_client-0.1.0/openapiclient/client.py

@@ -0,0 +1,219 @@
+import httpx
+import json
+import os.path
+from urllib.parse import urljoin, urlparse
+import yaml
+import types
+
+class OpenAPIClient:
+    """
+    A Python client for OpenAPI specifications, inspired by openapi-client-axios.
+    Uses httpx for HTTP requests.
+    """
+
+    def __init__(self, definition=None):
+        """
+        Initialize the OpenAPI client.
+
+        Args:
+            definition: URL or file path to the OpenAPI definition, or a dictionary containing the definition
+        """
+        self.definition_source = definition
+        self.definition = None
+        self.client = None
+        self.base_url = ''
+        self.session = None
+        self.source_url = None  # Store the source URL if loaded from a URL
+
+    async def init(self):
+        """
+        Initialize the client by loading and parsing the OpenAPI definition.
+
+        Returns:
+            DynamicClient: A client with methods generated from the OpenAPI definition
+        """
+        # Load the OpenAPI definition
+        await self.load_definition()
+
+        # Create HTTP session
+        self.session = httpx.AsyncClient()
+
+        # Set base URL from the servers list if available
+        self.setup_base_url()
+
+        # Create a dynamic client with methods based on the operations defined in the spec
+        return await self.create_dynamic_client()
+
+    async def load_definition(self):
+        """
+        Load the OpenAPI definition from a URL, file, or dictionary.
+        """
+        if isinstance(self.definition_source, dict):
+            self.definition = self.definition_source
+            return
+
+        if os.path.isfile(str(self.definition_source)):
+            # Load from file
+            with open(self.definition_source, 'r') as f:
+                content = f.read()
+                if self.definition_source.endswith('.yaml') or self.definition_source.endswith('.yml'):
+                    self.definition = yaml.safe_load(content)
+                else:
+                    self.definition = json.loads(content)
+            return
+
+        # Assume it's a URL
+        self.source_url = self.definition_source  # Store the source URL
+        async with httpx.AsyncClient() as client:
+            response = await client.get(self.definition_source)
+            if response.status_code == 200:
+                content_type = response.headers.get('Content-Type', '')
+                if 'yaml' in content_type or 'yml' in content_type:
+                    self.definition = yaml.safe_load(response.text)
+                else:
+                    self.definition = response.json()
+            else:
+                raise Exception(f"Failed to load OpenAPI definition: {response.status_code}")
+
+    def setup_base_url(self):
+        """
+        Set up the base URL for API requests, handling various server URL formats.
+        """
+        if 'servers' in self.definition and self.definition['servers']:
+            server_url = self.definition['servers'][0]['url']
+
+            # Check if this is a full URL or just a path
+            parsed_url = urlparse(server_url)
+
+            # If it's a full URL (has scheme), use it directly
+            if parsed_url.scheme:
+                self.base_url = server_url
+            # If it's not a full URL and we loaded from a URL, combine them
+            elif self.source_url:
+                # Parse the source URL to get scheme, hostname, and port
+                source_parsed = urlparse(self.source_url)
+                base = f"{source_parsed.scheme}://{source_parsed.netloc}"
+
+                # Combine the base with the server path
+                self.base_url = urljoin(base, server_url)
+            else:
+                # Just use what we have
+                self.base_url = server_url
+
+    async def create_dynamic_client(self):
+        """
+        Create a client with methods dynamically generated from the OpenAPI spec using metaprogramming.
+        
+        Returns:
+            DynamicClient: A client with methods for each operation in the spec
+        """
+        # Create a new class dynamically using type
+        methods_dict = {}
+        
+        # Generate methods for each path and operation
+        paths = self.definition.get('paths', {})
+        for path, path_item in paths.items():
+            for method, operation in path_item.items():
+                if method in ['get', 'post', 'put', 'delete', 'patch', 'options', 'head']:
+                    operation_id = operation.get('operationId')
+                    if operation_id:
+                        # Create a method for this operation and capture it in the closure
+                        method_func = self.create_operation_method(path, method, operation)
+
+                        # Create a function with proper binding
+                        def create_bound_method(func=method_func):
+                            async def bound_method(*args, **kwargs):
+                                return await func(*args, **kwargs)
+                            # Set the name and docstring
+                            bound_method.__name__ = operation_id
+                            bound_method.__doc__ = operation.get('summary', '') + "\n\n" + operation.get('description', '')
+                            return bound_method
+                        
+                        methods_dict[operation_id] = create_bound_method()
+
+        # Create the dynamic client class with the methods
+        DynamicClientClass = type('DynamicClient', (object,), methods_dict)
+
+        # Create an instance of this class
+        client = DynamicClientClass()
+
+        # Store reference to the api
+        client._api = self
+
+        return client
+
+    def create_operation_method(self, path, method, operation):
+        """
+        Create a method for an operation defined in the OpenAPI spec.
+
+        Args:
+            path: The path template (e.g., "/pets/{petId}")
+            method: The HTTP method (e.g., "get", "post")
+            operation: The operation object from the OpenAPI spec
+
+        Returns:
+            function: A method that performs the API request
+        """
+        async def operation_method(*args, **kwargs):
+            # Process path parameters
+            url = path
+            path_params = {}
+
+            # Extract parameters from operation definition
+            parameters = operation.get('parameters', [])
+            for param in parameters:
+                if param.get('in') == 'path':
+                    name = param.get('name')
+                    if name in kwargs:
+                        path_params[name] = kwargs.pop(name)
+
+            # Replace path parameters in the URL
+            for name, value in path_params.items():
+                url = url.replace(f"{{{name}}}", str(value))
+
+            # Build the full URL
+            full_url = urljoin(self.base_url, url)
+            
+            # Handle query parameters
+            query_params = {}
+            for param in parameters:
+                if param.get('in') == 'query':
+                    name = param.get('name')
+                    if name in kwargs:
+                        query_params[name] = kwargs.pop(name)
+            
+            # Handle request body
+            body = kwargs.pop('data', None)
+            
+            # Make the request
+            headers = kwargs.pop('headers', {})
+
+            response = await self.session.request(
+                method,
+                full_url,
+                params=query_params, 
+                json=body, 
+                headers=headers,
+                **kwargs
+            )
+
+            if 'application/json' in response.headers.get('Content-Type', ''):
+                result = response.json()
+            else:
+                result = response.text
+            
+            # Create response object similar to axios
+            return {
+                'data': result,
+                'status': response.status_code,
+                'headers': dict(response.headers),
+                'config': kwargs
+            }
+        
+        return operation_method
+    
+    async def close(self):
+        """Close the HTTP session."""
+        if self.session:
+            await self.session.aclose()
+

openapi_httpx_client-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

openapi_httpx_client-0.1.0/setup.py

@@ -0,0 +1,27 @@
+from setuptools import setup, find_packages
+
+with open("README.md", "r") as fh:
+    long_description = fh.read()
+
+setup(
+    name="openapi-httpx-client",
+    version="0.1.0",
+    author="lloydzhou",
+    author_email="lloydzhou@qq.com",
+    description="A Python client for OpenAPI specifications using httpx",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/lloydzhou/openapiclient",
+    packages=find_packages(),
+    install_requires=[
+        "httpx>=0.23.0",
+        "pyyaml>=6.0",
+    ],
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    python_requires=">=3.7",
+)
+