deepgram 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f5fc13bf4ebba6ff0f05315233f883576d9b0529548f75f9d07be96ae54ee7d4
-  data.tar.gz: cf5f6cf578576aa73ad5381d0df8319542706a0748228c858d22d3eff64df414
+  metadata.gz: 817aa3c44284b3c8bb2811a28f35b5fbf5d8f79e61b0c4ee3ff451fc3b9f50a0
+  data.tar.gz: cc596493ee0d80717af4d7cbb7f3f3c5420948c53eb0b2838cb50405986673a1
 SHA512:
-  metadata.gz: 1df3f021dc572844968d36222605bc2faa83b6dfb55c5a869ca44124085a97131f018ca000f982e2f093639bae0700ea10f6aefa6a03d161ccba36b2e3a6f738
-  data.tar.gz: ee8b6b2180cfeee3b5ecbe4c0c34aa4f81a5fb8e2dc0b44c680b12360be8357eabc8f138a7d9440f1d26a333ab8ef8d4317bd49f1b8ee30eb37ddfdfa5713f25
+  metadata.gz: 168c3ddaeafbfb84ff9d6355580b30a08a7dc1c19a954b5e622cb9d2ca238e3cda7bbebebd6a0c8ff12c32946739bdd452c957b842f08202c17ade88eb8a137b
+  data.tar.gz: ad459d45e906b0c855d9c73bf1f8a23c7e338040ac3fa0bb189801f78cc8d80e71216417b05981a0382c7ab300bbbabc810fde598778e80b803ffdd9739a0901

data/.rubocop.yml

@@ -0,0 +1,21 @@
+AllCops:
+    NewCops: disable
+
+Style/HashSyntax:
+  Enabled: false
+  
+Metrics/BlockLength:
+  Exclude:
+    # config files where we expect long blocks
+    - 'Gemfile'
+    - 'Guardfile'
+    - '*.gemspec'
+
+    # spec files that might have a big describe
+    - 'spec/**/*.rb'
+
+
+Metrics/AbcSize:
+  Exclude:
+    # spec files, especially matchers, can get complicated and that's OK
+    - 'lib/deepgram/response_handler.rb'

data/Guardfile

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+guard :rspec, cmd: 'bundle exec rspec' do
+  require 'guard/rspec/dsl'
+  dsl = Guard::RSpec::Dsl.new(self)
+
+  # RSpec files
+  rspec = dsl.rspec
+  watch(rspec.spec_helper) { rspec.spec_dir }
+  watch(rspec.spec_support) { rspec.spec_dir }
+  watch(rspec.spec_files)
+
+  # Ruby files
+  ruby = dsl.ruby
+  dsl.watch_spec_files_for(ruby.lib_files)
+end
+
+guard :rubocop, cli: ['--autocorrect'] do
+  watch(/.+\.rb$/)
+  watch(%r{(?:.+/)?\.rubocop(?:_todo)?\.yml$}) { |m| File.dirname(m[0]) }
+end

data/README.md

@@ -1,39 +1,87 @@
-# Deepgram
+# Deepgram Ruby Client
 
-TODO: Delete this and the text below, and describe your gem
+The Deepgram Ruby Client is a comprehensive library for interacting with the Deepgram API, allowing developers to easily integrate Deepgram's powerful speech recognition and processing capabilities into Ruby applications. This client covers various functionalities, including file transcription, real-time audio processing, and management of Deepgram projects and resources.
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/deepgram`. To experiment with that code, run `bin/console` for an interactive prompt.
+## Features
+
+- **Transcription**: Transcribe audio files or live audio streams with support for various audio formats.
+- **Text-to-Speech**: Convert text into natural-sounding speech, with support for asynchronous operations and callbacks.
+- **Project Management**: Manage Deepgram projects, including project creation, deletion, and updates.
+- **API Key Management**: Create, list, and delete API keys associated with your Deepgram projects.
+- **Member Management**: Manage project members, their roles, and permissions.
+- **Usage and Metrics**: Access detailed usage metrics and balance information for your Deepgram projects.
 
 ## Installation
 
-TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'deepgram'
+```
 
-Install the gem and add to the application's Gemfile by executing:
+And then execute:
 
-    $ bundle add UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+```bash
+bundle install
+```
 
-If bundler is not being used to manage dependencies, install the gem by executing:
+Or install it yourself as:
 
-    $ gem install UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+```bash
+gem install deepgram
+```
 
 ## Usage
 
-TODO: Write usage instructions here
+### Initialization
 
-## Development
+```ruby
+require 'deepgram'
+
+# Initialize the client for different functionalities
+read_client = Deepgram::Client.read
+speak_client = Deepgram::Client.speak
+listen_client = Deepgram::Client.listen
+management_client = Deepgram::Client.management
+on_prem_client = Deepgram::Client.on_prem
+```
+
+### Transcribing Audio Files
+
+```ruby
+response = listen_client.transcribe_file(path: 'path/to/your/audio_file.wav')
+puts response.transcript
+```
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+### Converting Text to Speech
+
+```ruby
+response = speak_client.speak(text: 'Hello, world!')
+# Save the speech file or process further
+```
+
+### Managing Projects
+
+```ruby
+# List all projects
+projects = management_client.projects
+
+# Create a new API key for a project
+key_response = management_client.create_key(project_id: 'your_project_id', comment: 'New key', scopes: ['full_access'])
+```
+
+## Development
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/deepgram. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[USERNAME]/deepgram/blob/main/CODE_OF_CONDUCT.md).
+Bug reports and pull requests are welcome on GitHub at [your-github-repo-link]. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](CODE_OF_CONDUCT.md).
 
 ## License
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+The gem is available as open source under the terms of the [MIT License](LICENSE.txt).
 
 ## Code of Conduct
 
-Everyone interacting in the Deepgram project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/deepgram/blob/main/CODE_OF_CONDUCT.md).
+Everyone interacting in the DeepgramRubyClient project's codebases, issue trackers, chat rooms, and mailing lists is expected to follow the [code of conduct](CODE_OF_CONDUCT.md).

data/Rakefile

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
 

data/harvard.wav

@@ -0,0 +1 @@
+{"metadata":{"transaction_key":"deprecated","request_id":"c214e86e-bf04-4942-bd89-0794deae057f","sha256":"971b4163670445c415c6b0fb6813c38093409ecac2f6b4d429ae3574d24ad470","created":"2024-03-19T13:58:17.216Z","duration":18.356188,"channels":1,"models":["1ed36bac-f71c-4f3f-a31f-02fd6525c489"],"model_info":{"1ed36bac-f71c-4f3f-a31f-02fd6525c489":{"name":"general","version":"2024-01-26.8851","arch":"base"}}},"results":{"channels":[{"alternatives":[{"transcript":"the stale smell of old beer lingers it takes heat to bring out the odor a cold dip restores health and zest a salt pickle tastes fine with ham a tacos all pasteur are my favorite a zest food is the hot cross bun","confidence":0.99121094,"words":[{"word":"the","start":1.318125,"end":1.6376704,"confidence":0.9946289},{"word":"stale","start":1.6376704,"end":2.1169887,"confidence":0.54296875},{"word":"smell","start":2.1169887,"end":2.3566477,"confidence":0.99853516},{"word":"of","start":2.3566477,"end":2.5963068,"confidence":0.99853516},{"word":"old","start":2.5963068,"end":2.8359659,"confidence":0.9824219},{"word":"beer","start":2.8359659,"end":3.1555114,"confidence":0.984375},{"word":"lingers","start":3.1555114,"end":3.554943,"confidence":0.99853516},{"word":"it","start":4.3538065,"end":4.6733522,"confidence":0.9980469},{"word":"takes","start":4.6733522,"end":4.913011,"confidence":0.99902344},{"word":"heat","start":4.913011,"end":5.232557,"confidence":1.0},{"word":"to","start":5.232557,"end":5.392329,"confidence":0.9980469},{"word":"bring","start":5.392329,"end":5.6319885,"confidence":0.9951172},{"word":"out","start":5.6319885,"end":5.7917614,"confidence":0.9868164},{"word":"the","start":5.7917614,"end":6.03142,"confidence":0.9970703},{"word":"odor","start":6.03142,"end":6.2710795,"confidence":0.99365234},{"word":"a","start":7.084627,"end":7.322388,"confidence":0.9658203},{"word":"cold","start":7.322388,"end":7.639403,"confidence":0.96191406},{"word":"dip","start":7.639403,"end":8.139402,"confidence":0.9916992},{"word":"restores","start":8.273433,"end":8.511194,"confidence":0.9946289},{"word":"health","start":8.511194,"end":8.828209,"confidence":0.9951172},{"word":"and","start":8.828209,"end":9.06597,"confidence":0.7734375},{"word":"zest","start":9.06597,"end":9.382985,"confidence":0.99853516},{"word":"a","start":9.937761,"end":10.254776,"confidence":0.9785156},{"word":"salt","start":10.254776,"end":10.571791,"confidence":0.9941406},{"word":"pickle","start":10.571791,"end":11.047314,"confidence":0.8808594},{"word":"tastes","start":11.047314,"end":11.364328,"confidence":0.6015625},{"word":"fine","start":11.364328,"end":11.602089,"confidence":0.9902344},{"word":"with","start":11.602089,"end":11.760597,"confidence":0.99609375},{"word":"ham","start":11.760597,"end":11.998358,"confidence":0.99658203},{"word":"a","start":12.315372,"end":12.361188,"confidence":0.99316406},{"word":"tacos","start":12.719988,"end":12.9591875,"confidence":0.71191406},{"word":"all","start":13.038921,"end":13.278121,"confidence":0.3178711},{"word":"pasteur","start":13.278121,"end":13.676788,"confidence":0.953125},{"word":"are","start":13.676788,"end":13.915988,"confidence":0.9995117},{"word":"my","start":13.915988,"end":14.075455,"confidence":0.9951172},{"word":"favorite","start":14.075455,"end":14.474121,"confidence":0.9951172},{"word":"a","start":15.111988,"end":15.351188,"confidence":0.9916992},{"word":"zest","start":15.351188,"end":15.829588,"confidence":0.99853516},{"word":"food","start":15.829588,"end":16.228254,"confidence":0.9941406},{"word":"is","start":16.228254,"end":16.467455,"confidence":0.9995117},{"word":"the","start":16.467455,"end":16.62692,"confidence":0.9975586},{"word":"hot","start":16.62692,"end":16.945854,"confidence":0.9995117},{"word":"cross","start":16.945854,"end":17.264788,"confidence":0.8491211},{"word":"bun","start":17.264788,"end":17.503988,"confidence":0.9604492}]}]}]}}

data/lib/deepgram/base.rb

@@ -1,11 +1,45 @@
 # frozen_string_literal: true
 
+require 'deepgram/response_handler'
+
 module Deepgram
+  # The Base class initializes the Faraday connection to interact with the Deepgram API
+  # and provides a generic request method for its subclasses.
   class Base
+    include ResponseHandler
+
+    # Initializes a Faraday connection to the Deepgram API.
+    # The API endpoint and authorization token are set via environment variables,
+    # with defaults provided.
+    #
+    # @param options [Hash] Optional parameters for future extensions.
     def initialize(options = {})
-      @connection = Faraday.new(url: ENV.fetch('DEEPGRAM_URL', 'https://api.deepgram.com/v1'))
-      @connection.headers['Authorization'] = "Token #{ENV.fetch('DEEPGRAM_API_KEY')}"
+      @connection = Faraday.new(url: ENV.fetch('DEEPGRAM_URL', 'https://api.deepgram.com'))
+      @connection.headers['Authorization'] = "Token #{ENV.fetch('DEEPGRAM_API_KEY', 'api-key')}"
       @options = options
     end
+
+    # Sends an HTTP request to the specified path using the initialized Faraday connection.
+    # This method is designed to be flexible, allowing any HTTP method to be used.
+    #
+    # @param method [Symbol] The HTTP method to use (:get, :post, etc.).
+    # @param path [String, nil] The path to append to the base API URL (optional).
+    # @param kwargs [Hash] Additional keyword arguments to include in the request.
+    # @yieldparam request [Faraday::Request] The request object, allowing for further customization.
+    # @return [Faraday::Response] The response from the Faraday connection.
+    def request(method, path = nil, **kwargs)
+      res = @connection.send(method, path, **kwargs) do |request|
+        yield(request) if block_given?
+        request.params.merge!(kwargs)
+      end
+
+      handle_response(res)
+    end
+
+    private
+
+    # Accessor for the Faraday connection instance
+    # @return [Faraday::Connection] The Faraday connection used to interact with the API.
+    attr_reader :connection
   end
 end

data/lib/deepgram/client.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Deepgram
+  # The Client module serves as a factory for creating instances of various
+  # specialized client classes within the Deepgram module. Each client class
+  # is tailored to interact with a specific part of the Deepgram API.
+  module Client
+    # Creates a new instance of the Read::Client class.
+    #
+    # @return [Deepgram::Read::Client] A client for interacting with the Deepgram Read API.
+    def self.read
+      Read::Client.new
+    end
+
+    # Creates a new instance of the Speak::Client class.
+    #
+    # @return [Deepgram::Speak::Client] A client for interacting with the Deepgram Speak API.
+    def self.speak
+      Speak::Client.new
+    end
+
+    # Creates a new instance of the Listen::Client class.
+    #
+    # @return [Deepgram::Listen::Client] A client for interacting with the Deepgram Listen API.
+    def self.listen
+      Listen::Client.new
+    end
+
+    # Creates a new instance of the Management::Client class.
+    #
+    # @return [Deepgram::Management::Client] A client for managing resources within the Deepgram platform.
+    def self.management
+      Management::Client.new
+    end
+
+    # Creates a new instance of the OnPrem::Client class.
+    #
+    # @return [Deepgram::OnPrem::Client] A client for managing on-premise deployments within the Deepgram platform.
+    def self.on_prem
+      OnPrem::Client.new
+    end
+  end
+end

data/lib/deepgram/exception.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Deepgram
+  # Base class for all Deepgram API exceptions.
+  class Exception < StandardError
+    attr_reader :error_data
+
+    # Initializes a new instance of the Exception class.
+    #
+    # @param message [String] The error message.
+    # @param error_data [Hash] Additional error data (e.g., headers, error codes).
+    def initialize(message, error_data = {})
+      super(message)
+      @error_data = error_data
+    end
+  end
+
+  # Base class for HTTP errors returned by the Deepgram API.
+  class HTTPError < Exception
+    # Returns the headers associated with the HTTP error.
+    #
+    # @return [Hash] The headers.
+    def headers
+      error_data[:headers]
+    end
+
+    # Returns the HTTP status code associated with the error.
+    #
+    # @return [Integer] The HTTP status code.
+    def http_code
+      error_data[:code]
+    end
+  end
+
+  # Exception raised when there are insufficient credits to perform a transcription.
+  class InsufficientCredits < HTTPError; end
+
+  # Exception raised when the rate limit for API requests has been exceeded.
+  class RateLimitExceeded < HTTPError; end
+
+  # Exception raised when the API request is invalid or malformed.
+  class BadRequest < HTTPError; end
+
+  # Exception raised when the API request is not authenticated or authorized.
+  class Unauthorized < HTTPError; end
+
+  # Exception raised when the API request is not permitted or forbidden.
+  class Forbidden < HTTPError; end
+
+  # Exception raised when the requested resource is not found.
+  class NotFound < HTTPError; end
+
+  # Exception raised when there is an internal server error on the Deepgram API side.
+  class InternalServerError < HTTPError; end
+
+  # Exception raised when there is a bad gateway error on the Deepgram API side.
+  class BadGateway < HTTPError; end
+
+  # Exception raised when the Deepgram API service is temporarily unavailable.
+  class ServiceUnavailable < HTTPError; end
+
+  # Exception raised when there is a gateway timeout error on the Deepgram API side.
+  class GatewayTimeout < HTTPError; end
+end

data/lib/deepgram/fixtures.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+module Deepgram
+  # The Fixtures module provides utility methods for loading fixture files
+  # used for testing purposes.
+  module Fixtures
+    # Returns the root directory path where the fixture files are located.
+    #
+    # @return [Pathname] The root directory path.
+    def self.root
+      @root ||= Pathname.new(__dir__).join('..', '..', 'spec', 'fixtures')
+    end
+
+    # Loads the content of a fixture file as a string.
+    #
+    # @param file_name [String] The name of the fixture file to load.
+    #
+    # @return [String] The content of the loaded file.
+    def self.load_file(file_name)
+      file_path = root.join(file_name)
+      File.read(file_path)
+    end
+
+    # Loads the content of a JSON fixture file and parses it as a Ruby object.
+    #
+    # @param file_name [String] The name of the JSON fixture file to load.
+    #
+    # @return [Object] The parsed Ruby object from the JSON file.
+    def self.load_json(file_name)
+      JSON.parse(load_file(file_name))
+    end
+
+    # Loads the content of a YAML fixture file and parses it as a Ruby object.
+    #
+    # @param file_name [String] The name of the YAML fixture file to load.
+    #
+    # @return [Object] The parsed Ruby object from the YAML file.
+    def self.load_yaml(file_name)
+      YAML.safe_load(load_file(file_name), permitted_classes: [])
+    end
+  end
+end

data/lib/deepgram/listen.rb

@@ -2,39 +2,125 @@
 
 module Deepgram
   module Listen
+    # The Client class within the Listen module extends the Base class
+    # to handle operations specific to the Deepgram 'Listen' API endpoint.
     class Client < Base
+      # Initializes the Client object for the Deepgram 'Listen' service,
+      # setting up the necessary API endpoint and request headers for JSON.
       def initialize
         super
-        @connection.path_prefix = 'listen'
+        @connection.path_prefix = 'v1/listen'
         @connection.headers['Content-Type'] = 'application/json'
         @connection.headers['Accept'] = 'application/json'
       end
 
+      # Transcribes audio content from a file.
+      #
+      # @param path [String] The local file system path to the audio file to be transcribed.
+      # @param audio_format [String] The MIME type of the audio file (defaults to 'audio/wav').
+      # @param kwargs [Hash] Additional keyword arguments for the request.
+      # @return [Deepgram::Listen::Response] The response object containing transcription results.
       def transcribe_file(path:, audio_format: 'audio/wav', **kwargs)
         validate_file_path(path)
-        @connection.post do |request|
+
+        request(:post, **kwargs) do |request|
           request.headers['Content-Type'] = audio_format
-          request.params.merge!(kwargs)
           request.body = File.binread(path)
         end
       end
 
+      # Transcribes audio content from a URL.
+      #
+      # @param url [String] The URL of the audio file to be transcribed.
+      # @param kwargs [Hash] Additional keyword arguments for the request.
+      # @return [Deepgram::Listen::Response] The response object containing transcription results.
       def transcribe_url(url:, **kwargs)
         validate_url(url)
-        @connection.post do |request|
-          request.params.merge!(kwargs)
+
+        request(:post, **kwargs) do |request|
           request.body = JSON.generate(url: url)
         end
       end
 
       private
 
+      # Validates the file path to ensure the file exists.
+      #
+      # @param path [String] The file path to validate.
+      # @raise [ArgumentError] If the file path does not exist.
       def validate_file_path(path)
         raise ArgumentError, "Invalid file path: #{path}" unless File.exist?(path)
       end
 
+      # Validates the URL to ensure it is properly formatted.
+      #
+      # @param url [String] The URL to validate.
+      # @raise [ArgumentError] If the URL is not properly formatted.
       def validate_url(url)
-        raise ArgumentError, "Invalid URL: #{url}" unless url.match?(%r{\A#{URI::DEFAULT_PARSER.make_regexp}\z})
+        raise ArgumentError, "Invalid URL: #{url}" unless url.match?(/\A#{URI::DEFAULT_PARSER.make_regexp}\z/)
+      end
+
+      # Overrides the request method from the Base class to wrap the response
+      # in a Deepgram::Listen::Response object.
+      #
+      # @param (see Base#request)
+      # @return [Deepgram::Listen::Response] The wrapped response object.
+      def request(method, path = nil, **kwargs)
+        res = super(method, path, **kwargs)
+
+        Response.new(status: res.status, body: res.body, headers: res.headers)
+      end
+    end
+
+    # The Response class encapsulates the response from the Deepgram Listen API,
+    # providing methods to access various parts of the response data.
+    class Response
+      attr_reader :status, :body, :headers
+
+      # Initializes a new Response object with the given status, body, and headers.
+      #
+      # @param status [Integer] The HTTP status code of the response.
+      # @param body [String] The body of the response, expected to be in JSON format.
+      # @param headers [Hash] The HTTP headers of the response.
+      def initialize(status:, body:, headers:)
+        @status = status
+        @body = body
+        @headers = headers
+      end
+
+      # Extracts and returns the metadata from the response data.
+      #
+      # @return [Hash, nil] The metadata from the response, if present.
+      def metadata
+        raw['metadata']
+      end
+
+      # Extracts and returns the transcript text from the first channel and alternative in the response data.
+      #
+      # @return [String, nil] The transcript text, if present.
+      def transcript
+        raw.dig('results', 'channels', 0, 'alternatives', 0, 'transcript')
+      end
+
+      # Extracts and returns the words array from the first channel and alternative in the response data.
+      #
+      # @return [Array, nil] The words array, if present.
+      def words
+        raw.dig('results', 'channels', 0, 'alternatives', 0, 'words')
+      end
+
+      # Extracts and returns the confidence score from the first channel and alternative in the response data.
+      #
+      # @return [Float, nil] The confidence score, if present.
+      def confidence
+        raw.dig('results', 'channels', 0, 'alternatives', 0, 'confidence')
+      end
+
+      # Parses the response body as JSON and returns the raw data.
+      #
+      # @return [Hash] The parsed JSON from the response body.
+      def raw
+        JSON.parse(@body)
       end
     end
   end

data/lib/deepgram/management.rb

@@ -0,0 +1,273 @@
+# frozen_string_literal: true
+
+module Deepgram
+  module Management
+    # Client class for interacting with Deepgram's Management API,
+    # allowing management of projects, keys, members, and more.
+    class Client < Base
+      # Sets up the API endpoint and headers for JSON content type.
+      def initialize
+        super
+        @connection.path_prefix = 'v1/projects'
+        @connection.headers['Content-Type'] = 'application/json'
+      end
+
+      # Projects
+
+      # Retrieves all projects.
+      # @return [Deepgram::Management::Response] The response object containing projects data.
+      def projects
+        request(:get)
+      end
+
+      # Retrieves a specific project by ID.
+      # @param id [String] The project ID.
+      # @param kwargs [Hash] Additional keyword arguments for the request.
+      # @return [Deepgram::Management::Response] The response object containing the project data.
+      def get_project(id, **kwargs)
+        request(:get, id, **kwargs)
+      end
+
+      # Updates the name of a specific project.
+      # @param id [String] The project ID.
+      # @param name [String] The new name for the project.
+      # @return [Deepgram::Management::Response] The response object containing the updated project data.
+      def update_project(id, name:)
+        request(:patch, id) do |request|
+          request.body = JSON.generate(name: name)
+        end
+      end
+
+      # Deletes a specific project.
+      # @param id [String] The project ID.
+      # @return [nil] Indicates the project has been successfully deleted.
+      def delete_project(id)
+        request(:delete, id)
+      end
+
+      # Keys
+
+      # Lists all keys for a project.
+      # @param project_id [String] The project ID.
+      # @return [Deepgram::Management::Response] The response object containing keys data.
+      def keys(project_id:)
+        request(:get, "#{project_id}/keys")
+      end
+
+      # Retrieves a specific key by key ID for a project.
+      # @param key_id [String] The key ID.
+      # @param project_id [String] The project ID.
+      # @param kwargs [Hash] Additional keyword arguments for the request.
+      # @return [Deepgram::Management::Response] The response object containing the key data.
+      def get_key(key_id, project_id:, **kwargs)
+        request(:get, "#{project_id}/keys/#{key_id}", **kwargs)
+      end
+
+      # Creates a new key for a project.
+      # @param project_id [String] The project ID.
+      # @param comment [String] Comment or description for the key.
+      # @param scopes [Array] Scopes or permissions assigned to the key.
+      # @param kwargs [Hash] Additional keyword arguments for the request.
+      # @return [Deepgram::Management::Response] The response object containing the new key data.
+      def create_key(project_id:, comment:, scopes:, **kwargs)
+        request(:post, "#{project_id}/keys", **kwargs) do |request|
+          request.body = JSON.generate(comment: comment, scopes: scopes)
+        end
+      end
+
+      # Deletes a specific key for a project.
+      # @param key_id [String] The key ID.
+      # @param project_id [String] The project ID.
+      # @return [nil] Indicates the key has been successfully deleted.
+      def delete_key(key_id, project_id:)
+        request(:delete, "#{project_id}/keys/#{key_id}")
+      end
+
+      # Members
+
+      # Lists all members of a project.
+      # @param project_id [String] The project ID.
+      # @return [Deepgram::Management::Response] The response object containing members data.
+      def members(project_id:)
+        request(:get, "#{project_id}/members")
+      end
+
+      # Removes a specific member from a project.
+      # @param member_id [String] The member ID.
+      # @param project_id [String] The project ID.
+      # @return [nil] Indicates the member has been successfully removed.
+      def remove_member(member_id, project_id:)
+        request(:delete, "#{project_id}/members/#{member_id}")
+      end
+
+      # Retrieves scopes for a specific member of a project.
+      # @param project_id [String] The project ID.
+      # @param member_id [String] The member ID.
+      # @return [Deepgram::Management::Response] The response object containing member's scopes data.
+      def member_scopes(project_id:, member_id:)
+        request(:get, "#{project_id}/members/#{member_id}/scopes")
+      end
+
+      # Updates the scopes for a specific member of a project.
+      # @param scope [Array] The new scopes for the member.
+      # @param project_id [String] The project ID.
+      # @param member_id [String] The member ID.
+      # @return [Deepgram::Management::Response] The response object indicating the update was successful.
+      def update_scope(scope, project_id:, member_id:)
+        request(:put, "#{project_id}/members/#{member_id}/scopes") do |request|
+          request.body = JSON.generate(scope: scope)
+        end
+      end
+
+      # Invitations
+
+      # Lists all invites for a project.
+      # @param project_id [String] The project ID.
+      # @return [Deepgram::Management::Response] The response object containing invites data.
+      def invites(project_id:)
+        request(:get, "#{project_id}/invites")
+      end
+
+      # Sends an invite to join a project.
+      # @param email [String] The email address of the invitee.
+      # @param project_id [String] The project ID.
+      # @param scope [Array] The scopes assigned to the invitee upon acceptance.
+      # @return [Deepgram::Management::Response] The response object indicating the invite was sent.
+      def send_invite(email:, project_id:, scope:)
+        request(:post, "#{project_id}/invites") do |request|
+          request.body = JSON.generate(email: email, scope: scope)
+        end
+      end
+
+      # Deletes an invite for a project.
+      # @param email [String] The email address of the invitee.
+      # @param project_id [String] The project ID.
+      # @return [nil] Indicates the invite has been successfully deleted.
+      def delete_invite(email, project_id:)
+        request(:delete, "#{project_id}/invites/#{email}")
+      end
+
+      # Allows a member to leave a project.
+      # @param project_id [String] The project ID.
+      # @return [nil] Indicates the member has left the project.
+      def leave_project(project_id:)
+        request(:delete, "#{project_id}/leave")
+      end
+
+      # Requests
+
+      # Lists all requests for a project.
+      # @param project_id [String] The project ID.
+      # @param kwargs [Hash] Additional keyword arguments for the request.
+      # @return [Deepgram::Management::Response] The response object containing requests data.
+      def requests(project_id:, **kwargs)
+        request(:get, "#{project_id}/requests", **kwargs)
+      end
+
+      # Retrieves a specific request for a project.
+      # @param request_id [String] The request ID.
+      # @param project_id [String] The project ID.
+      # @return [Deepgram::Management::Response] The response object containing the request data.
+      def get_request(request_id, project_id:)
+        request(:get, "#{project_id}/requests/#{request_id}")
+      end
+
+      # Usage
+
+      # Retrieves usage information for a project.
+      # @param project_id [String] The project ID.
+      # @param kwargs [Hash] Additional keyword arguments for the request.
+      # @return [Deepgram::Management::Response] The response object containing usage data.
+      def usage(project_id:, **kwargs)
+        request(:get, "#{project_id}/usage", **kwargs)
+      end
+
+      # Retrieves the available fields for usage data for a project.
+      # @param project_id [String] The project ID.
+      # @param kwargs [Hash] Additional keyword arguments for the request.
+      # @return [Deepgram::Management::Response] The response object containing fields data.
+      def fields(project_id:, **kwargs)
+        request(:get, "#{project_id}/usage/fields", **kwargs)
+      end
+
+      # Balances
+
+      # Lists all balances for a project.
+      # @param project_id [String] The project ID.
+      # @return [Deepgram::Management::Response] The response object containing balances data.
+      def balances(project_id:)
+        request(:get, "#{project_id}/balances")
+      end
+
+      # Retrieves a specific balance for a project.
+      # @param balance_id [String] The balance ID.
+      # @param project_id [String] The project ID.
+      # @return [Deepgram::Management::Response] The response object containing the balance data.
+      def balance(balance_id, project_id:)
+        request(:get, "#{project_id}/balances/#{balance_id}")
+      end
+
+      private
+
+      # Extends the Base class's request method to wrap the response in a Management::Response object.
+      # @param method [Symbol] The HTTP method.
+      # @param path [String] The endpoint path.
+      # @param kwargs [Hash] Additional keyword arguments for the request.
+      # @return [Deepgram::Management::Response] The wrapped response object.
+      def request(method, path = nil, **kwargs)
+        res = super(method, path, **kwargs)
+
+        Response.new(status: res.status, body: res.body, headers: res.headers)
+      end
+    end
+
+    # Encapsulates the response from the Management API, providing methods to access various response data.
+    class Response
+      def initialize(status:, body:, headers:)
+        @status = status
+        @body = body
+        @headers = headers
+      end
+
+      # Parses the response body as JSON and returns the raw data.
+      def raw
+        JSON.parse(@body)
+      end
+
+      # Methods for accessing specific parts of the response data, such as projects, keys, members, etc.
+      # Each method parses the raw JSON data and returns the relevant section, e.g., `raw['projects']` for `projects`.
+
+      def projects
+        raw['projects']
+      end
+
+      def keys
+        raw['api_keys']
+      end
+
+      def members
+        raw['members']
+      end
+
+      def scopes
+        raw['scopes']
+      end
+
+      def invites
+        raw['invites']
+      end
+
+      def requests
+        raw['requests']
+      end
+
+      def balances
+        raw['balances']
+      end
+
+      def distribution_credentials
+        raw['distribution_credentials']
+      end
+    end
+  end
+end

data/lib/deepgram/on_prem.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Deepgram
+  module OnPrem
+    # The Client class within the OnPrem module extends the Management::Client class
+    # to handle operations specific to on-premise deployments within the Deepgram platform.
+    class Client < Management::Client
+      # Retrieves a list of credentials for a given project.
+      #
+      # @param project_id [String] The unique identifier for the project.
+      # @return [Array] A list of credentials associated with the specified project.
+      def credentials(project_id:)
+        request(:get, "#{project_id}/onprem/distribution/credentials")
+      end
+
+      # Retrieves a specific credential by its ID within a given project.
+      #
+      # @param id [String] The unique identifier for the credential.
+      # @param project_id [String] The unique identifier for the project.
+      # @return [Hash] The details of the specified credential.
+      def get_credential(id, project_id:)
+        request(:get, "#{project_id}/onprem/distribution/credentials/#{id}")
+      end
+
+      # Creates a new credential within a project with the specified details.
+      #
+      # @param comments [String] Descriptive comments about the credential.
+      # @param scopes [Array] The scopes or permissions assigned to the credential.
+      # @param provider [String] The provider or platform for which the credential is valid.
+      # @param project_id [String] The unique identifier for the project.
+      # @return [Hash] The details of the newly created credential.
+      def create_credential(comments:, scopes:, provider:, project_id:)
+        request(:post, "#{project_id}/onprem/distribution/credentials") do |request|
+          request.body = JSON.generate(comments: comments, scopes: scopes, provider: provider)
+        end
+      end
+
+      # Deletes a specific credential by its ID from a given project.
+      #
+      # @param id [String] The unique identifier for the credential to be deleted.
+      # @param project_id [String] The unique identifier for the project.
+      # @return [nil] Indicates the credential has been successfully deleted.
+      def delete_credential(id, project_id:)
+        request(:delete, "#{project_id}/onprem/distribution/credentials/#{id}")
+      end
+    end
+  end
+end

data/lib/deepgram/read.rb

@@ -1,48 +1,92 @@
 # frozen_string_literal: true
 
+require 'deepgram/fixtures'
+
 module Deepgram
   module Read
+    # The Client class extends the Base class to handle read operations
+    # specific to the Deepgram 'Read' API endpoint.
     class Client < Base
+      # Initializes a Client object for the Deepgram 'Read' service.
+      # Sets the default language and appropriate headers for JSON requests.
+      #
+      # @param language [String] The default language to use for analysis (defaults to 'en').
       def initialize(language = 'en')
-        super
-
+        super()
         @connection.path_prefix = 'v1/read'
         @connection.params[:language] = language
         @connection.headers['Content-Type'] = 'application/json'
       end
 
-      def summarize(text:, **kwargs)
-        post(text, **kwargs) do |params|
-          params[:summarize] = true
+      # Sends a POST request to analyze text using the Deepgram Read API.
+      # Returns a Response object containing the analysis results.
+      #
+      # @param text [String] The text to be analyzed.
+      # @param kwargs [Hash] Additional keyword arguments to be sent with the request.
+      # @return [Deepgram::Read::Response] The response object containing analysis results.
+      def analyze(text:, **kwargs)
+        res = request(:post, **kwargs) do |request|
+          request.body = JSON.generate(text: text)
         end
+
+        Response.new(status: res.status, body: res.body, headers: res.headers)
       end
+    end
 
-      def topics(text:, **kwargs)
-        post(text, **kwargs) do |params|
-          params[:topics] = true
-        end
+    # The Response class encapsulates the response from the Deepgram Read API,
+    # providing methods to access various parts of the response data.
+    class Response
+      # Initializes a new Response object with the given status, body, and headers.
+      #
+      # @param status [Integer] The HTTP status code of the response.
+      # @param body [String] The body of the response, expected to be in JSON format.
+      # @param headers [Hash] The HTTP headers of the response.
+      def initialize(status:, body:, headers:)
+        @status = status
+        @body = body
+        @headers = headers
       end
 
-      def sentiment(text:, **kwargs)
-        post(text, **kwargs) do |params|
-          params[:sentiment] = true
-        end
+      # Parses the response body as JSON and returns the raw data.
+      #
+      # @return [Hash] The parsed JSON from the response body.
+      def raw
+        JSON.parse(@body)
       end
 
-      def intents(text:, **kwargs)
-        post(text, **kwargs) do |params|
-          params[:intents] = true
-        end
+      # Extracts and returns the metadata from the response data.
+      #
+      # @return [Hash, nil] The metadata from the response, if present.
+      def metadata
+        raw['metadata']
       end
 
-      private
+      # Extracts and returns the summary text from the response data.
+      #
+      # @return [String, nil] The summarized text, if present.
+      def summary
+        raw.dig('results', 'summary', 'text')
+      end
 
-      def post(text, **kwargs)
-        @connection.post do |request|
-          request.body = JSON.generate(text: text)
-          request.params.merge!(kwargs)
-          yield request.params if block_given?
-        end
+      # Extracts and returns the topics segments from the response data.
+      #
+      # @return [Array, nil] The topics segments, if present.
+      def topics
+        raw.dig('results', 'topics', 'segments')
+      end
+
+      # Extracts and returns the sentiments segments from the response data.
+      #
+      # @return [Array, nil] The sentiments segments, if present.
+      def sentiments
+        raw.dig('results', 'sentiments', 'segments')
+      end
+
+      # Extracts and returns the intents segments from the response data.
+      #
+      # @return [Array, nil] The intents segments, if present.
+      def intents
+        raw.dig('results', 'intents', 'segments')
       end
     end
   end

data/lib/deepgram/response_handler.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative 'exception'
+
+module Deepgram
+  # The ResponseHandler module provides a method for handling responses
+  # from the Deepgram API and raising appropriate exceptions based on
+  # the HTTP status code.
+  module ResponseHandler
+    # Handles the response from the Deepgram API.
+    #
+    # @param res [Faraday::Response] The response object from the API request.
+    #
+    # @raise [Deepgram::BadRequestError] If the response has a 400 status code.
+    # @raise [Deepgram::UnauthorizedError] If the response has a 401 status code.
+    # @raise [Deepgram::ForbiddenError] If the response has a 403 status code.
+    # @raise [Deepgram::NotFoundError] If the response has a 404 status code.
+    # @raise [Deepgram::RateLimitExceededError] If the response has a 429 status code.
+    # @raise [Deepgram::InternalServerErrorError] If the response has a 500 status code.
+    # @raise [Deepgram::BadGatewayError] If the response has a 502 status code.
+    # @raise [Deepgram::ServiceUnavailableError] If the response has a 503 status code.
+    #
+    # @return [Faraday::Response] The response object if the status code is between 200 and 226.
+    def handle_response(res) # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
+      case res.status
+      when 200..226 then res
+      when 400 then raise Deepgram::BadRequest.new(res.body, code: res.status, headers: res.headers)
+      when 401 then raise Deepgram::Unauthorized.new(res.body, code: res.status, headers: res.headers)
+      when 403 then raise Deepgram::Forbidden.new(res.body, code: res.status, headers: res.headers)
+      when 404 then raise Deepgram::NotFound.new(res.body, code: res.status, headers: res.headers)
+      when 429 then raise Deepgram::RateLimitExceeded.new(res.body, code: res.status, headers: res.headers)
+      when 500 then raise Deepgram::InternalServerError.new(res.body, code: res.status, headers: res.headers)
+      when 502 then raise Deepgram::BadGateway.new(res.body, code: res.status, headers: res.headers)
+      when 503 then raise Deepgram::ServiceUnavailable.new(res.body, code: res.status, headers: res.headers)
+      end
+    end
+  end
+end

data/lib/deepgram/speak.rb

@@ -2,28 +2,89 @@
 
 module Deepgram
   module Speak
+    # The Client class within the Speak module extends the Base class
+    # to handle operations specific to the Deepgram 'Speak' API endpoint.
     class Client < Base
+      # Initializes the Client object for the Deepgram 'Speak' service,
+      # setting up the necessary API endpoint and request headers for JSON.
       def initialize
         super
-
         @connection.path_prefix = 'v1/speak'
         @connection.headers['Content-Type'] = 'application/json'
       end
 
+      # Sends a synchronous request to convert text to speech.
+      #
+      # @param text [String] The text to be converted to speech.
+      # @param kwargs [Hash] Additional keyword arguments for the request.
+      # @return [Deepgram::Speak::Response] The response object containing the speech file.
       def speak(text:, **kwargs)
-        @connection.post do |request|
-          request.params.merge!(kwargs)
+        request(:post, **kwargs) do |request|
           request.body = JSON.generate(text: text)
         end
       end
 
+      # Sends an asynchronous request to convert text to speech, with the results
+      # sent to a specified callback URL.
+      #
+      # @param text [String] The text to be converted to speech.
+      # @param callback_url [String] The URL to which the response will be sent upon completion.
+      # @param kwargs [Hash] Additional keyword arguments for the request.
+      # @return [Deepgram::Speak::Response] The response object containing the speech file or request details.
       def speak_async(text:, callback_url:, **kwargs)
-        @connection.post do |request|
-          request.params.merge!(kwargs)
-          request.params[:callback] = callback_url
+        request(:post, callback_url: callback_url, **kwargs) do |request|
           request.body = JSON.generate(text: text)
         end
       end
+
+      private
+
+      # Overrides the request method from the Base class to wrap the response
+      # in a Deepgram::Speak::Response object.
+      #
+      # @param (see Base#request)
+      # @return [Deepgram::Speak::Response] The wrapped response object.
+      def request(method, path = nil, **kwargs)
+        res = super(method, path, **kwargs)
+
+        Response.new(status: res.status, body: res.body, headers: res.headers)
+      end
+    end
+
+    # The Response class encapsulates the response from the Deepgram Speak API,
+    # providing methods to access various parts of the response data.
+    class Response
+      # Initializes a new Response object with the given status, body, and headers.
+      #
+      # @param status [Integer] The HTTP status code of the response.
+      # @param body [String] The body of the response, expected to contain the speech file or request details.
+      # @param headers [Hash] The HTTP headers of the response.
+      def initialize(status:, body:, headers:)
+        @status = status
+        @body = body
+        @headers = headers
+      end
+
+      # Parses the response body as JSON and returns the raw data.
+      #
+      # @return [Hash] The parsed JSON from the response body.
+      def raw
+        JSON.parse(@body)
+      end
+
+      # Extracts and returns the request ID from the response data.
+      #
+      # @return [String, nil] The request ID, if present.
+      def request_id
+        raw['request_id']
+      end
+
+      # Returns the body of the response, which contains the speech file in asynchronous requests.
+      #
+      # @return [String] The body of the response.
+      def file
+        @body
+      end
     end
   end
 end

data/lib/deepgram/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Deepgram
-  VERSION = "0.1.0"
+  VERSION = '0.2.0'
 end

data/lib/deepgram.rb

@@ -1,13 +1,29 @@
 # frozen_string_literal: true
 
+# The Deepgram Ruby gem provides a simple and convenient way to interact
+# with the Deepgram APIs for speech recognition, text-to-speech, and
+# natural language processing tasks.
+#
+# This file serves as the main entry point for the gem and handles loading
+# the necessary dependencies and modules.
+
 require 'faraday'
 require 'dotenv/load'
+
+# Load version information
 require_relative 'deepgram/version'
+
+# Load base classes and modules
 require_relative 'deepgram/base'
 require_relative 'deepgram/listen'
 require_relative 'deepgram/speak'
 require_relative 'deepgram/read'
+require_relative 'deepgram/client'
+require_relative 'deepgram/management'
+require_relative 'deepgram/on_prem'
 
+# The Deepgram module is the main namespace for the gem.
+# It provides access to the various classes and modules
+# for interacting with the Deepgram APIs.
 module Deepgram
-  class Error < StandardError; end
 end

data/projects.json

@@ -0,0 +1,8 @@
+{
+  "projects": [
+    {
+      "project_id": "ccb6b56a-332d-46dc-ba33-618fdb0dbf91",
+      "name": "rileyjhardy@gmail.com's Project"
+    }
+  ]
+}

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: deepgram
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Riley Hardy
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-03-19 00:00:00.000000000 Z
+date: 2024-04-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -38,6 +38,76 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.18'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.18'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.7'
+- !ruby/object:Gem::Dependency
+  name: guard-rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.62'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.62'
 description: Ruby toolkit for Deepgram API https://www.deepgram.com
 email:
 - 54298858+rileyjhardy@users.noreply.github.com
@@ -46,18 +116,27 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".rspec"
+- ".rubocop.yml"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
+- Guardfile
 - LICENSE.txt
 - README.md
 - Rakefile
+- harvard.wav
 - lib/deepgram.rb
 - lib/deepgram/base.rb
+- lib/deepgram/client.rb
+- lib/deepgram/exception.rb
+- lib/deepgram/fixtures.rb
 - lib/deepgram/listen.rb
+- lib/deepgram/management.rb
+- lib/deepgram/on_prem.rb
 - lib/deepgram/read.rb
+- lib/deepgram/response_handler.rb
 - lib/deepgram/speak.rb
 - lib/deepgram/version.rb
-- sig/deepgram.rbs
+- projects.json
 homepage: https://github.com/rileyjhardy/deepgram
 licenses:
 - MIT
@@ -70,7 +149,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/sig/deepgram.rbs

@@ -1,4 +0,0 @@
-module Deepgram
-  VERSION: String
-  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
-end