pip install deepgram-sdk==3.*

from deepgram import Deepgram

# Your Deepgram API Key
DEEPGRAM_API_KEY = 'YOUR_DEEPGRAM_API_KEY'

# Initialize the Deepgram SDK
deepgram = Deepgram(DEEPGRAM_API_KEY)

from deepgram import DeepgramClient

# Create a Deepgram client using the DEEPGRAM_API_KEY from environment variables
deepgram = DeepgramClient()

FILE = 'interview_speech-analytics.wav'

# file is local
# Open the audio file
audio = open(FILE, 'rb')

# Set the source
source = {
	'buffer': audio,
}

# Send the audio to Deepgram and get the response
response = await asyncio.create_task(
  deepgram.transcription.prerecorded(
    source,
    {
      'smart_format': "true",
      'summarize': "v2",
    }
  )
)

# Write the response to the console
print(json.dumps(response, indent=4))

AUDIO_FILE = "preamble.wav"

# Call the transcribe_file method on the prerecorded class
  with open(AUDIO_FILE, "rb") as file:
  buffer_data = file.read()

payload: FileSource = {
	"buffer": buffer_data,
}

options = PrerecordedOptions(
  smart_format=True,
  summarize="v2",
)
file_response = deepgram.listen.prerecorded.v("1").transcribe_file(payload, options)

json = file_response.to_json()
print(f"{json}")

URL = 'https://static.deepgram.com/examples/interview_speech-analytics.wav'

# Set the source
source = {
    'url': URL,
}

# Send the audio to Deepgram and get the response
response = await asyncio.create_task(
  deepgram.transcription.prerecorded(
    source,
    {
      'smart_format': "true",
      'summarize': "v2",
    }
  )
)

# Write the response to the console
print(json.dumps(response, indent=4))

AUDIO_URL = {
    "url": "https://static.deepgram.com/examples/Bueller-Life-moves-pretty-fast.wav"
}

options = PrerecordedOptions(
    smart_format=True,
    summarize="v2",
)
url_response = deepgram.listen.prerecorded.v("1").transcribe_url(AUDIO_URL, options)

json = url_response.to_json()
print(f"{json}")

try:
  deepgramLive = await deepgram.transcription.live({
    'smart_format': True,
    'interim_results': False,
    'language': 'en-US',
    'model': 'nova-2',
  })
except Exception as e:
  print(f'Could not open socket: {e}')
  return

# Listen for the connection to close
deepgramLive.registerHandler(deepgramLive.event.CLOSE, lambda c: print(
                             f'Connection closed with code {c}.'))

# Listen for any transcripts received from Deepgram and write them to the console
deepgramLive.registerHandler(deepgramLive.event.TRANSCRIPT_RECEIVED, print)

# Listen for the connection to open and send streaming audio from the URL to Deepgram
# IMPORTANT: This is a blocking call with no way to exit except through a Cntl-C,
# IMPORTANT: disconnecting your internet, or killing the streaming (assuming you control that)
async with aiohttp.ClientSession() as session:
  async with session.get(URL) as audio:
  while True:
    data = await audio.content.readany()
    deepgramLive.send(data)

# If no data is being sent from the live stream, then break out of the loop.
if not data:
	break

# Indicate that we've finished sending data by sending the customary zero-byte message to the Deepgram streaming endpoint, and wait until we get back the final summary metadata object
await deepgramLive.finish()

try:
		# define callbacks for transcription messages
    def on_message(self, result, **kwargs):
        sentence = result.channel.alternatives[0].transcript
        if len(sentence) == 0:
            return
        print(f"speaker: {sentence}")

    dg_connection.on(LiveTranscriptionEvents.Transcript, on_message)

    # connect to websocket
    options = LiveOptions(model="nova-2", interim_results=False, language="en-US")
    dg_connection.start(options)

    lock_exit = threading.Lock()
    exit = False

    # define a worker thread
    def myThread():
      with httpx.stream("GET", URL) as r:
        for data in r.iter_bytes():
          lock_exit.acquire()
          if exit:
            	break
          lock_exit.release()

          dg_connection.send(data)

    # start the worker thread
    myHttp = threading.Thread(target=myThread)
    myHttp.start()

    # signal finished
    input("Press Enter to stop recording...\n\n")
    lock_exit.acquire()
    exit = True
    lock_exit.release()

    # Wait for the HTTP thread to close and join
    myHttp.join()

    # Indicate that we've finished
    dg_connection.finish()

except Exception as e:
    print(f"Could not open socket: {e}")
    return

result = await deepgram.projects.list()

result = deepgram.manage.v("1").get_projects()

result = await deepgram.projects.get(PROJECT_ID)

result = deepgram.manage.v("1").get_project(projectId)

result = await deepgram.projects.update(object)

result = deepgram.manage.v("1").update_project(projectId, name="My TEST RENAME Example")

result = await deepgram.projects.delete(PROJECT_ID)

result = deepgram.manage.v("1").delete_project(projectId)

result = await deepgram.keys.list(PROJECT_ID)

result = deepgram.manage.v("1").get_keys(projectId)

result = await deepgram.keys.get(PROJECT_ID, KEY_ID)

result = deepgram.manage.v("1").get_key(projectId, myKeyId)

result = await deepgram.keys.create(PROJECT_ID, COMMENT_FOR_KEY, SCOPES)

options = KeyOptions(
  comment="MyTestKey",
  scopes=["member"],
)

result = deepgram.manage.v("1").create_key(projectId, options)

result = await deepgram.keys.delete(PROJECT_ID, KEY_ID)

result = deepgram.manage.v("1").delete_key(projectId, keyId)

result = await deepgram.members.list_members(PROJECT_ID);

result = deepgram.manage.v("1").get_members(projectId)

result = await deepgram.members.remove_member(PROJECT_ID, MEMBER_ID)

result = deepgram.manage.v("1").remove_member(projectId, memberId)

result = await deepgram.scopes.get_scope(PROJECT_ID, MEMBER_ID)

result = deepgram.manage.v("1").get_member_scopes(projectId, memberId)

result = await deepgram.scopes.update_scope(PROJECT_ID, MEMBER_ID, 'member')

options = ScopeOptions
	scope="admin"
)
result = deepgram.manage.v("1").update_member_scope(projectId, memberId, options)

result = await deepgram.invitations.list_invitations(PROJECT_ID);

result = deepgram.manage.v("1").get_invites(projectId)

result = await deepgram.invitations.send_invitation(PROJECT_ID, {
  email: '[email protected]',
  scope: 'member',
})

options = InviteOptions(
  email="[email protected]",
  scope="member"
)

result = deepgram.manage.v("1").send_invite_options(projectId, options)

result = await deepgram.invitations.remove_invitation(
  PROJECT_ID,
  '[email protected]'
)

result = deepgram.manage.v("1").delete_invite(projectId, "[email protected]")

result = await deepgram.invitation.leave_project(PROJECT_ID);

result = deepgram.manage.v("1").leave_project(projectId)

result = await deepgram.usage.list_requests(PROJECT_ID, {
  'limit': 10,
  # other options are available
});

result = deepgram.manage.v("1").get_usage_requests(projectId, options)

result = await deepgram.usage.get_request(PROJECT_ID, REQUEST_ID);

result = deepgram.manage.v("1").get_usage_request(projectId, requestId)

result = await deepgram.usage.get_usage(PROJECT_ID, {
  'start': '2020-01-01T00:00:00+00:00',
  # other options are available
});

result = deepgram.manage.v("1").get_usage_summary(projectId, options)

result = await deepgram.usage.get_fields(PROJECT_ID, {
  'start': '2020-01-01T00:00:00+00:00',
  # other options are available
});

result = deepgram.manage.v("1").get_usage_fields(projectId, options)

result = await deepgram.billing.list_balance(PROJECT_ID);

result = deepgram.manage.v("1").get_balances(projectId)

result = await deepgram.billing.get_balance(PROJECT_ID, BALANCE_ID);

result = deepgram.manage.v("1").get_balance(projectId, balanceId)