http2py should be able to make a python binder for any valid OpenAPI spec

[thorwhalen]

http2py should be able to make a python binder for any valid OpenAPI spec.

There are OpenAPI-supported tools to do this out there, but I've heard from some colleague(s) that it creates a hard-to-use python object. If so, I still think it may be worth using it. [Addendum: I checked and indeed, it generates code for a whole package. Nice, but different than what we're going for in http2py (no code generation there)]

Q: How do we gauge (conditional pros/cons?) whether we'd rather an http2py-made python binder, or a swagger-generated package, or a pypi published package that uses the same web-service under the hood?

References

Here is a list of python integration tools.

Here is the only OpenAPI specs search engine I found.
In it you can find several tools that "render/use" the specs in some way. One I'd like to mention is the GUI tool. You give it the url of the specs and it makes this kind of playgrounds. See, notably, how they allow you to chain operations into pipelines.

openapi-python-generator

SDK Generation from an OpenAPI Specification File

OpenAPI with Python — a state of the art and our latest contribution

[thorwhalen]

TW:

ChatGPT:

To generate a Python client library for an OpenAPI specification, you can use the openapi-python-client library. This library generates a Python client library based on the API definition in an OpenAPI specification file.

Here are the steps to generate a Python client library from an OpenAPI specification using openapi-python-client:

Install the openapi-python-client library:

pip install openapi-python-client

Create a Python script that generates the client library:

from openapi_python_client import generate

generate(
    url='https://example.com/openapi.yaml',
    project_name='example_api_client',
    package_name='example_api_client'
)

In this script, we use the generate function from the openapi_python_client library to generate the Python client library. The url argument is the URL or local path to the OpenAPI specification file. The project_name argument is the name of the Python package to create, and the package_name argument is the name of the top-level module in the package.

Run the Python script to generate the client library:

python generate_client.py

This will generate a Python client library based on the OpenAPI specification file at the given URL or local path.

Install the generated client library:

cd example_api_client
pip install .
This installs the generated client library in your Python environment.

Use the client library in your Python code:

from example_api_client import ExampleApiClient

client = ExampleApiClient()
response = client.get_some_data()
print(response)

In this example, we import the ExampleApiClient class from the generated client library, create an instance of the client, and call a method on the client to get some data. The response is then printed to the console.

I hope this helps you generate a Python client library from your OpenAPI specification. Let me know if you have any further questions or concerns.

[thorwhalen]

openai_to_funcs function wrapping openapi-python-client

I'd like to have a python function that takes an openAPI spec (and other arguments such as host, etc.) and returns an object (e.g module object or instance of some custom class) whose attributes are python functions to the different routes of the spec.

I see that openapi-python-client seems to use code generation. That's not ideal in all situations. Sometimes, I'd just like to try something out with out all the boilerplate and side effects of generating and persisting code.
So I'd like to have some control over that.
For example:
* just have some dynamic approach that does everything in RAM
* do persisted code gen, but in temp files
* do persisted code gen in locations of my choice

cursor response

This is a great and nuanced request! You want a dynamic, in-memory Python client for OpenAPI specs (with optional codegen to temp or custom locations), rather than always generating and installing a package. This is a common need for rapid prototyping, notebooks, or dynamic environments.

Approaches

1. Dynamic In-Memory Client (No Codegen)

• Parse the OpenAPI spec (YAML/JSON).
• For each route, dynamically create a Python function that makes the appropriate HTTP call (using requests or httpx).
• Bundle these functions as attributes of a module-like object (e.g., a custom class or a types.SimpleNamespace).

2. Codegen to Temp or Custom Location

• Use openapi-python-client or similar, but direct output to a temp directory or a user-specified path.
• Dynamically import the generated module.

---

1. Dynamic In-Memory Client Example

Here’s a minimal working prototype for the dynamic approach:

import requests
import types
import yaml
import json

def openapi_to_client(spec, base_url=None):
    """
    spec: dict or str (YAML/JSON string or file path)
    base_url: override the spec's server URL
    Returns: an object whose attributes are functions for each route+method
    """
    # Load the spec if needed
    if isinstance(spec, str):
        if spec.strip().startswith('{') or spec.strip().startswith('openapi:'):
            # It's a string spec
            try:
                spec = json.loads(spec)
            except Exception:
                spec = yaml.safe_load(spec)
        else:
            # It's a file path
            with open(spec) as f:
                if spec.endswith('.json'):
                    spec = json.load(f)
                else:
                    spec = yaml.safe_load(f)
    # Get base_url
    if not base_url:
        base_url = spec.get('servers', [{}])[0].get('url', 'http://localhost')
    # Create the client object
    client = types.SimpleNamespace()
    for path, methods in spec['paths'].items():
        for method, details in methods.items():
            func_name = f"{method.lower()}_{path.strip('/').replace('/', '_').replace('{','').replace('}','')}"
            def make_func(path=path, method=method):
                def f(**kwargs):
                    url = base_url + path.format(**kwargs)
                    params = {k: v for k, v in kwargs.items() if '{'+k+'}' not in path}
                    resp = requests.request(method.upper(), url, json=params)
                    resp.raise_for_status()
                    return resp.json()
                return f
            setattr(client, func_name, make_func())
    return client

# Example usage:
# client = openapi_to_client("openapi.yaml")
# result = client.get_pets()

• This is a starting point. It can be extended to handle authentication, query/path/body params, etc.
• You can wrap the result in a custom class for more features.

---

2. Codegen to Temp or Custom Location

If you want to use codegen but control the output location:

import tempfile
import subprocess
import importlib.util
import sys
import os

def generate_and_import_openapi_client(openapi_path, output_dir=None):
    if output_dir is None:
        output_dir = tempfile.mkdtemp()
    subprocess.run([
        "openapi-python-client", "generate", "--path", openapi_path, "--output", output_dir
    ], check=True)
    # Find the generated package (assume only one directory)
    for entry in os.listdir(output_dir):
        pkg_path = os.path.join(output_dir, entry)
        if os.path.isdir(pkg_path):
            sys.path.insert(0, output_dir)
            return importlib.import_module(entry)
    raise RuntimeError("No client package found in output_dir")

# Example usage:
# client_module = generate_and_import_openapi_client("openapi.yaml")

---

3. Hybrid: Dynamic by Default, Codegen as Option

You can wrap both approaches in a single function, with a flag to choose between them.

---

Summary Table

Approach	Pros	Cons	Example Use Case
Dynamic/In-Memory	No files, fast, flexible	Less type safety, less doc	Prototyping, notebooks
Codegen/Temp	Full type safety, docs	Slower, temp files, import	Testing, short scripts
Codegen/Custom	Full control, reusable	More setup, cleanup needed	Production, CI/CD

---

Would you like:

• A more robust version of the dynamic client (with query/body param handling, etc.)?
• A ready-to-use hybrid function?
• Or help integrating this into your workflow?