deepgram.clients.manage.v1.async_client

   1# Copyright 2023-2024 Deepgram SDK contributors. All Rights Reserved.
   2# Use of this source code is governed by a MIT license that can be found in the LICENSE file.
   3# SPDX-License-Identifier: MIT
   4
   5import logging
   6from typing import Dict, Union, Optional
   7import json
   8
   9import httpx
  10
  11from ....utils import verboselogs
  12from ....options import DeepgramClientOptions
  13from ...common import AbstractAsyncRestClient, DeepgramError
  14
  15from .response import (
  16    Message,
  17    Project,
  18    ProjectsResponse,
  19    MembersResponse,
  20    Key,
  21    KeyResponse,
  22    KeysResponse,
  23    ScopesResponse,
  24    InvitesResponse,
  25    UsageRequest,
  26    UsageRequestsResponse,
  27    UsageSummaryResponse,
  28    UsageFieldsResponse,
  29    Balance,
  30    BalancesResponse,
  31    ModelResponse,
  32    ModelsResponse,
  33)
  34from .options import (
  35    ProjectOptions,
  36    ModelOptions,
  37    KeyOptions,
  38    ScopeOptions,
  39    InviteOptions,
  40    UsageRequestOptions,
  41    UsageSummaryOptions,
  42    UsageFieldsOptions,
  43)
  44
  45
  46class AsyncManageClient(
  47    AbstractAsyncRestClient
  48):  # pylint: disable=too-many-public-methods,too-many-lines
  49    """
  50    A client for managing Deepgram projects and associated resources via the Deepgram API.
  51
  52    This class provides methods for performing various operations on Deepgram projects, including:
  53    - Retrieving project details
  54    - Updating project settings
  55    - Managing project members and scopes
  56    - Handling project invitations
  57    - Monitoring project usage and balances
  58
  59    Args:
  60        config (DeepgramClientOptions): all the options for the client.
  61    """
  62
  63    _logger: verboselogs.VerboseLogger
  64    _config: DeepgramClientOptions
  65    _endpoint: str
  66
  67    def __init__(self, config: DeepgramClientOptions):
  68        self._logger = verboselogs.VerboseLogger(__name__)
  69        self._logger.addHandler(logging.StreamHandler())
  70        self._logger.setLevel(config.verbose)
  71        self._config = config
  72        self._endpoint = "v1/projects"
  73        super().__init__(config)
  74
  75    # pylint: disable=too-many-positional-arguments
  76
  77    # projects
  78    async def list_projects(
  79        self,
  80        timeout: Optional[httpx.Timeout] = None,
  81        addons: Optional[Dict] = None,
  82        headers: Optional[Dict] = None,
  83        **kwargs,
  84    ) -> ProjectsResponse:
  85        """
  86        Please see get_projects for more information.
  87        """
  88        return await self.get_projects(
  89            timeout=timeout, addons=addons, headers=headers, **kwargs
  90        )
  91
  92    async def get_projects(
  93        self,
  94        timeout: Optional[httpx.Timeout] = None,
  95        addons: Optional[Dict] = None,
  96        headers: Optional[Dict] = None,
  97        **kwargs,
  98    ) -> ProjectsResponse:
  99        """
 100        Gets a list of projects for the authenticated user.
 101
 102        Reference:
 103        https://developers.deepgram.com/reference/get-projects
 104        """
 105        self._logger.debug("ManageClient.get_projects ENTER")
 106        url = f"{self._config.url}/{self._endpoint}"
 107        self._logger.info("url: %s", url)
 108        self._logger.info("addons: %s", addons)
 109        self._logger.info("headers: %s", headers)
 110        result = await self.get(
 111            url, timeout=timeout, addons=addons, headers=headers, **kwargs
 112        )
 113        self._logger.info("result: %s", result)
 114        res = ProjectsResponse.from_json(result)
 115        self._logger.verbose("result: %s", res)
 116        self._logger.notice("get_projects succeeded")
 117        self._logger.debug("ManageClient.get_projects LEAVE")
 118        return res
 119
 120    async def get_project(
 121        self,
 122        project_id: str,
 123        timeout: Optional[httpx.Timeout] = None,
 124        addons: Optional[Dict] = None,
 125        headers: Optional[Dict] = None,
 126        **kwargs,
 127    ) -> Project:
 128        """
 129        Gets details for a specific project.
 130
 131        Reference:
 132        https://developers.deepgram.com/reference/get-project
 133        """
 134        self._logger.debug("ManageClient.get_project ENTER")
 135        url = f"{self._config.url}/{self._endpoint}/{project_id}"
 136        self._logger.info("url: %s", url)
 137        self._logger.info("project_id: %s", project_id)
 138        self._logger.info("addons: %s", addons)
 139        self._logger.info("headers: %s", headers)
 140        result = await self.get(
 141            url, timeout=timeout, addons=addons, headers=headers, **kwargs
 142        )
 143        self._logger.info("result: %s", result)
 144        res = Project.from_json(result)
 145        self._logger.verbose("result: %s", res)
 146        self._logger.notice("get_project succeeded")
 147        self._logger.debug("ManageClient.get_project LEAVE")
 148        return res
 149
 150    async def update_project_option(
 151        self,
 152        project_id: str,
 153        options: Union[Dict, ProjectOptions],
 154        timeout: Optional[httpx.Timeout] = None,
 155        addons: Optional[Dict] = None,
 156        headers: Optional[Dict] = None,
 157        **kwargs,
 158    ) -> Message:
 159        """
 160        Updates a project's settings.
 161
 162        Reference:
 163        https://developers.deepgram.com/reference/update-project
 164        """
 165        self._logger.debug("ManageClient.update_project_option ENTER")
 166        url = f"{self._config.url}/{self._endpoint}/{project_id}"
 167        self._logger.info("url: %s", url)
 168        self._logger.info("project_id: %s", project_id)
 169        if isinstance(options, ProjectOptions):
 170            self._logger.info("ProjectOptions switching class -> dict")
 171            options = options.to_dict()
 172        self._logger.info("options: %s", options)
 173        self._logger.info("addons: %s", addons)
 174        self._logger.info("headers: %s", headers)
 175        result = await self.patch(
 176            url, json=options, timeout=timeout, addons=addons, headers=headers, **kwargs
 177        )
 178        self._logger.info("result: %s", result)
 179        res = Message.from_json(result)
 180        self._logger.verbose("result: %s", res)
 181        self._logger.notice("update_project_option succeeded")
 182        self._logger.debug("ManageClient.update_project_option LEAVE")
 183        return res
 184
 185    async def update_project(
 186        self,
 187        project_id: str,
 188        name="",
 189        timeout: Optional[httpx.Timeout] = None,
 190        addons: Optional[Dict] = None,
 191        headers: Optional[Dict] = None,
 192        **kwargs,
 193    ) -> Message:
 194        """
 195        Updates a project's settings.
 196
 197        Reference:
 198        https://developers.deepgram.com/reference/update-project
 199        """
 200        self._logger.debug("ManageClient.update_project ENTER")
 201        url = f"{self._config.url}/{self._endpoint}/{project_id}"
 202        options = {
 203            "name": name,
 204        }
 205        self._logger.info("url: %s", url)
 206        self._logger.info("project_id: %s", project_id)
 207        self._logger.info("options: %s", options)
 208        self._logger.info("addons: %s", addons)
 209        self._logger.info("headers: %s", headers)
 210        result = await self.patch(
 211            url, json=options, timeout=timeout, addons=addons, headers=headers, **kwargs
 212        )
 213        self._logger.info("result: %s", result)
 214        res = Message.from_json(result)
 215        self._logger.verbose("result: %s", res)
 216        self._logger.notice("update_project succeeded")
 217        self._logger.debug("ManageClient.update_project LEAVE")
 218        return res
 219
 220    async def delete_project(
 221        self,
 222        project_id: str,
 223        timeout: Optional[httpx.Timeout] = None,
 224        addons: Optional[Dict] = None,
 225        headers: Optional[Dict] = None,
 226        **kwargs,
 227    ) -> Message:
 228        """
 229        Deletes a project.
 230
 231        Reference:
 232        https://developers.deepgram.com/reference/delete-project
 233        """
 234        self._logger.debug("ManageClient.delete_project ENTER")
 235        url = f"{self._config.url}/{self._endpoint}/{project_id}"
 236        self._logger.info("addons: %s", addons)
 237        self._logger.info("headers: %s", headers)
 238        result = await self.delete(
 239            url, timeout=timeout, addons=addons, headers=headers, **kwargs
 240        )
 241        self._logger.info("result: %s", result)
 242        res = Message.from_json(result)
 243        self._logger.verbose("result: %s", res)
 244        self._logger.notice("delete_project succeeded")
 245        self._logger.debug("ManageClient.delete_project LEAVE")
 246        return res
 247
 248    async def list_project_models(
 249        self,
 250        project_id: str,
 251        options: Optional[Union[Dict, ModelOptions]] = None,
 252        timeout: Optional[httpx.Timeout] = None,
 253        addons: Optional[Dict] = None,
 254        headers: Optional[Dict] = None,
 255        **kwargs,
 256    ) -> ModelsResponse:
 257        """
 258        Please see get_project_models.
 259        """
 260        return await self.get_project_models(
 261            project_id,
 262            options=options,
 263            timeout=timeout,
 264            addons=addons,
 265            headers=headers,
 266            **kwargs,
 267        )
 268
 269    async def get_project_models(
 270        self,
 271        project_id: str,
 272        options: Optional[Union[Dict, ModelOptions]] = None,
 273        timeout: Optional[httpx.Timeout] = None,
 274        addons: Optional[Dict] = None,
 275        headers: Optional[Dict] = None,
 276        **kwargs,
 277    ) -> ModelsResponse:
 278        """
 279        Gets models for a specific project.
 280
 281        Reference:
 282        https://developers.deepgram.com/reference/get-project
 283        https://developers.deepgram.com/reference/get-model
 284
 285        Args:
 286            project_id (str): The ID of the project.
 287            timeout (Optional[httpx.Timeout]): The timeout setting for the request.
 288            addons (Optional[Dict]): Additional options for the request.
 289            headers (Optional[Dict]): Headers to include in the request.
 290            **kwargs: Additional keyword arguments.
 291
 292        Returns:
 293            ModelsResponse: A response object containing the model details.
 294        """
 295        self._logger.debug("ManageClient.get_project_models ENTER")
 296
 297        if options is None:
 298            options = ModelOptions()
 299
 300        url = f"{self._config.url}/{self._endpoint}/{project_id}/models"
 301        self._logger.info("url: %s", url)
 302        self._logger.info("project_id: %s", project_id)
 303        if isinstance(options, ModelOptions):
 304            self._logger.info("ModelOptions switching class -> dict")
 305            options = options.to_dict()
 306        self._logger.info("options: %s", options)
 307        self._logger.info("addons: %s", addons)
 308        self._logger.info("headers: %s", headers)
 309        result = await self.get(
 310            url, json=options, timeout=timeout, addons=addons, headers=headers, **kwargs
 311        )
 312        self._logger.info("json: %s", result)
 313        res = ModelsResponse.from_json(result)
 314        self._logger.verbose("result: %s", res)
 315        self._logger.notice("get_project_models succeeded")
 316        self._logger.debug("ManageClient.get_project_models LEAVE")
 317        return res
 318
 319    async def get_project_model(
 320        self,
 321        project_id: str,
 322        model_id: str,
 323        timeout: Optional[httpx.Timeout] = None,
 324        addons: Optional[Dict] = None,
 325        headers: Optional[Dict] = None,
 326        **kwargs,
 327    ) -> ModelResponse:
 328        """
 329        Gets a single model for a specific project.
 330
 331        Reference:
 332        https://developers.deepgram.com/reference/get-project
 333        https://developers.deepgram.com/reference/get-model
 334
 335        Args:
 336            project_id (str): The ID of the project.
 337            model_id (str): The ID of the model.
 338            timeout (Optional[httpx.Timeout]): The timeout setting for the request.
 339            addons (Optional[Dict]): Additional options for the request.
 340            headers (Optional[Dict]): Headers to include in the request.
 341            **kwargs: Additional keyword arguments.
 342
 343        Returns:
 344            ModelResponse: A response object containing the model details.
 345        """
 346        self._logger.debug("ManageClient.get_project_model ENTER")
 347        url = f"{self._config.url}/{self._endpoint}/{project_id}/models/{model_id}"
 348        self._logger.info("url: %s", url)
 349        self._logger.info("project_id: %s", project_id)
 350        self._logger.info("model_id: %s", model_id)
 351        self._logger.info("addons: %s", addons)
 352        self._logger.info("headers: %s", headers)
 353        result = await self.get(
 354            url, timeout=timeout, addons=addons, headers=headers, **kwargs
 355        )
 356        self._logger.info("json: %s", result)
 357        res = ModelResponse.from_json(result)
 358        self._logger.verbose("result: %s", res)
 359        self._logger.notice("get_project_model succeeded")
 360        self._logger.debug("ManageClient.get_project_model LEAVE")
 361        return res
 362
 363    # models
 364    async def list_models(
 365        self,
 366        options: Optional[Union[Dict, ModelOptions]] = None,
 367        timeout: Optional[httpx.Timeout] = None,
 368        addons: Optional[Dict] = None,
 369        headers: Optional[Dict] = None,
 370        **kwargs,
 371    ) -> ModelsResponse:
 372        """
 373        Please see get_models for more information.
 374        """
 375        return await self.get_models(
 376            options=options, timeout=timeout, addons=addons, headers=headers, **kwargs
 377        )
 378
 379    async def get_models(
 380        self,
 381        options: Optional[Union[Dict, ModelOptions]] = None,
 382        timeout: Optional[httpx.Timeout] = None,
 383        addons: Optional[Dict] = None,
 384        headers: Optional[Dict] = None,
 385        **kwargs,
 386    ) -> ModelsResponse:
 387        """
 388        Gets all models available.
 389
 390        Reference:
 391        https://developers.deepgram.com/reference/get-model
 392
 393        Args:
 394            timeout (Optional[httpx.Timeout]): The timeout setting for the request.
 395            addons (Optional[Dict]): Additional options for the request.
 396            headers (Optional[Dict]): Headers to include in the request.
 397            **kwargs: Additional keyword arguments.
 398
 399        Returns:
 400            ModelsResponse: A response object containing the model details.
 401        """
 402        self._logger.debug("ManageClient.get_models ENTER")
 403
 404        if options is None:
 405            options = ModelOptions()
 406
 407        url = f"{self._config.url}/v1/models"
 408        self._logger.info("url: %s", url)
 409        if isinstance(options, ModelOptions):
 410            self._logger.info("ModelOptions switching class -> dict")
 411            options = options.to_dict()
 412        self._logger.info("options: %s", options)
 413        self._logger.info("addons: %s", addons)
 414        self._logger.info("headers: %s", headers)
 415        result = await self.get(
 416            url, json=options, timeout=timeout, addons=addons, headers=headers, **kwargs
 417        )
 418        self._logger.info("result: %s", result)
 419        res = ModelsResponse.from_json(result)
 420        self._logger.verbose("result: %s", res)
 421        self._logger.notice("get_models succeeded")
 422        self._logger.debug("ManageClient.get_models LEAVE")
 423        return res
 424
 425    async def get_model(
 426        self,
 427        model_id: str,
 428        timeout: Optional[httpx.Timeout] = None,
 429        addons: Optional[Dict] = None,
 430        headers: Optional[Dict] = None,
 431        **kwargs,
 432    ) -> ModelResponse:
 433        """
 434        Gets information for a specific model.
 435
 436        Reference:
 437        https://developers.deepgram.com/reference/get-model
 438
 439        Args:
 440            model_id (str): The ID of the model.
 441            timeout (Optional[httpx.Timeout]): The timeout setting for the request.
 442            addons (Optional[Dict]): Additional options for the request.
 443            headers (Optional[Dict]): Headers to include in the request.
 444            **kwargs: Additional keyword arguments.
 445
 446        Returns:
 447            ModelResponse: A response object containing the model details.
 448        """
 449        self._logger.debug("ManageClient.get_model ENTER")
 450        url = f"{self._config.url}/v1/models/{model_id}"
 451        self._logger.info("url: %s", url)
 452        self._logger.info("model_id: %s", model_id)
 453        self._logger.info("addons: %s", addons)
 454        self._logger.info("headers: %s", headers)
 455        result = await self.get(
 456            url, timeout=timeout, addons=addons, headers=headers, **kwargs
 457        )
 458        self._logger.info("result: %s", result)
 459        res = ModelResponse.from_json(result)
 460        self._logger.verbose("result: %s", res)
 461        self._logger.notice("get_model succeeded")
 462        self._logger.debug("ManageClient.get_model LEAVE")
 463        return res
 464
 465    # keys
 466    async def list_keys(
 467        self,
 468        project_id: str,
 469        timeout: Optional[httpx.Timeout] = None,
 470        addons: Optional[Dict] = None,
 471        headers: Optional[Dict] = None,
 472        **kwargs,
 473    ) -> KeysResponse:
 474        """
 475        Please see get_keys for more information.
 476        """
 477        return await self.get_keys(
 478            project_id, timeout=timeout, addons=addons, headers=headers, **kwargs
 479        )
 480
 481    async def get_keys(
 482        self,
 483        project_id: str,
 484        timeout: Optional[httpx.Timeout] = None,
 485        addons: Optional[Dict] = None,
 486        headers: Optional[Dict] = None,
 487        **kwargs,
 488    ) -> KeysResponse:
 489        """
 490        Gets a list of keys for a project.
 491
 492        Reference:
 493        https://developers.deepgram.com/reference/list-keys
 494        """
 495        self._logger.debug("ManageClient.get_keys ENTER")
 496        url = f"{self._config.url}/{self._endpoint}/{project_id}/keys"
 497        self._logger.info("url: %s", url)
 498        self._logger.info("project_id: %s", project_id)
 499        self._logger.info("addons: %s", addons)
 500        self._logger.info("headers: %s", headers)
 501        result = await self.get(
 502            url, timeout=timeout, addons=addons, headers=headers, **kwargs
 503        )
 504        self._logger.info("result: %s", result)
 505        res = KeysResponse.from_json(result)
 506        self._logger.verbose("result: %s", res)
 507        self._logger.notice("get_keys succeeded")
 508        self._logger.debug("ManageClient.get_keys LEAVE")
 509        return res
 510
 511    async def get_key(
 512        self,
 513        project_id: str,
 514        key_id: str,
 515        timeout: Optional[httpx.Timeout] = None,
 516        addons: Optional[Dict] = None,
 517        headers: Optional[Dict] = None,
 518        **kwargs,
 519    ) -> KeyResponse:
 520        """
 521        Gets details for a specific key.
 522
 523        Reference:
 524        https://developers.deepgram.com/reference/get-key
 525        """
 526        self._logger.debug("ManageClient.get_key ENTER")
 527        url = f"{self._config.url}/{self._endpoint}/{project_id}/keys/{key_id}"
 528        self._logger.info("url: %s", url)
 529        self._logger.info("project_id: %s", project_id)
 530        self._logger.info("key_id: %s", key_id)
 531        self._logger.info("addons: %s", addons)
 532        self._logger.info("headers: %s", headers)
 533        result = await self.get(
 534            url, timeout=timeout, addons=addons, headers=headers, **kwargs
 535        )
 536        self._logger.info("result: %s", result)
 537        res = KeyResponse.from_json(result)
 538        self._logger.verbose("result: %s", res)
 539        self._logger.notice("get_key succeeded")
 540        self._logger.debug("ManageClient.get_key LEAVE")
 541        return res
 542
 543    async def create_key(
 544        self,
 545        project_id: str,
 546        options: Union[Dict, KeyOptions],
 547        timeout: Optional[httpx.Timeout] = None,
 548        addons: Optional[Dict] = None,
 549        headers: Optional[Dict] = None,
 550        **kwargs,
 551    ) -> Key:
 552        """
 553        Creates a new key.
 554
 555        Reference:
 556        https://developers.deepgram.com/reference/create-key
 557        """
 558        self._logger.debug("ManageClient.create_key ENTER")
 559        url = f"{self._config.url}/{self._endpoint}/{project_id}/keys"
 560        self._logger.info("url: %s", url)
 561        self._logger.info("project_id: %s", project_id)
 562        if isinstance(options, KeyOptions):
 563            self._logger.info("KeyOptions switching class -> dict")
 564            options = options.to_dict()
 565        self._logger.info("options: %s", options)
 566        self._logger.info("addons: %s", addons)
 567        self._logger.info("headers: %s", headers)
 568        result = await self.post(
 569            url, json=options, timeout=timeout, addons=addons, headers=headers, **kwargs
 570        )
 571        self._logger.info("result: %s", result)
 572        res = Key.from_json(result)
 573        self._logger.verbose("result: %s", res)
 574        self._logger.notice("create_key succeeded")
 575        self._logger.debug("ManageClient.create_key LEAVE")
 576        return res
 577
 578    async def delete_key(
 579        self,
 580        project_id: str,
 581        key_id: str,
 582        timeout: Optional[httpx.Timeout] = None,
 583        addons: Optional[Dict] = None,
 584        headers: Optional[Dict] = None,
 585        **kwargs,
 586    ) -> Message:
 587        """
 588        Deletes a key.
 589
 590        Reference:
 591        https://developers.deepgram.com/reference/delete-key
 592        """
 593        self._logger.debug("ManageClient.delete_key ENTER")
 594        url = f"{self._config.url}/{self._endpoint}/{project_id}/keys/{key_id}"
 595        self._logger.info("url: %s", url)
 596        self._logger.info("project_id: %s", project_id)
 597        self._logger.info("key_id: %s", key_id)
 598        self._logger.info("addons: %s", addons)
 599        self._logger.info("headers: %s", headers)
 600        result = await self.delete(
 601            url, timeout=timeout, addons=addons, headers=headers, **kwargs
 602        )
 603        self._logger.info("result: %s", result)
 604        res = Message.from_json(result)
 605        self._logger.verbose("result: %s", res)
 606        self._logger.notice("delete_key succeeded")
 607        self._logger.debug("ManageClient.delete_key LEAVE")
 608        return res
 609
 610    # members
 611    async def list_members(
 612        self,
 613        project_id: str,
 614        timeout: Optional[httpx.Timeout] = None,
 615        addons: Optional[Dict] = None,
 616        headers: Optional[Dict] = None,
 617        **kwargs,
 618    ) -> MembersResponse:
 619        """
 620        Please see get_members for more information.
 621        """
 622        return await self.get_members(
 623            project_id, timeout=timeout, addons=addons, headers=headers, **kwargs
 624        )
 625
 626    async def get_members(
 627        self,
 628        project_id: str,
 629        timeout: Optional[httpx.Timeout] = None,
 630        addons: Optional[Dict] = None,
 631        headers: Optional[Dict] = None,
 632        **kwargs,
 633    ) -> MembersResponse:
 634        """
 635        Gets a list of members for a project.
 636
 637        Reference:
 638        https://developers.deepgram.com/reference/get-members
 639        """
 640        self._logger.debug("ManageClient.get_members ENTER")
 641        url = f"{self._config.url}/{self._endpoint}/{project_id}/members"
 642        self._logger.info("url: %s", url)
 643        self._logger.info("project_id: %s", project_id)
 644        self._logger.info("addons: %s", addons)
 645        self._logger.info("headers: %s", headers)
 646        result = await self.get(
 647            url, timeout=timeout, addons=addons, headers=headers, **kwargs
 648        )
 649        self._logger.info("result: %s", result)
 650        res = MembersResponse.from_json(result)
 651        self._logger.verbose("result: %s", res)
 652        self._logger.notice("get_members succeeded")
 653        self._logger.debug("ManageClient.get_members LEAVE")
 654        return res
 655
 656    async def remove_member(
 657        self,
 658        project_id: str,
 659        member_id: str,
 660        timeout: Optional[httpx.Timeout] = None,
 661        addons: Optional[Dict] = None,
 662        headers: Optional[Dict] = None,
 663        **kwargs,
 664    ) -> Message:
 665        """
 666        Removes a member from a project.
 667
 668        Reference:
 669        https://developers.deepgram.com/reference/remove-member
 670        """
 671        self._logger.debug("ManageClient.remove_member ENTER")
 672        url = f"{self._config.url}/{self._endpoint}/{project_id}/members/{member_id}"
 673        self._logger.info("url: %s", url)
 674        self._logger.info("project_id: %s", project_id)
 675        self._logger.info("member_id: %s", member_id)
 676        self._logger.info("addons: %s", addons)
 677        self._logger.info("headers: %s", headers)
 678        result = await self.delete(
 679            url, timeout=timeout, addons=addons, headers=headers, **kwargs
 680        )
 681        self._logger.info("result: %s", result)
 682        res = Message.from_json(result)
 683        self._logger.verbose("result: %s", res)
 684        self._logger.notice("remove_member succeeded")
 685        self._logger.debug("ManageClient.remove_member LEAVE")
 686        return res
 687
 688    # scopes
 689    async def get_member_scopes(
 690        self,
 691        project_id: str,
 692        member_id: str,
 693        timeout: Optional[httpx.Timeout] = None,
 694        addons: Optional[Dict] = None,
 695        headers: Optional[Dict] = None,
 696        **kwargs,
 697    ) -> ScopesResponse:
 698        """
 699        Gets a list of scopes for a member.
 700
 701        Reference:
 702        https://developers.deepgram.com/reference/get-member-scopes
 703        """
 704        self._logger.debug("ManageClient.get_member_scopes ENTER")
 705        url = f"{self._config.url}/{self._endpoint}/{project_id}/members/{member_id}/scopes"
 706        self._logger.info("url: %s", url)
 707        self._logger.info("project_id: %s", project_id)
 708        self._logger.info("member_id: %s", member_id)
 709        self._logger.info("addons: %s", addons)
 710        self._logger.info("headers: %s", headers)
 711        result = await self.get(
 712            url, timeout=timeout, addons=addons, headers=headers, **kwargs
 713        )
 714        self._logger.info("result: %s", result)
 715        res = ScopesResponse.from_json(result)
 716        self._logger.verbose("result: %s", res)
 717        self._logger.notice("get_member_scopes succeeded")
 718        self._logger.debug("ManageClient.get_member_scopes LEAVE")
 719        return res
 720
 721    async def update_member_scope(
 722        self,
 723        project_id: str,
 724        member_id: str,
 725        options: Union[Dict, ScopeOptions],
 726        timeout: Optional[httpx.Timeout] = None,
 727        addons: Optional[Dict] = None,
 728        headers: Optional[Dict] = None,
 729        **kwargs,
 730    ) -> Message:
 731        """
 732        Updates a member's scopes.
 733
 734        Reference:
 735        https://developers.deepgram.com/reference/update-scope
 736        """
 737        self._logger.debug("ManageClient.update_member_scope ENTER")
 738        url = f"{self._config.url}/{self._endpoint}/{project_id}/members/{member_id}/scopes"
 739        self._logger.info("url: %s", url)
 740        self._logger.info("project_id: %s", project_id)
 741        if isinstance(options, ScopeOptions):
 742            self._logger.info("ScopeOptions switching class -> dict")
 743            options = options.to_dict()
 744        self._logger.info("options: %s", options)
 745        self._logger.info("addons: %s", addons)
 746        self._logger.info("headers: %s", headers)
 747        result = await self.put(
 748            url, json=options, timeout=timeout, addons=addons, headers=headers, **kwargs
 749        )
 750        self._logger.info("result: %s", result)
 751        res = Message.from_json(result)
 752        self._logger.verbose("result: %s", res)
 753        self._logger.notice("update_member_scope succeeded")
 754        self._logger.debug("ManageClient.update_member_scope LEAVE")
 755        return res
 756
 757    # invites
 758    async def list_invites(
 759        self,
 760        project_id: str,
 761        timeout: Optional[httpx.Timeout] = None,
 762        addons: Optional[Dict] = None,
 763        headers: Optional[Dict] = None,
 764        **kwargs,
 765    ) -> InvitesResponse:
 766        """
 767        Please see get_invites for more information.
 768        """
 769        return await self.get_invites(
 770            project_id, timeout=timeout, addons=addons, headers=headers, **kwargs
 771        )
 772
 773    async def get_invites(
 774        self,
 775        project_id: str,
 776        timeout: Optional[httpx.Timeout] = None,
 777        addons: Optional[Dict] = None,
 778        headers: Optional[Dict] = None,
 779        **kwargs,
 780    ) -> InvitesResponse:
 781        """
 782        Gets a list of invites for a project.
 783
 784        Reference:
 785        https://developers.deepgram.com/reference/list-invites
 786        """
 787        self._logger.debug("ManageClient.get_invites ENTER")
 788        url = f"{self._config.url}/{self._endpoint}/{project_id}/invites"
 789        self._logger.info("url: %s", url)
 790        self._logger.info("project_id: %s", project_id)
 791        self._logger.info("addons: %s", addons)
 792        self._logger.info("headers: %s", headers)
 793        result = await self.get(
 794            url, timeout=timeout, addons=addons, headers=headers, **kwargs
 795        )
 796        self._logger.info("result: %s", result)
 797        res = InvitesResponse.from_json(result)
 798        self._logger.verbose("result: %s", res)
 799        self._logger.notice("get_invites succeeded")
 800        self._logger.debug("ManageClient.get_invites LEAVE")
 801        return res
 802
 803    async def send_invite_options(
 804        self,
 805        project_id: str,
 806        options: Union[Dict, InviteOptions],
 807        timeout: Optional[httpx.Timeout] = None,
 808        addons: Optional[Dict] = None,
 809        headers: Optional[Dict] = None,
 810        **kwargs,
 811    ) -> Message:
 812        """
 813        Sends an invite to a project.
 814
 815        Reference:
 816        https://developers.deepgram.com/reference/send-invite
 817        """
 818        self._logger.debug("ManageClient.send_invite_options ENTER")
 819        url = f"{self._config.url}/{self._endpoint}/{project_id}/invites"
 820        self._logger.info("url: %s", url)
 821        self._logger.info("project_id: %s", project_id)
 822        if isinstance(options, InviteOptions):
 823            self._logger.info("InviteOptions switching class -> dict")
 824            options = options.to_dict()
 825        self._logger.info("options: %s", options)
 826        self._logger.info("addons: %s", addons)
 827        self._logger.info("headers: %s", headers)
 828        result = await self.post(
 829            url, json=options, timeout=timeout, addons=addons, headers=headers, **kwargs
 830        )
 831        self._logger.info("result: %s", result)
 832        res = Message.from_json(result)
 833        self._logger.verbose("result: %s", res)
 834        self._logger.notice("send_invite_options succeeded")
 835        self._logger.debug("ManageClient.send_invite_options LEAVE")
 836        return res
 837
 838    async def send_invite(
 839        self,
 840        project_id: str,
 841        email: str,
 842        scope="member",
 843        timeout: Optional[httpx.Timeout] = None,
 844        addons: Optional[Dict] = None,
 845        headers: Optional[Dict] = None,
 846        **kwargs,
 847    ) -> Message:
 848        """
 849        Sends an invite to a project.
 850
 851        Reference:
 852        https://developers.deepgram.com/reference/send-invite
 853        """
 854        self._logger.debug("ManageClient.send_invite ENTER")
 855        url = f"{self._config.url}/{self._endpoint}/{project_id}/invites"
 856        options = {
 857            "email": email,
 858            "scope": scope,
 859        }
 860        self._logger.info("url: %s", url)
 861        self._logger.info("project_id: %s", project_id)
 862        self._logger.info("options: %s", options)
 863        self._logger.info("addons: %s", addons)
 864        self._logger.info("headers: %s", headers)
 865        result = await self.post(
 866            url, json=options, timeout=timeout, addons=addons, headers=headers, **kwargs
 867        )
 868        self._logger.info("result: %s", result)
 869        res = Message.from_json(result)
 870        self._logger.verbose("result: %s", res)
 871        self._logger.notice("send_invite succeeded")
 872        self._logger.debug("ManageClient.send_invite LEAVE")
 873        return res
 874
 875    async def delete_invite(
 876        self,
 877        project_id: str,
 878        email: str,
 879        timeout: Optional[httpx.Timeout] = None,
 880        addons: Optional[Dict] = None,
 881        headers: Optional[Dict] = None,
 882        **kwargs,
 883    ) -> Message:
 884        """
 885        Deletes an invite from a project.
 886
 887        Reference:
 888        https://developers.deepgram.com/reference/delete-invite
 889        """
 890        self._logger.debug("ManageClient.delete_invite ENTER")
 891        url = f"{self._config.url}/{self._endpoint}/{project_id}/invites/{email}"
 892        self._logger.info("url: %s", url)
 893        self._logger.info("project_id: %s", project_id)
 894        self._logger.info("email: %s", email)
 895        self._logger.info("addons: %s", addons)
 896        self._logger.info("headers: %s", headers)
 897        result = await self.delete(
 898            url, timeout=timeout, addons=addons, headers=headers, **kwargs
 899        )
 900        self._logger.info("result: %s", result)
 901        res = Message.from_json(result)
 902        self._logger.verbose("result: %s", res)
 903        self._logger.notice("delete_invite succeeded")
 904        self._logger.debug("ManageClient.delete_invite LEAVE")
 905        return res
 906
 907    async def leave_project(
 908        self,
 909        project_id: str,
 910        timeout: Optional[httpx.Timeout] = None,
 911        addons: Optional[Dict] = None,
 912        headers: Optional[Dict] = None,
 913        **kwargs,
 914    ) -> Message:
 915        """
 916        Leaves a project.
 917
 918        Reference:
 919        https://developers.deepgram.com/reference/leave-project
 920        """
 921        self._logger.debug("ManageClient.leave_project ENTER")
 922        url = f"{self._config.url}/{self._endpoint}/{project_id}/leave"
 923        self._logger.info("url: %s", url)
 924        self._logger.info("project_id: %s", project_id)
 925        self._logger.info("addons: %s", addons)
 926        self._logger.info("headers: %s", headers)
 927        result = await self.delete(
 928            url, timeout=timeout, addons=addons, headers=headers, **kwargs
 929        )
 930        self._logger.info("result: %s", result)
 931        res = Message.from_json(result)
 932        self._logger.verbose("result: %s", res)
 933        self._logger.notice("leave_project succeeded")
 934        self._logger.debug("ManageClient.leave_project LEAVE")
 935        return res
 936
 937    # usage
 938    async def get_usage_requests(
 939        self,
 940        project_id: str,
 941        options: Union[Dict, UsageRequestOptions],
 942        timeout: Optional[httpx.Timeout] = None,
 943        addons: Optional[Dict] = None,
 944        headers: Optional[Dict] = None,
 945        **kwargs,
 946    ) -> UsageRequestsResponse:
 947        """
 948        Gets a list of usage requests for a project.
 949
 950        Reference:
 951        https://developers.deepgram.com/reference/get-all-requests
 952        """
 953        self._logger.debug("ManageClient.get_usage_requests ENTER")
 954        url = f"{self._config.url}/{self._endpoint}/{project_id}/requests"
 955        self._logger.info("url: %s", url)
 956        self._logger.info("project_id: %s", project_id)
 957        if isinstance(options, UsageRequestOptions):
 958            self._logger.info("UsageRequestOptions switching class -> dict")
 959            options = options.to_dict()
 960        self._logger.info("options: %s", options)
 961        self._logger.info("addons: %s", addons)
 962        self._logger.info("headers: %s", headers)
 963        result = await self.get(
 964            url,
 965            options=options,
 966            timeout=timeout,
 967            addons=addons,
 968            headers=headers,
 969            **kwargs,
 970        )
 971        self._logger.info("result: %s", result)
 972        res = UsageRequestsResponse.from_json(result)
 973        self._logger.verbose("result: %s", res)
 974        self._logger.notice("get_usage_requests succeeded")
 975        self._logger.debug("ManageClient.get_usage_requests LEAVE")
 976        return res
 977
 978    async def get_usage_request(
 979        self,
 980        project_id: str,
 981        request_id: str,
 982        timeout: Optional[httpx.Timeout] = None,
 983        addons: Optional[Dict] = None,
 984        headers: Optional[Dict] = None,
 985        **kwargs,
 986    ) -> UsageRequest:
 987        """
 988        Gets details for a specific usage request.
 989
 990        Reference:
 991        https://developers.deepgram.com/reference/get-request
 992        """
 993        self._logger.debug("ManageClient.get_usage_request ENTER")
 994        url = f"{self._config.url}/{self._endpoint}/{project_id}/requests/{request_id}"
 995        self._logger.info("url: %s", url)
 996        self._logger.info("project_id: %s", project_id)
 997        self._logger.info("request_id: %s", request_id)
 998        self._logger.info("addons: %s", addons)
 999        self._logger.info("headers: %s", headers)
1000        result = await self.get(
1001            url, timeout=timeout, addons=addons, headers=headers, **kwargs
1002        )
1003        self._logger.info("result: %s", result)
1004
1005        # convert str to JSON to check response field
1006        json_result = json.loads(result)
1007        if json_result.get("response") is None:
1008            raise DeepgramError(
1009                "Response is not available yet. Please try again later."
1010            )
1011
1012        res = UsageRequest.from_json(result)
1013        self._logger.verbose("result: %s", res)
1014        self._logger.notice("get_usage_request succeeded")
1015        self._logger.debug("ManageClient.get_usage_request LEAVE")
1016        return res
1017
1018    async def get_usage_summary(
1019        self,
1020        project_id: str,
1021        options: Union[Dict, UsageSummaryOptions],
1022        timeout: Optional[httpx.Timeout] = None,
1023        addons: Optional[Dict] = None,
1024        headers: Optional[Dict] = None,
1025        **kwargs,
1026    ) -> UsageSummaryResponse:
1027        """
1028        Gets a summary of usage for a project.
1029
1030        Reference:
1031        https://developers.deepgram.com/reference/summarize-usage
1032        """
1033        self._logger.debug("ManageClient.get_usage_summary ENTER")
1034        url = f"{self._config.url}/{self._endpoint}/{project_id}/usage"
1035        self._logger.info("url: %s", url)
1036        self._logger.info("project_id: %s", project_id)
1037        if isinstance(options, UsageSummaryOptions):
1038            self._logger.info("UsageSummaryOptions switching class -> dict")
1039            options = options.to_dict()
1040        self._logger.info("options: %s", options)
1041        self._logger.info("addons: %s", addons)
1042        self._logger.info("headers: %s", headers)
1043        result = await self.get(
1044            url,
1045            options=options,
1046            timeout=timeout,
1047            addons=addons,
1048            headers=headers,
1049            **kwargs,
1050        )
1051        self._logger.info("result: %s", result)
1052        res = UsageSummaryResponse.from_json(result)
1053        self._logger.verbose("result: %s", res)
1054        self._logger.notice("get_usage_summary succeeded")
1055        self._logger.debug("ManageClient.get_usage_summary LEAVE")
1056        return res
1057
1058    async def get_usage_fields(
1059        self,
1060        project_id: str,
1061        options: Union[Dict, UsageFieldsOptions],
1062        timeout: Optional[httpx.Timeout] = None,
1063        addons: Optional[Dict] = None,
1064        headers: Optional[Dict] = None,
1065        **kwargs,
1066    ) -> UsageFieldsResponse:
1067        """
1068        Gets a list of usage fields for a project.
1069
1070        Reference:
1071        https://developers.deepgram.com/reference/get-fields
1072        """
1073        self._logger.debug("ManageClient.get_usage_fields ENTER")
1074        url = f"{self._config.url}/{self._endpoint}/{project_id}/usage/fields"
1075        self._logger.info("url: %s", url)
1076        self._logger.info("project_id: %s", project_id)
1077        if isinstance(options, UsageFieldsOptions):
1078            self._logger.info("UsageFieldsOptions switching class -> dict")
1079            options = options.to_dict()
1080        self._logger.info("options: %s", options)
1081        self._logger.info("addons: %s", addons)
1082        self._logger.info("headers: %s", headers)
1083        result = await self.get(
1084            url,
1085            options=options,
1086            timeout=timeout,
1087            addons=addons,
1088            headers=headers,
1089            **kwargs,
1090        )
1091        self._logger.info("result: %s", result)
1092        res = UsageFieldsResponse.from_json(result)
1093        self._logger.verbose("result: %s", res)
1094        self._logger.notice("get_usage_fields succeeded")
1095        self._logger.debug("ManageClient.get_usage_fields LEAVE")
1096        return res
1097
1098    # balances
1099    async def list_balances(
1100        self,
1101        project_id: str,
1102        timeout: Optional[httpx.Timeout] = None,
1103        addons: Optional[Dict] = None,
1104        headers: Optional[Dict] = None,
1105        **kwargs,
1106    ) -> BalancesResponse:
1107        """
1108        Please see get_balances for more information.
1109        """
1110        return await self.get_balances(
1111            project_id, timeout=timeout, addons=addons, headers=headers, **kwargs
1112        )
1113
1114    async def get_balances(
1115        self,
1116        project_id: str,
1117        timeout: Optional[httpx.Timeout] = None,
1118        addons: Optional[Dict] = None,
1119        headers: Optional[Dict] = None,
1120        **kwargs,
1121    ) -> BalancesResponse:
1122        """
1123        Gets a list of balances for a project.
1124
1125        Reference:
1126        https://developers.deepgram.com/reference/get-all-balances
1127        """
1128        self._logger.debug("ManageClient.get_balances ENTER")
1129        url = f"{self._config.url}/{self._endpoint}/{project_id}/balances"
1130        self._logger.info("url: %s", url)
1131        self._logger.info("project_id: %s", project_id)
1132        self._logger.info("addons: %s", addons)
1133        self._logger.info("headers: %s", headers)
1134        result = await self.get(
1135            url, timeout=timeout, addons=addons, headers=headers, **kwargs
1136        )
1137        self._logger.info("result: %s", result)
1138        res = BalancesResponse.from_json(result)
1139        self._logger.verbose("result: %s", res)
1140        self._logger.notice("get_balances succeeded")
1141        self._logger.debug("ManageClient.get_balances LEAVE")
1142        return res
1143
1144    async def get_balance(
1145        self,
1146        project_id: str,
1147        balance_id: str,
1148        timeout: Optional[httpx.Timeout] = None,
1149        addons: Optional[Dict] = None,
1150        headers: Optional[Dict] = None,
1151        **kwargs,
1152    ) -> Balance:
1153        """
1154        Gets details for a specific balance.
1155
1156        Reference:
1157        https://developers.deepgram.com/reference/get-balance
1158        """
1159        self._logger.debug("ManageClient.get_balance ENTER")
1160        url = f"{self._config.url}/{self._endpoint}/{project_id}/balances/{balance_id}"
1161        self._logger.info("url: %s", url)
1162        self._logger.info("project_id: %s", project_id)
1163        self._logger.info("balance_id: %s", balance_id)
1164        self._logger.info("addons: %s", addons)
1165        self._logger.info("headers: %s", headers)
1166        result = await self.get(
1167            url, timeout=timeout, addons=addons, headers=headers, **kwargs
1168        )
1169        self._logger.info("result: %s", result)
1170        res = Balance.from_json(result)
1171        self._logger.verbose("result: %s", res)
1172        self._logger.notice("get_balance succeeded")
1173        self._logger.debug("ManageClient.get_balance LEAVE")
1174        return res
1175
1176    # pylint: enable=too-many-positional-arguments