Orkes Clients SDK methods

docs/authorization/README.md

@@ -21,71 +21,80 @@ authorization_client = OrkesAuthorizationClient(configuration)
 
 #### Creating Application
 Creates an application and returns a ConductorApplication object.
+
 ```python
 from conductor.client.http.models.create_or_update_application_request import CreateOrUpdateApplicationRequest
 from conductor.client.http.models.conductor_application import ConductorApplication
 
 request = CreateOrUpdateApplicationRequest("APPLICATION_NAME")
-app = authorization_client.createApplication(request)
+app = authorization_client.create_application(request)
 application_id = app.id
 ```
 
 #### Get Application
+
 ```python
-app = authorization_client.getApplication(application_id)
+app = authorization_client.get_application(application_id)
 ```
 
 #### List All Applications
+
 ```python
-apps = authorization_client.listApplications()
+apps = authorization_client.list_applications()
 ```
 
 #### Update Application
 Updates an application and returns a ConductorApplication object.
 
 ```python
 request = CreateOrUpdateApplicationRequest("APPLICATION_NAME")
-updated_app = authorization_client.updateApplication(request, application_id)
+updated_app = authorization_client.update_application(request, application_id)
 ```
 
 #### Delete Application
+
 ```python
-authorization_client.deleteApplication(application_id)
+authorization_client.delete_application(application_id)
 ```
 
 #### Add a role for an Application user
 Add one of the roles out of ["USER", "ADMIN", "METADATA_MANAGER", "WORKFLOW_MANAGER", "USER_READ_ONLY"]
 to an application user.
+
 ```python
-authorization_client.addRoleToApplicationUser(application_id, "USER")
+authorization_client.add_role_to_application_user(application_id, "USER")
 ```
 
 #### Remove a role assigned to an Application user
+
 ```python
-authorization_client.removeRoleFromApplicationUser(application_id, "USER")
+authorization_client.remove_role_from_application_user(application_id, "USER")
 ```
 
 #### Set Application tags
+
 ```python
 from conductor.client.orkes.models.metadata_tag import MetadataTag
 
 tags = [
     MetadataTag("auth_tag", "val"), MetadataTag("auth_tag_2", "val2")
 ]
-authorization_client.getApplicationTags(tags, application_id)
+authorization_client.get_application_tags(tags, application_id)
 ```
 
 #### Get Application tags
+
 ```python
-tags = authorization_client.getApplicationTags(application_id)
+tags = authorization_client.get_application_tags(application_id)
 ```
 
 #### Delete Application tags
+
 ```python
 tags = [
     MetadataTag("auth_tag", "val"), MetadataTag("auth_tag_2", "val2")
 ]
-authorization_client.deleteApplicationTags(tags, application_id)
+authorization_client.delete_application_tags(tags, application_id)
 ```
 
 ### Access Key Management
@@ -94,10 +103,11 @@ authorization_client.deleteApplicationTags(tags, application_id)
 Creates an access key for the specified application and returns a CreatedAccessKey object.
 The SECRET for this access key is available in the returned object. This is the only time
 when the secret for this newly created access key can be retrieved and saved.
+
 ```python
 from conductor.client.orkes.models.created_access_key import CreatedAccessKey
 
-created_access_key = authorization_client.createAccessKey(application_id)
+created_access_key = authorization_client.create_access_key(application_id)
 ```
 
 #### Get Access Key
@@ -106,24 +116,27 @@ Retrieves all access keys for the specified application as List[AccessKey].
 ```python
 from conductor.client.orkes.models.access_key import AccessKey
 
-access_keys = authorization_client.getAccessKeys(application_id)
+access_keys = authorization_client.get_access_keys(application_id)
 ```
 
 #### Enabling / Disabling Access Key
 Toggle access key status between ACTIVE and INACTIVE.
+
 ```python
- access_key = authorization_client.toggleAccessKeyStatus(application_id, created_access_key.id)
+ access_key = authorization_client.toggle_access_key_status(application_id, created_access_key.id)
 ```
 
 #### Delete Acccess Key
+
 ```python
-authorization_client.deleteAccessKey(application_id, created_access_key.id)
+authorization_client.delete_access_key(application_id, created_access_key.id)
 ```
 
 ### User Management
 
 #### Create or Update User
 Creates or updates a user and returns a ConductorUser object.
+
 ```python
 from conductor.client.http.models.upsert_user_request import UpsertUserRequest
 from conductor.client.http.models.conductor_user import ConductorUser
@@ -132,28 +145,32 @@ user_id = 'test.user@company.com'
 user_name = "Test User"
 roles = ["USER"]
 req = UpsertUserRequest(user_name, roles)
-user = authorization_client.upsertUser(req, user_id)
+user = authorization_client.upsert_user(req, user_id)
 ```
 
 #### Get User
+
 ```python
-user = authorization_client.getUser(user_id)
+user = authorization_client.get_user(user_id)
 ```
 
 #### List All Users
+
 ```python
-users = authorization_client.listUsers()
+users = authorization_client.list_users()
 ```
 
 #### Delete User
+
 ```python
-authorization_client.deleteUser(user_id)
+authorization_client.delete_user(user_id)
 ```
 
 ### Group Management
 
 #### Create or Update a Group
 Creates or updates a user group and returns a Group object.
+
 ```python
 from conductor.client.http.models.upsert_group_request import UpsertGroupRequest
 from conductor.client.http.models.group import Group
@@ -162,45 +179,52 @@ group_id = 'test_group'
 group_name = "Test Group"
 group_user_roles = ["USER"]
 req = UpsertGroupRequest("Integration Test Group", group_user_roles)
-group = authorization_client.upsertGroup(req, group_id)
+group = authorization_client.upsert_group(req, group_id)
 ```
 
 #### Get Group
+
 ```python
-group = authorization_client.getGroup(group_id)
+group = authorization_client.get_group(group_id)
 ```
 
 #### List All Groups
 Retrives all groups as a List[Group]
+
 ```python
-users = authorization_client.listGroups()
+users = authorization_client.list_groups()
 ```
 
 #### Delete Group
+
 ```python
-authorization_client.deleteGroup(group_id)
+authorization_client.delete_group(group_id)
 ```
 
 #### Add users to a Group
+
 ```python
- authorization_client.addUserToGroup(group_id, user_id)
+ authorization_client.add_user_to_group(group_id, user_id)
 ```
 
 #### Get all users in a Group
 Retrives all users in a group as List[ConductorUser]
+
 ```python
-users = self.authorization_client.getUsersInGroup(group_id)
+users = self.authorization_client.get_users_in_group(group_id)
 ```
 
 #### Remove users from a group
+
 ```python
-authorization_client.removeUserFromGroup(group_id, user_id)
+authorization_client.remove_user_from_group(group_id, user_id)
 ```
 
 ### Permission Management
 
 #### Grant Permissions
 Grants a set of accesses to the specified Subject for a given Target.
+
 ```python
 from conductor.client.http.models.target_ref import TargetRef, TargetType
 from conductor.client.http.models.subject_ref import SubjectRef, SubjectType
@@ -213,34 +237,37 @@ access_group = [AccessType.EXECUTE]
 subject_user = SubjectRef(SubjectType.USER, user_id)
 access_user = [AccessType.EXECUTE, AccessType.READ]
 
-authorization_client.grantPermissions(subject_group, target, access_group)
-authorization_client.grantPermissions(subject_user, target, access_user)
+authorization_client.grant_permissions(subject_group, target, access_group)
+authorization_client.grant_permissions(subject_user, target, access_user)
 ```
 
 #### Get Permissions for a Target
 Given the target, returns all permissions associated with it as a Dict[str, List[SubjectRef]].
 In the returned dictionary, key is AccessType and value is a list of subjects.
+
 ```python
 from conductor.client.http.models.target_ref import TargetRef, TargetType
 
 target = TargetRef(TargetType.WORKFLOW_DEF, WORKFLOW_NAME)
-target_permissions = authorization_client.getPermissions(target)
+target_permissions = authorization_client.get_permissions(target)
 ```
 
 #### Get Permissions granted to a Group
 Given a group id, returns all the permissions granted to a group as List[GrantedPermission].
+
 ```python
 from conductor.client.orkes.models.granted_permission import GrantedPermission
 
-group_permissions = authorization_client.getGrantedPermissionsForGroup(group_id)
+group_permissions = authorization_client.get_granted_permissions_for_group(group_id)
 ```
 
 #### Get Permissions granted to a User
 Given a user id, returns all the permissions granted to a user as List[GrantedPermission].
+
 ```python
 from conductor.client.orkes.models.granted_permission import GrantedPermission
 
-user_permissions = authorization_client.getGrantedPermissionsForUser(user_id)
+user_permissions = authorization_client.get_granted_permissions_for_user(user_id)
 ```
 
 #### Remove Permissions
@@ -258,6 +285,6 @@ access_group = [AccessType.EXECUTE]
 subject_user = SubjectRef(SubjectType.USER, user_id)
 access_user = [AccessType.EXECUTE, AccessType.READ]
 
-authorization_client.removePermissions(subject_group, target, access_group)
-authorization_client.removePermissions(subject_user, target, access_user)
+authorization_client.remove_permissions(subject_group, target, access_group)
+authorization_client.remove_permissions(subject_user, target, access_user)
 ```

docs/exceptions/README.md

@@ -30,13 +30,13 @@ config = Configuration(server_api_url=SERVER_API_URL, authentication_settings=au
 metadata_client = OrkesMetadataClient(config)
 
 try:
-    metadata_client.getWorkflowDef(WORKFLOW_NAME, 1)
+    metadata_client.get_workflow_def(WORKFLOW_NAME, 1)
 except APIError as e:
     if e.code == APIErrorCode.NOT_FOUND:
         print(f"Error finding {WORKFLOW_NAME}: {e.message}")
     elif e.code == APIErrorCode.FORBIDDEN:
         print(f"Error accessing {WORKFLOW_NAME}: {e.message}")
     else:
         print(f"Error fetching {WORKFLOW_NAME}: {e.message}")
-    
+
 ```

docs/metadata/README.md

@@ -60,15 +60,15 @@ You should be able to register your workflow at the Conductor Server:
 from conductor.client.http.models.workflow_def import WorkflowDef
 
 workflowDef = workflow.to_workflow_def()
-metadata_client.registerWorkflowDef(workflowDef, True)
+metadata_client.register_workflow_def(workflowDef, True)
 ```
 
 ### Get Workflow Definition
 
 You should be able to get your workflow definiton that you added previously:
 
 ```python
-wfDef = metadata_client.getWorkflowDef('python_workflow_example_from_code')
+wfDef = metadata_client.get_workflow_def('python_workflow_example_from_code')
 ```
 
 In case there is an error in fetching the definition, errorStr will be populated.
@@ -80,15 +80,15 @@ You should be able to update your workflow after adding new tasks:
 ```python
 workflow >> SimpleTask("simple_task", "simple_task_ref_2")
 updatedWorkflowDef = workflow.to_workflow_def()
-metadata_client.updateWorkflowDef(updatedWorkflowDef, True)
+metadata_client.update_workflow_def(updatedWorkflowDef, True)
 ```
 
 ### Unregister Workflow Definition
 
 You should be able to unregister your workflow by passing name and version:
 
 ```python
-metadata_client.unregisterWorkflowDef('python_workflow_example_from_code', 1)
+metadata_client.unregister_workflow_def('python_workflow_example_from_code', 1)
 ```
 
 ## Task Definition Management
@@ -101,19 +101,19 @@ You should be able to register your task at the Conductor Server:
 from conductor.client.http.models.task_def import TaskDef
 
 taskDef = TaskDef(
-    name= "PYTHON_TASK",
+    name="PYTHON_TASK",
     description="Python Task Example",
     input_keys=["a", "b"]
 )
-metadata_client.registerTaskDef(taskDef)
+metadata_client.register_task_def(taskDef)
 ```
 
 ### Get Task Definition
 
 You should be able to get your task definiton that you added previously:
 
 ```python
-taskDef = metadata_client.getTaskDef('PYTHON_TASK')
+taskDef = metadata_client.get_task_def('PYTHON_TASK')
 ```
 
 ### Update Task Definition
@@ -123,15 +123,15 @@ You should be able to update your task definition by modifying field values:
 ```python
 taskDef.description = "Python Task Example New Description"
 taskDef.input_keys = ["a", "b", "c"]
-metadata_client.updateTaskDef(taskDef)
+metadata_client.update_task_def(taskDef)
 ```
 
 ### Unregister Task Definition
 
 You should be able to unregister your task at the Conductor Server:
 
 ```python
-metadata_client.unregisterTaskDef('python_task_example_from_code')
+metadata_client.unregister_task_def('python_task_example_from_code')
 ```
 
 ## Tag Management