raix-datacircle 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
checksums.yaml ADDED
@@ -0,0 +1,7 @@
1
+ ---
2
+ SHA256:
3
+ metadata.gz: 91136a4a0d260c16dc817fe46a43b04ff45d4fcf86c97a534aa2cfafd5f1d97d
4
+ data.tar.gz: fef3c498bee338a5216c97af10c5ca474d777ee2aadabd122ad4b022b3963c42
5
+ SHA512:
6
+ metadata.gz: 247a8fd672bc5b68e23aaa35ce61f20b4fea769803797ae2515c6921e3bbc495ba600ba79bbd7c9ffa79a83584d6d9ec34ab66d57814a37616b3a09f08c484b4
7
+ data.tar.gz: 9f7fe3da690f74617ce1f54da6a7a8ad3c6743bea8cb4d83f4fb38d7e934b7e400211e6e48c37c399ce450037d860ba1c08c4dd609ef6c1b5e4d5c6546ce0931
data/LICENSE.txt ADDED
@@ -0,0 +1,21 @@
1
+ MIT License
2
+
3
+ Copyright (c) 2026 Datacircle
4
+
5
+ Permission is hereby granted, free of charge, to any person obtaining a copy
6
+ of this software and associated documentation files (the "Software"), to deal
7
+ in the Software without restriction, including without limitation the rights
8
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9
+ copies of the Software, and to permit persons to whom the Software is
10
+ furnished to do so, subject to the following conditions:
11
+
12
+ The above copyright notice and this permission notice shall be included in all
13
+ copies or substantial portions of the Software.
14
+
15
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21
+ SOFTWARE.
data/README.md ADDED
@@ -0,0 +1,67 @@
1
+ # Datacircle functions for Raix
2
+
3
+ Find the best GTM APIs. We benchmark all the GTM APIs and we put the results on our website: https://datacircle.dev
4
+
5
+ This gem gives a [Raix](https://github.com/OlympiaAI/raix) chat four functions that call Datacircle's open API, https://api.datacircle.dev/v1. You need no key and no account.
6
+
7
+ | Function | What the function gives | Call |
8
+ | --- | --- | --- |
9
+ | `datacircle_list_apis` | Every GTM API on Datacircle, with the API's slug, number of plans, number of providers and best plan | `GET /apis` |
10
+ | `datacircle_best_plans` | One API's plans, sorted by score out of 100, best first. Each plan comes with a rank and a price per 1,000 calls | `GET /apis/{slug}/best` |
11
+ | `datacircle_search_plans` | Plans that match a provider or plan name. Search all APIs or one API. Sort by score, provider or price | `GET /plans` |
12
+ | `datacircle_provider` | The APIs a provider sells, and the provider's rank on each API | `GET /providers/{slug}` |
13
+
14
+ ## Install
15
+
16
+ ```bash
17
+ bundle add raix-datacircle
18
+ ```
19
+
20
+ The gem needs Raix 1.0.3 or later, and Ruby 3.2.2 or later.
21
+
22
+ ## Use the functions
23
+
24
+ Include `Raix::Datacircle` in a class that includes `Raix::ChatCompletion`:
25
+
26
+ ```ruby
27
+ require "raix/datacircle"
28
+
29
+ class GtmAdvisor
30
+ include Raix::ChatCompletion
31
+ include Raix::Datacircle
32
+
33
+ configure do |config|
34
+ config.model = "anthropic/claude-sonnet-4.5"
35
+ end
36
+ end
37
+
38
+ advisor = GtmAdvisor.new
39
+ advisor.transcript << { user: "Which email finder API is best for under $5 per 1,000?" }
40
+ advisor.chat_completion
41
+ ```
42
+
43
+ `Raix::Datacircle` includes `Raix::FunctionDispatch` for you. Raix runs each function the model calls, gives the model its answer and returns the model's text. To offer only some of the functions, pass `available_tools:`, like `available_tools: [:datacircle_best_plans]`.
44
+
45
+ Raix sends this model through OpenRouter. To call OpenAI's API instead, set the model to `gpt-4o` and call `advisor.chat_completion(openai: "gpt-4o")`. Set up your keys as Raix's README says.
46
+
47
+ You can call a function yourself:
48
+
49
+ ```ruby
50
+ Raix::Datacircle.call(:datacircle_best_plans, slug: "email-finder", limit: 3)
51
+ # => "{\"api\":\"Employee email\",\"slug\":\"email-finder\",...,\"plans\":[{\"api\":\"Employee email\",\"rank\":1,\"provider\":\"Emelia\",...}]}"
52
+ ```
53
+
54
+ Each function answers JSON. Each plan comes with a rank, provider, plan, score, price per 1,000 (`perThousand`, in dollars) and a page on datacircle.dev. That page lists every field. When the API has no data, for example for an unknown slug, the answer is `{"error": ...}` with the API's words. The model reads the error and can call the function again. A function never raises for the API's errors, so the chat goes on.
55
+
56
+ ## Network
57
+
58
+ Each function call makes one HTTPS GET request to https://api.datacircle.dev/v1. A function makes a second request when the model sends a name where a slug goes, or a provider where an API goes. A request holds only the function's own arguments: no key, no config, nothing from your messages. The API takes up to 60 calls a minute from one IP address. A function waits once, for a minute at most, when the API asks it to wait. The gem depends only on Raix and stores nothing.
59
+
60
+ ## Links
61
+
62
+ - Datacircle: https://datacircle.dev
63
+ - The API: https://datacircle.dev/api
64
+ - The API's spec: https://api.datacircle.dev/v1/openapi.json
65
+ - What each key means: https://datacircle.dev/fields
66
+
67
+ MIT license.
@@ -0,0 +1,76 @@
1
+ # frozen_string_literal: true
2
+
3
+ require 'json'
4
+ require 'net/http'
5
+ require 'uri'
6
+
7
+ module Raix
8
+ module Datacircle
9
+ # What Datacircle's API answered when it gave no data (its HTTP status in #status), or why it could not be reached.
10
+ class Error < StandardError
11
+ attr_reader :status
12
+
13
+ def initialize(message = nil, status: nil)
14
+ super(message)
15
+ @status = status
16
+ end
17
+ end
18
+
19
+ # One HTTPS GET to Datacircle's open API, with no key: its answer as a Hash or an Array.
20
+ class Client
21
+ BASE = 'https://api.datacircle.dev/v1'
22
+
23
+ def initialize(base_url: BASE)
24
+ @base = base_url.to_s.chomp('/')
25
+ end
26
+
27
+ def get(path, params = {})
28
+ uri = URI("#{@base}#{path}")
29
+ query = params.reject { |_, value| value.nil? || value.to_s.strip.empty? }
30
+ uri.query = URI.encode_www_form(query) unless query.empty?
31
+ 2.times do |attempt|
32
+ response = request(uri)
33
+ return parse(response) if response.is_a?(Net::HTTPSuccess)
34
+
35
+ if response.code == '429' && attempt.zero?
36
+ sleep(wait(response))
37
+ next
38
+ end
39
+ raise Error.new(words(response), status: response.code.to_i)
40
+ end
41
+ raise Error.new("Datacircle's API answered 429 twice: wait a minute and call again", status: 429)
42
+ end
43
+
44
+ private
45
+
46
+ def request(uri)
47
+ Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https', open_timeout: 15, read_timeout: 30) do |http|
48
+ http.get(uri.request_uri, 'Accept' => 'application/json', 'User-Agent' => "raix-datacircle/#{VERSION}")
49
+ end
50
+ rescue SocketError, SystemCallError, Timeout::Error, OpenSSL::SSL::SSLError, Net::HTTPBadResponse => e
51
+ raise Error, "Datacircle's API could not be reached: #{e.message}"
52
+ end
53
+
54
+ def parse(response)
55
+ JSON.parse(response.body.to_s)
56
+ rescue JSON::ParserError
57
+ raise Error.new("Datacircle's API answered #{response.code} with no JSON", status: response.code.to_i)
58
+ end
59
+
60
+ # The API asks to wait in Retry-After: its seconds, a minute at most.
61
+ def wait(response)
62
+ Integer(response['Retry-After'] || 30).clamp(1, 60)
63
+ rescue ArgumentError
64
+ 30
65
+ end
66
+
67
+ # The API's own words: its error of a 4xx, else its status.
68
+ def words(response)
69
+ parsed = JSON.parse(response.body.to_s)
70
+ parsed.is_a?(Hash) && parsed['error'] ? parsed['error'].to_s : "Datacircle's API answered #{response.code}"
71
+ rescue JSON::ParserError
72
+ "Datacircle's API answered #{response.code}"
73
+ end
74
+ end
75
+ end
76
+ end
@@ -0,0 +1,194 @@
1
+ # frozen_string_literal: true
2
+
3
+ module Raix
4
+ module Datacircle
5
+ # A plan holds about 90 keys (its terms of use, its aggregators...): these choose a plan, the rest is on its page.
6
+ PLAN_KEYS = %w[api rank provider plan score perThousand notFoundPerThousand billing pay currency units unit
7
+ strengths latencyMs page pricingPage docs].freeze
8
+
9
+ # Where a provider's plans are, for a model that sent a provider's name to an API's function.
10
+ FOR_PROVIDER = "A provider's plans: datacircle_search_plans with its name as query, like bright data, " \
11
+ 'or datacircle_provider.'
12
+
13
+ PRICE = "perThousand is a plan's price of 1,000 items in dollars, pay the plan's whole price in its currency."
14
+
15
+ # The four functions as Raix::FunctionDispatch declares them: name, description and parameters.
16
+ FUNCTIONS = {
17
+ datacircle_list_apis: [
18
+ "Lists the GTM APIs on Datacircle's sheet (https://datacircle.dev), with each API's slug, how many plans and " \
19
+ "providers it has and its best plan. Call it first to find an API's slug.",
20
+ { query: { type: 'string', description: "Words of the API's name or slug, like email or linkedin profile: the " \
21
+ "APIs that hold the most of them come first. The sheet's order when left out." },
22
+ limit: { type: 'integer', description: 'How many APIs to give, 1 to 200. 20 when left out: the sheet has about 150.' } }
23
+ ],
24
+ datacircle_best_plans: [
25
+ "Gives an API's plans best first by their score out of 100 on Datacircle's benchmark (https://datacircle.dev), " \
26
+ "each with its rank, provider, plan, $ per 1,000 calls and its page. #{PRICE}",
27
+ { slug: { type: 'string', required: true,
28
+ description: "The API's slug, like email-finder or linkedin-profile, as datacircle_list_apis gives it." },
29
+ limit: { type: 'integer', description: 'How many plans to give, 1 to 50. 10 when left out.' } }
30
+ ],
31
+ datacircle_search_plans: [
32
+ "Searches every plan on Datacircle's sheet (https://datacircle.dev), or one API's, by provider or plan name, " \
33
+ "sorted by score, provider or price. Gives how many were found and up to limit of them. #{PRICE}",
34
+ { query: { type: 'string', description: "Words that must all appear in the provider's or plan's name, like bright data." },
35
+ api: { type: 'string', description: "Only this API's plans: its name or slug, like email-finder. A provider's " \
36
+ 'name goes in query, never here. Every API when left out.' },
37
+ sort: { type: 'string', enum: %w[score provider price],
38
+ description: 'score (best first, the default), provider (A to Z) or price ($ per 1,000, lowest first).' },
39
+ limit: { type: 'integer', description: 'How many plans to give, 1 to 50. 10 when left out.' },
40
+ offset: { type: 'integer', description: 'How many found plans to skip first. 0 when left out.' } }
41
+ ],
42
+ datacircle_provider: [
43
+ "Gives each API one provider sells and its rank on each on Datacircle's benchmark (https://datacircle.dev), " \
44
+ 'with its best plan there, its best rank first. total is how many APIs it sells, ranked on how many of them ' \
45
+ 'it has a rank.',
46
+ { slug: { type: 'string', required: true,
47
+ description: "The provider's slug, like bright-data, or its name, like Bright Data: the name is made a slug." } }
48
+ ]
49
+ }.freeze
50
+
51
+ # The four calls of https://api.datacircle.dev/v1 behind the functions, each answering a Hash.
52
+ class Functions
53
+ def initialize(base_url: Client::BASE)
54
+ @client = Client.new(base_url: base_url)
55
+ end
56
+
57
+ # A function's answer as Raix puts it in the transcript: the call's JSON, or the API's error as {"error": ...}.
58
+ def call(name, arguments)
59
+ given = (arguments || {}).to_h.to_h { |key, value| [key.to_s.to_sym, value] }
60
+ method = name.to_s.delete_prefix('datacircle_').to_sym
61
+ parameters = FUNCTIONS.fetch(:"datacircle_#{method}").last.keys
62
+ found = begin
63
+ public_send(method, **given.slice(*parameters))
64
+ rescue Error => e
65
+ { 'error' => e.message }
66
+ end
67
+ JSON.generate(found)
68
+ end
69
+
70
+ # GET /apis, the APIs whose name or slug holds the most of the query's words first.
71
+ def list_apis(query: nil, limit: nil)
72
+ apis = @client.get('/apis')
73
+ words = query.to_s.downcase.tr('-', ' ').split
74
+ held = apis.each_with_index.filter_map do |api, index|
75
+ name = "#{api['api']} #{api['slug'].to_s.tr('-', ' ')}".downcase
76
+ matched = words.count { |word| name.include?(word) }
77
+ [-matched, index, api] if matched.positive? || words.empty?
78
+ end.sort_by { |matched, index, _| [matched, index] }
79
+ note = nil
80
+ if words.any? && (held.empty? || -held.first.first < words.size)
81
+ # A provider's name sent as an API's, like Bright Data, or a question: where its plans are, and the sheet's
82
+ # order when no API holds a word of it.
83
+ note = "No API's name holds every word of #{query.to_s.strip.inspect}. #{FOR_PROVIDER}"
84
+ if held.empty?
85
+ held = apis.each_with_index.map { |api, index| [0, index, api] }
86
+ note += " These are the sheet's APIs in its order."
87
+ end
88
+ end
89
+ found = { 'total' => held.size,
90
+ 'apis' => held.first(number(limit, 1, 200) || 20).map { |_, _, api| brief(api, %w[api slug plans providers best bestPage sheetPage]) } }
91
+ note ? { 'note' => note }.merge(found) : found
92
+ end
93
+
94
+ # GET /apis/{slug}/best
95
+ def best_plans(slug: nil, limit: nil)
96
+ api = slugify(slug)
97
+ return { 'error' => "Give an API's slug, like email-finder: datacircle_list_apis gives every slug. #{FOR_PROVIDER}" } if api.empty?
98
+
99
+ begin
100
+ found = @client.get("/apis/#{api}/best", limit: number(limit, 1, 50))
101
+ rescue Error => e
102
+ raise unless e.status == 404
103
+
104
+ # An API's name sent as its slug, like Employee email: the API of that name.
105
+ named = @client.get('/apis').find { |entry| slugify(entry['api']) == api }
106
+ # A provider's name sent as the API's slug: the API's words, and where a provider's plans are.
107
+ return { 'error' => "#{e.message}. datacircle_list_apis gives every API's slug. #{FOR_PROVIDER}" } unless named
108
+
109
+ found = @client.get("/apis/#{named['slug']}/best", limit: number(limit, 1, 50))
110
+ end
111
+ found.merge('plans' => Array(found['plans']).map { |plan| brief(plan) })
112
+ end
113
+
114
+ # GET /plans
115
+ def search_plans(query: nil, api: nil, sort: nil, limit: nil, offset: nil)
116
+ notes = []
117
+ begin
118
+ found = search(api, query, sort, limit, offset)
119
+ rescue Error => e
120
+ raise unless e.status == 400 && e.message.include?('api must be') && query.to_s.strip.empty?
121
+
122
+ # A provider's name sent as the API: the plans whose provider or plan name holds it.
123
+ api, query = nil, api
124
+ found = search(api, query, sort, limit, offset)
125
+ notes << "No API is named #{query.to_s.strip.inspect}: these are the plans whose provider or plan name holds it."
126
+ end
127
+ if found['total'].to_i.zero? && query.to_s.include?('-')
128
+ # A slug sent as a name, like bright-data, which no name holds: its words, like bright data. A name with a
129
+ # hyphen, like A-Leads, is found as it is first.
130
+ words = query.to_s.tr('-', ' ').split.join(' ')
131
+ found = search(api, words, sort, limit, offset)
132
+ notes << "No provider's or plan's name holds #{query.to_s.strip.inspect}: these are the plans whose name holds #{words.inspect}."
133
+ end
134
+ found = found.merge('plans' => Array(found['plans']).map { |plan| brief(plan) })
135
+ notes.empty? ? found : { 'note' => notes.join(' ') }.merge(found)
136
+ end
137
+
138
+ # GET /providers/{slug}
139
+ def provider(slug: nil)
140
+ name = slugify(slug)
141
+ return { 'error' => "Give a provider's slug or name, like bright-data or Bright Data" } if name.empty?
142
+
143
+ begin
144
+ found = @client.get("/providers/#{name}")
145
+ rescue Error => e
146
+ raise unless e.status == 404
147
+
148
+ return { 'error' => "#{e.message.split(':').first}. A provider's plans by its name: datacircle_search_plans with " \
149
+ 'words of its name as query, like bright data.' }
150
+ end
151
+ apis = Array(found['apis']).map do |entry|
152
+ plans = Array(entry['plans'])
153
+ brief(entry, %w[api slug rank bestPage]).merge('plans' => plans.size, 'best' => best(plans)).compact
154
+ end
155
+ # Its best rank first, the APIs where it has none last, in the API's order.
156
+ apis = apis.each_with_index.sort_by { |entry, index| [entry['rank'].is_a?(Numeric) ? entry['rank'] : Float::INFINITY, index] }.map(&:first)
157
+ found.merge('apis' => apis, 'total' => apis.size, 'ranked' => apis.count { |entry| entry['rank'].is_a?(Numeric) })
158
+ end
159
+
160
+ private
161
+
162
+ def search(api, query, sort, limit, offset)
163
+ @client.get('/plans', api: api.to_s.strip, query: query.to_s.strip,
164
+ sort: (sort.to_s if %w[score provider price].include?(sort.to_s)),
165
+ limit: number(limit, 1, 50), offset: number(offset, 0, 1_000_000))
166
+ end
167
+
168
+ def brief(item, keys = PLAN_KEYS)
169
+ keys.each_with_object({}) { |key, kept| kept[key] = item[key] unless item[key].nil? }
170
+ end
171
+
172
+ # A number the model sent, within the API's range, or nil when it sent none.
173
+ def number(value, low, high)
174
+ return nil if value.nil? || value.to_s.strip.empty?
175
+ return value.to_i.clamp(low, high) if value.is_a?(Numeric)
176
+
177
+ Integer(value.to_s.strip, 10).clamp(low, high)
178
+ rescue ArgumentError
179
+ nil
180
+ end
181
+
182
+ # The API's rule for a slug: the name in lowercase letters and digits, the rest a hyphen.
183
+ def slugify(value)
184
+ value.to_s.strip.downcase.unicode_normalize(:nfkd).gsub(/\p{Mn}/, '').gsub(/[^a-z0-9]+/, '-').gsub(/\A-|-\z/, '')
185
+ end
186
+
187
+ # A provider's best plan on an API: its lowest rank, else its first.
188
+ def best(plans)
189
+ top = plans.select { |plan| plan['rank'].is_a?(Numeric) }.min_by { |plan| plan['rank'] } || plans.first
190
+ top && brief(top, %w[plan score perThousand page])
191
+ end
192
+ end
193
+ end
194
+ end
@@ -0,0 +1,7 @@
1
+ # frozen_string_literal: true
2
+
3
+ module Raix
4
+ module Datacircle
5
+ VERSION = '0.1.0'
6
+ end
7
+ end
@@ -0,0 +1,50 @@
1
+ # frozen_string_literal: true
2
+
3
+ require 'json'
4
+ require 'active_support/concern'
5
+ require 'raix'
6
+ require_relative 'datacircle/version'
7
+ require_relative 'datacircle/client'
8
+ require_relative 'datacircle/functions'
9
+
10
+ module Raix
11
+ # Datacircle's open API as four functions of a Raix chat, with no key: find the best GTM APIs. We benchmark all the
12
+ # GTM APIs and we put the results on our website, https://datacircle.dev
13
+ #
14
+ # class GtmAdvisor
15
+ # include Raix::ChatCompletion
16
+ # include Raix::Datacircle
17
+ # end
18
+ #
19
+ # Including it includes Raix::FunctionDispatch after Raix::ChatCompletion, as Raix asks, and declares
20
+ # datacircle_list_apis, datacircle_best_plans, datacircle_search_plans and datacircle_provider on the class, one GET
21
+ # of https://api.datacircle.dev/v1 each. Each answers JSON; the API's error, or why it could not be reached, is
22
+ # answered as {"error": ...} for the model to read and call again, never raised.
23
+ module Datacircle
24
+ extend ActiveSupport::Concern
25
+ include Raix::ChatCompletion
26
+ include Raix::FunctionDispatch
27
+
28
+ class << self
29
+ # Where the functions call, https://api.datacircle.dev/v1 unless set.
30
+ attr_writer :base_url
31
+
32
+ def base_url
33
+ @base_url || Client::BASE
34
+ end
35
+
36
+ # One function's JSON, as the model gets it, with no chat: call(:datacircle_best_plans, slug: "email-finder").
37
+ def call(name, arguments = {})
38
+ Functions.new(base_url: base_url).call(name, arguments)
39
+ end
40
+ end
41
+
42
+ included do
43
+ FUNCTIONS.each do |name, (description, parameters)|
44
+ function(name, description, **parameters) do |arguments|
45
+ Raix::Datacircle.call(name, arguments)
46
+ end
47
+ end
48
+ end
49
+ end
50
+ end
metadata ADDED
@@ -0,0 +1,72 @@
1
+ --- !ruby/object:Gem::Specification
2
+ name: raix-datacircle
3
+ version: !ruby/object:Gem::Version
4
+ version: 0.1.0
5
+ platform: ruby
6
+ authors:
7
+ - Wayne Hamadi
8
+ bindir: bin
9
+ cert_chain: []
10
+ date: 1980-01-02 00:00:00.000000000 Z
11
+ dependencies:
12
+ - !ruby/object:Gem::Dependency
13
+ name: raix
14
+ requirement: !ruby/object:Gem::Requirement
15
+ requirements:
16
+ - - ">="
17
+ - !ruby/object:Gem::Version
18
+ version: 1.0.3
19
+ - - "<"
20
+ - !ruby/object:Gem::Version
21
+ version: '4'
22
+ type: :runtime
23
+ prerelease: false
24
+ version_requirements: !ruby/object:Gem::Requirement
25
+ requirements:
26
+ - - ">="
27
+ - !ruby/object:Gem::Version
28
+ version: 1.0.3
29
+ - - "<"
30
+ - !ruby/object:Gem::Version
31
+ version: '4'
32
+ description: 'Four Raix functions on Datacircle''s open API, with no key: list the
33
+ GTM APIs, the best plans of one API, a search of every plan and one provider''s
34
+ ranks. We benchmark all the GTM APIs and we put the results on our website: https://datacircle.dev'
35
+ email:
36
+ - wayne@datacircle.dev
37
+ executables: []
38
+ extensions: []
39
+ extra_rdoc_files: []
40
+ files:
41
+ - LICENSE.txt
42
+ - README.md
43
+ - lib/raix/datacircle.rb
44
+ - lib/raix/datacircle/client.rb
45
+ - lib/raix/datacircle/functions.rb
46
+ - lib/raix/datacircle/version.rb
47
+ homepage: https://datacircle.dev
48
+ licenses:
49
+ - MIT
50
+ metadata:
51
+ homepage_uri: https://datacircle.dev
52
+ source_code_uri: https://github.com/waynehamadi/raix-datacircle
53
+ documentation_uri: https://github.com/waynehamadi/raix-datacircle#readme
54
+ bug_tracker_uri: https://github.com/waynehamadi/raix-datacircle/issues
55
+ rdoc_options: []
56
+ require_paths:
57
+ - lib
58
+ required_ruby_version: !ruby/object:Gem::Requirement
59
+ requirements:
60
+ - - ">="
61
+ - !ruby/object:Gem::Version
62
+ version: 3.2.2
63
+ required_rubygems_version: !ruby/object:Gem::Requirement
64
+ requirements:
65
+ - - ">="
66
+ - !ruby/object:Gem::Version
67
+ version: '0'
68
+ requirements: []
69
+ rubygems_version: 3.6.9
70
+ specification_version: 4
71
+ summary: Find the best GTM APIs, in Raix.
72
+ test_files: []