altertable-lakehouse 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8292ffff4927b361aa1a04dcc2352542e008a977d7ca5d3d91e5913532f490f5
+  data.tar.gz: e00935a9e22c975c3318b13f2cf05512b6c5082e0109975a01057287775c7897
+SHA512:
+  metadata.gz: 443d6b8c28ff54b50dfc7fa52a8d9ac00a44a5398d92fc385ff60e8add97fc63e23be05a5d1b81674e8ffa568c0f8b4eecca80dfb6daf521c50e41af29d5c826
+  data.tar.gz: c6239d5ff43b91c17652401ef67c8258142df8db73eb6e852988ab6c404f8dae066c32a2a333033852b2f0b3a1535cb5e672bb9122b925fa0988c1f4291e37e7

data/.github/workflows/ci.yml

@@ -0,0 +1,40 @@
+name: CI
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby-version: ['3.0', '3.1', '3.2', '3.3', '3.4', '4.0']
+
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        submodules: recursive
+
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby-version }}
+        bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+
+    - name: Run tests
+      run: bundle exec rake spec
+
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: '3.4'
+        bundler-cache: true
+    - name: Run RuboCop
+      run: bundle exec rubocop

data/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "specs"]
+	path = specs
+	url = https://github.com/altertable-ai/altertable-client-specs.git

data/.rubocop.yml

@@ -0,0 +1,58 @@
+
+AllCops:
+  NewCops: enable
+  TargetRubyVersion: 3.0
+  Exclude:
+    - 'vendor/**/*'
+    - 'spec/**/*'
+    - 'bin/**/*'
+    - 'gemfiles/**/*'
+
+Style/Documentation:
+  Enabled: false
+Style/FrozenStringLiteralComment:
+  Enabled: false
+Style/StringLiterals:
+  Enabled: false
+Layout/LineLength:
+  Enabled: false
+Metrics/MethodLength:
+  Enabled: false
+Metrics/ParameterLists:
+  Enabled: false
+Metrics/AbcSize:
+  Enabled: false
+Metrics/CyclomaticComplexity:
+  Enabled: false
+Metrics/PerceivedComplexity:
+  Enabled: false
+Layout/TrailingWhitespace:
+  Enabled: false
+Metrics/ClassLength:
+  Enabled: false
+Gemspec/RequireMFA:
+  Enabled: false
+Gemspec/OrderedDependencies:
+  Enabled: false
+Gemspec/DevelopmentDependencies:
+  Enabled: false
+Style/IfUnlessModifier:
+  Enabled: false
+Layout/EmptyLineAfterGuardClause:
+  Enabled: false
+Layout/EmptyLinesAroundModuleBody:
+  Enabled: false
+Lint/MissingSuper:
+  Enabled: false
+Naming/MethodParameterName:
+  Enabled: false
+Layout/IndentationWidth:
+  Enabled: false
+Style/Proc:
+  Enabled: false
+Style/FetchEnvVar:
+  Enabled: false
+Style/MutableConstant:
+  Enabled: false
+Bundler/OrderedGems:
+  Enabled: false

data/CHANGELOG.md

@@ -0,0 +1,26 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## [Unreleased]
+
+### Changed
+- **BREAKING**: Removed per-request credential overrides from all client methods to comply with v0.3.0 specs. Authentication must now be configured at initialization time.
+
+## [0.2.0] - 2026-03-04
+
+### Changed
+- **BREAKING**: Replaced Bearer token authentication with HTTP Basic Auth.
+- **BREAKING**: Removed `api_key` argument from `Altertable::Lakehouse::Client.new`.
+- Added support for `username`/`password` and `basic_auth_token` in client initialization.
+- Added environment variable support for `ALTERTABLE_USERNAME`, `ALTERTABLE_PASSWORD`, and `ALTERTABLE_BASIC_AUTH_TOKEN`.
+- Updated streaming query parsing to raise `ParseError` on malformed JSON lines instead of silently ignoring them.
+
+## [0.1.0] - 2026-03-04
+
+### Added
+- Initial implementation of Altertable Lakehouse Ruby Client.
+- Support for `append`, `query` (streamed/accumulated), `upload`, `validate`.
+- Support for `get_query`, `cancel_query`.
+- Typed request/response models.
+- Faraday-based HTTP client with retries.

data/Gemfile

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+gemspec
+
+gem "rake", "~> 13.0"
+gem "rspec", "~> 3.0"
+gem "faraday-net_http"

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Altertable AI
+
+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,196 @@
+# Altertable Lakehouse Ruby Client
+
+Official Ruby client for the [Altertable Lakehouse API](https://altertable.ai/docs).
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem 'altertable-lakehouse'
+```
+
+And run:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install altertable-lakehouse
+
+## Quick Start
+
+```ruby
+require "altertable/lakehouse"
+
+# Initialize with credentials
+client = Altertable::Lakehouse::Client.new(
+  username: "your_username",
+  password: "your_password"
+)
+
+# Append a row
+client.append(
+  catalog: "main",
+  schema: "public",
+  table: "events",
+  payload: { user_id: 123, event: "signup", timestamp: Time.now.iso8601 }
+)
+
+# Query data
+result = client.query_all(
+  statement: "SELECT * FROM main.public.events LIMIT 10"
+)
+result[:rows].each { |row| puts row }
+```
+
+## API Reference
+
+### Initialization
+
+Supports Basic Authentication via username/password or pre-encoded token.
+
+```ruby
+# 1. Username/Password
+client = Altertable::Lakehouse::Client.new(
+  username: "your_username",
+  password: "your_password",
+  base_url: "https://api.altertable.ai", # Optional
+  timeout: 10 # Optional
+)
+
+# 2. Pre-encoded Basic Auth Token
+client = Altertable::Lakehouse::Client.new(
+  basic_auth_token: "dXNlcm5hbWU6cGFzc3dvcmQ=" # base64(username:password)
+)
+
+# 3. Environment Variables
+# Set ALTERTABLE_USERNAME and ALTERTABLE_PASSWORD
+# OR set ALTERTABLE_BASIC_AUTH_TOKEN
+client = Altertable::Lakehouse::Client.new
+```
+
+### `append`
+
+Appends one or more rows to a table.
+
+```ruby
+# Single row
+client.append(
+  catalog: "main",
+  schema: "public",
+  table: "events",
+  payload: { user_id: 123, event: "signup" }
+)
+
+# Batch append
+client.append(
+  catalog: "main",
+  schema: "public",
+  table: "events",
+  payload: [
+    { user_id: 123, event: "click" },
+    { user_id: 456, event: "view" }
+  ]
+)
+
+# Override credentials per-request
+client.append(
+  catalog: "main",
+  schema: "public",
+  table: "events",
+  payload: { user_id: 789 },
+  username: "other_user",
+  password: "other_password"
+)
+```
+
+### `query_all`
+
+Executes a SQL query and returns all rows in memory (accumulated).
+
+```ruby
+result = client.query_all(
+  statement: "SELECT * FROM main.public.events LIMIT 10"
+)
+
+puts result[:metadata] # Hash
+puts result[:columns]  # Array of columns
+result[:rows].each do |row|
+  puts row
+end
+```
+
+### `query` (Streaming)
+
+Executes a SQL query and streams rows efficiently for large result sets.
+
+```ruby
+result = client.query(
+  statement: "SELECT * FROM main.public.events"
+)
+
+# Note: metadata/columns are available after iteration starts
+result.each do |row|
+  puts row
+end
+```
+
+### `upload`
+
+Uploads a file (CSV, Parquet, etc.) to a table.
+
+```ruby
+File.open("data.csv", "rb") do |file|
+  client.upload(
+    catalog: "main",
+    schema: "public",
+    table: "events",
+    format: "csv",
+    mode: "append",
+    file_io: file
+  )
+end
+```
+
+### `get_query`
+
+Retrieves information about a query execution.
+
+```ruby
+info = client.get_query("query-uuid")
+puts info.state # e.g. "RUNNING", "COMPLETED"
+```
+
+### `cancel_query`
+
+Cancels a running query.
+
+```ruby
+client.cancel_query("query-uuid", session_id: "session-123")
+```
+
+### `validate`
+
+Validates a SQL statement without executing it.
+
+```ruby
+resp = client.validate(statement: "SELECT * FROM invalid_table")
+puts resp.valid # => false
+puts resp.error
+```
+
+## Configuration
+
+| Option | Type | Default | Description |
+| :--- | :--- | :--- | :--- |
+| `username` | String | `ENV["ALTERTABLE_USERNAME"]` | Basic Auth username |
+| `password` | String | `ENV["ALTERTABLE_PASSWORD"]` | Basic Auth password |
+| `basic_auth_token` | String | `ENV["ALTERTABLE_BASIC_AUTH_TOKEN"]` | Pre-encoded Basic Auth token |
+| `base_url` | String | `https://api.altertable.ai` | API base URL |
+| `timeout` | Integer | `10` | Request timeout in seconds |
+| `user_agent` | String | `nil` | Custom User-Agent suffix |
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/altertable/lakehouse/client.rb

@@ -0,0 +1,218 @@
+require "faraday"
+require "faraday/retry"
+require "faraday/net_http"
+require "json"
+require "base64"
+require_relative "models"
+require_relative "errors"
+require_relative "version"
+
+module Altertable
+  module Lakehouse
+    class Client
+      DEFAULT_BASE_URL = "https://api.altertable.ai"
+      DEFAULT_TIMEOUT = 10
+
+      def initialize(username: nil, password: nil, basic_auth_token: nil, base_url: nil, timeout: nil, user_agent: nil)
+        # 1. Try passed basic_auth_token
+        # 2. Try passed username/password
+        # 3. Try ENV["ALTERTABLE_BASIC_AUTH_TOKEN"]
+        # 4. Try ENV["ALTERTABLE_USERNAME"] / ENV["ALTERTABLE_PASSWORD"]
+
+        if basic_auth_token
+          @auth_header = "Basic #{basic_auth_token}"
+        elsif username && password
+          @auth_header = "Basic #{Base64.strict_encode64("#{username}:#{password}")}"
+        elsif (env_token = ENV["ALTERTABLE_BASIC_AUTH_TOKEN"])
+          @auth_header = "Basic #{env_token}"
+        elsif (env_user = ENV["ALTERTABLE_USERNAME"]) && (env_pass = ENV["ALTERTABLE_PASSWORD"])
+          @auth_header = "Basic #{Base64.strict_encode64("#{env_user}:#{env_pass}")}"
+        else
+          raise ConfigurationError, "Authentication credentials required (username/password or basic_auth_token)"
+        end
+
+        @base_url = base_url || DEFAULT_BASE_URL
+        @timeout = timeout || DEFAULT_TIMEOUT
+        @user_agent = user_agent ? "AltertableRuby/#{VERSION} #{user_agent}" : "AltertableRuby/#{VERSION}"
+        
+        @conn = Faraday.new(url: @base_url) do |f|
+          f.headers["Authorization"] = @auth_header
+          f.headers["User-Agent"] = @user_agent
+          f.headers["Content-Type"] = "application/json"
+          f.options.timeout = @timeout
+          f.request :retry, max: 3, interval: 0.05, backoff_factor: 2
+          f.adapter Faraday.default_adapter
+        end
+      end
+
+      # POST /append
+      def append(catalog:, schema:, table:, payload:)
+        params = { catalog: catalog, schema: schema, table: table }
+        req = Models::AppendRequest.new(payload)
+        resp = request(:post, "/append", body: req.to_h, query: params)
+        Models::AppendResponse.from_h(resp)
+      end
+
+      # POST /query (streamed)
+      def query(statement:, **options)
+        req_body = Models::QueryRequest.new(statement: statement, **options).to_h.to_json
+        
+        enum = Enumerator.new do |yielder|
+          buffer = ""
+          @conn.post("/query") do |req|
+            req.headers["Content-Type"] = "application/json"
+            req.body = req_body
+            req.options.on_data = Proc.new do |chunk, _|
+              buffer << chunk
+              while (line_end = buffer.index("\n"))
+                line = buffer.slice!(0, line_end + 1).strip
+                next if line.empty?
+                begin
+                  yielder << JSON.parse(line)
+                rescue JSON::ParserError
+                  raise ParseError, "Invalid JSON line: #{line}"
+                end
+              end
+            end
+          end
+          
+          # Process remaining buffer
+          unless buffer.empty?
+            begin
+              yielder << JSON.parse(buffer.strip)
+            rescue JSON::ParserError
+               raise ParseError, "Invalid JSON line: #{buffer}"
+            end
+          end
+        end
+        
+        QueryResult.new(enum)
+      end
+
+      # POST /query (accumulated)
+      def query_all(statement:, **options)
+        result = query(statement: statement, **options)
+        rows = result.to_a # Accumulate
+        {
+          metadata: result.metadata,
+          columns: result.columns,
+          rows: rows
+        }
+      end
+
+      # POST /upload
+      def upload(catalog:, schema:, table:, format:, mode:, file_io:, primary_key: nil)
+        params = { 
+          catalog: catalog, 
+          schema: schema, 
+          table: table, 
+          format: format, 
+          mode: mode 
+        }
+        params[:primary_key] = primary_key if primary_key
+
+        # Use a separate connection for multipart/binary if needed, 
+        # but spec says body is octet-stream.
+        resp = @conn.post("/upload") do |req|
+          req.params = params
+          req.headers["Content-Type"] = "application/octet-stream"
+          req.body = file_io # IO object or string
+        end
+        
+        handle_response(resp)
+      end
+
+      # GET /query/:query_id
+      def get_query(query_id)
+        resp = request(:get, "/query/#{query_id}")
+        Models::QueryLogResponse.from_h(resp)
+      end
+
+      # DELETE /query/:query_id
+      def cancel_query(query_id, session_id:)
+        resp = request(:delete, "/query/#{query_id}", query: { session_id: session_id })
+        Models::CancelQueryResponse.from_h(resp)
+      end
+
+      # POST /validate
+      def validate(statement:)
+        req = Models::ValidateRequest.new(statement: statement)
+        resp = request(:post, "/validate", body: req.to_h)
+        Models::ValidateResponse.from_h(resp)
+      end
+
+      private
+
+      def request(method, path, body: nil, query: nil, stream: false, &block)
+        resp = @conn.send(method, path) do |req|
+          req.params = query if query
+          req.body = body.to_json if body
+          if stream
+            req.options.on_data = block
+          end
+        end
+        
+        return if stream # Block handles data
+        
+        handle_response(resp)
+      rescue Faraday::ConnectionFailed => e
+        raise NetworkError, e.message
+      rescue Faraday::TimeoutError => e
+        raise TimeoutError, e.message
+      end
+
+      def handle_response(resp)
+        case resp.status
+        when 200..299
+          return nil if resp.body.nil? || resp.body.empty?
+          begin
+            JSON.parse(resp.body)
+          rescue JSON::ParserError
+            # For non-JSON responses (like empty upload response?)
+            resp.body
+          end
+        when 400
+          raise BadRequestError, "Bad Request: #{resp.body}"
+        when 401
+          raise AuthError, "Unauthorized"
+        when 404
+          raise ApiError, "Not Found: #{resp.url}" # Could be specific
+        else
+          raise ApiError, "API Error #{resp.status}: #{resp.body}"
+        end
+      end
+    end
+    
+    class QueryResult
+      include Enumerable
+      
+      attr_reader :metadata, :columns
+      
+      def initialize(enum)
+        @enum = enum
+        @metadata = nil
+        @columns = nil
+      end
+      
+      def each(&block)
+        # We need to wrap the enum to extract metadata/columns first
+        # Note: This will re-trigger the request if enumerated multiple times
+        first = true
+        second = true
+        
+        @enum.each do |item|
+          if first
+            @metadata = item
+            first = false
+          elsif second
+            @columns = item
+            second = false
+          else
+            block.call(item)
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/altertable/lakehouse/errors.rb

@@ -0,0 +1,27 @@
+module Altertable
+  module Lakehouse
+    class Error < StandardError
+      attr_reader :operation, :http_method, :http_path, :status_code, :retriable, :request_id, :cause
+
+      def initialize(message, operation: nil, http_method: nil, http_path: nil, status_code: nil, retriable: false, request_id: nil, cause: nil)
+        super(message)
+        @operation = operation
+        @http_method = http_method
+        @http_path = http_path
+        @status_code = status_code
+        @retriable = retriable
+        @request_id = request_id
+        @cause = cause
+      end
+    end
+
+    class AuthError < Error; end
+    class BadRequestError < Error; end
+    class NetworkError < Error; end
+    class TimeoutError < Error; end
+    class SerializationError < Error; end
+    class ParseError < Error; end
+    class ApiError < Error; end
+    class ConfigurationError < Error; end
+  end
+end

data/lib/altertable/lakehouse/models.rb

@@ -0,0 +1,157 @@
+module Altertable
+  module Lakehouse
+    module Models
+      class Request
+        def to_h
+          raise NotImplementedError
+        end
+      end
+
+      class AppendRequest < Request
+        attr_reader :payload
+
+        # Payload can be a single Hash or an Array of Hashes
+        def initialize(payload)
+          @payload = payload
+        end
+
+        def to_h
+          @payload
+        end
+      end
+
+      class AppendResponse < Request
+        attr_reader :ok, :error_code
+
+        def initialize(ok:, error_code: nil)
+          @ok = ok
+          @error_code = error_code
+        end
+
+        def self.from_h(h)
+          new(ok: h["ok"], error_code: h["error_code"])
+        end
+      end
+
+      class QueryRequest < Request
+        attr_reader :statement, :catalog, :schema, :session_id, :compute_size, :sanitize, :limit, :offset, :timezone, :ephemeral, :visible, :requested_by, :query_id
+
+        def initialize(statement:, catalog: nil, schema: nil, session_id: nil, compute_size: nil, sanitize: nil, limit: nil, offset: nil, timezone: nil, ephemeral: nil, visible: nil, requested_by: nil, query_id: nil)
+          @statement = statement
+          @catalog = catalog
+          @schema = schema
+          @session_id = session_id
+          @compute_size = compute_size
+          @sanitize = sanitize
+          @limit = limit
+          @offset = offset
+          @timezone = timezone
+          @ephemeral = ephemeral
+          @visible = visible
+          @requested_by = requested_by
+          @query_id = query_id
+        end
+
+        def to_h
+          h = { statement: @statement }
+          h[:catalog] = @catalog if @catalog
+          h[:schema] = @schema if @schema
+          h[:session_id] = @session_id if @session_id
+          h[:compute_size] = @compute_size if @compute_size
+          h[:sanitize] = @sanitize unless @sanitize.nil?
+          h[:limit] = @limit if @limit
+          h[:offset] = @offset if @offset
+          h[:timezone] = @timezone if @timezone
+          h[:ephemeral] = @ephemeral unless @ephemeral.nil?
+          h[:visible] = @visible unless @visible.nil?
+          h[:requested_by] = @requested_by if @requested_by
+          h[:query_id] = @query_id if @query_id
+          h
+        end
+      end
+
+      class ValidateRequest < Request
+        attr_reader :statement
+
+        def initialize(statement:)
+          @statement = statement
+        end
+
+        def to_h
+          { statement: @statement }
+        end
+      end
+
+      class ValidateResponse < Request
+        attr_reader :valid, :statement, :connections_errors, :error
+
+        def initialize(valid:, statement:, connections_errors: nil, error: nil)
+          @valid = valid
+          @statement = statement
+          @connections_errors = connections_errors
+          @error = error
+        end
+
+        def self.from_h(h)
+          new(
+            valid: h["valid"],
+            statement: h["statement"],
+            connections_errors: h["connections_errors"],
+            error: h["error"]
+          )
+        end
+      end
+      
+      class QueryLogResponse < Request
+        attr_reader :uuid, :start_time, :end_time, :duration_ms, :query, :session_id, :client_interface, :error, :stats, :progress, :visible, :requested_by, :user_agent
+
+        def initialize(uuid:, start_time:, end_time:, duration_ms:, query:, session_id:, client_interface:, error:, stats:, progress:, visible:, requested_by:, user_agent:)
+          @uuid = uuid
+          @start_time = start_time
+          @end_time = end_time
+          @duration_ms = duration_ms
+          @query = query
+          @session_id = session_id
+          @client_interface = client_interface
+          @error = error
+          @stats = stats
+          @progress = progress
+          @visible = visible
+          @requested_by = requested_by
+          @user_agent = user_agent
+        end
+        
+        def self.from_h(h)
+           new(
+             uuid: h["uuid"],
+             start_time: h["start_time"],
+             end_time: h["end_time"],
+             duration_ms: h["duration_ms"],
+             query: h["query"],
+             session_id: h["session_id"],
+             client_interface: h["client_interface"],
+             error: h["error"],
+             stats: h["stats"],
+             progress: h["progress"],
+             visible: h["visible"],
+             requested_by: h["requested_by"],
+             user_agent: h["user_agent"]
+           )
+        end
+      end
+
+      class CancelQueryResponse < Request
+        attr_reader :cancelled, :message
+
+        def initialize(cancelled:, message:)
+          @cancelled = cancelled
+          @message = message
+        end
+        
+        def self.from_h(h)
+          new(cancelled: h["cancelled"], message: h["message"])
+        end
+      end
+    end
+  end
+end

data/lib/altertable/lakehouse/version.rb

@@ -0,0 +1,5 @@
+module Altertable
+  module Lakehouse
+    VERSION = "0.2.0"
+  end
+end

data/lib/altertable/lakehouse.rb

@@ -0,0 +1,10 @@
+require_relative "lakehouse/version"
+require_relative "lakehouse/client"
+require_relative "lakehouse/models"
+require_relative "lakehouse/errors"
+
+module Altertable
+  module Lakehouse
+    class Error < StandardError; end
+  end
+end

metadata

@@ -0,0 +1,168 @@
+--- !ruby/object:Gem::Specification
+name: altertable-lakehouse
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Altertable AI
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.12'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.12'
+- !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: faraday-net_http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !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: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.18'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.18'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.50'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.50'
+description: Official Ruby client for Altertable Lakehouse API.
+email:
+- support@altertable.ai
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/ci.yml"
+- ".gitmodules"
+- ".rubocop.yml"
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/altertable/lakehouse.rb
+- lib/altertable/lakehouse/client.rb
+- lib/altertable/lakehouse/errors.rb
+- lib/altertable/lakehouse/models.rb
+- lib/altertable/lakehouse/version.rb
+homepage: https://github.com/altertable-ai/altertable-lakehouse-ruby
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/altertable-ai/altertable-lakehouse-ruby
+  source_code_uri: https://github.com/altertable-ai/altertable-lakehouse-ruby
+  changelog_uri: https://github.com/altertable-ai/altertable-lakehouse-ruby/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: Official Ruby client for Altertable Lakehouse
+test_files: []