linguin 1.1.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 461d92619f5fd7fac0ad19de24ba4eea626bf451efb4b873d9bfb0cd6afab741
-  data.tar.gz: bb8a97a922a53411f020f81a8760baec5e19fcb35350636a78c6a290a874e949
+  metadata.gz: 6d1af43a17413610039ec33597126a4d33b6f783b57a2a77e16b612530818242
+  data.tar.gz: 5fc45e06d4a565b456069010c429f64c8b992fef7f6723ac90b9a7d78594099f
 SHA512:
-  metadata.gz: f2c55feb0ddfdd683a3e57d135039f07e1873a8c81ebfe2dd248a74e62a0f180210449f3d99d9cc520232e8bb2fdc31aa4f92ea66d91ebfba765c03a2e4a3aa0
-  data.tar.gz: 1604d947cdb234df8004a23fbc8799a70e71cdbc8714c58ed1b1571d45a03d8ab48fbe83f45c80a36030c011221856f6d015c7b3d850e53f6f4e88797a7b259c
+  metadata.gz: 6cb9fddd4dda04e5457db7a0cd190fba098ace5c356fcd6f0402099bcb5a3b20eeee197a2ee5d46b269d1eab389543381f93c931869114c475c9d64292f953d6
+  data.tar.gz: 3ccc21471b50b8e3dd31b7a1cf2f18e4d11eb49bab233113a8c0789b12169be5792c567cf9a6f3d82a5cc788d8aa3e4527cea52729d28d60f55837991e74cc80

data/.rubocop.yml

@@ -11,7 +11,7 @@ Layout/LineLength:
 Layout/EmptyLineBetweenDefs:
   AllowAdjacentOneLineDefs: true
 Metrics/MethodLength:
-  Max: 15
+  Max: 16
 Gemspec/DateAssignment: # (new in 1.10)
   Enabled: true
 Layout/SpaceBeforeBrackets: # (new in 1.7)
@@ -80,3 +80,7 @@ Style/MultilineInPatternThen: # (new in 1.16)
   Enabled: true
 Style/QuotedSymbols: # (new in 1.16)
   Enabled: true
+Layout/LineEndStringConcatenationIndentation: # (new in 1.18)
+  Enabled: true
+Naming/InclusiveLanguage: # (new in 1.18)
+  Enabled: true

data/README.md

@@ -2,7 +2,7 @@
 
 [![Gem Version](https://badge.fury.io/rb/linguin.svg)](https://badge.fury.io/rb/linguin) ![build](https://github.com/LinguinAI/linguin-ruby/actions/workflows/main.yml/badge.svg) [![Ruby Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://github.com/testdouble/standard)
 
-This is a Ruby wrapper for the [Linguin AI](https://linguin.ai) API (see [API docs](https://linguin.ai/api-docs/v1)) providing Language Detection as a Service.
+This is a Ruby wrapper for the [Linguin AI](https://linguin.ai) API (see [API docs](https://linguin.ai/api-docs/v2)) providing Language and Profanity Detection as a Service.
 
 Linguin AI is free for up to 100 detections per day. You can get your API key [here](https://linguin.ai).
 
@@ -31,21 +31,25 @@ require "linguin"
 
 Linguin.api_key = "YOUR-API-KEY" # goto https://linguin.ai to get your key
 
-response = Linguin.detect("test")
+response = Linguin.detect_language("test")
 response.success? # => true
 response.results  # => [{ lang: "en", confidence: 0.97 }, ...]
+
+response = Linguin.detect_profanity("you are a moron")
+response.success? # => true
+response.score    # => 0.998
 ```
 
 If something goes wrong (here: empty text):
 
 ```ruby
-response = Linguin.detect("")
+response = Linguin.detect_language("")
 response.success? # => false
 response.error
 # => { code: 400, message: "The language of an empty text is more of a philosophical question." }
 
-# if you prefer to handle exceptions instead you can use `#detect!`:
-response = Linguin.detect!("")
+# if you prefer to handle exceptions instead you can use `#detect_language!`:
+response = Linguin.detect_language!("")
 # => raises Linguin::InputError
 ```
 
@@ -54,19 +58,25 @@ See the list of all exceptions [here](https://github.com/LinguinAI/linguin-ruby/
 ### Bulk detection
 
 To detect the language of multiple texts with one API call, you can pass them as an array. The results will be returned in the same order as the texts.
-All texts have to not be empty. Using `detect!` will result in an exception as for single detections.
+All texts have to not be empty. Using `detect_language!` will result in an exception as for single detections.
+
+The same is true for profanity detection: calling `detect_profanity!` with empty texts will result in an exception as for single detections.
 
 ```ruby
-response = Linguin.detect(["test", "bahnhof", "12341234"])
+response = Linguin.detect_language(["test", "bahnhof", "12341234"])
 response.results
 # => [ [{ lang: "en", confidence: 0.97 }, ...], [{ ... }], [] ]
 
-response = Linguin.detect(["test", ""])
+response = Linguin.detect_profanity(["a test", "you are a moron"])
+response.scores
+# => [0.0124, 0.9981]
+
+response = Linguin.detect_language(["test", ""])
 response.success? # => false
 response.error
 # => { code: 400, message: "At least one of the texts provided was empty." }
 
-Linguin.detect!(["test", ""])
+Linguin.detect_language!(["test", ""])
 # => raises Linguin::InputError
 ```
 

data/lib/linguin.rb

@@ -4,8 +4,10 @@ require_relative "linguin/version"
 require_relative "linguin/exceptions"
 require_relative "linguin/client"
 require_relative "linguin/base_response"
-require_relative "linguin/detection"
-require_relative "linguin/bulk_detection"
+require_relative "linguin/language_detection"
+require_relative "linguin/profanity_detection"
+require_relative "linguin/bulk_language_detection"
+require_relative "linguin/bulk_profanity_detection"
 require_relative "linguin/status"
 require_relative "linguin/languages"
 
@@ -36,12 +38,20 @@ module Linguin
       default_client.api_key = api_key
     end
 
-    def detect(text)
-      default_client.detect(text)
+    def detect_language(text)
+      default_client.detect_language(text)
     end
 
-    def detect!(text)
-      default_client.detect!(text)
+    def detect_language!(text)
+      default_client.detect_language!(text)
+    end
+
+    def detect_profanity(text)
+      default_client.detect_profanity(text)
+    end
+
+    def detect_profanity!(text)
+      default_client.detect_profanity!(text)
     end
 
     def status

data/lib/linguin/{bulk_detection.rb → bulk_language_detection.rb}

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
 module Linguin
-  # == Linguin::BulkDetection
-  # Returned by Linguin#detect(!) when called with an array of strings.
+  # == Linguin::BulkLanguageDetection
+  # Returned by Linguin#detect_language(!) when called with an array of strings.
   #
   # #success? - Bool - checks if detection results were found
   # #error - Hash - contains `error` and `message` about what went wrong
   # #results - Array - contains the detection results for each text, ordered by confidence descending
-  class BulkDetection < Detection; end
+  class BulkLanguageDetection < LanguageDetection; end
 end

data/lib/linguin/bulk_profanity_detection.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Linguin
+  # == Linguin::BulkProfanityDetection
+  # Returned by Linguin#detect_profanity(!) when called with an array of strings.
+  #
+  # #success? - Bool - checks if detection results were found
+  # #error - Hash - contains `error` and `message` about what went wrong
+  # #results - Array - contains the profanity scores of each text in the same order
+  class BulkProfanityDetection < BaseResponse
+    attr_writer :success
+    attr_accessor :scores
+
+    class << self
+      def error(code, message)
+        new do |detection|
+          detection.success = false
+          detection.error = {
+            code: code,
+            message: message
+          }
+        end
+      end
+
+      def success(result)
+        new do |detection|
+          detection.success = true
+          detection.scores = result[:scores]
+        end
+      end
+    end
+
+    def success?
+      !!@success
+    end
+  end
+end

data/lib/linguin/client.rb

@@ -9,7 +9,7 @@ module Linguin
   class Client
     include HTTParty
 
-    base_uri "https://api.linguin.ai/v1"
+    base_uri "https://api.linguin.ai/v2"
 
     # we are parsing the JSON response in Linguin::BaseResponse
     # in order to have symbolized keys
@@ -26,34 +26,41 @@ module Linguin
       configure_api_key(key)
     end
 
-    def detect(text)
+    def detect_language(text)
       ensure_api_key!
 
-      return bulk(text) if text.is_a?(Array)
+      return bulk_detect_language(text) if text.is_a?(Array)
 
       text = sanitize(text)
 
-      return Detection.error(400, "The language of an empty text is more of a philosophical question.") if text.empty?
+      if text.empty?
+        return LanguageDetection.error(400,
+                                       "The language of an empty text is more of a philosophical question.")
+      end
 
-      httparty_response = self.class.post("/detect", headers: headers, body: { q: text })
-      Detection.from_httparty(response: httparty_response)
+      httparty_response = self.class.post("/detect/language", headers: headers, body: { q: text })
+      LanguageDetection.from_httparty(response: httparty_response)
     end
 
-    def detect!(text)
-      detect(text).raise_on_error!
+    def detect_language!(text)
+      detect_language(text).raise_on_error!
     end
 
-    def bulk(texts)
-      texts = texts.map { |text| sanitize(text) }
+    def detect_profanity(text)
+      ensure_api_key!
+
+      return bulk_detect_profanity(text) if text.is_a?(Array)
+
+      text = text&.strip
 
-      return BulkDetection.error(400, "At least one of the texts provided was empty.") if texts.any?(&:empty?)
+      return ProfanityDetection.error(400, "Can an empty text have profanity in it? I doubt it.") if text.to_s.empty?
 
-      httparty_response = self.class.post("/bulk", headers: headers, body: { q: texts })
-      BulkDetection.from_httparty(response: httparty_response)
+      httparty_response = self.class.post("/detect/profanity", headers: headers, body: { q: text })
+      ProfanityDetection.from_httparty(response: httparty_response)
     end
 
-    def bulk!(texts)
-      bulk(texts).raise_on_error!
+    def detect_profanity!(text)
+      detect_profanity(text).raise_on_error!
     end
 
     def status
@@ -69,6 +76,24 @@ module Linguin
 
     private
 
+    def bulk_detect_language(texts)
+      texts = texts.map { |text| sanitize(text) }
+
+      return BulkLanguageDetection.error(400, "At least one of the texts provided was empty.") if texts.any?(&:empty?)
+
+      httparty_response = self.class.post("/bulk_detect/language", headers: headers, body: { q: texts })
+      BulkLanguageDetection.from_httparty(response: httparty_response)
+    end
+
+    def bulk_detect_profanity(texts)
+      texts.map! { |text| text.to_s.strip }
+
+      return BulkProfanityDetection.error(400, "At least one of the texts provided was empty.") if texts.any?(&:empty?)
+
+      httparty_response = self.class.post("/bulk_detect/profanity", headers: headers, body: { q: texts })
+      BulkProfanityDetection.from_httparty(response: httparty_response)
+    end
+
     def configure_api_key(key)
       @api_key = key
       self.headers = { "Authorization" => "Bearer #{key}" }

data/lib/linguin/{detection.rb → language_detection.rb}

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
 module Linguin
-  # == Linguin::Detection
-  # Returned by Linguin#detect(!).
+  # == Linguin::LanguageDetection
+  # Returned by Linguin#detect_language(!).
   #
   # #success? - Bool - checks if detection results were found
   # #error - Hash - contains `error` and `message` about what went wrong
   # #results - Array - contains the detection results, ordered by confidence descending
-  class Detection < BaseResponse
+  class LanguageDetection < BaseResponse
     attr_writer :success
     attr_accessor :results
 

data/lib/linguin/profanity_detection.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Linguin
+  # == Linguin::ProfanityDetection
+  # Returned by Linguin#detect_profanity(!).
+  #
+  # #success? - Bool - checks if detection results were found
+  # #error - Hash - contains `error` and `message` about what went wrong
+  # #result - Float - profanity score 0.0..1.0
+  class ProfanityDetection < BaseResponse
+    attr_writer :success
+    attr_accessor :score
+
+    class << self
+      def error(code, message)
+        new do |detection|
+          detection.success = false
+          detection.error = {
+            code: code,
+            message: message
+          }
+        end
+      end
+
+      def success(result)
+        new do |detection|
+          detection.success = true
+          detection.score = result[:score]
+        end
+      end
+    end
+
+    def success?
+      !!@success
+    end
+  end
+end

data/lib/linguin/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Linguin
-  VERSION = "1.1.0"
+  VERSION = "2.0.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: linguin
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Jan Schwenzien
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-06-22 00:00:00.000000000 Z
+date: 2021-08-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -129,11 +129,13 @@ files:
 - bin/setup
 - lib/linguin.rb
 - lib/linguin/base_response.rb
-- lib/linguin/bulk_detection.rb
+- lib/linguin/bulk_language_detection.rb
+- lib/linguin/bulk_profanity_detection.rb
 - lib/linguin/client.rb
-- lib/linguin/detection.rb
 - lib/linguin/exceptions.rb
+- lib/linguin/language_detection.rb
 - lib/linguin/languages.rb
+- lib/linguin/profanity_detection.rb
 - lib/linguin/status.rb
 - lib/linguin/version.rb
 - linguin.gemspec