fastpixapi 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2eff6b879ab56e0014de49b73002d24bc42fea9d708940b3675c0abeff0fcf94
+  data.tar.gz: 8539b2b948cf503c1743b2772fba64f9b9b05e580cd81ff2f2a80ef0df574912
+SHA512:
+  metadata.gz: e73482d1529a0a0b33fe5239e084c12634d0f57b8a1401cb76209e722255899e49807372432fc13c7fe6c51644f2eb7c802f2fdb9a14c1c122ddf8a2e586fdc1
+  data.tar.gz: '0076889ee5f69e540d4ee427210b6097f76733a9892c5f69732c9693fea4cf4049c1fd258581cd04c75af3a634c45a25a084106e20e55c9b9174b13022ce92b6'

data/lib/crystalline/metadata_fields.rb

@@ -0,0 +1,210 @@
+# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+
+# typed: true
+# frozen_string_literal: true
+
+module Crystalline
+  extend T::Sig
+  module MetadataFields
+    extend T::Sig
+
+    class Field
+      attr_accessor :name, :type, :metadata
+
+      def initialize(name, type, metadata)
+        @name = name
+        @type = type
+        @metadata = metadata
+      end
+    end
+
+    module ClassMethods
+      extend T::Sig
+
+      def fields
+        @__fields__ = [] if @__fields__.nil?
+
+        @__fields__
+      end
+
+      def field(field_name, type, metadata = {})
+        attr_accessor field_name
+
+        fields << Field.new(field_name, type, metadata)
+      end
+
+      def field_augmented?
+        true
+      end
+
+      def unmarshal_single(field_type, value, format_metadata = nil)
+        decoder = format_metadata.fetch(:decoder, nil)
+
+        if field_type.instance_of?(Class) && field_type.include?(::Crystalline::MetadataFields)
+          return field_type.from_dict(value)
+        elsif field_type.to_s == 'Date'
+          return Date.parse(value)
+        elsif field_type.to_s == 'DateTime'
+          return DateTime.parse(value)
+        elsif field_type.to_s == 'Object'
+          # rubocop:disable Lint/SuppressedException
+          begin
+            value = JSON.parse(value)
+          rescue TypeError, JSON::ParserError
+          end
+          # rubocop:enable Lint/SuppressedException
+          return value
+        elsif field_type.to_s == 'Float'
+          return value.to_f
+
+        end
+        if decoder.nil?
+          value
+        else
+          decoder.call(value)
+        end
+      end
+
+      sig { params(json_obj: T.any(String, T::Hash[Symbol, String])).returns(Object) }
+      def from_json(json_obj)
+        begin
+          d = JSON.parse(json_obj)
+        rescue TypeError, JSON::ParserError
+          d = json_obj
+        end
+        from_dict(d)
+      end
+
+      sig { params(d: T::Hash[Symbol, String]).returns(Object) }
+      def from_dict(d)
+        to_build = {}
+
+        fields.each do |field|
+          key = field.name
+          format_metadata = field.metadata.fetch(:format_json, {})
+          lookup = format_metadata.fetch(:letter_case, nil).call
+          value = d[lookup]
+          field_type = field.type
+          if T.nilable? field_type
+            if value == 'null'
+              to_build[key] = nil
+              next
+            end
+            field_type = T.nilable_of(field_type)
+          end
+          
+          # If field is not nilable, and the value is not in the dict, raise a KeyError
+          raise KeyError, "key #{lookup} not found in hash" if value.nil? && !T.nilable?(field.type)
+          # If field is nilable, and the value is not in the dict, just move to the next field
+          next if value.nil?
+
+          if T.arr? field_type
+            inner_type = T.arr_of(field_type)
+            unmarshalled_array = value.map { |f| unmarshal_single(inner_type, f, format_metadata) }
+            to_build[key] = unmarshalled_array
+          elsif T.hash? field_type
+            val_type = T.hash_of(field_type)
+
+            # rubocop:disable Style/HashTransformValues
+            unmarshalled_hash = value.map { |k, v| [k, unmarshal_single(val_type, v, format_metadata)] }.to_h
+            # rubocop:enable Style/HashTransformValues
+            to_build[key] = unmarshalled_hash
+          elsif T.union? field_type
+            discriminator = field.metadata.fetch(:discriminator, nil)
+            if !discriminator.nil?
+              type_to_deserialize = value.fetch(discriminator)
+              type_to_deserialize = T.get_union_types(field_type).find { |t| t.name.split('::').last == type_to_deserialize }              
+              unmarshalled_val = Crystalline.unmarshal_json(value, type_to_deserialize)
+              to_build[key] = unmarshalled_val
+            else
+              union_types = T.get_union_types(field_type)
+              union_types = union_types.sort_by { |klass| Crystalline.non_nilable_attr_count(klass) }
+
+              union_types.each do |union_type|
+                begin
+                  unmarshalled_val = Crystalline.unmarshal_json(value, union_type)
+                  to_build[key] = unmarshalled_val
+                rescue TypeError
+                  next
+                rescue NoMethodError
+                  next
+                rescue KeyError
+                  next
+                end
+                break
+              end
+            end
+          elsif field_type.instance_of?(Class) && field_type.include?(::Crystalline::MetadataFields)
+            unmarshalled = Crystalline.unmarshal_json(value, field_type)
+            to_build[key] = unmarshalled
+          else
+            final_value = unmarshal_single(field_type, value, format_metadata)
+            to_build[key] = final_value
+          end
+        end
+
+        new(**to_build)
+      end
+    end
+
+    def initialize
+      instance = allocate
+      fields.each { |mod| instance.singleton_class.include(mod) }
+      instance.send(:initialize)
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    def fields
+      self.class.fields
+    end
+
+    def field(field_name)
+      fields.each do |f|
+        return f if f.name == field_name
+      end
+    end
+
+    def marshal_single(field)
+      if field.class.include? ::Crystalline::MetadataFields
+        field.to_dict
+      else
+        ::Crystalline.val_to_string(field, primitives: false)
+      end
+    end
+
+    def to_dict
+      result = {}
+      fields.sort_by(&:name).each do |field|
+        format_json_meta = field.metadata[:format_json]
+        required = !format_json_meta.nil? && format_json_meta.include?(:required)
+        if !format_json_meta.nil? && format_json_meta.include?(:letter_case)
+          key = format_json_meta[:letter_case].call(field.name)
+        else
+          key = field.name
+        end
+
+        f = send(field.name)
+        next if f.nil? && !required
+        result[key] = nil if f.nil? && required
+
+        if f.is_a? Array
+          result[key] = f.map { |o| marshal_single(o) }
+        elsif f.is_a? Hash
+          result[key] = f.map { |k, v| [k, marshal_single(v)] }
+        else
+          result[key] = marshal_single(f)
+        end
+      end
+      result
+    end
+
+    def to_json(*args)
+      JSON.generate(to_dict, *args)
+    end
+  end
+
+
+end

data/lib/crystalline/t.rb

@@ -0,0 +1,78 @@
+# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+
+# typed: true
+# frozen_string_literal: true
+
+module T
+  def self.arr?(t)
+    if t.respond_to? :underlying_class
+      return t.underlying_class == ::Array
+    end
+    false
+  end
+
+  def self.arr_of(t)
+    get_raw_type(t.type)
+  end
+
+  def self.hash?(t)
+    if t.respond_to? :underlying_class
+      return t.underlying_class == ::Hash
+    end
+    false
+  end
+
+  def self.hash_of(t)
+    get_raw_type(t.values)
+  end
+
+  def self.nilable?(t)
+    # in sorbet all `T.any` types provide unwrap_nilable for some reason
+    # So, in order to make this check more robust, we check if the type responds to the `types` method, and if so, whether
+    # one of those types is NilClass.  For non-nilable unions, `types` will return a valid list that does not include NilClass
+    return false unless t.respond_to?(:unwrap_nilable)
+    return true unless t.respond_to?(:types)
+    t.types.map { |tt| simplify_type(tt) }.include?(NilClass)
+  end
+
+  def self.nilable_of(t)
+    
+    if nilable t
+      return simplify_type t.unwrap_nilable
+    end
+    nil
+  end
+
+  def self.simplifiable?(t)
+    return t.is_a? T::Types::Simple
+  end
+
+  def self.simplify_type(t)
+    if t.is_a? T::Types::Simple
+      return t.raw_type
+    end
+    t
+  end
+
+    
+  def self.union?(t)
+    return false unless t.respond_to? :types
+    return false if t.types.any? { |tt| get_raw_type(tt) == TrueClass }
+    return false if t.types.length == 2 && t.types.any? { |tt| get_raw_type(tt) == NilClass }
+    t.types.length > 1
+  end
+
+  def self.get_union_types(t)
+    t.types.map { |tt| get_raw_type(tt) }
+  end
+
+
+  def self.get_raw_type(t)
+    if t.respond_to? :raw_type
+      return t.raw_type
+    elsif t.respond_to? :raw_a
+      return T::Boolean if t.raw_a in [TrueClass, FalseClass]
+    end
+    t
+  end
+end

data/lib/crystalline/utils.rb

@@ -0,0 +1,95 @@
+# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+
+# typed: true
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+
+module Crystalline
+  extend T::Sig
+
+  sig { params(complex: Object).returns(Object) }
+  def self.to_dict(complex)
+    if complex.is_a? Array
+      complex.map { |v| Crystalline.to_dict(v) }
+    elsif complex.is_a? Hash
+      complex.transform_values { |v| Crystalline.to_dict(v) }
+    elsif complex.respond_to?(:class) && complex.class.include?(::Crystalline::MetadataFields)
+      complex.to_dict
+    else
+      val_to_string complex, primitives: false
+    end
+  end
+
+  def self.to_json(complex)
+    JSON.dump(to_dict(complex))
+  end
+
+  sig { params(data: Object, type: Object).returns(Object) }
+  def self.unmarshal_json(data, type)
+    if T.simplifiable? type
+      type = T.simplify_type type
+    end
+    if type.instance_of?(Class) && type.include?(::Crystalline::MetadataFields)
+      type.from_dict(data)
+    elsif T.union? type
+      union_types = T.get_union_types(type)
+      union_types = union_types.sort_by { |klass| Crystalline.non_nilable_attr_count(klass) }
+
+      union_types.each do |union_type|
+        unmarshalled_val = Crystalline.unmarshal_json(data, union_type)
+        return unmarshalled_val
+      rescue TypeError
+        next
+      rescue NoMethodError
+        next
+      rescue KeyError
+        next
+      end
+    elsif T.arr? type
+      data.map { |v| Crystalline.unmarshal_json(v, T.arr_of(type)) }
+    elsif T.hash? type
+      data.transform_values { |v| Crystalline.unmarshal_json(v, T.hash_of(type)) }
+    elsif T.nilable?(type) && data == 'null'
+      nil
+    else
+      data
+    end
+  end
+
+  sig { params(val: Object, primitives: T::Boolean).returns(Object) }
+  def self.val_to_string(val, primitives: true)
+    if val.is_a? T::Enum
+      val.serialize
+    elsif val.is_a? DateTime
+      val.strftime('%Y-%m-%dT%H:%M:%S.%NZ')
+    elsif val.nil?
+      nil
+    elsif primitives
+      val.to_s
+    else
+      val
+    end
+  end
+
+  sig { params(klass: T.any(Class, T::Types::TypedArray, T::Types::TypedHash)).returns(Integer) }
+  def self.non_nilable_attr_count(klass)
+    # somewhat sane sort ordering for Union deserialization.
+    # All Crystalline objects return the number of non-nilable fields
+    # All non-string primitives return 2
+    # All arrays and hashes return 1
+    # Strings return 0 (since any data can deserialize to a string, it should be our last attempt)
+    if klass.respond_to? :fields
+      return -1 * klass.fields.count do |field|
+        !T.nilable? field.type
+      end
+    else
+      if klass == String
+        return 0
+      elsif klass.is_a?(T::Types::TypedArray) || klass.is_a?(T::Types::TypedHash)
+        return 1
+      end
+      return 2
+    end
+  end
+end

data/lib/crystalline.rb

@@ -0,0 +1,12 @@
+# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+
+# typed: true
+# frozen_string_literal: true
+
+module Crystalline
+  autoload :MetadataFields, 'crystalline/metadata_fields'
+end
+
+
+require_relative 'crystalline/utils'
+require_relative 'crystalline/t'