hookkaido 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 43fa5c7c35cc9356aa25ab096a92b9ac009ab261619ea5362296685b10aeca79
+  data.tar.gz: cfd220e1c1cad4596ac1af84b1b2e96ee710a6d9adb401ce9a28a7c44ccba8ad
+SHA512:
+  metadata.gz: 1065670322b34a7f0bc5dae369016d75b1c885933435ebf7ff577a33462d5305f028823423a524dbdca565d8948c4cc8f7b6e11f40564be1e2776d127471d3c8
+  data.tar.gz: fff89ee6e896e1e1c8d60bd90e061ec08bfee0e89938ee664f34760f9e87a5e017a2ba151176854346de830a2ebbbb5bdce6073dccfae8f75224b8980b991618

data/LICENSE.txt

@@ -0,0 +1,9 @@
+The MIT License (MIT)
+
+Copyright © 2025 Species File Group
+
+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,107 @@
+# Hookkaido
+
+Hookkaido is a Ruby wrapper on the [OLS](https://www.ebi.ac.uk/ols4/) API. Code follows the spirit/approach of the Gem [serrano](https://github.com/sckott/serrano), and indeed much of the wrapping utility is copied 1:1 from that repo, thanks [@sckott](https://github.com/sckott).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'hookkaido'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install hookkaido
+
+## Quick start
+
+Search for ontology terms from the (default) Uberon ontology matching 'femur':
+```ruby
+bin/console
+h = Hookkaido.search('femur')
+h.keys
+=> [:results, :page, :pagesize, :total]
+
+h[:total]
+=> 32
+h[:results].first
+=> {iri: "http://purl.obolibrary.org/obo/UBERON_0015052", label: "femur endochondral element", ontology_prefix: "uberon", description: "A femur bone or its cartilage or pre-cartilage precursor."}
+```
+
+Uberon aggregates results from many ontologies; you're likely to get more targeted results by specifying an ontology more specific to your use case, such as HAO (Hymenopteran Anatomy Ontology) for example:
+```ruby
+h = Hookkaido.search('femur', ontologies: 'hao')
+h[:total]
+=> 10
+h[:results].map{ |r| [r[:label], r[:description], r[:iri]] }
+=> 
+[["mesofemur", "The femur that is located on the mid leg.", "http://purl.obolibrary.org/obo/HAO_0001131"],
+ ["metafemur", "The femur that is located on the hind leg.", "http://purl.obolibrary.org/obo/HAO_0001140"],
+ ["profemur", "The femur that is located on the fore leg.", "http://purl.obolibrary.org/obo/HAO_0001124"],
+ ["femur", "The leg segment that is distal to the trochanter and proximal to the tibia.", "http://purl.obolibrary.org/obo/HAO_0000327"],
+ ["trochantellus", "The area that is located proximally on the femur and is delimited by a groove.", "http://purl.obolibrary.org/obo/HAO_0001033"],
+ ["protrochantero-profemoral muscle",
+  "The intrinsic leg muscle that arises anteriorly from the wall of the protrochanter and inserts on the proximal profemoral apodeme.",
+  "http://purl.obolibrary.org/obo/HAO_0001238"],
+ ["mesotrochantero-mesofemoral muscle",
+  "The intrinsic leg muscle that arises anteriorly from the wall of the mesotrochanter and inserts on the proximal mesofemoral apodeme.",
+  "http://purl.obolibrary.org/obo/HAO_0001261"],
+ ["metatrochantero-metafemoral muscle",
+  "The intrinsic leg muscle that arises anteriorly from the wall of the metatrochanter and inserts on the proximal metafemoral apodeme.",
+  "http://purl.obolibrary.org/obo/HAO_0001280"],
+ ["tibial fossa of the femur", "The fossa that is located distally on the femur and accommodates the femoral condyle of the tibia.", "http://purl.obolibrary.org/obo/HAO_0001207"],
+ ["sturdy spines of the hind femur", "The spine that is located on the ventral face of the metafemur.", "http://purl.obolibrary.org/obo/HAO_0002491"]]
+```
+
+Search more than one specific ontology - *at most 3 may be provided*, if none are provided then the default Uberon is searched.
+```ruby
+ Hookkaido.search('femur', ontologies: ['hao', 'lepao'])
+ ```
+ Available ontology identifiers can be found at https://www.ebi.ac.uk/ols4/ontologies, or you can return the list (with much less data per ontology) using Hookkaido:
+```ruby
+a = Hookkaido.ontologies
+
+a.first
+=> 
+{oid: "ado",
+ title: "Alzheimer's Disease Ontology (ADO)",
+ description:
+  "Alzheimer's Disease Ontology is a knowledge-based ontology that encompasses varieties of concepts related to Alzheimer'S Disease, foundamentally structured by upper level Basic Formal Ontology(BFO). This Ontology is enriched by the interrelational entities that demonstrate the nextwork of the understanding on Alzheimer's disease and can be readily applied for text mining."}
+```
+
+### Pagination
+
+For pagination in `search`, use the `page` and `per` parameters:
+```ruby
+h = Hookkaido.search('head', per: 50, page: 1)
+
+[h[:page], h[:per], h[:total]]
+=> [1, 50, 143]
+```
+
+The `ontologies` endpoint isn't paged - at time of writing it will return ~285 ontologies.
+
+---
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, update the `CHANGELOG.md`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/SpeciesFileGroup/hookkaido. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/SpeciesFileGroup/hookkaido/blob/main/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT license](https://github.com/SpeciesFileGroup/hookkaido/blob/main/LICENSE.txt). You can learn more about the MIT license on [Wikipedia](https://en.wikipedia.org/wiki/MIT_License) and compare it with other open source licenses at the [Open Source Initiative](https://opensource.org/license/mit/).
+
+## Code of Conduct
+
+Everyone interacting in the Hookkaido project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/SpeciesFileGroup/hookkaido/blob/main/CODE_OF_CONDUCT.md).

data/lib/hookkaido/error.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+module Hookkaido
+  class Error < StandardError; end
+  class BadRequest < Error; end
+  class NotFound < Error; end
+  class InternalServerError < Error; end
+  class BadGateway < Error; end
+  class ServiceUnavailable < Error; end
+  class GatewayTimeout < Error; end
+end

data/lib/hookkaido/faraday.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+require 'faraday'
+require 'multi_json'
+module Faraday
+  module TwOntologyErrors
+    class Middleware < Faraday::Middleware
+      def call(env)
+        @app.call(env).on_complete do |response|
+          case response[:status].to_i
+          when 400 then raise Hookkaido::BadRequest,  compose(response)
+          when 404 then raise Hookkaido::NotFound,    compose(response)
+          when 500 then raise Hookkaido::InternalServerError, compose(response)
+          when 502 then raise Hookkaido::BadGateway,  compose(response)
+          when 503 then raise Hookkaido::ServiceUnavailable,  compose(response)
+          when 504 then raise Hookkaido::GatewayTimeout,      compose(response)
+          end
+        end
+      end
+      private
+      def compose(response)
+        body = begin
+          MultiJson.load(response[:body]) if response[:body].to_s.strip.start_with?('{', '[')
+        rescue MultiJson::ParseError
+          nil
+        end
+        "#{response[:method].to_s.upcase} #{response[:url]}: #{[response[:status], body].compact.join(' ')}"
+      end
+    end
+  end
+end

data/lib/hookkaido/helpers/configuration.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+module Configuration
+  def configuration
+    yield self
+  end
+  def define_setting(name, default = nil)
+    class_variable_set("@@#{name}", default)
+    define_class_method "#{name}=" do |value|
+      class_variable_set("@@#{name}", value)
+    end
+    define_class_method name do
+      class_variable_get("@@#{name}")
+    end
+  end
+  private
+  def define_class_method(name, &block)
+    (class << self; self; end).instance_eval { define_method name, &block }
+  end
+end

data/lib/hookkaido/request.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+require_relative 'faraday'
+require 'faraday/follow_redirects'
+require 'multi_json'
+require_relative 'utils'
+
+module Hookkaido
+  class Request
+    def initialize(url:, verbose: false, headers: {}, timeout: 10)
+      @url = url
+      @verbose = verbose
+      @headers = headers
+      @timeout = timeout
+    end
+
+    def perform(endpoint, params: {}, method: :get)
+      Faraday::Utils.default_space_encoding = '+'
+      conn = Faraday.new(url: @url) do |f|
+        f.request :url_encoded
+        f.response :follow_redirects
+        f.response :logger if @verbose
+        f.options.timeout = @timeout
+        f.use Faraday::TwOntologyErrors::Middleware
+        f.adapter Faraday.default_adapter
+      end
+
+      conn.headers['Accept'] = 'application/json,*/*'
+      conn.headers[:user_agent] = make_user_agent
+      conn.headers['X-USER-AGENT'] = make_user_agent
+      @headers.each { |k, v| conn.headers[k] = v }
+      res = case method
+            when :get  then conn.get(endpoint, params)
+            when :post then conn.post(endpoint, params)
+            else raise ArgumentError, "Unsupported method: #{method}"
+            end
+
+      MultiJson.load(res.body)
+    end
+  end
+end

data/lib/hookkaido/sources/ols.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+module Hookkaido
+  module Sources
+    module OLS
+      BASE = 'https://www.ebi.ac.uk/ols4/api'
+
+      # Fetch OLS ontology IDs (lowercased)
+      def self.ontologies(verbose:, timeout:)
+        json = Hookkaido::Request
+          .new(url: BASE, verbose: verbose, timeout: timeout)
+          .perform('ontologies', params: { size: 500 }, method: :get)
+
+        arr = []
+        if json.is_a?(Hash)
+          emb = json['_embedded'] && json['_embedded']['ontologies']
+          if emb.is_a?(Array)
+            emb.each do |o|
+              oid = (o['config'] && o['config']['id'])&.to_s&.downcase || ''
+              title = (o['config'] && o['config']['title']) || ''
+              description = (o['config'] && o['config']['description']) || ''
+              arr << { oid:, title:, description: }
+            end
+          end
+        elsif json.is_a?(Array)
+          json.each do |o|
+            oid = (o['config'] && o['config']['id'])&.to_s&.downcase || ''
+            title = (o['config'] && o['config']['title']) || ''
+            description = (o['config'] && o['config']['description']) || ''
+            arr << { oid:, title:, description: }
+          end
+        end
+
+        arr.uniq
+      end
+
+      # Single-call search across up to 3 ontologies; returns results + combined total
+      def self.search(term, ontologies:, rows:, start:, verbose:, timeout:)
+        onts = Array(ontologies).map { |x| x.to_s.downcase }.uniq
+        params = {
+          q: term,
+          type: 'class',
+          ontology: onts.join(','), # multi-ontology in one call
+          queryFields: 'label,synonym',
+          fieldList: 'iri,label,description,ontology_prefix',
+          rows: rows,
+          start: start
+        }
+
+        json = Hookkaido::Request
+                 .new(url: BASE, verbose: verbose, timeout: timeout)
+                 .perform('search', params: params, method: :get)
+
+        resp  = json && json['response']
+        docs  = (resp && resp['docs']) || []
+        total = (resp && resp['numFound']) || 0
+
+        results = docs.map { |doc| normalize_doc(doc) }.compact
+        { results: results, total: total.to_i }
+      end
+
+      def self.normalize_doc(doc)
+        iri = doc['iri']
+        return nil unless iri
+
+        label = doc['label']
+        label = label.first if label.is_a?(Array)
+
+        description = doc['description']
+        description = description.first if description.is_a?(Array)
+
+        {
+          iri: iri,
+          label:,
+          ontology_prefix: doc['ontology_prefix'],
+          description:
+        }
+      end
+      private_class_method :normalize_doc
+    end
+  end
+end

data/lib/hookkaido/utils.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+def make_user_agent
+  requa = "Faraday/v" + Faraday::VERSION
+  habua = "Hookkaido/v" + Hookkaido::VERSION
+  ua = "#{requa} #{habua}"
+  ua += " (mailto:%s)" % Hookkaido.mailto if Hookkaido.mailto
+  ua
+end
+
+class Hash
+  def tosymbols
+    map { |(k, v)| [k.to_sym, v] }.to_h
+  end
+end

data/lib/hookkaido/version.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+module Hookkaido
+  VERSION = "0.1.0"
+end

data/lib/hookkaido.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+require 'erb'
+require_relative 'hookkaido/error'
+require_relative 'hookkaido/version'
+require_relative 'hookkaido/request'
+require 'hookkaido/helpers/configuration'
+require_relative 'hookkaido/sources/ols'
+
+module Hookkaido
+  extend Configuration
+
+  define_setting :timeout, (ENV['TW_ONTOLOGY_TIMEOUT'] || 10).to_i
+  define_setting :mailto, ENV['HOOKKAIDO_API_EMAIL']
+
+  # List available ontology IDs (lowercased)
+  def self.ontologies(verbose: false)
+    Sources::OLS.ontologies(verbose: verbose, timeout: timeout)
+  end
+
+  # Search OLS for terms in specific ontologies matching a user-provided term.
+  # @!param term [String] search string that returned ontology terms should
+  #   match in some way
+  # @!param ontologies
+  # Return: { results:, page:, per:, total: }
+  def self.search(term, ontologies: [], per: 25, page: 1, verbose: false)
+    raise ArgumentError, 'term cannot be blank' if term.to_s.strip.empty?
+
+    requested = Array(ontologies).flat_map { |t| t.is_a?(String) && t.include?(',') ? t.split(',') : [t] }
+    requested = requested.map { |t| t.to_s.strip.downcase }.reject(&:empty?)
+    requested = ['uberon'] if requested.empty?
+    requested = requested.uniq.first(3)
+    # Uberon is a union of many other ontologies, so can return a lot of results
+    # - put other results first.
+    requested.push('uberon') if requested.delete('uberon')
+
+    # Validate against OLS catalog
+    #available = ontologies(verbose: verbose)
+    #targets = (requested & available)
+    #targets = ['uberon'] if targets.empty?
+    targets = requested
+
+    per_page = per.to_i
+    start    = [(page.to_i - 1), 0].max * per_page
+
+    payload = Sources::OLS.search(
+      term,
+      ontologies: targets,
+      rows: per_page,
+      start: start,
+      verbose: verbose,
+      timeout: timeout
+    )
+
+    results = payload[:results] || []
+    total   = payload[:total].to_i
+
+    # De-duplicate by IRI
+    uniq = {}
+    results.each { |r| uniq[r[:iri]] ||= r if r[:iri] }
+
+    {
+      results: uniq.values,
+      page: page.to_i,
+      per: per_page,
+      total: total
+    }
+  end
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification
+name: hookkaido
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Tom Klein
+bindir: bin
+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.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+- !ruby/object:Gem::Dependency
+  name: faraday-follow_redirects
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+description: Look up ontology terms across selected OLS ontologies.
+email:
+- trklein@illinois.edu
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/hookkaido.rb
+- lib/hookkaido/error.rb
+- lib/hookkaido/faraday.rb
+- lib/hookkaido/helpers/configuration.rb
+- lib/hookkaido/request.rb
+- lib/hookkaido/sources/ols.rb
+- lib/hookkaido/utils.rb
+- lib/hookkaido/version.rb
+homepage: https://github.com/SpeciesFileGroup/hookkaido
+licenses:
+- MIT
+metadata:
+  generated_by: ChatGPT (OpenAI) assistance
+  homepage_uri: https://github.com/SpeciesFileGroup/hookkaido
+  source_code_uri: https://github.com/SpeciesFileGroup/hookkaido
+  rubygems_mfa_required: 'false'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: OLS4-backed ontology search
+test_files: []