Change the style of property names for API class accessors

Author: yugokato

README.md

@@ -174,12 +174,12 @@ Alternatively, you can instantiate your client directly from the parent `OpenAPI
 
 ### Make an API request
 
-To make an API request with your API client, call an API function as  `client.<API_TAG>.<api_function_name>()`. 
+To make an API request with your API client, call an API function as  `client.<ApiTag>.<api_function_name>()`. 
 The function will take all parameters documented in the OpenAPI specs as keyword arguments. 
 
 eg. To call the login API defined under the Auth tag:
 ```pycon
->>> r = client.AUTH.login(username='foo', password='bar')
+>>> r = client.Auth.login(username='foo', password='bar')
 2024-01-01T00:00:00.863-0800 - request: POST http://127.0.0.1:5000/v1/auth/login
 2024-01-01T00:00:00.877-0800 - response: 201 (Created)
 - request_id: a2b20acf-22d5-4131-ac0d-6796bf19d2af
@@ -330,11 +330,11 @@ class DemoAppAPIClient(OpenAPIClient):
         super().__init__("demo_app", env=env, doc="openapi.json")
 
     @cached_property
-    def AUTH(self):
+    def Auth(self):
         return AuthAPI(self)
 
     @cached_property
-    def USERS(self):
+    def Users(self):
         return UsersAPI(self)
 ```
 
@@ -441,10 +441,10 @@ parameters and/or with raw `requests` library options (eg. `timeout`, `headers`,
 Some attributes available from the API class: 
 ```pycon
 >>> # Get tag data
->>> client.AUTH.TAGs
+>>> client.Auth.TAGs
 ('Auth',)
 >>> # Get available endpoints under this API class 
->>> pprint(client.AUTH.endpoints)
+>>> pprint(client.Auth.endpoints)
 [Endpoint(tags=('Auth',),
           api_class=<class 'openapi_test_client.clients.demo_app.api.auth.AuthAPI'>,
           method='post',
@@ -492,11 +492,11 @@ DELETE /v1/users/{user_id}
 
 Each API class function is decorated with a `@endpoint.<method>(<path>)` endpoint decorator. This decorator converts the original function into an instance of the `EndpointHandler` class at runtime. The `EndpointHandler` object acts as a proxy to a per-endpoint `EndpointFunc` object, which is also created at runtime and is responsible for handling the actual API calls via its base class's `__call__()` method. Additionally, the `EndpointFunc` object provides various capabilities and attributes related to the endpoint.
 
-eg. The Login API is accessible via `client.AUTH.login()` API function, which is actually an instance of 
+eg. The Login API is accessible via `client.Auth.login()` API function, which is actually an instance of 
 `AuthAPILoginEndpointFunc` class returned by its associated `EndpointHandler` obj.
 
 ```pycon
->>> client.AUTH.login
+>>> client.Auth.login
 <openapi_test_client.libraries.api.api_functions.endpoint.AuthAPILoginEndpointFunc object at 0x1074abf10>
 (mapped to: <function AuthAPI.login at 0x10751c360>)
 ```
@@ -511,9 +511,9 @@ The endpoint function is also accessible directly from the API class:
 
 Various endpoint data is available from the endpoint function via `endpoint` property:
 ```pycon
->>> print(client.AUTH.login.endpoint)
+>>> print(client.Auth.login.endpoint)
 POST /v1/auth/login
->>> pprint(client.AUTH.login.endpoint)
+>>> pprint(client.Auth.login.endpoint)
 Endpoint(tags=('Auth',),
          api_class=<class 'openapi_test_client.clients.demo_app.api.auth.AuthAPI'>,
          method='post',
@@ -525,18 +525,18 @@ Endpoint(tags=('Auth',),
          is_public=True,
          is_documented=True,
          is_deprecated=False)
->>> client.AUTH.login.endpoint.method
+>>> client.Auth.login.endpoint.method
 'post'
->>> client.AUTH.login.endpoint.path
+>>> client.Auth.login.endpoint.path
 '/v1/auth/login'
->>> client.AUTH.login.endpoint.url
+>>> client.Auth.login.endpoint.url
 'http://127.0.0.1:5000/v1/auth/login'
 ```
 
 Note that the same endpoint data is also available directly from the API class, except for `url` will always be `None`.
 ```pycon
 >>> from openapi_test_client.clients.demo_app.api.auth import AuthAPI
->>> client.AUTH.login.endpoint == AuthAPI.login.endpoint
+>>> client.Auth.login.endpoint == AuthAPI.login.endpoint
 True
 >>> print(AuthAPI.login.endpoint)
 POST /v1/auth/login
@@ -557,7 +557,7 @@ Endpoint(tags=('Auth',),
 An example of the additional capability the `EndpointFunc` obj provides - Automatic retry:
 ```pycon
 # Call the endpiont with the automatic retry (you can specify a retry condition if needed)
->>> r = client.AUTH.login.with_retry(username='foo', password='bar')
+>>> r = client.Auth.login.with_retry(username='foo', password='bar')
 2024-01-01T00:00:00.153-0000 - request: POST http://127.0.0.1:5000/v1/auth/login
 2024-01-01T00:00:00.158-0000 - response: 429 (Too Many Requests)
 - request_id: 1b028ff7-0880-430c-b5a3-12aa057892cf
@@ -590,7 +590,7 @@ An example of the additional capability the `EndpointFunc` obj provides - Automa
 Each endpoint is represented as an `EndpointModel` dataclass model, which holds various context around each 
 parameter (eg. type annotation).
 ```pycon
->>> model = client.AUTH.login.endpoint.model
+>>> model = client.Auth.login.endpoint.model
 >>> print(model)
 <class 'types.AuthAPILoginEndpointModel'>
 >>> pprint(model.__dataclass_fields__, sort_dicts=False)
@@ -774,7 +774,7 @@ Here are some comparisons between regular models and pydantic models:
 - Regular dataclass model (Validation will be done on the server-side)
 ```pycon 
 >>> # Model definition
->>> model = client.USERS.create_user.endpoint.model
+>>> model = client.Users.create_user.endpoint.model
 >>> print(model)
 <class 'types.UsersAPICreateUserEndpointModel'>
 >>> pprint(model.__dataclass_fields__, sort_dicts=False)
@@ -785,7 +785,7 @@ Here are some comparisons between regular models and pydantic models:
  'metadata': Field(name='metadata',type=typing.Optional[openapi_test_client.clients.demo_app.models.users.Metadata],default=<object object at 0x107b410b0>,default_factory=<dataclasses._MISSING_TYPE object at 0x107ea61d0>,init=True,repr=True,hash=None,compare=True,metadata=mappingproxy({}),kw_only=True,_field_type=_FIELD)}
 >>>
 >>> # Make an API request with the invalid parameter values
->>> r = client.USERS.create_user(first_name=123, email="foo", role="something", metadata=Metadata(social_links=SocialLinks(facebook="test")), extra=123)
+>>> r = client.Users.create_user(first_name=123, email="foo", role="something", metadata=Metadata(social_links=SocialLinks(facebook="test")), extra=123)
 2024-01-01T00:00:00.741-0800 - The request contains one or more parameters UsersAPI.create_user() does not expect:
 - extra
 2024-01-01T00:00:00.742-0800 - request: POST http://127.0.0.1:5000/v1/users
@@ -874,7 +874,7 @@ Here are some comparisons between regular models and pydantic models:
 - Pydantic model (Validation will be done on the client-side)
 ```pycon
 >>> # Model definition
->>> pydantic_model = client.USERS.create_user.endpoint.model.to_pydantic()
+>>> pydantic_model = client.Users.create_user.endpoint.model.to_pydantic()
 >>> print(pydantic_model)
 <class 'types.UsersAPICreateUserEndpointModel'>
 >>> pprint(pydantic_model.model_fields, sort_dicts=False)
@@ -885,7 +885,7 @@ Here are some comparisons between regular models and pydantic models:
  'metadata': FieldInfo(annotation=Union[Metadata, NoneType], required=False, default=None)}
 >>>
 >>> # Make an API request with the same invalid parmeter values, but with validate=True option
->>> r = client.USERS.create_user(first_name=123, email="foo", role="something", metadata=Metadata(social_links=SocialLinks(facebook="test")), extra=123, validate=True)
+>>> r = client.Users.create_user(first_name=123, email="foo", role="something", metadata=Metadata(social_links=SocialLinks(facebook="test")), extra=123, validate=True)
 2024-01-01T00:00:00.830-0800 - The request contains one or more parameters UsersAPI.create_user() does not expect:
 - extra
 Traceback (most recent call last):

images/generate.gif

@@ -29,5 +29,5 @@ def post_request_hook(
     ):
         super().post_request_hook(endpoint, response, request_exception, *path_params, **params)
         if response and response.ok:
-            if endpoint in self.api_client.AUTH.endpoints:
+            if endpoint in self.api_client.Auth.endpoints:
                 manage_auth_session(self.api_client, endpoint, response)

src/openapi_test_client/clients/demo_app/api/base/demo_app_api.py

@@ -41,8 +41,8 @@ def manage_auth_session(api_client: DemoAppAPIClient, endpoint: Endpoint, r: Res
     :param endpoint: The Endpoint object of the API endpoint
     :param r: RestResponse object returned from the request
     """
-    if endpoint == api_client.AUTH.login.endpoint:
+    if endpoint == api_client.Auth.login.endpoint:
         token = r.response["token"]
         api_client.rest_client.set_bearer_token(token)
-    elif endpoint == api_client.AUTH.logout.endpoint:
+    elif endpoint == api_client.Auth.logout.endpoint:
         api_client.rest_client.unset_bear_token()

src/openapi_test_client/clients/demo_app/api/request_hooks/post_request.py

@@ -11,7 +11,7 @@ class DemoAppAPIClient(OpenAPIClient):
 
     Usage:
     >>> client = DemoAppAPIClient()
-    >>> r = client.AUTH.login(username="foo", password="bar")
+    >>> r = client.Auth.login(username="foo", password="bar")
     >>> assert r.status_code == 200
     >>> token = r.response["token"]
     """
@@ -20,9 +20,9 @@ def __init__(self, env: str = "dev"):
         super().__init__("demo_app", env=env, doc="openapi.json")
 
     @cached_property
-    def AUTH(self):
+    def Auth(self):
         return AuthAPI(self)
 
     @cached_property
-    def USERS(self):
+    def Users(self):
         return UsersAPI(self)

src/openapi_test_client/clients/demo_app/demo_app_client.py

@@ -22,12 +22,12 @@ def init_api_classes(base_api_class: type[APIClassType]) -> list[type[APIClassTy
     Note: This function must be called from the __init__.py of a directory that contains API class files
 
     Example:
-        `AuthAPI.endpoints` or `<DemoAppAPIClient>.AUTH.endpoints` will return the following `Endpoint` objects
+        `AuthAPI.endpoints` or `<DemoAppAPIClient>.Auth.endpoints` will return the following `Endpoint` objects
 
         >>> from openapi_test_client.clients.demo_app import DemoAppAPIClient
         >>>
         >>> client = DemoAppAPIClient()
-        >>> client.AUTH.endpoints
+        >>> client.Auth.endpoints
         [
             Endpoint(tag='Auth', api_class=<class 'test_client.clients.demo_app.api.auth.AuthAPI'>, method='post', path='/v1/auth/login', func_name='login', model=<class 'types.LoginEndpointModel'>),
             Endpoint(tag='Auth', api_class=<class 'test_client.clients.demo_app.api.auth.AuthAPI'>, method='get', path='/v1/auth/logout', func_name='logout', model=<class 'types.LogoutEndpointModel'>)

src/openapi_test_client/libraries/api/api_classes/__init__.py

@@ -621,7 +621,7 @@ def generate_api_client(temp_api_client: OpenAPIClient, show_generated_code: boo
     ):
         mod = inspect.getmodule(api_class)
         imports_code += f"from .{API_CLASS_DIR_NAME}.{Path(mod.__file__).stem} import {api_class.__name__}\n"
-        property_name = camel_to_snake(api_class.__name__.removesuffix("API")).upper()
+        property_name = api_class.__name__.removesuffix("API")
         api_client_code += (
             f"{TAB}@cached_property\n{TAB}def {property_name}(self):\n{TAB}{TAB}return {api_class.__name__}(self)\n\n"
         )

src/openapi_test_client/libraries/api/api_client_generator.py

@@ -82,9 +82,9 @@ def __call__(
             >>> from openapi_test_client.clients.demo_app import DemoAppAPIClient
             >>>
             >>> client = DemoAppAPIClient()
-            >>> r = client.AUTH.login(username="foo", password="bar")
+            >>> r = client.Auth.login(username="foo", password="bar")
             >>> # Above API call can be also done directly from the endpoint object, if you need to:
-            >>> endpoint = client.AUTH.login.endpoint
+            >>> endpoint = client.Auth.login.endpoint
             >>> r2 = endpoint(client, username="foo", password="bar")
         """
         endpoint_func: EndpointFunc = getattr(self.api_class(api_client), self.func_name)
@@ -109,23 +109,23 @@ class endpoint:
         >>>         ...
         >>>
         >>> client = DemoAppAPIClient()
-        >>> type(client.AUTH.login)
+        >>> type(client.Auth.login)
         <class 'openapi_test_client.libraries.api.api_functions.endpoint.AuthAPILoginEndpointFunc'>
         >>> type(AuthAPI.login)
         <class 'openapi_test_client.libraries.api.api_functions.endpoint.AuthAPILoginEndpointFunc'>
-        >>> isinstance(client.AUTH.login, EndpointFunc) and isinstance(AuthAPI.login, EndpointFunc)
+        >>> isinstance(client.Auth.login, EndpointFunc) and isinstance(AuthAPI.login, EndpointFunc)
         True
-        >>> client.AUTH.login.endpoint
+        >>> client.Auth.login.endpoint
         Endpoint(tags=('Auth',), api_class=<class 'openapi_test_client.clients.demo_app.api.auth.AuthAPI'>, method='post', path='/v1/auth/login', func_name='login', model=<class 'types.AuthAPILoginEndpointModel'>, url='http://127.0.0.1:5000/v1/auth/login', content_type=None, is_public=False, is_documented=True, is_deprecated=False)
         >>> AuthAPI.login.endpoint
         Endpoint(tags=('Auth',), api_class=<class 'openapi_test_client.clients.demo_app.api.auth.AuthAPI'>, method='post', path='/v1/auth/login', func_name='login', model=<class 'types.AuthAPILoginEndpointModel'>, url=None, content_type=None, is_public=False, is_documented=True, is_deprecated=False)
-        >>> str(client.AUTH.login.endpoint)
+        >>> str(client.Auth.login.endpoint)
         'POST /v1/auth/login'
         >>> str(AuthAPI.login.endpoint)
         'POST /v1/auth/login'
-        >>> client.AUTH.login.endpoint.path
+        >>> client.Auth.login.endpoint.path
         '/v1/auth/login'
-        >>> client.AUTH.login.endpoint.url
+        >>> client.Auth.login.endpoint.url
         'http://127.0.0.1:5000/v1/auth/login'
 
     """  # noqa: E501

src/openapi_test_client/libraries/api/api_functions/endpoints.py

@@ -65,10 +65,10 @@ def unauthenticated_api_client() -> DemoAppAPIClient:
 @pytest.fixture(scope="session")
 def api_client() -> DemoAppAPIClient:
     client = DemoAppAPIClient()
-    r = client.AUTH.login(username="foo", password="bar")
+    r = client.Auth.login(username="foo", password="bar")
     assert r.ok
     yield client
-    client.AUTH.logout()
+    client.Auth.logout()
 
 
 @pytest.fixture

tests/integration/conftest.py

@@ -7,11 +7,11 @@
 @pytest.mark.parametrize("validation_mode", [False, True])
 def test_user_login_logout(unauthenticated_api_client: DemoAppAPIClient, validation_mode: bool):
     """Check basic client/server functionality of Auth login/logout APIs"""
-    r = unauthenticated_api_client.AUTH.login(username="foo", password="bar", validate=validation_mode)
+    r = unauthenticated_api_client.Auth.login(username="foo", password="bar", validate=validation_mode)
     assert r.ok
     assert set(r.response.keys()) == {"token"}
 
-    r = unauthenticated_api_client.AUTH.logout()
+    r = unauthenticated_api_client.Auth.logout()
     assert r.ok
     assert r.response["message"] == "logged out"
 
@@ -25,7 +25,7 @@ def test_user_login_with_invalid_params(unauthenticated_api_client: DemoAppAPICl
     - password: missing required parameter
     """
     helper.do_test_invalid_params(
-        endpoint_func=unauthenticated_api_client.AUTH.login,
+        endpoint_func=unauthenticated_api_client.Auth.login,
         validation_mode=validation_mode,
         invalid_params=dict(username=123),
         num_expected_errors=2,

tests/integration/test_api_auth.py

@@ -10,7 +10,7 @@
 @pytest.mark.parametrize("validation_mode", [False, True])
 def test_create_user(api_client: DemoAppAPIClient, validation_mode: bool):
     """Check basic client/server functionality of create user API"""
-    r = api_client.USERS.create_user(
+    r = api_client.Users.create_user(
         first_name="test",
         last_name="test",
         email="[email protected]",
@@ -29,7 +29,7 @@ def test_create_user(api_client: DemoAppAPIClient, validation_mode: bool):
 def test_get_user(api_client: DemoAppAPIClient, validation_mode: bool):
     """Check basic client/server functionality of get user API"""
     user_id = 5
-    r = api_client.USERS.get_user(user_id, validate=validation_mode)
+    r = api_client.Users.get_user(user_id, validate=validation_mode)
     assert r.status_code == 200
     assert r.response["id"] == user_id
 
@@ -38,7 +38,7 @@ def test_get_user(api_client: DemoAppAPIClient, validation_mode: bool):
 def test_get_users(api_client: DemoAppAPIClient, validation_mode: bool):
     """Check basic client/server functionality of get users API"""
     role = "support"
-    r = api_client.USERS.get_users(role=role, validate=validation_mode)
+    r = api_client.Users.get_users(role=role, validate=validation_mode)
     assert r.status_code == 200
     assert len(r.response) == len([x for x in USERS if x.role.value == role])
 
@@ -53,7 +53,7 @@ def test_upload_image(api_client: DemoAppAPIClient, validation_mode: bool):
         b"\x01c`\x00\x00\x00\x02\x00\x01su\x01\x18\x00\x00\x00\x00IEND\xaeB`\x82"
     )
     file = File(filename="test_image.png", content=image_data, content_type="image/png")
-    r = api_client.USERS.upload_image(file=file, description="test image", validate=validation_mode)
+    r = api_client.Users.upload_image(file=file, description="test image", validate=validation_mode)
     assert r.status_code == 201
     assert r.response["message"] == f"Image '{file.filename}' uploaded"
 
@@ -62,7 +62,7 @@ def test_upload_image(api_client: DemoAppAPIClient, validation_mode: bool):
 def test_delete_user(api_client: DemoAppAPIClient, validation_mode: bool):
     """Check basic client/server functionality of delete user API"""
     user_id = 1 + bool(validation_mode)
-    r = api_client.USERS.delete_user(user_id, validate=validation_mode)
+    r = api_client.Users.delete_user(user_id, validate=validation_mode)
     assert r.status_code == 200
     assert r.response["message"] == f"Deleted user {user_id}"
 
@@ -82,7 +82,7 @@ def test_create_user_with_invalid_params(api_client: DemoAppAPIClient, validatio
 
     """
     helper.do_test_invalid_params(
-        endpoint_func=api_client.USERS.create_user,
+        endpoint_func=api_client.Users.create_user,
         validation_mode=validation_mode,
         invalid_params=dict(
             first_name=123,
@@ -106,7 +106,7 @@ def test_get_users_with_invalid_params(api_client: DemoAppAPIClient, validation_
     - role: Invalid enum value
     """
     helper.do_test_invalid_params(
-        endpoint_func=api_client.USERS.get_users,
+        endpoint_func=api_client.Users.get_users,
         validation_mode=validation_mode,
         invalid_params=dict(id="test", role="test"),
         num_expected_errors=2,
@@ -126,7 +126,7 @@ def test_upload_image_with_invalid_params(api_client: DemoAppAPIClient, validati
           the content is properly uploaded with the multipart/form-data Content-Type header
     """
     helper.do_test_invalid_params(
-        endpoint_func=api_client.USERS.upload_image,
+        endpoint_func=api_client.Users.upload_image,
         validation_mode=validation_mode,
         invalid_params=dict(file="test"),
         num_expected_errors=1,

tests/integration/test_api_users.py

@@ -91,7 +91,7 @@ def test_update_client(temp_app_client: OpenAPIClient, dry_run: bool, option: st
     NOTE: temp_app_client is a temporary client generated for this test against the demo_app app.
           API class and model file code should be identical to DemoAppAPIClient's, except for API function names
     """
-    users_api = getattr(temp_app_client, "USERS")
+    users_api = getattr(temp_app_client, "Users")
     assert users_api._unnamed_endpoint_1.endpoint == UsersAPI.create_user.endpoint
     users_api_class_file = Path(inspect.getabsfile(type(users_api)))
     assert users_api_class_file.exists()

tests/integration/test_script.py

@@ -31,7 +31,7 @@ def api_client() -> DemoAppAPIClient:
 def api_class_or_instance(request: FixtureRequest, api_client: DemoAppAPIClient) -> AuthAPI | type[AuthAPI]:
     """Parametrize fixture that returns the demo API client's AuthAPI class or an isntance of the class"""
     if request.param == "instance":
-        return api_client.AUTH
+        return api_client.Auth
     else:
         return AuthAPI