open_fda_api 0.0.6 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 98cb0c21f6d0b4f002d0e913b36eab334ed077d5db0e34cab62b7fc02d735f79
-  data.tar.gz: b35f1e48a6be0fa33f2695e01223095ca33dff89e5d97d340e768e86fb4690ba
+  metadata.gz: adc99f4c0266329d56ee1cbc6592789908b09a98580136813e3d8033e33c2328
+  data.tar.gz: 6fc8dc376b266e216e5f263248cbae5342c655a50ba3aa1c9d37245a6b521bdf
 SHA512:
-  metadata.gz: 5bbdf5fbd2c3244b6f9952e8caf1734b63c96f4ad4977a276b8fecb3d043ffff1c2f66a5de1afdd477aa8d1dd1caf742634d763d13fd1cfa1bae4cd9c0ded735
-  data.tar.gz: 12ef328cbc3216b3c9643131ca2656c62f91103a062c0ae555c6736a0683dd62dc015b75920db90ca70afe8b19d5d51b21a72cb4afc76fb11dccd575dd6e76b9
+  metadata.gz: 95da4769cc677e55b92f682bc4b7f05d98543cfcfa05f2d4786c8254e52a6399235e3850a11c7d70ba63dd61ea28e42fda25fc336e8ac1fb3710e9e9a4dc29ca
+  data.tar.gz: f93d3fa2ffc26fad6f9460333326d32f97f51f99dcd567b85ddd62b5ed4e5f868d4aff4bcc8183b37214927e7a03ff4e64fee534c8a98a1c2f5ffc3fe7ee619c

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 ## [Unreleased]
 
+## [0.0.9] - 2022-01-24
+- Filled out the following Drug endpoints:
+  - product_labeling
+  - ndc_directory
+  - recall_enforcement_reports
+  - drugs_at_fda
+
+## [0.0.8] - 2022-01-24
+- Delete the `OpenFdaApi.client` method since its only function was to forward messages
+
+## [0.0.7] - 2022-01-23
+- Use Faraday instead of using Net::HTTP directly
+- Introduce `QueryInputs` to group query params passed in together
+
+## [0.0.6] - 2022-01-21
+- Support for more query fields
+
 ## [0.0.5] - 2022-01-20
 - Validate, against search fields given to us from openFDA API, when building queries.
 

data/Gemfile.lock

@@ -1,7 +1,9 @@
 PATH
   remote: .
   specs:
-    open_fda_api (0.0.6)
+    open_fda_api (0.0.9)
+      faraday (~> 1.9)
+      faraday_middleware (~> 1.2)
 
 GEM
   remote: https://rubygems.org/
@@ -9,7 +11,33 @@ GEM
     ast (2.4.2)
     coderay (1.1.3)
     diff-lcs (1.5.0)
+    faraday (1.9.3)
+      faraday-em_http (~> 1.0)
+      faraday-em_synchrony (~> 1.0)
+      faraday-excon (~> 1.1)
+      faraday-httpclient (~> 1.0)
+      faraday-multipart (~> 1.0)
+      faraday-net_http (~> 1.0)
+      faraday-net_http_persistent (~> 1.0)
+      faraday-patron (~> 1.0)
+      faraday-rack (~> 1.0)
+      faraday-retry (~> 1.0)
+      ruby2_keywords (>= 0.0.4)
+    faraday-em_http (1.0.0)
+    faraday-em_synchrony (1.0.0)
+    faraday-excon (1.1.0)
+    faraday-httpclient (1.0.1)
+    faraday-multipart (1.0.3)
+      multipart-post (>= 1.2, < 3)
+    faraday-net_http (1.0.1)
+    faraday-net_http_persistent (1.2.0)
+    faraday-patron (1.0.0)
+    faraday-rack (1.0.0)
+    faraday-retry (1.0.3)
+    faraday_middleware (1.2.0)
+      faraday (~> 1.0)
     method_source (1.0.0)
+    multipart-post (2.1.1)
     parallel (1.21.0)
     parser (3.1.0.0)
       ast (~> 2.4.1)
@@ -45,6 +73,7 @@ GEM
     rubocop-ast (1.15.1)
       parser (>= 3.0.1.1)
     ruby-progressbar (1.11.0)
+    ruby2_keywords (0.0.5)
     unicode-display_width (2.1.0)
 
 PLATFORMS

data/README.md

@@ -16,37 +16,64 @@ And then execute:
 bundle install
 ```
 
-## Documentation
+## Usage
 
-There are 5 main category of endpoints that openFDA API provides: Drug, Device, Food, Other, and Tobacco.
-
-Each category has further subcategories. Everything is accessible from the `OpenFdaApi.client`.
+```ruby
+client = OpenFdaApi.client
 
+# First 20 results where (fieldA=foo AND fieldB=bar) OR (fieldC=baz AND fieldA exists)
+# Sorted by (fieldD) in descending order
+# Skip the first 8 results
+args = { 
+  search: [{"fieldA" => "foo", "fieldB" => "bar"}, {"fieldC" => "baz", "_exists_" => "fieldA"}],
+  sort: [{"fieldD" => "desc"}],
+  skip: 8,
+  limit: 20 
+}
+
+# Drug API
+client.drugs.adverse_events(args)
+client.drugs.product_labeling(args)
+client.drugs.ndc_directory(args)
+client.drugs.recall_enforcement_reports(args)
+client.drugs.drugs_at_fda(args)
+
+# Device API
+client.device.premarket_501ks(args)
+client.device.classification(args)
+client.device.recall_enforcement_reports(args)
+client.device.adverse_events(args)
+client.device.premarket_approval(args)
+client.device.recalls(args)
+client.device.registrations_and_listings(args)
+client.device.covid19_serological_tests(args)
+client.device.unique_device_identifier(args)
+
+# Food API
+client.food.recall_enforcement_reports(args)
+client.food.adverse_events(args)
+
+# Other API
+client.other.nsde(args)
+client.other.substance_data_reports(args)
+
+# Tobacco API
+client.tobacco.problem_reports(args)
+```
 
-### Drug
+### Querying
 
-The Drug API has the following endpoints: Adverse Events, Product Labeling, NDC Directory, Recall Enforcement Reports, and Drugs@FDA.
+The openFDA API can be queried with these arguments: `search`, `sort`, `count`, `skip`, and `limit`.
 
-Here's how you interact with each:
+`search`, `sort`, and `count` have the same format. They are arrays of hashes. Each hash has a set of fields and values
+that are ANDed together and all the elements in the array are ORed together. Here are some examples to illustrate:
 
-#### Adverse Events
 ```ruby
-require 'open_fda_api'
+search = [{"patient.drug.openfda.pharm_class_epc" => "nonsteroidal+anti-inflammatory+drug" }]
 
-client = OpenFdaApi.client
-drugs_api = client.drugs
-
-search_args = [{"patient.patientweight"=>"50", "occurcountry"=>"ca"}]
-drugs_api.adverse_events(search: search_args, skip: 1) # => {"meta" => {...}, "results" => [...]}
+# patient.drug.openfda.pharm_class_epc:"nonsteroidal+anti-inflammatory+drug"&count=patient.reaction.reactionmeddrapt.exact
 ```
 
-#### Device (Not Implemented Yet)
-#### Food (Not Implemented Yet)
-#### Other (Not Implemented Yet)
-#### Tobacco (Not Implemented Yet)
-
-
-
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies.

data/bin/console

@@ -11,5 +11,8 @@ require "open_fda_api"
 # require "pry"
 # Pry.start
 
+client = OpenFdaApi::Client.new
+puts "Client is ready: #{client}"
+
 require "irb"
 IRB.start(__FILE__)

data/lib/open_fda_api/client.rb

@@ -1,18 +1,34 @@
 # frozen_string_literal: true
 
-require_relative "./drugs"
+require "faraday"
+require "faraday_middleware"
 
 module OpenFdaApi
   # Gives you access to the main nouns in the openFDA API
   class Client
-    attr_reader :api_key
+    attr_reader :api_key, :adapter
 
-    def initialize(api_key: nil)
+    BASE_URL = "https://api.fda.gov"
+
+    def initialize(api_key: nil, adapter: Faraday.default_adapter, stubs: nil)
       @api_key = api_key
+      @adapter = adapter
+      @stubs   = stubs
     end
 
     def drugs
-      OpenFdaApi::Drugs.new
+      OpenFdaApi::Drugs.new(self)
+    end
+
+    def connection
+      @connection ||= Faraday.new(BASE_URL) do |conn|
+        conn.request :json
+
+        conn.response :dates
+        conn.response :json, content_type: "application/json"
+
+        conn.adapter adapter, @stubs
+      end
     end
   end
 end

data/lib/open_fda_api/drugs.rb

@@ -3,7 +3,6 @@
 require "net/http"
 require "json"
 require "yaml"
-require "open_fda_api/query_builder"
 
 module OpenFdaApi
   # Interact with the Drugs API Endpoint:
@@ -13,25 +12,77 @@ module OpenFdaApi
   #  - Recall Enforcement Reports
   #  - Drugs@FDA)
   class Drugs
-    def initialize
+    attr_reader :client, :path_base
+
+    def initialize(client)
+      @client = client
       @host = "api.fda.gov"
       @path_base = "/drug"
     end
 
-    # The openFDA drug adverse event API returns data that has been collected from the
-    # FDA Adverse Event Reporting System (FAERS), a database that contains information on
-    # adverse event and medication error reports submitted to FDA.
-    #
     # @param search [Array<Hash>] Search fields defined in https://open.fda.gov/apis/drug/event/searchable-fields/
     # @param sort   [Array<Hash>] Sort fields defined in https://open.fda.gov/apis/drug/event/searchable-fields/
     # @param count  [Array<Hash>] Count fields defined https://open.fda.gov/apis/drug/event/searchable-fields/
     # @param skip   [Integer]     Number of results to skip
+    # @param limit  [Integer]     Number of results to return
+    # @return Response from the API parsed as JSON
+    def adverse_events(search: [], sort: [], count: [], skip: 0, limit: 1)
+      endpoint = "event.json"
+      inputs   = build_inputs(search: search, sort: sort, count: count, skip: skip, limit: limit)
+      query    = build_query(inputs, self.class.valid_adverse_events_fields)
+      make_request(endpoint, query)
+    end
+
+    # @param search [Array<Hash>] Search fields defined in https://open.fda.gov/apis/drug/event/searchable-fields/
+    # @param sort   [Array<Hash>] Sort fields defined in https://open.fda.gov/apis/drug/event/searchable-fields/
+    # @param count  [Array<Hash>] Count fields defined https://open.fda.gov/apis/drug/event/searchable-fields/
+    # @param skip   [Integer]     Number of results to skip
+    # @param limit  [Integer]     Number of results to return
+    # @return Response from the API parsed as JSON
+    def product_labeling(search: [], sort: [], count: [], skip: 0, limit: 1)
+      endpoint = "label.json"
+      inputs   = build_inputs(search: search, sort: sort, count: count, skip: skip, limit: limit)
+      query    = build_query(inputs, {}) # TODO: Upload valid fields
+      make_request(endpoint, query)
+    end
+
+    # @param search [Array<Hash>] Search fields defined in https://open.fda.gov/apis/drug/event/searchable-fields/
+    # @param sort   [Array<Hash>] Sort fields defined in https://open.fda.gov/apis/drug/event/searchable-fields/
+    # @param count  [Array<Hash>] Count fields defined https://open.fda.gov/apis/drug/event/searchable-fields/
+    # @param skip   [Integer]     Number of results to skip
+    # @param limit  [Integer]     Number of results to return
+    # @return Response from the API parsed as JSON
+    def ndc_directory(search: [], sort: [], count: [], skip: 0, limit: 1)
+      endpoint = "ndc.json"
+      inputs   = build_inputs(search: search, sort: sort, count: count, skip: skip, limit: limit)
+      query    = build_query(inputs, {}) # TODO: Upload valid fields
+      make_request(endpoint, query)
+    end
+
+    # @param search [Array<Hash>] Search fields defined in https://open.fda.gov/apis/drug/event/searchable-fields/
+    # @param sort   [Array<Hash>] Sort fields defined in https://open.fda.gov/apis/drug/event/searchable-fields/
+    # @param count  [Array<Hash>] Count fields defined https://open.fda.gov/apis/drug/event/searchable-fields/
+    # @param skip   [Integer]     Number of results to skip
+    # @param limit  [Integer]     Number of results to return
+    # @return Response from the API parsed as JSON
+    def recall_enforcement_reports(search: [], sort: [], count: [], skip: 0, limit: 1)
+      endpoint = "enforcement.json"
+      inputs   = build_inputs(search: search, sort: sort, count: count, skip: skip, limit: limit)
+      query    = build_query(inputs, {}) # TODO: Upload valid fields
+      make_request(endpoint, query)
+    end
+
+    # @param search [Array<Hash>] Search fields defined in https://open.fda.gov/apis/drug/event/searchable-fields/
+    # @param sort   [Array<Hash>] Sort fields defined in https://open.fda.gov/apis/drug/event/searchable-fields/
+    # @param count  [Array<Hash>] Count fields defined https://open.fda.gov/apis/drug/event/searchable-fields/
+    # @param skip   [Integer]     Number of results to skip
+    # @param limit  [Integer]     Number of results to return
     # @return Response from the API parsed as JSON
-    def adverse_events(search: [], sort: [], count: [], skip: 0)
-      endpoint = "/event.json"
-      query    = build_query(search, sort, count, skip, self.class.valid_adverse_events_fields)
-      url      = build_url(endpoint, query)
-      make_request(url)
+    def drugs_at_fda(search: [], sort: [], count: [], skip: 0, limit: 1)
+      endpoint = "drugsfda.json"
+      inputs   = build_inputs(search: search, sort: sort, count: count, skip: skip, limit: limit)
+      query    = build_query(inputs, {}) # TODO: Upload valid fields
+      make_request(endpoint, query)
     end
 
     def self.valid_adverse_events_fields
@@ -40,17 +91,21 @@ module OpenFdaApi
 
     private
 
-    def build_url(endpoint, query)
-      URI::HTTPS.build(host: @host, path: @path_base + endpoint, query: query)
+    def build_query(query_input, valid_search_fields)
+      QueryBuilder.new(query_input: query_input, valid_search_fields: valid_search_fields).build_query
     end
 
-    def build_query(search, sort, count, skip, valid_search_fields)
-      QueryBuilder.new(search: search, sort: sort, count: count, skip: skip,
-                       valid_search_fields: valid_search_fields).build_query
+    def build_inputs(search:, sort:, count:, skip:, limit:)
+      QueryInputs.new(search: search, sort: sort, count: count, skip: skip, limit: limit)
     end
 
-    def make_request(url)
-      JSON.parse(Net::HTTP.get(url))
+    def make_request(endpoint, query)
+      url = "#{path_base}/#{endpoint}"
+      if query.empty?
+        client.connection.get(url)
+      else
+        client.connection.get(url, query)
+      end.body
     end
   end
 end

data/lib/open_fda_api/query_builder.rb

@@ -26,52 +26,58 @@ module OpenFdaApi
   #   is 25000. See Paging if you require paging through larger result sets.
   class QueryBuilder
     # @param [Hash] valid_search_fields
-    # @param [Array<Hash>] search
-    # @param [Array<Hash>] sort
-    # @param [Array<Hash>] count
-    # @param [Integer] skip
-    def initialize(valid_search_fields:, search: [], sort: [], count: [], skip: 0)
-      validate_arguments!(valid_search_fields, search: search, sort: sort, count: count, skip: skip)
-      @search = build_query_string(query_type: "search", query_fields: search)
-      @sort   = build_query_string(query_type: "sort",   query_fields: sort)
-      @count  = build_query_string(query_type: "count",  query_fields: count)
-      @skip   = build_skip_string(skip)
+    # @param [QueryInput] query_input
+    def initialize(query_input:, valid_search_fields:)
+      # TODO: Turn validations back on once we get basic functionality working; need to flex on different field types
+      # validate_arguments!(valid_search_fields, query_input: query_input)
+      warn "You've passed in a valid_search_fields arg but it isn't being used right now..." if valid_search_fields
+      @search = build_query_string(query_fields: query_input.search)
+      @sort   = build_query_string(query_fields: query_input.sort)
+      @count  = build_query_string(query_fields: query_input.count)
+      @skip   = build_skip_string(query_input.skip)
+      @limit  = query_input.limit
     end
 
-    # @return [String] the query string portion of a request
+    # @return [Hash] the query string portion of a request
     def build_query
-      [@search, @sort, @count, @skip].reject! { |v| v.nil? || v.empty? }.join("&")
+      {
+        search: @search,
+        sort: @sort,
+        count: @count,
+        skip: @skip,
+        limit: @limit
+      }.compact.reject { |_k, v| v.to_s.empty? }
     end
 
     private
 
-    def validate_arguments!(valid_search_fields, search:, sort:, count:, skip:)
+    def validate_arguments!(valid_search_fields, query_input:)
       # `search` keys must exist in adverse_events_fields.yml
-      invalid_fields = get_invalid_fields(valid_search_fields: valid_search_fields, fields: search)
+      invalid_fields = get_invalid_fields(valid_search_fields: valid_search_fields, fields: query_input.search)
       raise InvalidQueryArgument, "'search' has invalid fields: #{invalid_fields}" if invalid_fields.any?
 
       # `sort` keys must exist in adverse_events_fields.yml
-      invalid_fields = get_invalid_fields(valid_search_fields: valid_search_fields, fields: sort)
+      invalid_fields = get_invalid_fields(valid_search_fields: valid_search_fields, fields: query_input.sort)
       raise InvalidQueryArgument, "'sort' has invalid fields: #{invalid_fields}" if invalid_fields.any?
 
       # `count` keys must exist in adverse_events_fields.yml
-      invalid_fields = get_invalid_fields(valid_search_fields: valid_search_fields, fields: count)
+      invalid_fields = get_invalid_fields(valid_search_fields: valid_search_fields, fields: query_input.count)
       raise InvalidQueryArgument, "'count' has invalid fields: #{invalid_fields}" if invalid_fields.any?
 
       # `count` and `skip` cannot be set at the same time
-      return unless count_and_skip_set?(count, skip)
+      return unless count_and_skip_set?(query_input.count, query_input.skip)
 
       raise InvalidQueryArgument, "'count' and 'skip' cannot both be set at the same time!"
     end
 
-    def build_query_string(query_type:, query_fields:)
+    def build_query_string(query_fields:)
       return "" if query_fields.empty?
 
-      "#{query_type}=#{build_groupings(query_fields)}"
+      build_groupings(query_fields).to_s
     end
 
     def build_skip_string(skip)
-      skip.positive? ? "skip=#{skip}" : ""
+      skip.positive? ? skip.to_s : ""
     end
 
     def build_groupings(fields)

data/lib/open_fda_api/query_inputs.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module OpenFdaApi
+  # Group of inputs to build the query against the API with
+  class QueryInputs
+    attr_reader :search, :sort, :count, :skip, :limit
+
+    def initialize(**params)
+      @search = params[:search] || []
+      @sort   = params[:sort]   || []
+      @count  = params[:count]  || []
+      @skip   = params[:skip]   || 0
+      @limit  = params[:limit]  || nil
+    end
+  end
+end

data/lib/open_fda_api/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module OpenFdaApi
-  VERSION = "0.0.6"
+  VERSION = "0.0.9"
 end

data/lib/open_fda_api.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
 require_relative "open_fda_api/version"
-require_relative "open_fda_api/client"
 
 # A Ruby wrapper for the openFDA API: https://open.fda.gov/apis/
 module OpenFdaApi
   class Error < StandardError; end
 
-  def self.client(api_key: nil)
-    OpenFdaApi::Client.new(api_key: api_key)
-  end
+  autoload :Client, "open_fda_api/client"
+  autoload :Drugs,  "open_fda_api/drugs"
+  autoload :QueryInputs, "open_fda_api/query_inputs"
+  autoload :QueryBuilder, "open_fda_api/query_builder"
 end

data/open_fda_api.gemspec

@@ -27,7 +27,9 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   # Uncomment to register a new dependency of your gem
-  # spec.add_dependency "example-gem", "~> 1.0"
+  spec.add_dependency "faraday", "~> 1.9"
+  spec.add_dependency "faraday_middleware", "~> 1.2"
+
   spec.add_development_dependency "pry"
 
   # For more information and examples about making a new gem, checkout our

metadata

@@ -1,15 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: open_fda_api
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.9
 platform: ruby
 authors:
 - Hebron George
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-01-21 00:00:00.000000000 Z
+date: 2022-01-24 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+- !ruby/object:Gem::Dependency
+  name: faraday_middleware
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -49,6 +77,7 @@ files:
 - lib/open_fda_api/client.rb
 - lib/open_fda_api/drugs.rb
 - lib/open_fda_api/query_builder.rb
+- lib/open_fda_api/query_inputs.rb
 - lib/open_fda_api/version.rb
 - open_fda_api.gemspec
 homepage: https://github.com/hebron-george/open_fda_api