copy_ai 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d7dfa8e0173b3f8e9ff2c8faa3278493da38351a46b40577b4b52a2d87e5b0f4
+  data.tar.gz: 25e0c4672631e4cab8b6b0a1a25702db84a37f95458e44eb375714c205659e3a
+SHA512:
+  metadata.gz: 8f17f32b94bc25eef3d9125693c1eaeb85c0c41bbff569530dd7ce06c537e9811864996b80a071efcb5abe39d9c54d7ae298443bc8aa45eab2bd16c43e91555d
+  data.tar.gz: 820c92832dc61a4488acbc64c888152c786cc6a1b5bc48ca917c11a1049f8b95929e9f89aced95bf6b4cb1d9433737dbc2ffbc150e51477cbd9329436f8489f5

data/CHANGELOG.md

@@ -0,0 +1,6 @@
+## [0.1.0] - 2024-08-19
+* Initial Release
+
+## [0.0.1] - 2024-08-18
+
+* Draft Creation

data/MIT-LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright Fernand Arioja
+
+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,145 @@
+# A [Ruby](https://www.ruby-lang.org) interface to the [Copy.ai Workflows API](https://docs.copy.ai/docs/getting-started)
+
+## Installation
+
+Install the gem and add to the application's Gemfile:
+
+    bundle add copy_ai
+
+Or, to install directly:
+
+    gem install copy_ai
+
+## Usage
+
+First, obtain credentials from <https://docs.copy.ai/reference/authentication>.
+
+```ruby
+require "copy_ai"
+
+copy_ai_credentials = {
+  api_key:              "INSERT YOUR X API KEY HERE",
+  api_endpoint:         "INSERT YOUR X API ENDPOINT HERE"
+}
+
+# Initialize a API client with your Workspace Api Key
+copy_ai_client = CopyAi::Client.new(**copy_ai_credentials)
+
+# Register webhook
+# url: your site webhook URL
+# event_type: https://docs.copy.ai/reference/register-webhook#event-types
+# optional workflow_id: If a workflow ID is not specified, you will receive events for all workflows in your workspace.
+response = CopyAi::Webook.register(copy_ai_client, url: 'https://cloud-asm.com/webhook', event_type: 'workflowRun.completed', workflow_id: <workflow-id>)
+# {
+    "status": "success",
+    "data": {
+      "id": "<id of webhook>",
+      "url": "<https://mywebsite.com/webhook>",
+      "eventType": "workflowRun.completed",
+      "workflowId": "<workflow-id>"
+    }
+  }
+
+# Starting a Workflow Run
+post = copy_ai_client.post(body: {
+  startVariables: {
+	  "Input 1": "<Inputs vary depending on the workflow used.>",
+	  "Input 2": "<The best way to see an example is to try it!>"
+	},
+	"metadata": {
+    "api": true
+	}
+})
+# { "status": "success", "data": { "id": "<run-id>" } }
+
+# Tracking / Poll for Progress
+copy_ai_client.get
+# {
+    "status": "success",
+    "data":
+    {
+      "id": "<run-id>",
+      "input":
+      { 
+        "Input 1": "Inputs vary depending on the workflow used.",
+        "Input 2": "The best way to see an example is to try it!" 
+      },
+      "status": "PROCESSING",
+      "output":
+      {
+        "Output 1": "<Outputs vary depending on the workflow used.>",
+        "Output 2": "<The best way to see an example is to try it!>"
+      },
+      "createdAt": "2022-11-18T20:30:07.434Z"
+    }
+  }
+
+# Run Completion
+# When the run is complete, the status will change to COMPLETE and a POST request will be sent to the registered webhooks to notify of the workflow's completion.
+# {
+    "type": "workflowRun.completed",
+    "workflowRunId": "<run-id>",
+    "workflowId": "<workflow-id>",
+    "result":
+    {
+      "Output 1": "<Outputs vary depending on the workflow used.>",
+      "Output 2": "<The best way to see an example is to try it!>"
+    },
+    "metadata":
+    {
+      /* any metadata set on the workflow run */
+    },
+    "credits": 2 
+  }
+```
+
+## Development
+
+1. Checkout and repo:
+
+       git checkout git@github.com:wwwfernand/copy_ai.git
+
+2. Enter the repo's directory:
+
+       cd copy_ai
+
+3. Install dependencies via Bundler:
+
+       bundle install
+
+4. Run the default Rake task to ensure all tests pass:
+
+       bundle exec rake
+
+5. Create a new branch for your feature or bug fix:
+
+       git checkout -b my-new-branch
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/wwwfernand/copy_ai.
+
+Pull requests will only be accepted if they meet all the following criteria:
+
+1. Code must conform to [Standard Ruby](https://github.com/standardrb/standard#readme).
+
+       bundle exec rake standard
+
+2. Code must conform to the [RuboCop rules](https://github.com/rubocop/rubocop#readme).
+
+       bundle exec rake rubocop
+
+3. 100% LOC code coverage.
+
+       bundle exec rake test
+
+4. 100% mutation coverage.
+
+       bundle exec rake mutant
+
+5. RBS type signatures (in `sig/copy_ai.rbs`).
+
+       bundle exec rake steep
+
+## 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,34 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.options = "--pride"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+require "standard/rake"
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+require "steep"
+require "steep/cli"
+
+desc "Type check with Steep"
+task :steep do
+  Steep::CLI.new(argv: ["check"], stdout: $stdout, stderr: $stderr, stdin: $stdin).run
+end
+
+require "mutant"
+
+desc "Run mutant"
+task :mutant do
+  system(*%w[bundle exec mutant run]) or raise "Mutant task failed"
+end
+
+desc "Run linters"
+task lint: %i[rubocop standard]
+
+task default: %i[test lint mutant steep]

data/bin/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "copy_ai"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+require "irb"
+IRB.start(__FILE__)

data/lib/copy_ai/authenticator.rb

@@ -0,0 +1,15 @@
+module CopyAi
+  class Authenticator
+    AUTHENTICATION_HEADER = "x-copy-ai-api-key".freeze
+
+    attr_accessor :api_key
+
+    def initialize(api_key:)
+      @api_key = api_key
+    end
+
+    def header
+      {AUTHENTICATION_HEADER => api_key}
+    end
+  end
+end

data/lib/copy_ai/client.rb

@@ -0,0 +1,72 @@
+require "forwardable"
+require_relative "authenticator"
+require_relative "connection"
+require_relative "request_builder"
+require_relative "response_parser"
+
+module CopyAi
+  class Client
+    extend Forwardable
+
+    attr_reader :api_key, :api_endpoint, :workflow_id
+
+    def_delegators :@connection, :open_timeout, :read_timeout, :write_timeout, :debug_output
+    def_delegators :@connection, :open_timeout=, :read_timeout=, :write_timeout=, :debug_output=
+
+    def initialize(api_key:, api_endpoint:,
+      open_timeout: Connection::DEFAULT_OPEN_TIMEOUT,
+      read_timeout: Connection::DEFAULT_READ_TIMEOUT,
+      write_timeout: Connection::DEFAULT_WRITE_TIMEOUT,
+      debug_output: Connection::DEFAULT_DEBUG_OUTPUT)
+
+      @api_key = api_key
+      @api_endpoint = api_endpoint
+      initialize_authenticator
+      initialize_workflow_id
+      @connection = Connection.new(open_timeout:, read_timeout:, write_timeout:, debug_output:)
+      @request_builder = RequestBuilder.new
+      @response_parser = ResponseParser.new
+    end
+
+    def get
+      execute_request(:get, body: nil)
+    end
+
+    def post(body:)
+      execute_request(:post, body:)
+    end
+
+    def api_key=(api_key)
+      @api_key = api_key
+      initialize_authenticator
+    end
+
+    def api_endpoint=(api_endpoint)
+      @api_endpoint = api_endpoint
+      initialize_workflow_id
+    end
+
+    private
+
+    def initialize_workflow_id
+      raise ArgumentError, "Missing Credentials" if api_endpoint.nil? || api_endpoint.empty?
+
+      @workflow_id = api_endpoint.split("/").at(-2)
+
+      raise ArgumentError, "Invalid Credentials" if workflow_id.nil?
+    end
+
+    def initialize_authenticator
+      raise ArgumentError, "Missing Credentials" if api_key.nil? || api_key.empty?
+
+      @authenticator = Authenticator.new(api_key:)
+    end
+
+    def execute_request(http_method, body:)
+      uri = URI(api_endpoint)
+      request = @request_builder.build(http_method:, uri:, body:, authenticator: @authenticator)
+      response = @connection.perform(request:)
+      @response_parser.parse(response:)
+    end
+  end
+end

data/lib/copy_ai/connection.rb

@@ -0,0 +1,57 @@
+require "forwardable"
+require "net/http"
+require "openssl"
+require "uri"
+require_relative "errors/network_error"
+
+module CopyAi
+  class Connection
+    extend Forwardable
+
+    DEFAULT_OPEN_TIMEOUT = 60 # seconds
+    DEFAULT_READ_TIMEOUT = 60 # seconds
+    DEFAULT_WRITE_TIMEOUT = 60 # seconds
+    DEFAULT_DEBUG_OUTPUT = File.open(File::NULL, "w")
+    NETWORK_ERRORS = [
+      Errno::ECONNREFUSED,
+      Errno::ECONNRESET,
+      Net::OpenTimeout,
+      Net::ReadTimeout,
+      OpenSSL::SSL::SSLError
+    ].freeze
+
+    attr_accessor :open_timeout, :read_timeout, :write_timeout, :debug_output
+
+    def initialize(open_timeout: DEFAULT_OPEN_TIMEOUT, read_timeout: DEFAULT_READ_TIMEOUT,
+      write_timeout: DEFAULT_WRITE_TIMEOUT, debug_output: DEFAULT_DEBUG_OUTPUT)
+      @open_timeout = open_timeout
+      @read_timeout = read_timeout
+      @write_timeout = write_timeout
+      @debug_output = debug_output
+    end
+
+    def perform(request:)
+      http_client = build_http_client(request.uri.host, request.uri.port)
+      http_client.use_ssl = true
+      http_client.request(request)
+    rescue *NETWORK_ERRORS => e
+      raise NetworkError, "Network error: #{e}"
+    end
+
+    private
+
+    def build_http_client(host, port)
+      http_client = Net::HTTP.new(host, port)
+      configure_http_client(http_client)
+    end
+
+    def configure_http_client(http_client)
+      http_client.tap do |c|
+        c.open_timeout = open_timeout
+        c.read_timeout = read_timeout
+        c.write_timeout = write_timeout
+        c.set_debug_output(debug_output)
+      end
+    end
+  end
+end

data/lib/copy_ai/errors/bad_gateway.rb

@@ -0,0 +1,5 @@
+require_relative "server_error"
+
+module CopyAi
+  class BadGateway < ServerError; end
+end

data/lib/copy_ai/errors/bad_request.rb

@@ -0,0 +1,5 @@
+require_relative "client_error"
+
+module CopyAi
+  class BadRequest < ClientError; end
+end

data/lib/copy_ai/errors/client_error.rb

@@ -0,0 +1,5 @@
+require_relative "http_error"
+
+module CopyAi
+  class ClientError < HTTPError; end
+end

data/lib/copy_ai/errors/connection_exception.rb

@@ -0,0 +1,5 @@
+require_relative "client_error"
+
+module CopyAi
+  class ConnectionException < ClientError; end
+end

data/lib/copy_ai/errors/error.rb

@@ -0,0 +1,3 @@
+module CopyAi
+  class Error < StandardError; end
+end

data/lib/copy_ai/errors/forbidden.rb

@@ -0,0 +1,5 @@
+require_relative "client_error"
+
+module CopyAi
+  class Forbidden < ClientError; end
+end

data/lib/copy_ai/errors/gateway_timeout.rb

@@ -0,0 +1,5 @@
+require_relative "server_error"
+
+module CopyAi
+  class GatewayTimeout < ServerError; end
+end

data/lib/copy_ai/errors/gone.rb

@@ -0,0 +1,5 @@
+require_relative "client_error"
+
+module CopyAi
+  class Gone < ClientError; end
+end

data/lib/copy_ai/errors/http_error.rb

@@ -0,0 +1,41 @@
+require "json"
+require_relative "error"
+
+module CopyAi
+  class HTTPError < Error
+    JSON_CONTENT_TYPE_REGEXP = %r{application/(problem\+|)json}
+
+    attr_reader :response, :code
+
+    def initialize(response:)
+      super(error_message(response))
+      @response = response
+      @code = response.code
+    end
+
+    def error_message(response)
+      if json?(response)
+        message_from_json_response(response)
+      else
+        response.message
+      end
+    end
+
+    def message_from_json_response(response)
+      response_object = JSON.parse(response.body)
+      if response_object.key?("title") && response_object.key?("detail")
+        "#{response_object.fetch("title")}: #{response_object.fetch("detail")}"
+      elsif response_object.key?("error")
+        response_object.fetch("error")
+      elsif response_object["errors"].instance_of?(Array)
+        response_object.fetch("errors").map { |error| error.fetch("message") }.join(", ")
+      else
+        response.message
+      end
+    end
+
+    def json?(response)
+      JSON_CONTENT_TYPE_REGEXP === response["content-type"]
+    end
+  end
+end

data/lib/copy_ai/errors/internal_server_error.rb

@@ -0,0 +1,5 @@
+require_relative "server_error"
+
+module CopyAi
+  class InternalServerError < ServerError; end
+end

data/lib/copy_ai/errors/network_error.rb

@@ -0,0 +1,5 @@
+require_relative "error"
+
+module CopyAi
+  class NetworkError < Error; end
+end

data/lib/copy_ai/errors/not_acceptable.rb

@@ -0,0 +1,5 @@
+require_relative "client_error"
+
+module CopyAi
+  class NotAcceptable < ClientError; end
+end

data/lib/copy_ai/errors/not_found.rb

@@ -0,0 +1,5 @@
+require_relative "client_error"
+
+module CopyAi
+  class NotFound < ClientError; end
+end

data/lib/copy_ai/errors/payload_too_large.rb

@@ -0,0 +1,5 @@
+require_relative "client_error"
+
+module CopyAi
+  class PayloadTooLarge < ClientError; end
+end

data/lib/copy_ai/errors/server_error.rb

@@ -0,0 +1,5 @@
+require_relative "http_error"
+
+module CopyAi
+  class ServerError < HTTPError; end
+end

data/lib/copy_ai/errors/service_unavailable.rb

@@ -0,0 +1,5 @@
+require_relative "server_error"
+
+module CopyAi
+  class ServiceUnavailable < ServerError; end
+end

data/lib/copy_ai/errors/unauthorized.rb

@@ -0,0 +1,5 @@
+require_relative "client_error"
+
+module CopyAi
+  class Unauthorized < ClientError; end
+end

data/lib/copy_ai/errors/unprocessable_entity.rb

@@ -0,0 +1,5 @@
+require_relative "client_error"
+
+module CopyAi
+  class UnprocessableEntity < ClientError; end
+end

data/lib/copy_ai/request_builder.rb

@@ -0,0 +1,40 @@
+require "net/http"
+require "uri"
+require_relative "authenticator"
+require_relative "version"
+
+module CopyAi
+  class RequestBuilder
+    DEFAULT_HEADERS = {"Content-Type" => "application/json"}.freeze
+    HTTP_METHODS = {
+      get: Net::HTTP::Get,
+      post: Net::HTTP::Post
+    }.freeze
+
+    def build(http_method:, uri:, authenticator:, body:)
+      raise ArgumentError, "Missing Credentials" unless authenticator
+
+      request = create_request(http_method:, uri:, body:)
+      add_headers(request:, header: authenticator.header)
+      request
+    end
+
+    private
+
+    def create_request(http_method:, uri:, body:)
+      http_method_class = HTTP_METHODS[http_method]
+
+      raise ArgumentError, "Unsupported HTTP method: #{http_method}" unless http_method_class
+
+      request = http_method_class.new(uri)
+      request.body = body.to_json unless body.nil?
+      request
+    end
+
+    def add_headers(request:, header:)
+      DEFAULT_HEADERS.merge(header).each do |key, value|
+        request.add_field(key, value)
+      end
+    end
+  end
+end

data/lib/copy_ai/response_parser.rb

@@ -0,0 +1,59 @@
+require "json"
+require "net/http"
+require_relative "errors/bad_gateway"
+require_relative "errors/bad_request"
+require_relative "errors/connection_exception"
+require_relative "errors/http_error"
+require_relative "errors/forbidden"
+require_relative "errors/gateway_timeout"
+require_relative "errors/gone"
+require_relative "errors/internal_server_error"
+require_relative "errors/not_acceptable"
+require_relative "errors/not_found"
+require_relative "errors/payload_too_large"
+require_relative "errors/service_unavailable"
+require_relative "errors/unauthorized"
+require_relative "errors/unprocessable_entity"
+
+module CopyAi
+  class ResponseParser
+    ERROR_MAP = {
+      400 => BadRequest,
+      401 => Unauthorized,
+      403 => Forbidden,
+      404 => NotFound,
+      406 => NotAcceptable,
+      409 => ConnectionException,
+      410 => Gone,
+      413 => PayloadTooLarge,
+      422 => UnprocessableEntity,
+      500 => InternalServerError,
+      502 => BadGateway,
+      503 => ServiceUnavailable,
+      504 => GatewayTimeout
+    }.freeze
+    JSON_CONTENT_TYPE_REGEXP = %r{application/json}
+
+    def parse(response:)
+      raise error(response) unless response.is_a?(Net::HTTPSuccess)
+
+      return unless json?(response)
+
+      JSON.parse(response.body)
+    end
+
+    private
+
+    def error(response)
+      error_class(response).new(response:)
+    end
+
+    def error_class(response)
+      ERROR_MAP[Integer(response.code)] || HTTPError
+    end
+
+    def json?(response)
+      JSON_CONTENT_TYPE_REGEXP === response["content-type"]
+    end
+  end
+end

data/lib/copy_ai/version.rb

@@ -0,0 +1,3 @@
+module CopyAi
+  VERSION = Gem::Version.create("0.1.0")
+end

data/lib/copy_ai/webhook.rb

@@ -0,0 +1,30 @@
+module CopyAi
+  module Webhook
+    extend self
+    EVENT_TYPES = [
+      "workflowRun.started",
+      "workflowRun.completed",
+      "workflowRun.failed",
+      "workflowCreditLimit.reached"
+    ].freeze
+    WEBHOOK_URL = "https://api.copy.ai/api/webhook".freeze
+
+    # If a workflow ID is not included, events for all workflows in your workspace will be received
+    def register(client, url:, event_type:, workflow_id: nil)
+      raise ArgumentError, "Missing Arguments" if client.nil? || url.nil? || event_type.nil?
+
+      validate!(event_type:)
+      webhook_client = client.dup.tap { |c| c.api_endpoint = WEBHOOK_URL }
+      body = {url:, eventType: event_type, workflowId: workflow_id}
+      webhook_client.post(body:)
+    end
+
+    private
+
+    def validate!(event_type:)
+      return if EVENT_TYPES.include?(event_type)
+
+      raise ArgumentError, "Invalid event_type: #{event_type}"
+    end
+  end
+end

data/lib/copy_ai.rb

@@ -0,0 +1,2 @@
+require_relative "copy_ai/client"
+require_relative "copy_ai/webhook"

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: copy_ai
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Fernand Arioja
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-08-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.1.3.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.1.3.4
+description: A Ruby client library for accessing the Copy.ai API, allowing developers
+  to easily integrate Copy.ai's text generation capabilities into their Ruby applications
+email:
+- dev.cloud.asm@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- MIT-LICENSE
+- README.md
+- Rakefile
+- bin/console
+- lib/copy_ai.rb
+- lib/copy_ai/authenticator.rb
+- lib/copy_ai/client.rb
+- lib/copy_ai/connection.rb
+- lib/copy_ai/errors/bad_gateway.rb
+- lib/copy_ai/errors/bad_request.rb
+- lib/copy_ai/errors/client_error.rb
+- lib/copy_ai/errors/connection_exception.rb
+- lib/copy_ai/errors/error.rb
+- lib/copy_ai/errors/forbidden.rb
+- lib/copy_ai/errors/gateway_timeout.rb
+- lib/copy_ai/errors/gone.rb
+- lib/copy_ai/errors/http_error.rb
+- lib/copy_ai/errors/internal_server_error.rb
+- lib/copy_ai/errors/network_error.rb
+- lib/copy_ai/errors/not_acceptable.rb
+- lib/copy_ai/errors/not_found.rb
+- lib/copy_ai/errors/payload_too_large.rb
+- lib/copy_ai/errors/server_error.rb
+- lib/copy_ai/errors/service_unavailable.rb
+- lib/copy_ai/errors/unauthorized.rb
+- lib/copy_ai/errors/unprocessable_entity.rb
+- lib/copy_ai/request_builder.rb
+- lib/copy_ai/response_parser.rb
+- lib/copy_ai/version.rb
+- lib/copy_ai/webhook.rb
+homepage: https://github.com/wwwfernand/copy_ai
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/wwwfernand/copy_ai
+  source_code_uri: https://github.com/wwwfernand/copy_ai
+  changelog_uri: https://github.com/wwwfernand/copy_ai/master/CHANGELOG.md
+  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.6
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.27
+signing_key:
+specification_version: 4
+summary: A Ruby interface to the Copy.ai API
+test_files: []