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