diff --git a/README.md b/README.md index 5cdcc2d..5983a2a 100644 --- a/README.md +++ b/README.md @@ -49,12 +49,12 @@ print(master_realm.model_dump_json(indent=2)) ```console { "name": "master", - "display_name": null, + "displayName": null, "description": null, "id": "794f2375-f043-4789-bd0c-e5534e8deeaa", - "built_in": true, - "created_at": "2025-05-12T09:44:08.284000Z", - "updated_at": "2025-05-12T09:44:08.284000Z" + "builtIn": true, + "createdAt": "2025-05-12T09:44:08.284000Z", + "updatedAt": "2025-05-12T09:44:08.284000Z" } ``` diff --git a/docs/user_guide.rst b/docs/user_guide.rst index b01b150..29b6527 100644 --- a/docs/user_guide.rst +++ b/docs/user_guide.rst @@ -296,12 +296,12 @@ the resource you are requesting. 794f2375-f043-4789-bd0c-e5534e8deeaa { "name": "master", - "display_name": null, + "displayName": null, "description": null, "id": "794f2375-f043-4789-bd0c-e5534e8deeaa", - "built_in": true, - "created_at": "2025-05-12T09:44:08.284000Z", - "updated_at": "2025-05-12T09:44:08.284000Z" + "builtIn": true, + "createdAt": "2025-05-12T09:44:08.284000Z", + "updatedAt": "2025-05-12T09:44:08.284000Z" } Since the realm ID is present, we can use the ``realm`` property too. And just to be extremely sure, we verify that the diff --git a/flame_hub/_auth_client.py b/flame_hub/_auth_client.py index 229b00f..063750d 100644 --- a/flame_hub/_auth_client.py +++ b/flame_hub/_auth_client.py @@ -23,260 +23,260 @@ class CreateRealm(BaseModel): name: str - display_name: str | None + displayName: str | None description: str | None class UpdateRealm(BaseModel): name: str | UNSET_T = UNSET - display_name: str | None | UNSET_T = UNSET + displayName: str | None | UNSET_T = UNSET description: str | None | UNSET_T = UNSET class Realm(CreateRealm): id: uuid.UUID - built_in: bool - created_at: datetime - updated_at: datetime + builtIn: bool + createdAt: datetime + updatedAt: datetime class CreateUser(BaseModel): name: str - display_name: str | None + displayName: str | None email: t.Annotated[EmailStr, IsOptionalField] = None active: bool - name_locked: bool - first_name: str | None - last_name: str | None + nameLocked: bool + firstName: str | None + lastName: str | None class User(CreateUser): id: uuid.UUID avatar: str | None cover: str | None - realm_id: uuid.UUID + realmId: uuid.UUID realm: t.Annotated[Realm, IsIncludable] = None - created_at: datetime - updated_at: datetime + createdAt: datetime + updatedAt: datetime class UpdateUser(BaseModel): name: str | UNSET_T = UNSET - display_name: str | UNSET_T = UNSET + displayName: str | UNSET_T = UNSET email: str | None | UNSET_T = UNSET active: bool | UNSET_T = UNSET - name_locked: bool | UNSET_T = UNSET - first_name: str | None | UNSET_T = UNSET - last_name: str | None | UNSET_T = UNSET + nameLocked: bool | UNSET_T = UNSET + firstName: str | None | UNSET_T = UNSET + lastName: str | None | UNSET_T = UNSET password: str | None | UNSET_T = UNSET class CreateRobot(BaseModel): name: str - realm_id: t.Annotated[uuid.UUID, Field(), WrapValidator(uuid_validator)] + realmId: t.Annotated[uuid.UUID, Field(), WrapValidator(uuid_validator)] secret: str | None - display_name: str | None + displayName: str | None class Robot(BaseModel): id: uuid.UUID name: str - display_name: str | None + displayName: str | None description: str | None active: bool - created_at: datetime - updated_at: datetime - user_id: uuid.UUID | None + createdAt: datetime + updatedAt: datetime + userId: uuid.UUID | None user: t.Annotated[User | None, IsIncludable] = None realm: t.Annotated[Realm, IsIncludable] = None - realm_id: uuid.UUID + realmId: uuid.UUID class UpdateRobot(BaseModel): - display_name: str | None | UNSET_T = UNSET + displayName: str | None | UNSET_T = UNSET name: str | UNSET_T = UNSET - realm_id: t.Annotated[uuid.UUID | UNSET_T, Field(), WrapValidator(uuid_validator)] = UNSET + realmId: t.Annotated[uuid.UUID | UNSET_T, Field(), WrapValidator(uuid_validator)] = UNSET secret: str | UNSET_T = UNSET class CreatePermission(BaseModel): name: str - display_name: str | None + displayName: str | None description: str | None - realm_id: t.Annotated[uuid.UUID | None, Field(), WrapValidator(uuid_validator)] - policy_id: t.Annotated[uuid.UUID | None, Field(), WrapValidator(uuid_validator)] + realmId: t.Annotated[uuid.UUID | None, Field(), WrapValidator(uuid_validator)] + policyId: t.Annotated[uuid.UUID | None, Field(), WrapValidator(uuid_validator)] class Permission(CreatePermission): id: uuid.UUID - built_in: bool - client_id: uuid.UUID | None - created_at: datetime - updated_at: datetime + builtIn: bool + clientId: uuid.UUID | None + createdAt: datetime + updatedAt: datetime realm: t.Annotated[Realm | None, IsIncludable] = None class UpdatePermission(BaseModel): name: str | UNSET_T = UNSET - display_name: str | None | UNSET_T = UNSET + displayName: str | None | UNSET_T = UNSET description: str | None | UNSET_T = UNSET - realm_id: t.Annotated[uuid.UUID | None | UNSET_T, Field(), WrapValidator(uuid_validator)] = UNSET - policy_id: t.Annotated[uuid.UUID | None | UNSET_T, Field(), WrapValidator(uuid_validator)] = UNSET + realmId: t.Annotated[uuid.UUID | None | UNSET_T, Field(), WrapValidator(uuid_validator)] = UNSET + policyId: t.Annotated[uuid.UUID | None | UNSET_T, Field(), WrapValidator(uuid_validator)] = UNSET class CreateRole(BaseModel): name: str - display_name: str | None + displayName: str | None description: str | None class Role(CreateRole): id: uuid.UUID target: str | None - realm_id: uuid.UUID | None - created_at: datetime - updated_at: datetime + realmId: uuid.UUID | None + createdAt: datetime + updatedAt: datetime realm: t.Annotated[Realm | None, IsIncludable] = None class UpdateRole(BaseModel): name: str | UNSET_T = UNSET - display_name: str | None | UNSET_T = UNSET + displayName: str | None | UNSET_T = UNSET description: str | None | UNSET_T = UNSET class CreateRolePermission(BaseModel): - role_id: t.Annotated[uuid.UUID, Field(), WrapValidator(uuid_validator)] - permission_id: t.Annotated[uuid.UUID, Field(), WrapValidator(uuid_validator)] + roleId: t.Annotated[uuid.UUID, Field(), WrapValidator(uuid_validator)] + permissionId: t.Annotated[uuid.UUID, Field(), WrapValidator(uuid_validator)] class RolePermission(CreateRolePermission): id: uuid.UUID - role_realm_id: uuid.UUID | None - permission_realm_id: uuid.UUID | None - policy_id: uuid.UUID | None - created_at: datetime - updated_at: datetime + roleRealmId: uuid.UUID | None + permissionRealmId: uuid.UUID | None + policyId: uuid.UUID | None + createdAt: datetime + updatedAt: datetime role: t.Annotated[Role, IsIncludable] = None - role_realm: t.Annotated[Realm | None, IsIncludable] = None + roleRealm: t.Annotated[Realm | None, IsIncludable] = None permission: t.Annotated[Permission, IsIncludable] = None - permission_realm: t.Annotated[Realm | None, IsIncludable] = None + permissionRealm: t.Annotated[Realm | None, IsIncludable] = None class CreateUserPermission(BaseModel): - user_id: t.Annotated[uuid.UUID, Field(), WrapValidator(uuid_validator)] - permission_id: t.Annotated[uuid.UUID, Field(), WrapValidator(uuid_validator)] + userId: t.Annotated[uuid.UUID, Field(), WrapValidator(uuid_validator)] + permissionId: t.Annotated[uuid.UUID, Field(), WrapValidator(uuid_validator)] class UserPermission(CreateUserPermission): id: uuid.UUID - user_realm_id: uuid.UUID | None - permission_realm_id: uuid.UUID | None - policy_id: uuid.UUID | None - created_at: datetime - updated_at: datetime + userRealmId: uuid.UUID | None + permissionRealmId: uuid.UUID | None + policyId: uuid.UUID | None + createdAt: datetime + updatedAt: datetime permission: t.Annotated[Permission, IsIncludable] = None user: t.Annotated[User, IsIncludable] = None - permission_realm: t.Annotated[Realm | None, IsIncludable] = None - user_realm: t.Annotated[Realm | None, IsIncludable] = None + permissionRealm: t.Annotated[Realm | None, IsIncludable] = None + userRealm: t.Annotated[Realm | None, IsIncludable] = None class CreateUserRole(BaseModel): - user_id: t.Annotated[uuid.UUID, Field(), WrapValidator(uuid_validator)] - role_id: t.Annotated[uuid.UUID, Field(), WrapValidator(uuid_validator)] + userId: t.Annotated[uuid.UUID, Field(), WrapValidator(uuid_validator)] + roleId: t.Annotated[uuid.UUID, Field(), WrapValidator(uuid_validator)] class UserRole(CreateUserRole): id: uuid.UUID - user_realm_id: uuid.UUID | None - role_realm_id: uuid.UUID | None - created_at: datetime - updated_at: datetime + userRealmId: uuid.UUID | None + roleRealmId: uuid.UUID | None + createdAt: datetime + updatedAt: datetime user: t.Annotated[User, IsIncludable] = None role: t.Annotated[Role, IsIncludable] = None - user_realm: t.Annotated[Realm | None, IsIncludable] = None - role_realm: t.Annotated[Realm | None, IsIncludable] = None + userRealm: t.Annotated[Realm | None, IsIncludable] = None + roleRealm: t.Annotated[Realm | None, IsIncludable] = None class CreateRobotPermission(BaseModel): - robot_id: t.Annotated[uuid.UUID, Field(), WrapValidator(uuid_validator)] - permission_id: t.Annotated[uuid.UUID, Field(), WrapValidator(uuid_validator)] + robotId: t.Annotated[uuid.UUID, Field(), WrapValidator(uuid_validator)] + permissionId: t.Annotated[uuid.UUID, Field(), WrapValidator(uuid_validator)] class RobotPermission(CreateRobotPermission): id: uuid.UUID - robot_realm_id: uuid.UUID | None - permission_realm_id: uuid.UUID | None - policy_id: uuid.UUID | None - created_at: datetime - updated_at: datetime + robotRealmId: uuid.UUID | None + permissionRealmId: uuid.UUID | None + policyId: uuid.UUID | None + createdAt: datetime + updatedAt: datetime robot: t.Annotated[Robot, IsIncludable] = None permission: t.Annotated[Permission, IsIncludable] = None - robot_realm: t.Annotated[Realm | None, IsIncludable] = None - permission_realm: t.Annotated[Realm | None, IsIncludable] = None + robotRealm: t.Annotated[Realm | None, IsIncludable] = None + permissionRealm: t.Annotated[Realm | None, IsIncludable] = None class CreateRobotRole(BaseModel): - robot_id: t.Annotated[uuid.UUID, Field(), WrapValidator(uuid_validator)] - role_id: t.Annotated[uuid.UUID, Field(), WrapValidator(uuid_validator)] + robotId: t.Annotated[uuid.UUID, Field(), WrapValidator(uuid_validator)] + roleId: t.Annotated[uuid.UUID, Field(), WrapValidator(uuid_validator)] class RobotRole(CreateRobotRole): id: uuid.UUID - robot_realm_id: uuid.UUID | None - role_realm_id: uuid.UUID | None - created_at: datetime - updated_at: datetime + robotRealmId: uuid.UUID | None + roleRealmId: uuid.UUID | None + createdAt: datetime + updatedAt: datetime robot: t.Annotated[Robot, IsIncludable] = None role: t.Annotated[Role, IsIncludable] = None - robot_realm: t.Annotated[Realm | None, IsIncludable] = None - role_realm: t.Annotated[Realm | None, IsIncludable] = None + robotRealm: t.Annotated[Realm | None, IsIncludable] = None + roleRealm: t.Annotated[Realm | None, IsIncludable] = None class CreateClient(BaseModel): name: str secret: str | None - display_name: str | None + displayName: str | None description: str | None - redirect_uri: str | None + redirectUri: str | None active: bool - is_confidential: bool - secret_hashed: bool - grant_types: str | None - realm_id: t.Annotated[uuid.UUID, Field(), WrapValidator(uuid_validator)] + isConfidential: bool + secretHashed: bool + grantTypes: str | None + realmId: t.Annotated[uuid.UUID, Field(), WrapValidator(uuid_validator)] class Client(BaseModel): id: uuid.UUID name: str - built_in: bool - display_name: str | None + builtIn: bool + displayName: str | None description: str | None - redirect_uri: str | None + redirectUri: str | None active: bool - is_confidential: bool - secret_hashed: bool - grant_types: str | None - secret_encrypted: bool + isConfidential: bool + secretHashed: bool + grantTypes: str | None + secretEncrypted: bool scope: str | None - base_url: str | None - root_url: str | None - created_at: datetime - updated_at: datetime - realm_id: uuid.UUID + baseUrl: str | None + rootUrl: str | None + createdAt: datetime + updatedAt: datetime + realmId: uuid.UUID realm: t.Annotated[Realm, IsIncludable] = None class UpdateClient(BaseModel): name: str | UNSET_T = UNSET secret: str | None | UNSET_T = UNSET - display_name: str | None | UNSET_T = UNSET + displayName: str | None | UNSET_T = UNSET description: str | None | UNSET_T = UNSET - redirect_uri: str | None | UNSET_T = UNSET + redirectUri: str | None | UNSET_T = UNSET active: bool | UNSET_T = UNSET - is_confidential: bool | UNSET_T = UNSET - secret_hashed: bool | UNSET_T = UNSET - grant_types: str | None | UNSET_T = UNSET + isConfidential: bool | UNSET_T = UNSET + secretHashed: bool | UNSET_T = UNSET + grantTypes: str | None | UNSET_T = UNSET class AuthClient(BaseClient): @@ -304,69 +304,67 @@ def get_realms(self, **params: te.Unpack[GetKwargs]) -> list[Realm]: def find_realms(self, **params: te.Unpack[FindAllKwargs]) -> list[Realm]: return self._find_all_resources(Realm, "realms", **params) - def create_realm(self, name: str, display_name: str = None, description: str = None) -> Realm: + def create_realm(self, name: str, displayName: str = None, description: str = None) -> Realm: return self._create_resource( Realm, CreateRealm( name=name, - display_name=display_name, + displayName=displayName, description=description, ), "realms", ) - def delete_realm(self, realm_id: Realm | uuid.UUID | str): - self._delete_resource("realms", realm_id) + def delete_realm(self, realmId: Realm | uuid.UUID | str): + self._delete_resource("realms", realmId) - def get_realm(self, realm_id: Realm | uuid.UUID | str, **params: te.Unpack[GetKwargs]) -> Realm | None: - return self._get_single_resource(Realm, "realms", realm_id, **params) + def get_realm(self, realmId: Realm | uuid.UUID | str, **params: te.Unpack[GetKwargs]) -> Realm | None: + return self._get_single_resource(Realm, "realms", realmId, **params) def update_realm( self, - realm_id: Realm | str | uuid.UUID, + realmId: Realm | str | uuid.UUID, name: str | UNSET_T = UNSET, - display_name: str | None | UNSET_T = UNSET, + displayName: str | None | UNSET_T = UNSET, description: str | None | UNSET_T = UNSET, ) -> Realm: return self._update_resource( Realm, UpdateRealm( name=name, - display_name=display_name, + displayName=displayName, description=description, ), "realms", - realm_id, + realmId, ) - def create_robot( - self, name: str, realm_id: Realm | str | uuid.UUID, secret: str, display_name: str = None - ) -> Robot: + def create_robot(self, name: str, realmId: Realm | str | uuid.UUID, secret: str, displayName: str = None) -> Robot: return self._create_resource( Robot, - CreateRobot(name=name, display_name=display_name, realm_id=realm_id, secret=secret), + CreateRobot(name=name, displayName=displayName, realmId=realmId, secret=secret), "robots", ) - def delete_robot(self, robot_id: Robot | str | uuid.UUID): - self._delete_resource("robots", robot_id) + def delete_robot(self, robotId: Robot | str | uuid.UUID): + self._delete_resource("robots", robotId) - def get_robot(self, robot_id: Robot | str | uuid.UUID, **params: te.Unpack[GetKwargs]) -> Robot | None: - return self._get_single_resource(Robot, "robots", robot_id, include=get_includable_names(Robot), **params) + def get_robot(self, robotId: Robot | str | uuid.UUID, **params: te.Unpack[GetKwargs]) -> Robot | None: + return self._get_single_resource(Robot, "robots", robotId, include=get_includable_names(Robot), **params) def update_robot( self, - robot_id: Robot | str | uuid.UUID, + robotId: Robot | str | uuid.UUID, name: str | UNSET_T = UNSET, - display_name: str | None | UNSET_T = UNSET, - realm_id: Realm | str | uuid.UUID | UNSET_T = UNSET, + displayName: str | None | UNSET_T = UNSET, + realmId: Realm | str | uuid.UUID | UNSET_T = UNSET, secret: str | UNSET_T = UNSET, ) -> Robot: return self._update_resource( Robot, - UpdateRobot(name=name, display_name=display_name, realm_id=realm_id, secret=secret), + UpdateRobot(name=name, displayName=displayName, realmId=realmId, secret=secret), "robots", - robot_id, + robotId, ) def get_robots(self, **params: te.Unpack[GetKwargs]) -> list[Robot]: @@ -378,45 +376,45 @@ def find_robots(self, **params: te.Unpack[FindAllKwargs]) -> list[Robot]: def create_permission( self, name: str, - display_name: str = None, + displayName: str = None, description: str = None, - realm_id: Realm | uuid.UUID | str = None, + realmId: Realm | uuid.UUID | str = None, ) -> Permission: return self._create_resource( Permission, CreatePermission( name=name, - display_name=display_name, + displayName=displayName, description=description, - realm_id=realm_id, - policy_id=None, # TODO: add policies when hub implements them + realmId=realmId, + policyId=None, # TODO: add policies when hub implements them ), "permissions", ) def get_permission( - self, permission_id: Permission | uuid.UUID | str, **params: te.Unpack[GetKwargs] + self, permissionId: Permission | uuid.UUID | str, **params: te.Unpack[GetKwargs] ) -> Permission | None: return self._get_single_resource( - Permission, "permissions", permission_id, include=get_includable_names(Permission), **params + Permission, "permissions", permissionId, include=get_includable_names(Permission), **params ) - def delete_permission(self, permission_id: Permission | uuid.UUID | str): - self._delete_resource("permissions", permission_id) + def delete_permission(self, permissionId: Permission | uuid.UUID | str): + self._delete_resource("permissions", permissionId) def update_permission( self, - permission_id: Permission | uuid.UUID | str, + permissionId: Permission | uuid.UUID | str, name: str | UNSET_T = UNSET, - display_name: str | None | UNSET_T = UNSET, + displayName: str | None | UNSET_T = UNSET, description: str | None | UNSET_T = UNSET, - realm_id: Realm | uuid.UUID | str | None | UNSET_T = UNSET, + realmId: Realm | uuid.UUID | str | None | UNSET_T = UNSET, ) -> Permission: return self._update_resource( Permission, - UpdatePermission(name=name, display_name=display_name, description=description, realm_id=realm_id), + UpdatePermission(name=name, displayName=displayName, description=description, realmId=realmId), "permissions", - permission_id, + permissionId, ) def get_permissions(self, **params: te.Unpack[GetKwargs]) -> list[Permission]: @@ -425,31 +423,31 @@ def get_permissions(self, **params: te.Unpack[GetKwargs]) -> list[Permission]: def find_permissions(self, **params: te.Unpack[FindAllKwargs]) -> list[Permission]: return self._find_all_resources(Permission, "permissions", include=get_includable_names(Permission), **params) - def create_role(self, name: str, display_name: str = None, description: str = None) -> Role: + def create_role(self, name: str, displayName: str = None, description: str = None) -> Role: return self._create_resource( Role, - CreateRole(name=name, display_name=display_name, description=description), + CreateRole(name=name, displayName=displayName, description=description), "roles", ) - def get_role(self, role_id: Role | uuid.UUID | str, **params: te.Unpack[GetKwargs]) -> Role | None: - return self._get_single_resource(Role, "roles", role_id, include=get_includable_names(Role), **params) + def get_role(self, roleId: Role | uuid.UUID | str, **params: te.Unpack[GetKwargs]) -> Role | None: + return self._get_single_resource(Role, "roles", roleId, include=get_includable_names(Role), **params) - def delete_role(self, role_id: Role | uuid.UUID | str): - self._delete_resource("roles", role_id) + def delete_role(self, roleId: Role | uuid.UUID | str): + self._delete_resource("roles", roleId) def update_role( self, - role_id: Role | uuid.UUID | str, + roleId: Role | uuid.UUID | str, name: str | UNSET_T = UNSET, - display_name: str | None | UNSET_T = UNSET, + displayName: str | None | UNSET_T = UNSET, description: str | None | UNSET_T = UNSET, ) -> Role: return self._update_resource( Role, - UpdateRole(name=name, display_name=display_name, description=description), + UpdateRole(name=name, displayName=displayName, description=description), "roles", - role_id, + roleId, ) def get_roles(self, **params: te.Unpack[GetKwargs]) -> list[Role]: @@ -459,27 +457,27 @@ def find_roles(self, **params: te.Unpack[FindAllKwargs]) -> list[Role]: return self._find_all_resources(Role, "roles", include=get_includable_names(Role), **params) def create_role_permission( - self, role_id: Role | uuid.UUID | str, permission_id: Permission | uuid.UUID | str + self, roleId: Role | uuid.UUID | str, permissionId: Permission | uuid.UUID | str ) -> RolePermission: return self._create_resource( RolePermission, - CreateRolePermission(role_id=role_id, permission_id=permission_id), + CreateRolePermission(roleId=roleId, permissionId=permissionId), "role-permissions", ) def get_role_permission( - self, role_permission_id: RolePermission | uuid.UUID | str, **params: te.Unpack[GetKwargs] + self, rolePermissionId: RolePermission | uuid.UUID | str, **params: te.Unpack[GetKwargs] ) -> RolePermission | None: return self._get_single_resource( RolePermission, "role-permissions", - role_permission_id, + rolePermissionId, include=get_includable_names(RolePermission), **params, ) - def delete_role_permission(self, role_permission_id: RolePermission | uuid.UUID | str): - self._delete_resource("role-permissions", role_permission_id) + def delete_role_permission(self, rolePermissionId: RolePermission | uuid.UUID | str): + self._delete_resource("role-permissions", rolePermissionId) def get_role_permissions(self, **params: te.Unpack[GetKwargs]) -> list[RolePermission]: return self._get_all_resources( @@ -501,56 +499,56 @@ def create_user( self, name: str, email: str, - display_name: str = None, + displayName: str = None, active: bool = True, - name_locked: bool = False, - first_name: str = None, - last_name: str = None, + nameLocked: bool = False, + firstName: str = None, + lastName: str = None, ) -> User: return self._create_resource( User, CreateUser( name=name, - display_name=display_name, + displayName=displayName, email=email, active=active, - name_locked=name_locked, - first_name=first_name, - last_name=last_name, + nameLocked=nameLocked, + firstName=firstName, + lastName=lastName, ), "users", ) - def get_user(self, user_id: User | uuid.UUID | str, **params: te.Unpack[GetKwargs]) -> User | None: - return self._get_single_resource(User, "users", user_id, include=get_includable_names(User), **params) + def get_user(self, userId: User | uuid.UUID | str, **params: te.Unpack[GetKwargs]) -> User | None: + return self._get_single_resource(User, "users", userId, include=get_includable_names(User), **params) - def delete_user(self, user_id: User | uuid.UUID | str): - self._delete_resource("users", user_id) + def delete_user(self, userId: User | uuid.UUID | str): + self._delete_resource("users", userId) def update_user( self, - user_id: User | uuid.UUID | str, + userId: User | uuid.UUID | str, name: str | UNSET_T = UNSET, - display_name: str | UNSET_T = UNSET, + displayName: str | UNSET_T = UNSET, email: str | None | UNSET_T = UNSET, active: bool | UNSET_T = UNSET, - name_locked: bool | UNSET_T = UNSET, - first_name: str | None | UNSET_T = UNSET, - last_name: str | None | UNSET_T = UNSET, + nameLocked: bool | UNSET_T = UNSET, + firstName: str | None | UNSET_T = UNSET, + lastName: str | None | UNSET_T = UNSET, ) -> User: return self._update_resource( User, UpdateUser( name=name, - display_name=display_name, + displayName=displayName, email=email, active=active, - name_locked=name_locked, - first_name=first_name, - last_name=last_name, + nameLocked=nameLocked, + firstName=firstName, + lastName=lastName, ), "users", - user_id, + userId, ) def get_users(self, **params: te.Unpack[GetKwargs]) -> list[User]: @@ -561,28 +559,28 @@ def find_users(self, **params: te.Unpack[FindAllKwargs]) -> list[User]: def create_user_permission( self, - user_id: User | uuid.UUID | str, - permission_id: Permission | uuid.UUID | str, + userId: User | uuid.UUID | str, + permissionId: Permission | uuid.UUID | str, ) -> UserPermission: return self._create_resource( UserPermission, - CreateUserPermission(user_id=user_id, permission_id=permission_id), + CreateUserPermission(userId=userId, permissionId=permissionId), "user-permissions", ) def get_user_permission( - self, user_permission_id: UserPermission | uuid.UUID | str, **params: te.Unpack[GetKwargs] + self, userPermissionId: UserPermission | uuid.UUID | str, **params: te.Unpack[GetKwargs] ) -> UserPermission | None: return self._get_single_resource( UserPermission, "user-permissions", - user_permission_id, + userPermissionId, include=get_includable_names(UserPermission), **params, ) - def delete_user_permission(self, user_permission_id: UserPermission | uuid.UUID | str): - self._delete_resource("user-permissions", user_permission_id) + def delete_user_permission(self, userPermissionId: UserPermission | uuid.UUID | str): + self._delete_resource("user-permissions", userPermissionId) def get_user_permissions(self, **params: te.Unpack[GetKwargs]) -> list[UserPermission]: return self._get_all_resources( @@ -600,22 +598,20 @@ def find_user_permissions(self, **params: te.Unpack[FindAllKwargs]) -> list[User **params, ) - def create_user_role(self, user_id: User | uuid.UUID | str, role_id: Role | uuid.UUID | str) -> UserRole: + def create_user_role(self, userId: User | uuid.UUID | str, roleId: Role | uuid.UUID | str) -> UserRole: return self._create_resource( UserRole, - CreateUserRole(user_id=user_id, role_id=role_id), + CreateUserRole(userId=userId, roleId=roleId), "user-roles", ) - def get_user_role( - self, user_role_id: UserRole | uuid.UUID | str, **params: te.Unpack[GetKwargs] - ) -> UserRole | None: + def get_user_role(self, userRoleId: UserRole | uuid.UUID | str, **params: te.Unpack[GetKwargs]) -> UserRole | None: return self._get_single_resource( - UserRole, "user-roles", user_role_id, include=get_includable_names(UserRole), **params + UserRole, "user-roles", userRoleId, include=get_includable_names(UserRole), **params ) - def delete_user_role(self, user_role_id: UserRole | uuid.UUID | str): - self._delete_resource("user-roles", user_role_id) + def delete_user_role(self, userRoleId: UserRole | uuid.UUID | str): + self._delete_resource("user-roles", userRoleId) def get_user_roles(self, **params: te.Unpack[GetKwargs]) -> list[UserRole]: return self._get_all_resources(UserRole, "user-roles", include=get_includable_names(UserRole), **params) @@ -624,27 +620,27 @@ def find_user_roles(self, **params: te.Unpack[FindAllKwargs]) -> list[UserRole]: return self._find_all_resources(UserRole, "user-roles", include=get_includable_names(UserRole), **params) def create_robot_permission( - self, robot_id: Robot | uuid.UUID | str, permission_id: Permission | uuid.UUID | str + self, robotId: Robot | uuid.UUID | str, permissionId: Permission | uuid.UUID | str ) -> RobotPermission: return self._create_resource( RobotPermission, - CreateRobotPermission(robot_id=robot_id, permission_id=permission_id), + CreateRobotPermission(robotId=robotId, permissionId=permissionId), "robot-permissions", ) def get_robot_permission( - self, robot_permission_id: RobotPermission | uuid.UUID | str, **params: te.Unpack[GetKwargs] + self, robotPermissionId: RobotPermission | uuid.UUID | str, **params: te.Unpack[GetKwargs] ) -> RobotPermission | None: return self._get_single_resource( RobotPermission, "robot-permissions", - robot_permission_id, + robotPermissionId, include=get_includable_names(RobotPermission), **params, ) - def delete_robot_permission(self, robot_permission_id: RobotPermission | uuid.UUID | str): - self._delete_resource("robot-permissions", robot_permission_id) + def delete_robot_permission(self, robotPermissionId: RobotPermission | uuid.UUID | str): + self._delete_resource("robot-permissions", robotPermissionId) def get_robot_permissions(self, **params: te.Unpack[GetKwargs]) -> list[RobotPermission]: return self._get_all_resources( @@ -662,22 +658,22 @@ def find_robot_permissions(self, **params: te.Unpack[FindAllKwargs]) -> list[Rob **params, ) - def create_robot_role(self, robot_id: Robot | uuid.UUID | str, role_id: Role | uuid.UUID | str) -> RobotRole: + def create_robot_role(self, robotId: Robot | uuid.UUID | str, roleId: Role | uuid.UUID | str) -> RobotRole: return self._create_resource( RobotRole, - CreateRobotRole(robot_id=robot_id, role_id=role_id), + CreateRobotRole(robotId=robotId, roleId=roleId), "robot-roles", ) def get_robot_role( - self, robot_role_id: RobotRole | uuid.UUID | str, **params: te.Unpack[GetKwargs] + self, robotRoleId: RobotRole | uuid.UUID | str, **params: te.Unpack[GetKwargs] ) -> RobotRole | None: return self._get_single_resource( - RobotRole, "robot-roles", robot_role_id, include=get_includable_names(RobotRole), **params + RobotRole, "robot-roles", robotRoleId, include=get_includable_names(RobotRole), **params ) - def delete_robot_role(self, robot_role_id: RobotRole | uuid.UUID | str): - self._delete_resource("robot-roles", robot_role_id) + def delete_robot_role(self, robotRoleId: RobotRole | uuid.UUID | str): + self._delete_resource("robot-roles", robotRoleId) def get_robot_roles(self, **params: te.Unpack[GetKwargs]) -> list[RobotRole]: return self._get_all_resources(RobotRole, "robot-roles", include=get_includable_names(RobotRole), **params) @@ -688,38 +684,38 @@ def find_robot_roles(self, **params: te.Unpack[FindAllKwargs]) -> list[RobotRole def create_client( self, name: str, - realm_id: Realm | str | uuid.UUID, + realmId: Realm | str | uuid.UUID, secret: str = None, - display_name: str = None, + displayName: str = None, description: str = None, - redirect_uri: str = None, + redirectUri: str = None, active: bool = True, - is_confidential: bool = True, - secret_hashed: bool = False, - grant_types: str = None, + isConfidential: bool = True, + secretHashed: bool = False, + grantTypes: str = None, ) -> Client: return self._create_resource( Client, CreateClient( name=name, - realm_id=realm_id, + realmId=realmId, secret=secret, - display_name=display_name, + displayName=displayName, description=description, - redirect_uri=redirect_uri, + redirectUri=redirectUri, active=active, - is_confidential=is_confidential, - secret_hashed=secret_hashed, - grant_types=grant_types, + isConfidential=isConfidential, + secretHashed=secretHashed, + grantTypes=grantTypes, ), "clients", ) - def delete_client(self, client_id: Client | uuid.UUID | str): - self._delete_resource("clients", client_id) + def delete_client(self, clientId: Client | uuid.UUID | str): + self._delete_resource("clients", clientId) - def get_client(self, client_id: Client | uuid.UUID | str, **params: te.Unpack[GetKwargs]) -> Client | None: - return self._get_single_resource(Client, "clients", client_id, include=get_includable_names(Client), **params) + def get_client(self, clientId: Client | uuid.UUID | str, **params: te.Unpack[GetKwargs]) -> Client | None: + return self._get_single_resource(Client, "clients", clientId, include=get_includable_names(Client), **params) def get_clients(self, **params: te.Unpack[GetKwargs]) -> list[Client]: return self._get_all_resources(Client, "clients", include=get_includable_names(Client), **params) @@ -729,30 +725,30 @@ def find_clients(self, **params: te.Unpack[FindAllKwargs]) -> list[Client]: def update_client( self, - client_id: Client | uuid.UUID | str, + clientId: Client | uuid.UUID | str, name: str | UNSET_T = UNSET, secret: str | None | UNSET_T = UNSET, - display_name: str | None | UNSET_T = UNSET, + displayName: str | None | UNSET_T = UNSET, description: str | None | UNSET_T = UNSET, - redirect_uri: str | None | UNSET_T = UNSET, + redirectUri: str | None | UNSET_T = UNSET, active: bool | UNSET_T = UNSET, - is_confidential: bool | UNSET_T = UNSET, - secret_hashed: bool | UNSET_T = UNSET, - grant_types: str | None | UNSET_T = UNSET, + isConfidential: bool | UNSET_T = UNSET, + secretHashed: bool | UNSET_T = UNSET, + grantTypes: str | None | UNSET_T = UNSET, ) -> Client: return self._update_resource( Client, UpdateClient( name=name, secret=secret, - display_name=display_name, + displayName=displayName, description=description, - redirect_uri=redirect_uri, + redirectUri=redirectUri, active=active, - is_confidential=is_confidential, - secret_hashed=secret_hashed, - grant_types=grant_types, + isConfidential=isConfidential, + secretHashed=secretHashed, + grantTypes=grantTypes, ), "clients", - client_id, + clientId, ) diff --git a/tests/test_auth.py b/tests/test_auth.py index 6ddfbdf..3cfb59c 100644 --- a/tests/test_auth.py +++ b/tests/test_auth.py @@ -140,9 +140,9 @@ def robot_role_includables(): @pytest.fixture() def client(auth_client, master_realm): - new_client = auth_client.create_client(name=next_random_string().lower(), realm_id=master_realm) + new_client = auth_client.create_client(name=next_random_string().lower(), realmId=master_realm) yield new_client - auth_client.delete_client(client_id=new_client) + auth_client.delete_client(clientId=new_client) @pytest.fixture(scope="session") @@ -302,8 +302,8 @@ def test_get_role_permissions(auth_client, role_permission, role_permission_incl @pytest.mark.xfail(reason="bug in authup") def test_find_role_permissions(auth_client, role_permission, role_permission_includables): - # Use "role_id" for filtering because there is no filter mechanism for attribute "id". - role_perms_find = auth_client.find_role_permissions(filter={"role_id": role_permission.role_id}) + # Use "roleId" for filtering because there is no filter mechanism for attribute "id". + role_perms_find = auth_client.find_role_permissions(filter={"roleId": role_permission.roleId}) assert [role_permission.id] == [rp.id for rp in role_perms_find] assert all( @@ -369,8 +369,8 @@ def test_get_user_permissions(auth_client, user_permission, user_permission_incl @pytest.mark.xfail(reason="bug in authup") def test_find_user_permissions(auth_client, user_permission, user_permission_includables): - # Use "user_id" for filtering because there is no filter mechanism for attribute "id". - user_perms_find = auth_client.find_user_permissions(filter={"user_id": user_permission.user_id}) + # Use "userId" for filtering because there is no filter mechanism for attribute "id". + user_perms_find = auth_client.find_user_permissions(filter={"userId": user_permission.userId}) assert len(user_perms_find) > 0 assert all( @@ -400,8 +400,8 @@ def test_get_user_roles(auth_client, user_role, user_role_includables): @pytest.mark.xfail(reason="bug in authup") def test_find_user_roles(auth_client, user_role, user_role_includables): - # Use "user_id" for filtering because there is no filter mechanism for attribute "id". - user_roles_find = auth_client.find_user_roles(filter={"user_id": user_role.user_id}) + # Use "userId" for filtering because there is no filter mechanism for attribute "id". + user_roles_find = auth_client.find_user_roles(filter={"userId": user_role.userId}) assert len(user_roles_find) > 0 assert all(includable in ur.model_fields_set for ur in user_roles_find for includable in user_role_includables) @@ -431,8 +431,8 @@ def test_get_robot_permissions(auth_client, robot_permission, robot_permission_i @pytest.mark.xfail(reason="bug in authup") def test_find_robot_permissions(auth_client, robot_permission, robot_permission_includables): - # Use "robot_id" for filtering because there is no filter mechanism for attribute "id". - robot_perms_find = auth_client.find_robot_permissions(filter={"robot_id": robot_permission.robot_id}) + # Use "robotId" for filtering because there is no filter mechanism for attribute "id". + robot_perms_find = auth_client.find_robot_permissions(filter={"robotId": robot_permission.robotId}) assert [robot_permission.id] == [rp.id for rp in robot_perms_find] assert all( @@ -462,22 +462,22 @@ def test_get_robot_roles(auth_client, robot_role, robot_role_includables): @pytest.mark.xfail(reason="bug in authup, see https://github.com/authup/authup/issues/2649") def test_find_robot_roles(auth_client, robot_role, robot_role_includables): - # Use "robot_id" for filtering because there is no filter mechanism for attribute "id". - robot_roles_find = auth_client.find_robot_roles(filter={"robot_id": robot_role.robot_id}) + # Use "robotId" for filtering because there is no filter mechanism for attribute "id". + robot_roles_find = auth_client.find_robot_roles(filter={"robotId": robot_role.robotId}) assert [robot_role.id] == [rr.id for rr in robot_roles_find] assert all(includable in rr.model_fields_set for rr in robot_roles_find for includable in robot_role_includables) def test_get_client(auth_client, client, client_includables): - client_get = auth_client.get_client(client_id=client) + client_get = auth_client.get_client(clientId=client) assert client_get.id == client.id assert all(includable in client_get.model_fields_set for includable in client_includables) def test_get_client_not_found(auth_client): - assert auth_client.get_client(client_id=next_uuid()) is None + assert auth_client.get_client(clientId=next_uuid()) is None def test_get_clients(auth_client, client, client_includables): @@ -497,7 +497,7 @@ def test_find_clients(auth_client, client, client_includables): def test_update_client(auth_client, client): new_name = next_random_string().lower() - new_client = auth_client.update_client(client_id=client, name=new_name) + new_client = auth_client.update_client(clientId=client, name=new_name) assert client != new_client assert new_client.name == new_name diff --git a/tests/test_flow.py b/tests/test_flow.py index 0aa9e26..7e7b48a 100644 --- a/tests/test_flow.py +++ b/tests/test_flow.py @@ -52,7 +52,7 @@ def test_robot_auth(auth_client, auth_base_url, master_realm): def test_client_auth(auth_client, auth_base_url, master_realm): client_secret = next_random_string(length=64) - client_resource = auth_client.create_client(name=next_random_string(), realm_id=master_realm, secret=client_secret) + client_resource = auth_client.create_client(name=next_random_string(), realmId=master_realm, secret=client_secret) client_id = str(client_resource.id) client_auth = ClientAuth(