fastapi2postman 0.1.2__tar.gz → 0.2.0__tar.gz

{fastapi2postman-0.1.2 → fastapi2postman-0.2.0}/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2023 ashhadahsan
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+MIT License
+
+Copyright (c) 2023 ashhadahsan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.

fastapi2postman-0.2.0/PKG-INFO

@@ -0,0 +1,135 @@
+Metadata-Version: 2.4
+Name: fastapi2postman
+Version: 0.2.0
+Summary: Turn a FastAPI app into a Postman collection you can run straight away.
+Keywords: fastapi,postman,newman,openapi,api,cli
+Author: Ashhad Ahsan Rehman
+Author-email: Ashhad Ahsan Rehman <ashhadahsan@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Framework :: FastAPI
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Topic :: Software Development :: Testing
+Classifier: Typing :: Typed
+Requires-Dist: fastapi>=0.105
+Requires-Python: >=3.11
+Project-URL: Source, https://github.com/ashhadahsan/fastapi2postman
+Project-URL: Changelog, https://github.com/ashhadahsan/fastapi2postman/blob/main/CHANGELOG.md
+Description-Content-Type: text/markdown
+
+# fastapi2postman
+
+[![PyPI](https://img.shields.io/pypi/v/fastapi2postman?cacheSeconds=3600)](https://pypi.org/project/fastapi2postman/)
+[![Python](https://img.shields.io/pypi/pyversions/fastapi2postman?cacheSeconds=3600)](https://pypi.org/project/fastapi2postman/)
+[![CI](https://github.com/ashhadahsan/fastapi2postman/actions/workflows/ci.yml/badge.svg)](https://github.com/ashhadahsan/fastapi2postman/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/ashhadahsan/fastapi2postman/blob/main/LICENSE)
+
+**Turn a FastAPI app into a Postman collection you can run straight away.**
+
+```console
+$ pip install fastapi2postman
+$ fastapi2postman --app main.py
+output.json: 25 requests
+```
+
+Import `output.json` into Postman, fill in the collection's variables, and send the login request. The token is saved for every other request.
+
+Install it in the same environment as your app, because it imports the app to read its schema. Everything comes from `app.openapi()`, so what shows in your `/docs` shows in the collection.
+
+## What's in the collection
+
+| In your app | In Postman |
+| --- | --- |
+| `include_router()` and mounted FastAPI apps | Every route with its full path. Routes with `include_in_schema=False` and mounted apps with `openapi_url=None` stay out |
+| Tags | A folder per tag |
+| A route with several methods | One request per method |
+| Path parameters | Path variables such as `:item_id` with a sample value |
+| Query and header parameters, including those inside `Depends()` | Filled in, with optional ones switched off |
+| Pydantic body models | A sample JSON body that follows your `Field` limits, enums, formats, defaults and declared examples |
+| `Form()` and `File()` | Form fields and file pickers |
+| Docstrings | Request descriptions |
+| Title, version and description | Collection info |
+| `servers`, or `--base-url` | A `{{baseUrl}}` variable |
+
+## Auth
+
+Auth is found wherever you declared it: on the route, in a nested `Depends()`, in `Security()`, or in the `dependencies=` of a route, `APIRouter`, `include_router()` or `FastAPI`.
+
+| In your app | In Postman |
+| --- | --- |
+| `HTTPBearer` and subclasses, any `OAuth2…` scheme, OpenID Connect | Bearer auth with `{{bearerToken}}` |
+| A dependency with an `authorization` header parameter | Bearer auth with `{{bearerToken}}` |
+| `HTTPBasic` | Basic auth with `{{username}}` and `{{password}}` |
+| `APIKeyHeader`, `APIKeyQuery` | The header or query parameter, set to a variable with the same name |
+| A query parameter, header or form field whose name contains `token`, `api_key`, `secret` or `password` | The same, so `x_token` is sent as `{{x-token}}` |
+
+Secret variables start blank, so the file holds no credentials. You fill them in inside Postman.
+
+**The token saves itself.** A `POST` route that is your `tokenUrl`, or that returns `access_token` or `accessToken`, gets a script that stores the token in `{{bearerToken}}`. Those requests come first in the collection, so running the whole collection works.
+
+**Auth the schema can't show.** Middleware, or a dependency that reads `request.headers`, doesn't appear in OpenAPI. Use `--bearer` to send `{{bearerToken}}` on every request that has no auth of its own.
+
+## Pointing it at your app
+
+Run it from your project root.
+
+| `--app` | Loads |
+| --- | --- |
+| `main.py` | `app` from that file |
+| `main.py:api` | `api` from that file |
+| `src/shop/main.py` | `app` from that file. Relative imports work if the folder has an `__init__.py` |
+| `shop.main` | `app` from that module |
+| `shop.main:api` | `api` from that module |
+| `shop.main:create_app` | The app that this factory function returns |
+
+## Options
+
+```text
+--app APP            the app: main.py, main.py:api or package.main:api. The
+                     name defaults to app, and may be a factory
+--output OUTPUT      output file (default: output.json)
+--name NAME          collection name (default: the app's title)
+--base-url BASE_URL  where the requests go (default: the app's first server,
+                     else http://localhost:8000)
+--host HOST          shorthand for --base-url http://HOST:PORT
+--port PORT          shorthand for --base-url http://HOST:PORT
+--bearer             send {{bearerToken}} on every request without auth of
+                     its own: for auth in middleware, or in a dependency
+                     reading request.headers, which the app's schema can't
+                     show
+--version            show program's version number and exit
+```
+
+## From Python
+
+```python
+from fastapi2postman import to_postman
+
+collection = to_postman(app, name="Shop", base_url="https://api.example.com")
+```
+
+`to_postman` returns the collection as a dict.
+
+## Limits
+
+- **Samples are placeholders.** Any `pattern`, and validators that compare fields, can't be read from the schema. Declare `examples=` on the field where a sample gets rejected.
+- **A request holds one auth.** If a route declares several, the first one Postman supports is used. API keys don't count, because they're sent as plain headers or query parameters.
+- **Cookies are left to Postman's cookie jar**, which fills up when you log in. That covers `Cookie()` parameters and `APIKeyCookie`.
+- **The token script reads the top level of a JSON response.** A login returning a bare `token` field or a nested token isn't detected, because a bare `token` could just as well be a reset or invite token.
+- **Only FastAPI apps are followed into mounts.** Other mounted apps have no schema to read.
+
+## Contributing
+
+See [CONTRIBUTING.md](https://github.com/ashhadahsan/fastapi2postman/blob/main/CONTRIBUTING.md). Each change is checked by running a generated collection in Newman, Postman's command-line runner, against a live app.
+
+## License
+
+MIT. Inspired by [flask2postman](https://github.com/numberly/flask2postman).

fastapi2postman-0.2.0/README.md

@@ -0,0 +1,108 @@
+# fastapi2postman
+
+[![PyPI](https://img.shields.io/pypi/v/fastapi2postman?cacheSeconds=3600)](https://pypi.org/project/fastapi2postman/)
+[![Python](https://img.shields.io/pypi/pyversions/fastapi2postman?cacheSeconds=3600)](https://pypi.org/project/fastapi2postman/)
+[![CI](https://github.com/ashhadahsan/fastapi2postman/actions/workflows/ci.yml/badge.svg)](https://github.com/ashhadahsan/fastapi2postman/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/ashhadahsan/fastapi2postman/blob/main/LICENSE)
+
+**Turn a FastAPI app into a Postman collection you can run straight away.**
+
+```console
+$ pip install fastapi2postman
+$ fastapi2postman --app main.py
+output.json: 25 requests
+```
+
+Import `output.json` into Postman, fill in the collection's variables, and send the login request. The token is saved for every other request.
+
+Install it in the same environment as your app, because it imports the app to read its schema. Everything comes from `app.openapi()`, so what shows in your `/docs` shows in the collection.
+
+## What's in the collection
+
+| In your app | In Postman |
+| --- | --- |
+| `include_router()` and mounted FastAPI apps | Every route with its full path. Routes with `include_in_schema=False` and mounted apps with `openapi_url=None` stay out |
+| Tags | A folder per tag |
+| A route with several methods | One request per method |
+| Path parameters | Path variables such as `:item_id` with a sample value |
+| Query and header parameters, including those inside `Depends()` | Filled in, with optional ones switched off |
+| Pydantic body models | A sample JSON body that follows your `Field` limits, enums, formats, defaults and declared examples |
+| `Form()` and `File()` | Form fields and file pickers |
+| Docstrings | Request descriptions |
+| Title, version and description | Collection info |
+| `servers`, or `--base-url` | A `{{baseUrl}}` variable |
+
+## Auth
+
+Auth is found wherever you declared it: on the route, in a nested `Depends()`, in `Security()`, or in the `dependencies=` of a route, `APIRouter`, `include_router()` or `FastAPI`.
+
+| In your app | In Postman |
+| --- | --- |
+| `HTTPBearer` and subclasses, any `OAuth2…` scheme, OpenID Connect | Bearer auth with `{{bearerToken}}` |
+| A dependency with an `authorization` header parameter | Bearer auth with `{{bearerToken}}` |
+| `HTTPBasic` | Basic auth with `{{username}}` and `{{password}}` |
+| `APIKeyHeader`, `APIKeyQuery` | The header or query parameter, set to a variable with the same name |
+| A query parameter, header or form field whose name contains `token`, `api_key`, `secret` or `password` | The same, so `x_token` is sent as `{{x-token}}` |
+
+Secret variables start blank, so the file holds no credentials. You fill them in inside Postman.
+
+**The token saves itself.** A `POST` route that is your `tokenUrl`, or that returns `access_token` or `accessToken`, gets a script that stores the token in `{{bearerToken}}`. Those requests come first in the collection, so running the whole collection works.
+
+**Auth the schema can't show.** Middleware, or a dependency that reads `request.headers`, doesn't appear in OpenAPI. Use `--bearer` to send `{{bearerToken}}` on every request that has no auth of its own.
+
+## Pointing it at your app
+
+Run it from your project root.
+
+| `--app` | Loads |
+| --- | --- |
+| `main.py` | `app` from that file |
+| `main.py:api` | `api` from that file |
+| `src/shop/main.py` | `app` from that file. Relative imports work if the folder has an `__init__.py` |
+| `shop.main` | `app` from that module |
+| `shop.main:api` | `api` from that module |
+| `shop.main:create_app` | The app that this factory function returns |
+
+## Options
+
+```text
+--app APP            the app: main.py, main.py:api or package.main:api. The
+                     name defaults to app, and may be a factory
+--output OUTPUT      output file (default: output.json)
+--name NAME          collection name (default: the app's title)
+--base-url BASE_URL  where the requests go (default: the app's first server,
+                     else http://localhost:8000)
+--host HOST          shorthand for --base-url http://HOST:PORT
+--port PORT          shorthand for --base-url http://HOST:PORT
+--bearer             send {{bearerToken}} on every request without auth of
+                     its own: for auth in middleware, or in a dependency
+                     reading request.headers, which the app's schema can't
+                     show
+--version            show program's version number and exit
+```
+
+## From Python
+
+```python
+from fastapi2postman import to_postman
+
+collection = to_postman(app, name="Shop", base_url="https://api.example.com")
+```
+
+`to_postman` returns the collection as a dict.
+
+## Limits
+
+- **Samples are placeholders.** Any `pattern`, and validators that compare fields, can't be read from the schema. Declare `examples=` on the field where a sample gets rejected.
+- **A request holds one auth.** If a route declares several, the first one Postman supports is used. API keys don't count, because they're sent as plain headers or query parameters.
+- **Cookies are left to Postman's cookie jar**, which fills up when you log in. That covers `Cookie()` parameters and `APIKeyCookie`.
+- **The token script reads the top level of a JSON response.** A login returning a bare `token` field or a nested token isn't detected, because a bare `token` could just as well be a reset or invite token.
+- **Only FastAPI apps are followed into mounts.** Other mounted apps have no schema to read.
+
+## Contributing
+
+See [CONTRIBUTING.md](https://github.com/ashhadahsan/fastapi2postman/blob/main/CONTRIBUTING.md). Each change is checked by running a generated collection in Newman, Postman's command-line runner, against a live app.
+
+## License
+
+MIT. Inspired by [flask2postman](https://github.com/numberly/flask2postman).

fastapi2postman-0.2.0/pyproject.toml

@@ -0,0 +1,80 @@
+[project]
+name = "fastapi2postman"
+version = "0.2.0"
+description = "Turn a FastAPI app into a Postman collection you can run straight away."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.11"
+dependencies = ["fastapi>=0.105"]
+keywords = [
+    "fastapi",
+    "postman",
+    "newman",
+    "openapi",
+    "api",
+    "cli",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Framework :: FastAPI",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: 3.15",
+    "Topic :: Software Development :: Testing",
+    "Typing :: Typed",
+]
+
+[[project.authors]]
+name = "Ashhad Ahsan Rehman"
+email = "ashhadahsan@gmail.com"
+
+[project.urls]
+Source = "https://github.com/ashhadahsan/fastapi2postman"
+Changelog = "https://github.com/ashhadahsan/fastapi2postman/blob/main/CHANGELOG.md"
+
+[project.scripts]
+fastapi2postman = "fastapi2postman.cli:main"
+
+[build-system]
+requires = ["uv_build>=0.13.6,<0.14"]
+build-backend = "uv_build"
+
+[tool.ruff]
+line-length = 120
+
+[tool.ruff.lint]
+select = [
+    "E",
+    "F",
+    "I",
+    "UP",
+    "B",
+]
+
+[tool.mypy]
+strict = true
+files = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+filterwarnings = ["ignore:Duplicate Operation ID:UserWarning"]
+
+[tool.coverage.run]
+source = ["fastapi2postman"]
+
+[dependency-groups]
+dev = [
+    "coverage>=7.17.2",
+    "jsonschema>=4.26.0",
+    "mypy>=2.4.1",
+    "pytest>=9.2.0",
+    "python-multipart>=0.0.33",
+    "ruff>=0.17.3",
+    "uvicorn>=0.54.0",
+]

fastapi2postman-0.2.0/pyproject.toml.orig

@@ -0,0 +1,65 @@
+[project]
+name = "fastapi2postman"
+version = "0.2.0"
+description = "Turn a FastAPI app into a Postman collection you can run straight away."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Ashhad Ahsan Rehman", email = "ashhadahsan@gmail.com" }]
+requires-python = ">=3.11"
+dependencies = ["fastapi>=0.105"]
+keywords = ["fastapi", "postman", "newman", "openapi", "api", "cli"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Environment :: Console",
+  "Framework :: FastAPI",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+  "Programming Language :: Python :: 3.15",
+  "Topic :: Software Development :: Testing",
+  "Typing :: Typed",
+]
+
+[project.urls]
+Source = "https://github.com/ashhadahsan/fastapi2postman"
+Changelog = "https://github.com/ashhadahsan/fastapi2postman/blob/main/CHANGELOG.md"
+
+[project.scripts]
+fastapi2postman = "fastapi2postman.cli:main"
+
+[build-system]
+requires = ["uv_build>=0.13.6,<0.14"]
+build-backend = "uv_build"
+
+[tool.ruff]
+line-length = 120
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B"]
+
+[tool.mypy]
+strict = true
+files = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+# FastAPI warns about every route with several methods; the collection doesn't use operation ids.
+filterwarnings = ["ignore:Duplicate Operation ID:UserWarning"]
+
+[tool.coverage.run]
+source = ["fastapi2postman"]
+
+[dependency-groups]
+dev = [
+    "coverage>=7.17.2",
+    "jsonschema>=4.26.0",
+    "mypy>=2.4.1",
+    "pytest>=9.2.0",
+    "python-multipart>=0.0.33",
+    "ruff>=0.17.3",
+    "uvicorn>=0.54.0",
+]

fastapi2postman-0.2.0/src/fastapi2postman/__init__.py

@@ -0,0 +1,327 @@
+"""Turn a FastAPI app into a Postman collection you can run straight away."""
+
+import json
+import re
+from collections.abc import Iterator
+from typing import Any
+from urllib.parse import urljoin, urlsplit
+
+from fastapi import FastAPI
+from starlette.routing import Mount
+
+__all__ = ["to_postman"]
+
+Json = dict[str, Any]
+
+_METHODS = {"get", "put", "post", "delete", "options", "head", "patch", "trace"}
+_FORM_MODES = {"application/x-www-form-urlencoded": "urlencoded", "multipart/form-data": "formdata"}
+# Parameters with these names hold a blank variable: the real value must never end up in a collection people share.
+_SECRET = re.compile(r"token|api[-_]?key|secret|password", re.IGNORECASE)
+_BEARER = {"type": "bearer", "bearer": [{"key": "token", "value": "{{bearerToken}}", "type": "string"}]}
+_BASIC = {
+    "type": "basic",
+    "basic": [
+        {"key": "username", "value": "{{username}}", "type": "string"},
+        {"key": "password", "value": "{{password}}", "type": "string"},
+    ],
+}
+_FORMATS = {
+    "date": "2026-01-01",
+    "date-time": "2026-01-01T00:00:00Z",
+    "duration": "P1D",
+    "email": "user@example.com",
+    "ipv4": "127.0.0.1",
+    "ipv6": "::1",
+    "time": "00:00:00",
+    "uri": "https://example.com/",
+    "uuid": "00000000-0000-4000-8000-000000000000",
+    "uuid4": "00000000-0000-4000-8000-000000000000",
+}
+
+
+def _compact(values: Json) -> Json:
+    return {key: value for key, value in values.items() if value}
+
+
+def _resolve(schema: Json, spec: Json) -> Json:
+    if "$ref" not in schema:
+        return schema
+    target = spec
+    for part in schema["$ref"].removeprefix("#/").split("/"):
+        target = target[part]
+    return target
+
+
+def _sample(schema: Json, spec: Json, seen: tuple[str, ...] = ()) -> Any:
+    """A value for this schema: what it declares, else a placeholder built from its type and limits."""
+    ref = schema.get("$ref")
+    if ref:
+        return None if ref in seen else _sample(_resolve(schema, spec), spec, (*seen, ref))  # a recursive model stops
+    if "example" in schema:
+        return schema["example"]
+    if schema.get("examples"):
+        return schema["examples"][0]
+    if schema.get("default") is not None:
+        return schema["default"]
+    if "const" in schema:
+        return schema["const"]
+    if schema.get("enum"):
+        return schema["enum"][0]
+    for key in ("anyOf", "oneOf"):
+        if key in schema:
+            options = [option for option in schema[key] if option.get("type") != "null"]
+            return _sample(options[0], spec, seen) if options else None
+    if "allOf" in schema:
+        parts = [_sample(part, spec, seen) for part in schema["allOf"]]
+        if all(isinstance(part, dict) for part in parts):
+            return {key: value for part in parts for key, value in part.items()}
+        return parts[0]
+    if "properties" in schema:
+        return {name: _sample(prop, spec, seen) for name, prop in schema["properties"].items()}
+    kind = schema.get("type")
+    if kind == "object":
+        extra = schema.get("additionalProperties")
+        return {"key": _sample(extra, spec, seen)} if isinstance(extra, dict) else {}
+    if kind == "array":
+        item = _sample(schema.get("items", {}), spec, seen)
+        return [] if item is None else [item] * schema.get("minItems", 1)
+    if kind == "string":
+        placeholder = "string".ljust(schema.get("minLength", 0), "x")[: schema.get("maxLength")]
+        return _FORMATS.get(schema.get("format", ""), placeholder)
+    if kind in ("integer", "number"):
+        for limit, step in (("minimum", 0), ("exclusiveMinimum", 1), ("maximum", 0), ("exclusiveMaximum", -1)):
+            if limit in schema:
+                return schema[limit] + step
+        return 1
+    return True if kind == "boolean" else None
+
+
+def _example(holder: Json, spec: Json) -> Any:
+    """The example a parameter or media type declares, else a sample of its schema."""
+    if "example" in holder:
+        return holder["example"]
+    for example in holder.get("examples", {}).values():
+        if "value" in example:
+            return example["value"]
+    return _sample(holder.get("schema", {}), spec)
+
+
+def _text(value: Any) -> str:
+    """How a sample looks in a URL, a header or a form."""
+    if isinstance(value, list):
+        value = value[0] if value else ""
+    if value is None:
+        return ""
+    return value if isinstance(value, str) else json.dumps(value)
+
+
+def _variable(name: str) -> str:
+    return "{{" + name + "}}"
+
+
+def _field(name: str, value: Any, description: str | None = None, required: bool = True) -> Json:
+    """A query parameter, header, path variable or form field. Optional ones start switched off."""
+    field: Json = {"key": name, "value": _text(value)}
+    if description:
+        field["description"] = description
+    if not required:
+        field["disabled"] = True
+    return field
+
+
+def _is_upload(schema: Json) -> bool:
+    if schema.get("format") == "binary" or schema.get("contentMediaType") == "application/octet-stream":
+        return True
+    return any(_is_upload(option) for option in (*schema.get("anyOf", ()), schema.get("items")) if option)
+
+
+def _form_fields(holder: Json, spec: Json, multipart: bool) -> list[Json]:
+    schema = _resolve(holder.get("schema", {}), spec)
+    fields = []
+    for name, prop in schema.get("properties", {}).items():
+        value = _variable(name) if _SECRET.search(name) else _sample(prop, spec)
+        field = _field(name, value, prop.get("description"), name in schema.get("required", []))
+        if multipart and _is_upload(prop):
+            del field["value"]
+            field.update(type="file", src=[])
+        elif multipart:
+            field["type"] = "text"
+        fields.append(field)
+    return fields
+
+
+def _body(media: str, holder: Json, spec: Json) -> Json:
+    mode = _FORM_MODES.get(media)
+    if mode:
+        return {"mode": mode, mode: _form_fields(holder, spec, multipart=mode == "formdata")}
+    sample = _example(holder, spec)
+    if media.endswith("json"):
+        raw, language = json.dumps(sample, indent=2, ensure_ascii=False), "json"
+    else:
+        raw, language = _text(sample), "text"
+    return {"mode": "raw", "raw": raw, "options": {"raw": {"language": language}}}
+
+
+def _auth_for(scheme: Json) -> Json | None:
+    http = scheme.get("scheme", "").lower()
+    # OAuth2 and OpenID Connect end in a bearer token too, and logging in fills it (see _token_field).
+    if scheme.get("type") in ("oauth2", "openIdConnect") or http == "bearer":
+        return _BEARER
+    return _BASIC if http == "basic" else None
+
+
+def _request(path: str, method: str, operation: Json, spec: Json) -> Json:
+    fields: dict[str, list[Json]] = {"path": [], "query": [], "header": []}
+    auth = None
+    for param in operation.get("parameters", []):
+        where, name = param["in"], param["name"]
+        if where == "header" and name.lower() == "authorization":
+            auth = _BEARER  # a dependency reading the header itself
+        elif where in fields:  # cookies are left to Postman's cookie jar, which logging in fills
+            secret = where != "path" and _SECRET.search(name)
+            value = _variable(name) if secret else _example(param, spec)
+            fields[where].append(_field(name, value, param.get("description"), param.get("required", False)))
+
+    schemes = spec.get("components", {}).get("securitySchemes", {})
+    # An operation's own list wins, and an empty one means public even when the whole API declares security.
+    security = operation["security"] if "security" in operation else spec.get("security", [])
+    for requirement in security:
+        for scheme_name in requirement:
+            scheme = schemes.get(scheme_name, {})
+            if scheme.get("type") == "apiKey" and scheme["in"] in fields:
+                # A plain field, not Postman's API key auth: a request holds one auth, and a key can come with a token.
+                fields[scheme["in"]].append(_field(scheme["name"], _variable(scheme["name"])))
+            else:
+                auth = auth or _auth_for(scheme)
+
+    body = None
+    content = operation.get("requestBody", {}).get("content", {})
+    if content:
+        media, holder = next(iter(content.items()))
+        body = _body(media, holder, spec)
+        if body["mode"] == "raw":  # Postman sets the Content-Type of a form itself
+            fields["header"].insert(0, {"key": "Content-Type", "value": media})
+
+    route = path.replace("{", ":").replace("}", "")
+    enabled = [f"{field['key']}={field['value']}" for field in fields["query"] if "disabled" not in field]
+    url = {
+        "raw": _variable("baseUrl") + route + ("?" + "&".join(enabled) if enabled else ""),
+        "host": [_variable("baseUrl")],
+        "path": route.split("/")[1:],
+        "query": fields["query"],
+        "variable": fields["path"],
+    }
+    return _compact(
+        {
+            "method": method.upper(),
+            "header": fields["header"],
+            "url": _compact(url),
+            "description": operation.get("description"),
+            "auth": auth,
+            "body": body,
+        }
+    )
+
+
+def _token_field(path: str, method: str, operation: Json, spec: Json) -> str | None:
+    """The response field holding a bearer token, when this route is the one that logs you in."""
+    if method != "post":
+        return None  # a GET reads a token, it doesn't start a session
+    for status, response in operation.get("responses", {}).items():
+        schema = response.get("content", {}).get("application/json", {}).get("schema", {})
+        properties = _resolve(schema, spec).get("properties", {})
+        # ponytail: OAuth2's own field names only. A bare `token` could be a reset or invite token; add it if asked.
+        for field in ("access_token", "accessToken"):
+            if status.startswith("2") and field in properties:
+                return field
+    route = "/" + path.strip("/")
+    for scheme in spec.get("components", {}).get("securitySchemes", {}).values():
+        for flow in scheme.get("flows", {}).values():
+            token_path = urlsplit(flow.get("tokenUrl", "")).path.strip("/")
+            if token_path and route.endswith("/" + token_path):
+                return "access_token"
+    return None
+
+
+def _item(path: str, method: str, operation: Json, spec: Json) -> Json:
+    item = {
+        "name": operation.get("summary") or f"{method.upper()} {path}",
+        "request": _request(path, method, operation, spec),
+    }
+    token_field = _token_field(path, method, operation, spec)
+    if token_field:
+        script = [
+            "// Keeps the token from this response for the requests that need one.",
+            "if (pm.response.code < 300) {",
+            f"    const token = pm.response.json().{token_field};",
+            "    if (token) pm.collectionVariables.set('bearerToken', token);",
+            "}",
+        ]
+        item["event"] = [{"listen": "test", "script": {"type": "text/javascript", "exec": script}}]
+    return item
+
+
+def _specs(app: FastAPI, prefix: str = "") -> Iterator[tuple[str, Json]]:
+    """The OpenAPI schema of the app and of each FastAPI app mounted in it, with the path each one is under."""
+    yield prefix, app.openapi()
+    for route in app.routes:
+        if isinstance(route, Mount) and isinstance(route.app, FastAPI) and route.app.openapi_url:
+            yield from _specs(route.app, prefix + route.path)
+
+
+def to_postman(app: FastAPI, *, name: str | None = None, base_url: str | None = None, bearer: bool = False) -> Json:
+    """Build a Postman collection (format v2.1) from a FastAPI app.
+
+    Args:
+        app: The app. Everything comes from `app.openapi()`, so whatever shows in its docs shows here, including
+            parameters and auth declared in `Depends()`, at any depth.
+        name: The collection name. Defaults to the app's title.
+        base_url: Where the requests go. Defaults to the app's first server, else http://localhost:8000.
+        bearer: Send `{{bearerToken}}` on every request that declares no auth of its own. For auth OpenAPI can't see:
+            middleware, or a dependency reading `request.headers`.
+    """
+    specs = list(_specs(app))
+    main_spec = specs[0][1]
+    servers = main_spec.get("servers", [])
+    server = servers[0]["url"] if servers else ""
+
+    requests = []
+    for prefix, spec in specs:
+        for path, path_item in spec.get("paths", {}).items():
+            for method, operation in path_item.items():
+                if method in _METHODS:
+                    tags = operation.get("tags") or [None]
+                    requests.append((tags[0], _item(prefix + path, method, operation, spec)))
+    requests.sort(key=lambda request: "event" not in request[1])  # logging in comes first, so a full run has the token
+
+    items: list[Json] = []
+    folders: dict[str, Json] = {}
+    for tag, item in requests:
+        if tag is None:
+            items.append(item)
+            continue
+        if tag not in folders:
+            folders[tag] = {"name": tag, "item": []}
+            items.append(folders[tag])
+        folders[tag]["item"].append(item)
+
+    info = main_spec["info"]
+    collection: Json = {
+        "info": _compact(
+            {
+                "name": name or info["title"],
+                "description": info.get("description"),
+                "version": info.get("version"),
+                "schema": "https://schema.getpostman.com/json/collection/v2.1.0/collection.json",
+            }
+        ),
+        "item": items,
+    }
+    if bearer:
+        collection["auth"] = _BEARER
+    secrets = re.findall(r"\{\{([\w-]+)\}\}", json.dumps(collection))
+    variables = {"baseUrl": (base_url or urljoin("http://localhost:8000", server)).rstrip("/")} | {
+        secret: "" for secret in secrets if secret != "baseUrl"
+    }
+    collection["variable"] = [{"key": key, "value": value} for key, value in variables.items()]
+    return collection

fastapi2postman-0.2.0/src/fastapi2postman/cli.py

@@ -0,0 +1,89 @@
+"""The fastapi2postman command."""
+
+import argparse
+import json
+import os
+import sys
+from importlib import import_module, metadata
+from pathlib import Path
+
+from fastapi import FastAPI
+
+from . import to_postman
+
+
+def _module_of(path: Path) -> tuple[str, Path]:
+    """The dotted name of a file and the folder to import it from, which is above its package if it's in one."""
+    parts = [path.stem]
+    root = path.parent
+    while (root / "__init__.py").is_file():
+        parts.insert(0, root.name)
+        root = root.parent
+    return ".".join(parts), root
+
+
+def _load_app(spec: str) -> FastAPI:
+    target, attribute = spec, "app"
+    if ":" in spec and not Path(spec).is_file():  # a colon can be part of a path: C:\project\app.py
+        target, attribute = spec.rsplit(":", 1)
+
+    name = target
+    search = [os.getcwd()]  # a console script has its own folder on sys.path, not the project's
+    if Path(target).is_file():
+        name, root = _module_of(Path(target).resolve())
+        search.insert(0, str(root))
+    sys.path[:0] = search
+
+    try:
+        module = import_module(name)
+    except ModuleNotFoundError as error:
+        if error.name != name and not name.startswith(f"{error.name}."):
+            raise  # something the app itself imports is missing, and the traceback says what
+        raise SystemExit(
+            f"fastapi2postman: cannot find {target!r}: give a .py file, or a module importable from {os.getcwd()}"
+        ) from error
+    if not hasattr(module, attribute):
+        raise SystemExit(f"fastapi2postman: {name} has no attribute {attribute!r}")
+
+    app = getattr(module, attribute)
+    if not isinstance(app, FastAPI) and callable(app):
+        app = app()  # a factory
+    if not isinstance(app, FastAPI):
+        raise SystemExit(f"fastapi2postman: {spec} gives {type(app).__name__}, not a FastAPI app")
+    return app
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        prog="fastapi2postman", description="Turn a FastAPI app into a Postman collection you can run straight away."
+    )
+    parser.add_argument(
+        "--app",
+        required=True,
+        help="the app: main.py, main.py:api or package.main:api. The name defaults to app, and may be a factory",
+    )
+    parser.add_argument("--output", default="output.json", help="output file (default: %(default)s)")
+    parser.add_argument("--name", help="collection name (default: the app's title)")
+    parser.add_argument(
+        "--base-url", help="where the requests go (default: the app's first server, else http://localhost:8000)"
+    )
+    parser.add_argument("--host", help="shorthand for --base-url http://HOST:PORT")
+    parser.add_argument("--port", type=int, help="shorthand for --base-url http://HOST:PORT")
+    parser.add_argument(
+        "--bearer",
+        action="store_true",
+        help="send {{bearerToken}} on every request without auth of its own: for auth in middleware, or in a "
+        "dependency reading request.headers, which the app's schema can't show",
+    )
+    parser.add_argument("--version", action="version", version=metadata.version("fastapi2postman"))
+    args = parser.parse_args()
+
+    base_url = args.base_url
+    if not base_url and (args.host or args.port):
+        base_url = f"http://{args.host or 'localhost'}:{args.port or 8000}"
+
+    collection = to_postman(_load_app(args.app), name=args.name, base_url=base_url, bearer=args.bearer)
+    text = json.dumps(collection, indent=2, ensure_ascii=False)
+    Path(args.output).write_text(text + "\n", encoding="utf-8")
+    count = sum(len(entry.get("item", [entry])) for entry in collection["item"])
+    print(f"{args.output}: {count} requests")

fastapi2postman-0.1.2/PKG-INFO

@@ -1,105 +0,0 @@
-Metadata-Version: 2.1
-Name: fastapi2postman
-Version: 0.1.2
-Summary: FastAPI APIs to Postman collections
-Home-page: https://github.com/ashhadahsan/fastapi2postman
-Author: Ashhad Ahsan Rehman
-Author-email: ashhadahsan@gmail.com
-License: MIT
-Platform: OS Independent
-Classifier: Development Status :: 3 - Alpha
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Environment :: Console
-Classifier: Environment :: Web Environment
-Classifier: Framework :: FastAPI
-Classifier: Intended Audience :: Developers
-Classifier: Intended Audience :: End Users/Desktop
-Classifier: Intended Audience :: System Administrators
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
-Classifier: Topic :: Internet :: WWW/HTTP :: Site Management
-Classifier: Topic :: Software Development :: Testing
-Classifier: Topic :: Utilities
-License-File: LICENSE
-
-.. _Postman: https://www.postman.com/
-.. _FastAPI: https://fastapi.tiangolo.com/
-.. _flask2postman: https://github.com/numberly/flask2postman/
-
-================
-fastapi2postman
-================
-
-.. image:: https://img.shields.io/pypi/v/flask2postman.svg
-   :target: https://pypi.org/project/fastapi2postman
-.. image:: https://img.shields.io/github/license/numberly/flask2postman.svg
-   :target: https://github.com/ashhadahsan/fastapi2postman/blob/main/LICENSE
-
-|
-
-A tool that creates a Postman_ collection from a FastAPI_ application.
-
-Inspired from flask2postman_
-
-
-Install
-=======
-
-.. code-block:: sh
-
-    $ pip install fastapi2postman
-
-
-Example
-=======
-
-Let's say that you have a FastAPI project called "app.py"  and you want to generate a Postman collection out of it.
-
-You just need to tell :code:`fastapi2postman` 
-
-.. code-block:: sh
-
-    $ fastapi2postman --app app.py 
-
-If you want to change the name of the output file use --output flag, the default name is ofcousre output.json
-
-.. code-block:: sh
-
-    $ fastapi2postman --app app.py --output output.json
-
-This will generate the JSON configuration, and write it into the
-:code:`output.json` file. You can then import this file into Postman ("Import
-Collection" button), and profit:
-
-On a side note, you can see that endpoint's docstrings are automatically
-imported as descriptions.
-
-
-Usage
-=====
-
-.. code-block:: sh
-
-    usage: fastapi2postman [-h] [--output OUTPUT] [--name NAME] [--host HOST]
-                       [--port PORT] --app APP
-
-optional arguments:
-  -h, --help       show this help message and exit
-  --output OUTPUT  Output file
-  --name NAME      Collection name
-  --host HOST      API host
-  --port PORT      API port
-  --app APP        Path to FastAPI application instance
-
-
-License
-=======
-
-MIT
-

fastapi2postman-0.1.2/README.rst

@@ -1,74 +0,0 @@
-.. _Postman: https://www.postman.com/
-.. _FastAPI: https://fastapi.tiangolo.com/
-.. _flask2postman: https://github.com/numberly/flask2postman/
-
-================
-fastapi2postman
-================
-
-.. image:: https://img.shields.io/pypi/v/flask2postman.svg
-   :target: https://pypi.org/project/fastapi2postman
-.. image:: https://img.shields.io/github/license/numberly/flask2postman.svg
-   :target: https://github.com/ashhadahsan/fastapi2postman/blob/main/LICENSE
-
-|
-
-A tool that creates a Postman_ collection from a FastAPI_ application.
-
-Inspired from flask2postman_
-
-
-Install
-=======
-
-.. code-block:: sh
-
-    $ pip install fastapi2postman
-
-
-Example
-=======
-
-Let's say that you have a FastAPI project called "app.py"  and you want to generate a Postman collection out of it.
-
-You just need to tell :code:`fastapi2postman` 
-
-.. code-block:: sh
-
-    $ fastapi2postman --app app.py 
-
-If you want to change the name of the output file use --output flag, the default name is ofcousre output.json
-
-.. code-block:: sh
-
-    $ fastapi2postman --app app.py --output output.json
-
-This will generate the JSON configuration, and write it into the
-:code:`output.json` file. You can then import this file into Postman ("Import
-Collection" button), and profit:
-
-On a side note, you can see that endpoint's docstrings are automatically
-imported as descriptions.
-
-
-Usage
-=====
-
-.. code-block:: sh
-
-    usage: fastapi2postman [-h] [--output OUTPUT] [--name NAME] [--host HOST]
-                       [--port PORT] --app APP
-
-optional arguments:
-  -h, --help       show this help message and exit
-  --output OUTPUT  Output file
-  --name NAME      Collection name
-  --host HOST      API host
-  --port PORT      API port
-  --app APP        Path to FastAPI application instance
-
-
-License
-=======
-
-MIT

fastapi2postman-0.1.2/fastapi2postman.egg-info/PKG-INFO

@@ -1,105 +0,0 @@
-Metadata-Version: 2.1
-Name: fastapi2postman
-Version: 0.1.2
-Summary: FastAPI APIs to Postman collections
-Home-page: https://github.com/ashhadahsan/fastapi2postman
-Author: Ashhad Ahsan Rehman
-Author-email: ashhadahsan@gmail.com
-License: MIT
-Platform: OS Independent
-Classifier: Development Status :: 3 - Alpha
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Environment :: Console
-Classifier: Environment :: Web Environment
-Classifier: Framework :: FastAPI
-Classifier: Intended Audience :: Developers
-Classifier: Intended Audience :: End Users/Desktop
-Classifier: Intended Audience :: System Administrators
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
-Classifier: Topic :: Internet :: WWW/HTTP :: Site Management
-Classifier: Topic :: Software Development :: Testing
-Classifier: Topic :: Utilities
-License-File: LICENSE
-
-.. _Postman: https://www.postman.com/
-.. _FastAPI: https://fastapi.tiangolo.com/
-.. _flask2postman: https://github.com/numberly/flask2postman/
-
-================
-fastapi2postman
-================
-
-.. image:: https://img.shields.io/pypi/v/flask2postman.svg
-   :target: https://pypi.org/project/fastapi2postman
-.. image:: https://img.shields.io/github/license/numberly/flask2postman.svg
-   :target: https://github.com/ashhadahsan/fastapi2postman/blob/main/LICENSE
-
-|
-
-A tool that creates a Postman_ collection from a FastAPI_ application.
-
-Inspired from flask2postman_
-
-
-Install
-=======
-
-.. code-block:: sh
-
-    $ pip install fastapi2postman
-
-
-Example
-=======
-
-Let's say that you have a FastAPI project called "app.py"  and you want to generate a Postman collection out of it.
-
-You just need to tell :code:`fastapi2postman` 
-
-.. code-block:: sh
-
-    $ fastapi2postman --app app.py 
-
-If you want to change the name of the output file use --output flag, the default name is ofcousre output.json
-
-.. code-block:: sh
-
-    $ fastapi2postman --app app.py --output output.json
-
-This will generate the JSON configuration, and write it into the
-:code:`output.json` file. You can then import this file into Postman ("Import
-Collection" button), and profit:
-
-On a side note, you can see that endpoint's docstrings are automatically
-imported as descriptions.
-
-
-Usage
-=====
-
-.. code-block:: sh
-
-    usage: fastapi2postman [-h] [--output OUTPUT] [--name NAME] [--host HOST]
-                       [--port PORT] --app APP
-
-optional arguments:
-  -h, --help       show this help message and exit
-  --output OUTPUT  Output file
-  --name NAME      Collection name
-  --host HOST      API host
-  --port PORT      API port
-  --app APP        Path to FastAPI application instance
-
-
-License
-=======
-
-MIT
-

fastapi2postman-0.1.2/fastapi2postman.egg-info/SOURCES.txt

@@ -1,10 +0,0 @@
-LICENSE
-README.rst
-fastapi2postman.py
-setup.py
-fastapi2postman.egg-info/PKG-INFO
-fastapi2postman.egg-info/SOURCES.txt
-fastapi2postman.egg-info/dependency_links.txt
-fastapi2postman.egg-info/entry_points.txt
-fastapi2postman.egg-info/requires.txt
-fastapi2postman.egg-info/top_level.txt

fastapi2postman-0.1.2/fastapi2postman.egg-info/dependency_links.txt

@@ -1 +0,0 @@
-

fastapi2postman-0.1.2/fastapi2postman.egg-info/entry_points.txt

@@ -1,3 +0,0 @@
-[console_scripts]
-fastapi2postman = fastapi2postman:main
-

fastapi2postman-0.1.2/fastapi2postman.egg-info/requires.txt

@@ -1,4 +0,0 @@
-click>=8.0.0
-requests>=2.26.0
-fastapi>=0.68.1
-uvicorn>=0.15.0

fastapi2postman-0.1.2/fastapi2postman.egg-info/top_level.txt

@@ -1 +0,0 @@
-fastapi2postman

fastapi2postman-0.1.2/fastapi2postman.py

@@ -1,72 +0,0 @@
-import argparse
-import json
-import os
-import sys
-from fastapi.routing import APIRoute
-
-
-def register_routes(app):
-    routes = []
-    for route in app.routes:
-        if isinstance(route, APIRoute):
-            routes.append(
-                {
-                    "name": route.name,
-                    "method": ",".join(route.methods),
-                    "url": str(route.path),
-                    "path": str(route.path).replace("{", ":").replace("}", ""),
-                }
-            )
-    return routes
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--output", type=str, help="Output file", default="output.json")
-    parser.add_argument(
-        "--name", type=str, help="Collection name", default="FastAPI API"
-    )
-    parser.add_argument("--host", type=str, help="API host", default="localhost")
-    parser.add_argument("--port", type=int, help="API port", default=8000)
-    parser.add_argument(
-        "--app",
-        type=str,
-        help="Path to FastAPI application instance",
-        default="app.py",
-        required=True,
-    )
-    args = parser.parse_args()
-
-    app_path = args.app
-    app_dir, app_file = os.path.split(app_path)
-    sys.path.append(app_dir)
-    app_name, _ = os.path.splitext(app_file)
-    app_module = __import__(app_name)
-    app = getattr(app_module, "app")
-
-    routes = register_routes(app)
-
-    collection = {
-        "info": {
-            "name": args.name,
-            "schema": "https://schema.getpostman.com/json/collection/v2.1.0/collection.json",
-        },
-        "item": [],
-    }
-
-    for route in routes:
-        item = {
-            "name": route["name"],
-            "request": {
-                "url": f'http://{args.host}:{args.port}{route["url"]}',
-                "method": route["method"],
-            },
-        }
-        collection["item"].append(item)
-
-    with open(args.output, "w") as f:
-        json.dump(collection, f, indent=4)
-
-
-if __name__ == "__main__":
-    main()

fastapi2postman-0.1.2/setup.cfg

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

fastapi2postman-0.1.2/setup.py

@@ -1,45 +0,0 @@
-from setuptools import setup, find_packages
-
-with open("README.rst") as file:
-    long_description = file.read()
-setup(
-    name="fastapi2postman",
-    version="0.1.2",
-    description="FastAPI APIs to Postman collections",
-    long_description=long_description,
-    author="Ashhad Ahsan Rehman",
-    license="MIT",
-    author_email="ashhadahsan@gmail.com",
-    url="https://github.com/ashhadahsan/fastapi2postman",
-    packages=find_packages(),
-    platforms=["OS Independent"],
-    install_requires=[
-        "click>=8.0.0",
-        "requests>=2.26.0",
-        "fastapi>=0.68.1",
-        "uvicorn>=0.15.0",
-    ],
-    classifiers=[
-        "Development Status :: 3 - Alpha",
-        "License :: OSI Approved :: MIT License",
-        "Development Status :: 5 - Production/Stable",
-        "Environment :: Console",
-        "Environment :: Web Environment",
-        "Framework :: FastAPI",
-        "Intended Audience :: Developers",
-        "Intended Audience :: End Users/Desktop",
-        "Intended Audience :: System Administrators",
-        "Operating System :: OS Independent",
-        "Programming Language :: Python :: 3",
-        "Programming Language :: Python :: 3.6",
-        "Programming Language :: Python :: 3.7",
-        "Programming Language :: Python :: 3.8",
-        "Programming Language :: Python :: 3.9",
-        "Topic :: Internet :: WWW/HTTP :: Dynamic Content",
-        "Topic :: Internet :: WWW/HTTP :: Site Management",
-        "Topic :: Software Development :: Testing",
-        "Topic :: Utilities",
-    ],
-    py_modules=["fastapi2postman"],
-    entry_points={"console_scripts": ["fastapi2postman = fastapi2postman:main"]},
-)