lda_gov 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6b11b53da03541ac152c2f82a616f5d148f25df35746066d8407abcaeed0ec2a
+  data.tar.gz: eed3157d2c8714c4c218652ecc727ecd4c399208a19054063a9ba75dbb4cf626
+SHA512:
+  metadata.gz: c442d0857cbe0ce7da7e5abc3bc2971ff06c014f21bcde21c5a85a9de52d531187d81b3f0e4556cc98c73b046c961acf3cc3db771f7243ec10e9ab5c7817d671
+  data.tar.gz: 96c78265857b7b05a135806c09e8c60826575d94cf7b6e963a09e3b538ab9664d01936a76bd11ee94e264019c7d11d038b7b9722b9bf0136d8a43c564cfbc7d3

data/CHANGELOG.md

@@ -0,0 +1,14 @@
+# Changelog
+
+## [0.1.0] - 2025-03-13
+
+### Added
+- Initial release
+- Filings resource (list, find, quarterly, by_registrant_and_client, by_issue)
+- Contributions resource (list, find)
+- Registrants resource (list, find)
+- Clients resource (list, find)
+- Lobbyists resource (list, find)
+- Constants resource (filing_types, lobbying_issues, government_entities, states, countries, contribution_types)
+- Django REST Framework pagination support
+- Token-based authentication (optional)

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Jack Killilea
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,228 @@
+# LDA Gov
+
+A Ruby client for the [LDA.gov](https://lda.gov) Lobbying Disclosure Act API. Access lobbying filings, contributions, registrants, clients, lobbyists, and reference data.
+
+No API key required for basic access (15 req/min anonymous). Optional API key available at [lda.gov/api](https://lda.gov/api/) for higher rate limits.
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem 'lda_gov'
+```
+
+Then `bundle install`, or install directly:
+
+```bash
+gem install lda_gov
+```
+
+## Quick Start
+
+```ruby
+require 'lda_gov'
+
+# Search recent lobbying filings
+filings = LDA.filings.list(filing_year: 2024)
+filings.each { |f| puts f['filing_uuid'] }
+```
+
+## Usage
+
+### Filings
+
+```ruby
+# List filings with filters
+filings = LDA.filings.list(filing_year: 2024, filing_period: 'Q1')
+
+# Find a specific filing
+filing = LDA.filings.find('some-filing-uuid')
+
+# Quarterly filings
+LDA.filings.quarterly(year: 2024, quarter: 1)
+
+# Filter by registrant and client
+LDA.filings.by_registrant_and_client(
+  registrant_name: 'Acme Lobbying',
+  client_name: 'Big Corp'
+)
+
+# Filter by lobbying issue
+LDA.filings.by_issue(issue_code: 'HCR')
+```
+
+### Contributions
+
+```ruby
+contributions = LDA.contributions.list
+contribution = LDA.contributions.find(123)
+```
+
+### Registrants
+
+```ruby
+registrants = LDA.registrants.list
+registrant = LDA.registrants.find(456)
+```
+
+### Clients
+
+```ruby
+clients = LDA.clients.list
+client = LDA.clients.find(789)
+```
+
+### Lobbyists
+
+```ruby
+lobbyists = LDA.lobbyists.list
+lobbyist = LDA.lobbyists.find(101)
+```
+
+### Constants (Reference Data)
+
+```ruby
+LDA.constants.filing_types
+LDA.constants.lobbying_issues
+LDA.constants.government_entities
+LDA.constants.states
+LDA.constants.countries
+LDA.constants.contribution_types
+```
+
+### Pagination
+
+Iterate page by page with `each_page`:
+
+```ruby
+LDA.filings.each_page(filing_year: 2024) do |page|
+  page.each { |filing| process(filing) }
+end
+```
+
+Fetch all results at once:
+
+```ruby
+all_filings = LDA.filings.all_filings(filing_year: 2024)
+all_filings.size  # => total count
+
+# Available on all resources
+LDA.contributions.all_contributions
+LDA.registrants.all_registrants
+LDA.clients.all_clients
+LDA.lobbyists.all_lobbyists
+```
+
+## Configuration
+
+```ruby
+LDA.configure do |config|
+  config.api_key = ENV['LDA_API_KEY']       # Optional — enables higher rate limits
+  config.timeout = 60                        # Request timeout in seconds (default: 30)
+  config.retries = 5                         # Max retries on 429/5xx (default: 3)
+  config.logger  = Logger.new($stdout)       # Optional request logging
+end
+```
+
+### Rails Initializer
+
+```ruby
+# config/initializers/lda_gov.rb
+LDA.configure do |config|
+  config.api_key = ENV['LDA_API_KEY']
+  config.timeout = 30
+  config.retries = 3
+  config.logger  = Rails.logger if Rails.env.development?
+end
+```
+
+### Per-Instance Client
+
+For different configurations in the same process:
+
+```ruby
+client = LDA::Client.new(custom_config)
+client.filings.list(filing_year: 2024)
+client.contributions.list
+```
+
+## Response Object
+
+All API calls return an `LDA::Response`:
+
+```ruby
+response = LDA.filings.list(filing_year: 2024)
+
+response.results             # Array of result hashes
+response.each { |r| ... }   # Enumerable — supports map, select, first, etc.
+response.size                # Results on this page
+response.empty?              # No results?
+response.count               # Total matching records (from API envelope)
+response.total_count         # Alias for count
+response.next_page?          # More pages available?
+response.next_page_number    # Page number from next URL
+response.success?            # HTTP 2xx?
+
+response['key']              # Direct hash access
+response.dig('nested', 'key')
+response.raw                 # Raw parsed JSON body
+response.to_h                # Always returns a Hash
+response.to_json             # JSON string
+```
+
+## Error Handling
+
+```ruby
+begin
+  LDA.filings.find('INVALID')
+rescue LDA::BadRequestError => e
+  puts "Bad request: #{e.status} — #{e.body}"
+rescue LDA::NotFoundError => e
+  puts "Not found: #{e.status}"
+rescue LDA::UnauthorizedError => e
+  puts "Unauthorized: #{e.body}"
+rescue LDA::RateLimitError
+  puts 'Rate limited — retries exhausted'
+rescue LDA::ServerError => e
+  puts "Server error: #{e.status}"
+rescue LDA::ConnectionError => e
+  puts "Network issue: #{e.message}"
+end
+```
+
+Error hierarchy:
+
+```
+LDA::Error
+├── ClientError
+│   ├── BadRequestError         (400)
+│   ├── NotFoundError           (404)
+│   ├── UnauthorizedError       (401)
+│   ├── UnprocessableEntityError (422)
+│   └── RateLimitError          (429)
+├── ServerError                 (500+)
+└── ConnectionError             (timeouts, DNS, refused)
+```
+
+All `ClientError` and `ServerError` subclasses expose `.status` and `.body`.
+
+## Development
+
+```bash
+git clone https://github.com/xjackk/lda_gov.git
+cd lda_gov
+bundle install
+
+bundle exec rspec       # Run tests
+bundle exec rubocop     # Lint
+```
+
+## Requirements
+
+- Ruby >= 3.1
+- Faraday ~> 2.0
+
+## License
+
+MIT License. See [LICENSE.txt](LICENSE.txt).

data/lib/lda_gov/client.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require 'faraday/retry'
+
+module LDA
+  class Client
+    MAX_PAGES = 100
+
+    attr_reader :config
+
+    def initialize(config = LDA.configuration)
+      @config = config
+    end
+
+    def connection
+      @connection ||= build_connection
+    end
+
+    def get(path, params = {})
+      response = connection.get(path, compact_params(params))
+      handle_response(response)
+    rescue Faraday::TimeoutError => e
+      raise ConnectionError, "Request timed out: #{e.message}"
+    rescue Faraday::ConnectionFailed => e
+      raise ConnectionError, "Connection failed: #{e.message}"
+    end
+
+    def paginate(path, params = {})
+      page = 1
+      iterations = 0
+      loop do
+        iterations += 1
+        response = get(path, params.merge(page: page))
+        yield response
+        break if response.empty?
+        break unless response.next_page?
+
+        page = response.next_page_number
+        break if page.nil?
+        break if iterations >= MAX_PAGES
+      end
+    end
+
+    def all(path, params = {})
+      records = []
+      paginate(path, params) { |response| records.concat(response.results) }
+      records
+    end
+
+    # Resource accessors
+
+    def filings
+      @filings ||= Resources::Filings.new(self)
+    end
+
+    def contributions
+      @contributions ||= Resources::Contributions.new(self)
+    end
+
+    def registrants
+      @registrants ||= Resources::Registrants.new(self)
+    end
+
+    def clients
+      @clients ||= Resources::Clients.new(self)
+    end
+
+    def lobbyists
+      @lobbyists ||= Resources::Lobbyists.new(self)
+    end
+
+    def constants
+      @constants ||= Resources::Constants.new(self)
+    end
+
+    def inspect
+      "#<#{self.class} base_url=#{config.base_url.inspect} timeout=#{config.timeout}>"
+    end
+
+    private
+
+    def build_connection # rubocop:disable Metrics/MethodLength
+      Faraday.new(url: config.base_url) do |f|
+        f.options.timeout      = config.timeout
+        f.options.open_timeout = 10
+
+        f.headers['User-Agent'] = "lda_gov-rb/#{LDA::VERSION}"
+        f.headers['Authorization'] = "Token #{config.api_key}" if config.api_key
+
+        f.request :json
+        f.response :json, content_type: /\bjson$/
+
+        f.request :retry,
+                  max: config.retries,
+                  interval: 0.5,
+                  interval_randomness: 0.5,
+                  backoff_factor: 2,
+                  retry_statuses: [429, 500, 502, 503, 504],
+                  exceptions: [
+                    Faraday::TimeoutError,
+                    Faraday::ConnectionFailed,
+                    Faraday::RetriableResponse
+                  ]
+
+        f.response :logger, config.logger if config.logger
+        f.adapter config.adapter
+      end
+    end
+
+    def compact_params(params)
+      params.compact.transform_keys(&:to_s)
+    end
+
+    def handle_response(response)
+      case response.status
+      when 200..299
+        Response.new(response.body, response.status)
+      when 400
+        raise BadRequestError.new(status: response.status, body: response.body)
+      when 401
+        raise UnauthorizedError.new(status: response.status, body: response.body)
+      when 404
+        raise NotFoundError.new(status: response.status, body: response.body)
+      when 422
+        raise UnprocessableEntityError.new(status: response.status, body: response.body)
+      when 429
+        raise RateLimitError.new(status: 429, body: response.body)
+      when 400..499
+        raise ClientError.new(status: response.status, body: response.body)
+      when 500..599
+        raise ServerError.new(status: response.status, body: response.body)
+      else
+        raise Error, "Unexpected HTTP status: #{response.status}"
+      end
+    end
+  end
+end

data/lib/lda_gov/configuration.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module LDA
+  class Configuration
+    DEFAULT_BASE_URL = 'https://lda.gov/api/v1/'
+    DEFAULT_TIMEOUT  = 30
+    DEFAULT_RETRIES  = 3
+
+    attr_accessor :base_url, :timeout, :retries, :logger, :adapter, :api_key
+
+    def initialize
+      @base_url = DEFAULT_BASE_URL
+      @timeout  = DEFAULT_TIMEOUT
+      @retries  = DEFAULT_RETRIES
+      @logger   = nil
+      @adapter  = Faraday.default_adapter
+      @api_key  = ENV.fetch('LDA_API_KEY', nil)
+    end
+
+    def to_h
+      {
+        base_url: base_url,
+        timeout: timeout,
+        retries: retries,
+        logger: logger,
+        adapter: adapter,
+        api_key: api_key
+      }
+    end
+
+    def inspect
+      "#<#{self.class} base_url=#{base_url.inspect} timeout=#{timeout} retries=#{retries}>"
+    end
+  end
+end

data/lib/lda_gov/error.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module LDA
+  class Error < StandardError; end
+
+  class ClientError < Error
+    attr_reader :status, :body
+
+    def initialize(message = nil, status: nil, body: nil)
+      @status = status
+      @body   = body
+      super(message || "HTTP #{status}: #{body}")
+    end
+  end
+
+  class BadRequestError < ClientError; end
+  class NotFoundError < ClientError; end
+  class UnauthorizedError < ClientError; end
+  class RateLimitError < ClientError; end
+  class UnprocessableEntityError < ClientError; end
+
+  class ServerError < Error
+    attr_reader :status, :body
+
+    def initialize(message = nil, status: nil, body: nil)
+      @status = status
+      @body   = body
+      super(message || "Server error HTTP #{status}")
+    end
+  end
+
+  class ConnectionError < Error; end
+end

data/lib/lda_gov/resources/base.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module LDA
+  module Resources
+    class Base
+      def initialize(client = LDA.client)
+        @client = client
+      end
+
+      private
+
+      attr_reader :client
+
+      def get(path, params = {})
+        client.get(path, params)
+      end
+    end
+  end
+end

data/lib/lda_gov/resources/clients.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module LDA
+  module Resources
+    class Clients < Base
+      def list(**params)
+        get('clients/', params)
+      end
+
+      def find(client_id)
+        get("clients/#{client_id}/")
+      end
+
+      def each_page(**params, &)
+        client.paginate('clients/', params, &)
+      end
+
+      def all_clients(**params)
+        client.all('clients/', params)
+      end
+    end
+  end
+end

data/lib/lda_gov/resources/constants.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module LDA
+  module Resources
+    class Constants < Base
+      def filing_types
+        get('constants/filing/filingtypes/')
+      end
+
+      def lobbying_issues
+        get('constants/filing/lobbyingissuecodes/')
+      end
+
+      def government_entities
+        get('constants/filing/governmententities/')
+      end
+
+      def states
+        get('constants/general/states/')
+      end
+
+      def countries
+        get('constants/general/countries/')
+      end
+
+      def contribution_types
+        get('constants/contribution/contributiontypes/')
+      end
+    end
+  end
+end

data/lib/lda_gov/resources/contributions.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module LDA
+  module Resources
+    class Contributions < Base
+      def list(**params)
+        get('contributions/', params)
+      end
+
+      def find(contribution_id)
+        get("contributions/#{contribution_id}/")
+      end
+
+      def each_page(**params, &)
+        client.paginate('contributions/', params, &)
+      end
+
+      def all_contributions(**params)
+        client.all('contributions/', params)
+      end
+    end
+  end
+end

data/lib/lda_gov/resources/filings.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module LDA
+  module Resources
+    class Filings < Base
+      def list(**params)
+        get('filings/', params)
+      end
+
+      def find(filing_uuid)
+        get("filings/#{filing_uuid}/")
+      end
+
+      def each_page(**params, &)
+        client.paginate('filings/', params, &)
+      end
+
+      def all_filings(**params)
+        client.all('filings/', params)
+      end
+
+      def quarterly(year:, quarter:, **params)
+        get('filings/', params.merge(filing_year: year, filing_period: "Q#{quarter}"))
+      end
+
+      def by_registrant_and_client(registrant_name:, client_name:, **params)
+        get('filings/', params.merge(registrant_name: registrant_name, client_name: client_name))
+      end
+
+      def by_issue(issue_code:, **params)
+        get('filings/', params.merge(lobbying_issue: issue_code))
+      end
+    end
+  end
+end

data/lib/lda_gov/resources/lobbyists.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module LDA
+  module Resources
+    class Lobbyists < Base
+      def list(**params)
+        get('lobbyists/', params)
+      end
+
+      def find(lobbyist_id)
+        get("lobbyists/#{lobbyist_id}/")
+      end
+
+      def each_page(**params, &)
+        client.paginate('lobbyists/', params, &)
+      end
+
+      def all_lobbyists(**params)
+        client.all('lobbyists/', params)
+      end
+    end
+  end
+end

data/lib/lda_gov/resources/registrants.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module LDA
+  module Resources
+    class Registrants < Base
+      def list(**params)
+        get('registrants/', params)
+      end
+
+      def find(registrant_id)
+        get("registrants/#{registrant_id}/")
+      end
+
+      def each_page(**params, &)
+        client.paginate('registrants/', params, &)
+      end
+
+      def all_registrants(**params)
+        client.all('registrants/', params)
+      end
+    end
+  end
+end

data/lib/lda_gov/response.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module LDA
+  class Response
+    include Enumerable
+
+    attr_reader :raw, :status
+
+    def initialize(body, status)
+      @raw    = body
+      @status = status
+    end
+
+    def each(&)
+      results.each(&)
+    end
+
+    def results
+      return raw if raw.is_a?(Array)
+
+      raw['results'] || []
+    end
+
+    def size
+      results.size
+    end
+    alias length size
+
+    def empty?
+      results.empty?
+    end
+
+    def count
+      return raw['count'] if raw.is_a?(Hash) && raw.key?('count')
+
+      size
+    end
+    alias total_count count
+
+    def next_url
+      return nil unless raw.is_a?(Hash)
+
+      raw['next']
+    end
+
+    def previous_url
+      return nil unless raw.is_a?(Hash)
+
+      raw['previous']
+    end
+
+    def next_page?
+      !next_url.nil?
+    end
+
+    def next_page_number
+      return nil unless next_url
+
+      uri = URI.parse(next_url)
+      params = URI.decode_www_form(uri.query || '')
+      page_param = params.find { |k, _| k == 'page' }
+      page_param ? page_param[1].to_i : nil
+    rescue URI::InvalidURIError
+      nil
+    end
+
+    def [](key)
+      return nil unless raw.is_a?(Hash)
+
+      raw[key]
+    end
+
+    def dig(*keys)
+      return nil unless raw.is_a?(Hash)
+
+      raw.dig(*keys)
+    end
+
+    def to_h
+      raw.is_a?(Hash) ? raw : { 'results' => raw }
+    end
+
+    def to_json(*)
+      to_h.to_json
+    end
+
+    def success?
+      status >= 200 && status < 300
+    end
+
+    def inspect
+      "#<#{self.class} status=#{status} size=#{size} count=#{count} next_page?=#{next_page?}>"
+    end
+  end
+end

data/lib/lda_gov/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module LDA
+  VERSION = '0.1.0'
+end

data/lib/lda_gov.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'lda_gov/version'
+require 'lda_gov/configuration'
+require 'lda_gov/error'
+require 'lda_gov/response'
+require 'lda_gov/client'
+require 'lda_gov/resources/base'
+require 'lda_gov/resources/filings'
+require 'lda_gov/resources/contributions'
+require 'lda_gov/resources/registrants'
+require 'lda_gov/resources/clients'
+require 'lda_gov/resources/lobbyists'
+require 'lda_gov/resources/constants'
+
+module LDA
+  @mutex = Mutex.new
+
+  class << self
+    def configuration
+      @mutex.synchronize { @configuration ||= Configuration.new }
+    end
+
+    def configure
+      @mutex.synchronize { yield(@configuration ||= Configuration.new) }
+    end
+
+    def reset!
+      @mutex.synchronize do
+        @configuration = Configuration.new
+        @client = nil
+      end
+    end
+
+    def client
+      @mutex.synchronize { @client ||= Client.new(@configuration || Configuration.new) }
+    end
+
+    def filings
+      Resources::Filings.new(client)
+    end
+
+    def contributions
+      Resources::Contributions.new(client)
+    end
+
+    def registrants
+      Resources::Registrants.new(client)
+    end
+
+    def clients
+      Resources::Clients.new(client)
+    end
+
+    def lobbyists
+      Resources::Lobbyists.new(client)
+    end
+
+    def constants
+      Resources::Constants.new(client)
+    end
+  end
+end

metadata

@@ -0,0 +1,178 @@
+--- !ruby/object:Gem::Specification
+name: lda_gov
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jack Killilea
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2026-03-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: faraday-retry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+- !ruby/object:Gem::Dependency
+  name: vcr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.2'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.23'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.23'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.65'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.65'
+- !ruby/object:Gem::Dependency
+  name: rubocop-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: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+description: |
+  A Ruby client for the Lobbying Disclosure Act (LDA) API at lda.gov.
+  Access lobbying filings, registrants, clients, lobbyists, and contribution reports.
+email:
+- xkillilea@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/lda_gov.rb
+- lib/lda_gov/client.rb
+- lib/lda_gov/configuration.rb
+- lib/lda_gov/error.rb
+- lib/lda_gov/resources/base.rb
+- lib/lda_gov/resources/clients.rb
+- lib/lda_gov/resources/constants.rb
+- lib/lda_gov/resources/contributions.rb
+- lib/lda_gov/resources/filings.rb
+- lib/lda_gov/resources/lobbyists.rb
+- lib/lda_gov/resources/registrants.rb
+- lib/lda_gov/response.rb
+- lib/lda_gov/version.rb
+homepage: https://github.com/xjackk/lda_gov
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/xjackk/lda_gov
+  source_code_uri: https://github.com/xjackk/lda_gov/tree/main/lib
+  changelog_uri: https://github.com/xjackk/lda_gov/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/xjackk/lda_gov/issues
+  rubygems_mfa_required: 'true'
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.11
+signing_key: 
+specification_version: 4
+summary: Ruby client for the LDA.gov lobbying disclosure API
+test_files: []