Fixes the following annoying warning:

"openapi_prefix" has been deprecated in favor of "root_path", which follows more closely the ASGI standard, is simpler, and more automatic. Check the docs at https://fastapi.tiangolo.com/advanced/sub-applications/

Fixes #13.

My app is behind some proxy so it's url is smth like http://abc.cd/some/path/v1_0/ to support it properly I'm adding root_path="/some/path", and in general everything is working ok as in most cases this param is just ignored, except openapidocs, where it's used to generate path to openapi.json:

http://abc.cd/some/path/v1_0/docs

    const ui = SwaggerUIBundle({
        url: '/v1_0/openapi.json',

should be:

    const ui = SwaggerUIBundle({
        url: '/some/path/v1_0/openapi.json',

Rewriting the decorator using functools.wraps() allows for tab completion and correctly reflecting of attributes and signature of wrapped function.

Closes #11.

Currently, if we are to support multiple versions of an API with many endpoints, we need to duplicate each endpoint (even if logic does not change for every endpoint) in order to be backward compatible.

An array of values could be passed to @version() to allow a single method to support multiple versions. Example:

Current:

def handle_home() -> str:
    return "You are home."

@app.get("/home")
@version(1, 0)
def home() -> str:
    return handle_home()

@app.get("/home")
@version(1, 1)
def home() -> str:
    return handle_home()

@app.get("/home")
@version(1, 2)
def home() -> str:
    return handle_home()

Suggested:

@app.get("/home")
@version([1, 0], [1, 1], [1, 2])
def home() -> str:
    return "You are home"

First of all, thank you so much for this extension, saved us a lot of additional unnecessary work!

Bug description Looks like description from tags metadata is not loaded/visible on OpenAPI docs, even if I pass it directly to VersionedFastAPI constructor. name is loaded, but description not. I haven't checked externalDocs attribute yet.

To Reproduce Here is the part of the code from my main.py:

tags_metadata = [
    {"name": "products", "description": "Operations with products and product types."},
    {"name": "cameras", "description": "Operations with cameras."}
]

app = FastAPI(title="My App")

app.include_router(product_router.router)
app.include_router(camera_router.router)

@app.get("/")
@version(1, 0)
def root():
    return {"message": "Hello World!"}

app = VersionedFastAPI(app, openapi_tags=tags_metadata)

... and in the product_router.py, I have defined:

router = APIRouter(prefix="/products", tags=["products"])

... and the same way in camera_router.py.

Expected behavior How it should look like, is described here: FastAPI-Metadata. When I turn off fastapi-versioning, everything works like expected.

Environment

• Docker version: 19.03.13
• FastAPI version: 0.62.0 (built with official FastAPI Docker image and manually updated fastapi)
• fastapi-versioning version: 0.5.0

Thanks!

• we are implementing FastAPI to replace an existing API of ours which currently sits at version 2
• we want the ability to make the default version in fastapi-versioning customisable, as opposed to always defaulting to (1, 0)
• this PR implements this!

Hi,

Thanks for this project. Shouldn't it be version_route_mapping: Dict[Tuple[int, int], List[APIRoute]] = defaultdict(list) instead of:

https://github.com/DeanWay/fastapi-versioning/blob/3db32d809caa70217700902a31eb8093d0d647cf/fastapi_versioning/versioning.py#L37

First of all thank you for your work on the module! I really like what you are doing and its working great.

Describe the bug During startup of the API a warning message is shown (likely due to a change in FastAPI): "openapi_prefix" has been deprecated in favor of "root_path", which follows more closely the ASGI standard, is simpler, and more automatic. Check the docs at https://fastapi.tiangolo.com/advanced/sub-applications-proxy/ Might be a simple change here ?

To Reproduce Minimal example:

#example.py
import uvicorn
from fastapi import Depends, FastAPI
from fastapi_versioning import version, VersionedFastAPI

app = FastAPI()

@app.get(path='/example')
@version(1, 0)
def example():
    return 'test'

app = VersionedFastAPI(app) #here the warning is shown

if __name__ == "__main__":
    uvicorn.run("example:app",host="127.0.0.1",port=8000,reload=True,debug=True)

Warning message:

Not related to the bug I was happy to find that module is even doing more than you write in the readme: If a route is only specified in version v1_0 and not overwritten by a new version it is also available in newer endpoints (e.g. v2_0). For me this seems worth mentioning in the readme 👍

Implement functools.wraps in the version decorator to avoid breaking tab completion and breaking wrapped function signature:

https://github.com/DeanWay/fastapi-versioning/blob/875863c0a312e4d30ecbb351abc3e145fa203b62/fastapi_versioning/versioning.py#L12

In cases where FastAPI routes are defined as bound methods on a Class, attribute assignment for the method requires .__func__._api_version to access the underlying function.

Is your feature request related to a problem? Please describe. In code used dunder property __api_version__ for function.

Describe the solution you'd like Just set the _api_version.

Describe alternatives you've considered This looks more pythonic, than your idea.

Are there a good number of people interested in this still? Could potentially fork this and address some of the issues here based off how many people would want that. I see it hasn't been maintained in over a year.

Describe the bug Some arguments of FastAPI() won't work

To Reproduce Use argument swagger_ui_parameters={"docExpansion": "none"} and check that it won't work in the versioning, as it won't collapse the tabs.

Expected behavior I expect all arguments of FastAPI() to work.

Additional context I already did a PR with a quick fix. PR #71

Till now some arguments of FastAPI where not working, like:

    description="Core API",
    swagger_ui_parameters={"docExpansion": "none"},

This issue is yet fixed

Describe the bug Even with docs_url set to None, the docs are still served. Per the FastAPI documentation, the app should no longer serve docs with this option set.

You can disable it by setting docs_url=None. https://fastapi.tiangolo.com/tutorial/metadata/#docs-urls

def docs_url_kwargs() -> dict:
    return  {
        "openapi_url": None,
        "docs_url": None,
        "redoc_url": None,
    }

application = FastAPI(
    title='Example FastApi',
    description='Nice',
    **docs_url_kwargs(),
)
application = VersionedFastAPI(
    application,
    version_format="{major}",
    prefix_format="/v{major}/api/",
    description='version',
    enable_latest=True,
    **docs_url_kwargs(),
)

To Reproduce Set docs_url=None when instantiating the FastAPI app and VersionedFastAPI but still see the docs served at /docs.

Expected behavior Expecting docs to no longer be served (for production use case).

Additional details Issue may be here: https://github.com/DeanWay/fastapi-versioning/blob/18d480f5bb067088f157f235a673cb4c65ec77d5/fastapi_versioning/versioning.py#L68-L73

Is your feature request related to a problem? Please describe. This is a question regarding #35. I am curious about why you would want the keyword "latest" to be in the path, because it feels more natural that /api/endpoint serve the latest version of the API by default.

Describe the solution you'd like If that is clear, i guess we can remove the keyword "latest" from the prefix in versioning.py, line 76, so anything from the default API direct to the latest API. Reference source code link:

modification:

if enable_latest:
        prefix = "/"
......

Alternative option The above question is actually from the concern whether I could set some version of API to be a generic API like... suppose you have v1, v2, and v3 APIs where all have /items endpoint, and you want v2 to be accessible by default path like /items ( /items redirect to /v2/items )

Additional context I would mainly want to know the decision behind the usage of the keyword; #35 describes the reason, but it's not really convincing to me and if the concern here is about serving the latest version to client, generic API call without any version, keyword, etc would be better for users and also for restfulness too.