text: # Copyright (c) 2021 AccelByte Inc. All Rights Reserved.
  # This is licensed software from AccelByte Inc, for limitations
  # and restrictions contact your company contract manager.
  # 
  # Code generated. DO NOT EDIT!
  
  # template file: justice_py_sdk_codegen/__main__.py
  
  # pylint: disable=duplicate-code
  # pylint: disable=line-too-long
  # pylint: disable=missing-function-docstring
  # pylint: disable=missing-function-docstring
  # pylint: disable=missing-module-docstring
  # pylint: disable=too-many-arguments
  # pylint: disable=too-many-branches
  # pylint: disable=too-many-instance-attributes
  # pylint: disable=too-many-lines
  # pylint: disable=too-many-locals
  # pylint: disable=too-many-public-methods
  # pylint: disable=too-many-return-statements
  # pylint: disable=too-many-statements
  # pylint: disable=unused-import
  
  from typing import Any, Dict, List, Optional, Tuple, Union
  
  from ....core import HeaderStr
  from ....core import get_namespace as get_services_namespace
  from ....core import run_request
  from ....core import run_request_async
  from ....core import same_doc_as
  
  from ..models import BulkOperationResult
  from ..models import ErrorEntity
  from ..models import KeyGroupCreate
  from ..models import KeyGroupDynamicInfo
  from ..models import KeyGroupInfo
  from ..models import KeyGroupPagingSlicedResult
  from ..models import KeyGroupUpdate
  from ..models import KeyPagingSliceResult
  from ..models import ValidationErrorEntity
  
  from ..operations.key_group import CreateKeyGroup
  from ..operations.key_group import GetKeyGroup
  from ..operations.key_group import GetKeyGroupDynamic
  from ..operations.key_group import ListKeys
  from ..operations.key_group import ListKeysStatusEnum
  from ..operations.key_group import QueryKeyGroups
  from ..operations.key_group import UpdateKeyGroup
  from ..operations.key_group import UploadKeys
  from ..models import KeyGroupCreateStatusEnum
  from ..models import KeyGroupInfoStatusEnum
  from ..models import KeyGroupUpdateStatusEnum
  
  
  @same_doc_as(CreateKeyGroup)
  def create_key_group(body: Optional[KeyGroupCreate] = None, namespace: Optional[str] = None, x_additional_headers: Optional[Dict[str, str]] = None, **kwargs):
      if namespace is None:
          namespace, error = get_services_namespace()
          if error:
              return None, error
      request = CreateKeyGroup.create(
          body=body,
          namespace=namespace,
      )
      return run_request(request, additional_headers=x_additional_headers, **kwargs)
  
  
  @same_doc_as(CreateKeyGroup)
  async def create_key_group_async(body: Optional[KeyGroupCreate] = None, namespace: Optional[str] = None, x_additional_headers: Optional[Dict[str, str]] = None, **kwargs):
      if namespace is None:
          namespace, error = get_services_namespace()
          if error:
              return None, error
      request = CreateKeyGroup.create(
          body=body,
          namespace=namespace,
      )
      return await run_request_async(request, additional_headers=x_additional_headers, **kwargs)
  
  
  @same_doc_as(GetKeyGroup)
  def get_key_group(key_group_id: str, namespace: Optional[str] = None, x_additional_headers: Optional[Dict[str, str]] = None, **kwargs):
      if namespace is None:
          namespace, error = get_services_namespace()
          if error:
              return None, error
      request = GetKeyGroup.create(
          key_group_id=key_group_id,
          namespace=namespace,
      )
      return run_request(request, additional_headers=x_additional_headers, **kwargs)
  
  
  @same_doc_as(GetKeyGroup)
  async def get_key_group_async(key_group_id: str, namespace: Optional[str] = None, x_additional_headers: Optional[Dict[str, str]] = None, **kwargs):
      if namespace is None:
          namespace, error = get_services_namespace()
          if error:
              return None, error
      request = GetKeyGroup.create(
          key_group_id=key_group_id,
          namespace=namespace,
      )
      return await run_request_async(request, additional_headers=x_additional_headers, **kwargs)
  
  
  @same_doc_as(GetKeyGroupDynamic)
  def get_key_group_dynamic(key_group_id: str, namespace: Optional[str] = None, x_additional_headers: Optional[Dict[str, str]] = None, **kwargs):
      if namespace is None:
          namespace, error = get_services_namespace()
          if error:
              return None, error
      request = GetKeyGroupDynamic.create(
          key_group_id=key_group_id,
          namespace=namespace,
      )
      return run_request(request, additional_headers=x_additional_headers, **kwargs)
  
  
  @same_doc_as(GetKeyGroupDynamic)
  async def get_key_group_dynamic_async(key_group_id: str, namespace: Optional[str] = None, x_additional_headers: Optional[Dict[str, str]] = None, **kwargs):
      if namespace is None:
          namespace, error = get_services_namespace()
          if error:
              return None, error
      request = GetKeyGroupDynamic.create(
          key_group_id=key_group_id,
          namespace=namespace,
      )
      return await run_request_async(request, additional_headers=x_additional_headers, **kwargs)
  
  
  @same_doc_as(ListKeys)
  def list_keys(key_group_id: str, limit: Optional[int] = None, offset: Optional[int] = None, status: Optional[Union[str, ListKeysStatusEnum]] = None, namespace: Optional[str] = None, x_additional_headers: Optional[Dict[str, str]] = None, **kwargs):
      if namespace is None:
          namespace, error = get_services_namespace()
          if error:
              return None, error
      request = ListKeys.create(
          key_group_id=key_group_id,
          limit=limit,
          offset=offset,
          status=status,
          namespace=namespace,
      )
      return run_request(request, additional_headers=x_additional_headers, **kwargs)
  
  
  @same_doc_as(ListKeys)
  async def list_keys_async(key_group_id: str, limit: Optional[int] = None, offset: Optional[int] = None, status: Optional[Union[str, ListKeysStatusEnum]] = None, namespace: Optional[str] = None, x_additional_headers: Optional[Dict[str, str]] = None, **kwargs):
      if namespace is None:
          namespace, error = get_services_namespace()
          if error:
              return None, error
      request = ListKeys.create(
          key_group_id=key_group_id,
          limit=limit,
          offset=offset,
          status=status,
          namespace=namespace,
      )
      return await run_request_async(request, additional_headers=x_additional_headers, **kwargs)
  
  
  @same_doc_as(QueryKeyGroups)
  def query_key_groups(limit: Optional[int] = None, name: Optional[str] = None, offset: Optional[int] = None, tag: Optional[str] = None, namespace: Optional[str] = None, x_additional_headers: Optional[Dict[str, str]] = None, **kwargs):
      if namespace is None:
          namespace, error = get_services_namespace()
          if error:
              return None, error
      request = QueryKeyGroups.create(
          limit=limit,
          name=name,
          offset=offset,
          tag=tag,
          namespace=namespace,
      )
      return run_request(request, additional_headers=x_additional_headers, **kwargs)
  
  
  @same_doc_as(QueryKeyGroups)
  async def query_key_groups_async(limit: Optional[int] = None, name: Optional[str] = None, offset: Optional[int] = None, tag: Optional[str] = None, namespace: Optional[str] = None, x_additional_headers: Optional[Dict[str, str]] = None, **kwargs):
      if namespace is None:
          namespace, error = get_services_namespace()
          if error:
              return None, error
      request = QueryKeyGroups.create(
          limit=limit,
          name=name,
          offset=offset,
          tag=tag,
          namespace=namespace,
      )
      return await run_request_async(request, additional_headers=x_additional_headers, **kwargs)
  
  
  @same_doc_as(UpdateKeyGroup)
  def update_key_group(key_group_id: str, body: Optional[KeyGroupUpdate] = None, namespace: Optional[str] = None, x_additional_headers: Optional[Dict[str, str]] = None, **kwargs):
      if namespace is None:
          namespace, error = get_services_namespace()
          if error:
              return None, error
      request = UpdateKeyGroup.create(
          key_group_id=key_group_id,
          body=body,
          namespace=namespace,
      )
      return run_request(request, additional_headers=x_additional_headers, **kwargs)
  
  
  @same_doc_as(UpdateKeyGroup)
  async def update_key_group_async(key_group_id: str, body: Optional[KeyGroupUpdate] = None, namespace: Optional[str] = None, x_additional_headers: Optional[Dict[str, str]] = None, **kwargs):
      if namespace is None:
          namespace, error = get_services_namespace()
          if error:
              return None, error
      request = UpdateKeyGroup.create(
          key_group_id=key_group_id,
          body=body,
          namespace=namespace,
      )
      return await run_request_async(request, additional_headers=x_additional_headers, **kwargs)
  
  
  @same_doc_as(UploadKeys)
  def upload_keys(key_group_id: str, file: Optional[Any] = None, namespace: Optional[str] = None, x_additional_headers: Optional[Dict[str, str]] = None, **kwargs):
      if namespace is None:
          namespace, error = get_services_namespace()
          if error:
              return None, error
      request = UploadKeys.create(
          key_group_id=key_group_id,
          file=file,
          namespace=namespace,
      )
      return run_request(request, additional_headers=x_additional_headers, **kwargs)
  
  
  @same_doc_as(UploadKeys)
  async def upload_keys_async(key_group_id: str, file: Optional[Any] = None, namespace: Optional[str] = None, x_additional_headers: Optional[Dict[str, str]] = None, **kwargs):
      if namespace is None:
          namespace, error = get_services_namespace()
          if error:
              return None, error
      request = UploadKeys.create(
          key_group_id=key_group_id,
          file=file,
          namespace=namespace,
      )
      return await run_request_async(request, additional_headers=x_additional_headers, **kwargs)
  