temper-rb 0.5.1

data/lib/temper/generated/models/segment_info.rb

@@ -0,0 +1,200 @@
+=begin
+#Temper Cloud API
+
+#Knowledge base management API for temper cloud
+
+The version of the OpenAPI document: 0.5.1
+
+Generated by: https://openapi-generator.tech
+Generator version: 7.23.0
+
+=end
+
+require 'date'
+require 'time'
+
+module Temper::Generated
+  # One landed segment, as `begin`/`append`/`list-blocks` report it — the resume unit.  `content_hash` is the **block merkle** (`kb_block_revisions.block_body_hash`, i.e. `temper_substrate::content::body_hash_from_chunk_hashes` over the block's own chunk hashes) — NOT the whole-segment-text sha256 the client sends inbound as `AppendBlockPayload.content_hash`. The two are deliberately distinct hashes over the same segment: the inbound one is the client's cheap identity check on raw text; this outbound one is the server-computed chunk merkle that already exists as the block's canonical hash. The client re-derives this same merkle from its own packed chunk hashes (not the raw text) to diff against on resume — comparing against the raw-text hash would never match.
+  class SegmentInfo < ApiModelBase
+    attr_accessor :content_hash
+
+    attr_accessor :seq
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'content_hash' => :'content_hash',
+        :'seq' => :'seq'
+      }
+    end
+
+    # Returns attribute mapping this model knows about
+    def self.acceptable_attribute_map
+      attribute_map
+    end
+
+    # Returns all the JSON keys this model knows about
+    def self.acceptable_attributes
+      acceptable_attribute_map.values
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'content_hash' => :'String',
+        :'seq' => :'Integer'
+      }
+    end
+
+    # List of attributes with nullable: true
+    def self.openapi_nullable
+      Set.new([
+      ])
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      if (!attributes.is_a?(Hash))
+        fail ArgumentError, "The input argument (attributes) must be a hash in `Temper::Generated::SegmentInfo` initialize method"
+      end
+
+      # check to see if the attribute exists and convert string to symbol for hash key
+      acceptable_attribute_map = self.class.acceptable_attribute_map
+      attributes = attributes.each_with_object({}) { |(k, v), h|
+        if (!acceptable_attribute_map.key?(k.to_sym))
+          fail ArgumentError, "`#{k}` is not a valid attribute in `Temper::Generated::SegmentInfo`. Please check the name to make sure it's valid. List of attributes: " + acceptable_attribute_map.keys.inspect
+        end
+        h[k.to_sym] = v
+      }
+
+      if attributes.key?(:'content_hash')
+        self.content_hash = attributes[:'content_hash']
+      else
+        self.content_hash = nil
+      end
+
+      if attributes.key?(:'seq')
+        self.seq = attributes[:'seq']
+      else
+        self.seq = nil
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      warn '[DEPRECATED] the `list_invalid_properties` method is obsolete'
+      invalid_properties = Array.new
+      if @content_hash.nil?
+        invalid_properties.push('invalid value for "content_hash", content_hash cannot be nil.')
+      end
+
+      if @seq.nil?
+        invalid_properties.push('invalid value for "seq", seq cannot be nil.')
+      end
+
+      if @seq < 0
+        invalid_properties.push('invalid value for "seq", must be greater than or equal to 0.')
+      end
+
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      warn '[DEPRECATED] the `valid?` method is obsolete'
+      return false if @content_hash.nil?
+      return false if @seq.nil?
+      return false if @seq < 0
+      true
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] content_hash Value to be assigned
+    def content_hash=(content_hash)
+      if content_hash.nil?
+        fail ArgumentError, 'content_hash cannot be nil'
+      end
+
+      @content_hash = content_hash
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] seq Value to be assigned
+    def seq=(seq)
+      if seq.nil?
+        fail ArgumentError, 'seq cannot be nil'
+      end
+
+      if seq < 0
+        fail ArgumentError, 'invalid value for "seq", must be greater than or equal to 0.'
+      end
+
+      @seq = seq
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          content_hash == o.content_hash &&
+          seq == o.seq
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Integer] Hash code
+    def hash
+      [content_hash, seq].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def self.build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      attributes = attributes.transform_keys(&:to_sym)
+      transformed_hash = {}
+      openapi_types.each_pair do |key, type|
+        if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil?
+          transformed_hash["#{key}"] = nil
+        elsif type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the attribute
+          # is documented as an array but the input is not
+          if attributes[attribute_map[key]].is_a?(Array)
+            transformed_hash["#{key}"] = attributes[attribute_map[key]].map { |v| _deserialize($1, v) }
+          end
+        elsif !attributes[attribute_map[key]].nil?
+          transformed_hash["#{key}"] = _deserialize(type, attributes[attribute_map[key]])
+        end
+      end
+      new(transformed_hash)
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        if value.nil?
+          is_nullable = self.class.openapi_nullable.include?(attr)
+          next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
+        end
+
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+  end
+
+end

data/lib/temper/generated/models/segmented_begin.rb

@@ -0,0 +1,212 @@
+=begin
+#Temper Cloud API
+
+#Knowledge base management API for temper cloud
+
+The version of the OpenAPI document: 0.5.1
+
+Generated by: https://openapi-generator.tech
+Generator version: 7.23.0
+
+=end
+
+require 'date'
+require 'time'
+
+module Temper::Generated
+  # Marks an `IngestPayload` as the first request of a segmented (multi-block) ingest session. Presence (not a bool) tells the ingest handler to take the segmented-begin branch and return a [`SegmentedBeginResponse`].
+  class SegmentedBegin < ApiModelBase
+    # The segment budget (bytes of text) this session's boundaries were cut at. Recorded so a resume re-derives identical segment boundaries — see the design's determinism note.
+    attr_accessor :block_budget
+
+    # sha256 of the source bytes, for the resume/re-ingest source-integrity check (`kb_ingestion_records.source_hash`). `None` when the source has no stable identity (e.g. piped stdin).
+    attr_accessor :source_hash
+
+    # Best-effort total block count, if the client knows it upfront (e.g. from a pre-scan of the source). Purely informational — not validated against the actual landed count (that's `FinalizePayload.expected_blocks`).
+    attr_accessor :total_blocks_hint
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'block_budget' => :'block_budget',
+        :'source_hash' => :'source_hash',
+        :'total_blocks_hint' => :'total_blocks_hint'
+      }
+    end
+
+    # Returns attribute mapping this model knows about
+    def self.acceptable_attribute_map
+      attribute_map
+    end
+
+    # Returns all the JSON keys this model knows about
+    def self.acceptable_attributes
+      acceptable_attribute_map.values
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'block_budget' => :'Integer',
+        :'source_hash' => :'String',
+        :'total_blocks_hint' => :'Integer'
+      }
+    end
+
+    # List of attributes with nullable: true
+    def self.openapi_nullable
+      Set.new([
+        :'source_hash',
+        :'total_blocks_hint'
+      ])
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      if (!attributes.is_a?(Hash))
+        fail ArgumentError, "The input argument (attributes) must be a hash in `Temper::Generated::SegmentedBegin` initialize method"
+      end
+
+      # check to see if the attribute exists and convert string to symbol for hash key
+      acceptable_attribute_map = self.class.acceptable_attribute_map
+      attributes = attributes.each_with_object({}) { |(k, v), h|
+        if (!acceptable_attribute_map.key?(k.to_sym))
+          fail ArgumentError, "`#{k}` is not a valid attribute in `Temper::Generated::SegmentedBegin`. Please check the name to make sure it's valid. List of attributes: " + acceptable_attribute_map.keys.inspect
+        end
+        h[k.to_sym] = v
+      }
+
+      if attributes.key?(:'block_budget')
+        self.block_budget = attributes[:'block_budget']
+      else
+        self.block_budget = nil
+      end
+
+      if attributes.key?(:'source_hash')
+        self.source_hash = attributes[:'source_hash']
+      end
+
+      if attributes.key?(:'total_blocks_hint')
+        self.total_blocks_hint = attributes[:'total_blocks_hint']
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      warn '[DEPRECATED] the `list_invalid_properties` method is obsolete'
+      invalid_properties = Array.new
+      if @block_budget.nil?
+        invalid_properties.push('invalid value for "block_budget", block_budget cannot be nil.')
+      end
+
+      if @block_budget < 0
+        invalid_properties.push('invalid value for "block_budget", must be greater than or equal to 0.')
+      end
+
+      if !@total_blocks_hint.nil? && @total_blocks_hint < 0
+        invalid_properties.push('invalid value for "total_blocks_hint", must be greater than or equal to 0.')
+      end
+
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      warn '[DEPRECATED] the `valid?` method is obsolete'
+      return false if @block_budget.nil?
+      return false if @block_budget < 0
+      return false if !@total_blocks_hint.nil? && @total_blocks_hint < 0
+      true
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] block_budget Value to be assigned
+    def block_budget=(block_budget)
+      if block_budget.nil?
+        fail ArgumentError, 'block_budget cannot be nil'
+      end
+
+      if block_budget < 0
+        fail ArgumentError, 'invalid value for "block_budget", must be greater than or equal to 0.'
+      end
+
+      @block_budget = block_budget
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] total_blocks_hint Value to be assigned
+    def total_blocks_hint=(total_blocks_hint)
+      if !total_blocks_hint.nil? && total_blocks_hint < 0
+        fail ArgumentError, 'invalid value for "total_blocks_hint", must be greater than or equal to 0.'
+      end
+
+      @total_blocks_hint = total_blocks_hint
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          block_budget == o.block_budget &&
+          source_hash == o.source_hash &&
+          total_blocks_hint == o.total_blocks_hint
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Integer] Hash code
+    def hash
+      [block_budget, source_hash, total_blocks_hint].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def self.build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      attributes = attributes.transform_keys(&:to_sym)
+      transformed_hash = {}
+      openapi_types.each_pair do |key, type|
+        if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil?
+          transformed_hash["#{key}"] = nil
+        elsif type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the attribute
+          # is documented as an array but the input is not
+          if attributes[attribute_map[key]].is_a?(Array)
+            transformed_hash["#{key}"] = attributes[attribute_map[key]].map { |v| _deserialize($1, v) }
+          end
+        elsif !attributes[attribute_map[key]].nil?
+          transformed_hash["#{key}"] = _deserialize(type, attributes[attribute_map[key]])
+        end
+      end
+      new(transformed_hash)
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        if value.nil?
+          is_nullable = self.class.openapi_nullable.include?(attr)
+          next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
+        end
+
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+  end
+
+end

data/lib/temper/generated/models/segmented_begin_response.rb

@@ -0,0 +1,247 @@
+=begin
+#Temper Cloud API
+
+#Knowledge base management API for temper cloud
+
+The version of the OpenAPI document: 0.5.1
+
+Generated by: https://openapi-generator.tech
+Generator version: 7.23.0
+
+=end
+
+require 'date'
+require 'time'
+
+module Temper::Generated
+  # Response to a segmented begin (block 0 landed via the ordinary create path).
+  class SegmentedBeginResponse < ApiModelBase
+    attr_accessor :blocks
+
+    # The live `body_hash` after block 0 — see [`BlocksResponse::body_hash`]. Present here too so a session that appends nothing still has a value to echo at finalize.
+    attr_accessor :body_hash
+
+    # Client-side ingest-session id (written into the `.temper/` resume manifest). Despite the name it is **not** the ledger's `kb_events.correlation_id`: this value is minted server-side and never reaches an event. Since P3 a caller *can* supply an act-grain correlation (`ActContext::correlation`), so threading a segmented session's `block_created` + `resource_finalized` events onto one correlation is now possible — but it needs a precedence rule against a caller-supplied value, and is deliberately left unbuilt (task 019f4a19).
+    attr_accessor :correlation_id
+
+    attr_accessor :resource_id
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'blocks' => :'blocks',
+        :'body_hash' => :'body_hash',
+        :'correlation_id' => :'correlation_id',
+        :'resource_id' => :'resource_id'
+      }
+    end
+
+    # Returns attribute mapping this model knows about
+    def self.acceptable_attribute_map
+      attribute_map
+    end
+
+    # Returns all the JSON keys this model knows about
+    def self.acceptable_attributes
+      acceptable_attribute_map.values
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'blocks' => :'Array<SegmentInfo>',
+        :'body_hash' => :'String',
+        :'correlation_id' => :'String',
+        :'resource_id' => :'String'
+      }
+    end
+
+    # List of attributes with nullable: true
+    def self.openapi_nullable
+      Set.new([
+      ])
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      if (!attributes.is_a?(Hash))
+        fail ArgumentError, "The input argument (attributes) must be a hash in `Temper::Generated::SegmentedBeginResponse` initialize method"
+      end
+
+      # check to see if the attribute exists and convert string to symbol for hash key
+      acceptable_attribute_map = self.class.acceptable_attribute_map
+      attributes = attributes.each_with_object({}) { |(k, v), h|
+        if (!acceptable_attribute_map.key?(k.to_sym))
+          fail ArgumentError, "`#{k}` is not a valid attribute in `Temper::Generated::SegmentedBeginResponse`. Please check the name to make sure it's valid. List of attributes: " + acceptable_attribute_map.keys.inspect
+        end
+        h[k.to_sym] = v
+      }
+
+      if attributes.key?(:'blocks')
+        if (value = attributes[:'blocks']).is_a?(Array)
+          self.blocks = value
+        end
+      else
+        self.blocks = nil
+      end
+
+      if attributes.key?(:'body_hash')
+        self.body_hash = attributes[:'body_hash']
+      else
+        self.body_hash = nil
+      end
+
+      if attributes.key?(:'correlation_id')
+        self.correlation_id = attributes[:'correlation_id']
+      else
+        self.correlation_id = nil
+      end
+
+      if attributes.key?(:'resource_id')
+        self.resource_id = attributes[:'resource_id']
+      else
+        self.resource_id = nil
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      warn '[DEPRECATED] the `list_invalid_properties` method is obsolete'
+      invalid_properties = Array.new
+      if @blocks.nil?
+        invalid_properties.push('invalid value for "blocks", blocks cannot be nil.')
+      end
+
+      if @body_hash.nil?
+        invalid_properties.push('invalid value for "body_hash", body_hash cannot be nil.')
+      end
+
+      if @correlation_id.nil?
+        invalid_properties.push('invalid value for "correlation_id", correlation_id cannot be nil.')
+      end
+
+      if @resource_id.nil?
+        invalid_properties.push('invalid value for "resource_id", resource_id cannot be nil.')
+      end
+
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      warn '[DEPRECATED] the `valid?` method is obsolete'
+      return false if @blocks.nil?
+      return false if @body_hash.nil?
+      return false if @correlation_id.nil?
+      return false if @resource_id.nil?
+      true
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] blocks Value to be assigned
+    def blocks=(blocks)
+      if blocks.nil?
+        fail ArgumentError, 'blocks cannot be nil'
+      end
+
+      @blocks = blocks
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] body_hash Value to be assigned
+    def body_hash=(body_hash)
+      if body_hash.nil?
+        fail ArgumentError, 'body_hash cannot be nil'
+      end
+
+      @body_hash = body_hash
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] correlation_id Value to be assigned
+    def correlation_id=(correlation_id)
+      if correlation_id.nil?
+        fail ArgumentError, 'correlation_id cannot be nil'
+      end
+
+      @correlation_id = correlation_id
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] resource_id Value to be assigned
+    def resource_id=(resource_id)
+      if resource_id.nil?
+        fail ArgumentError, 'resource_id cannot be nil'
+      end
+
+      @resource_id = resource_id
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          blocks == o.blocks &&
+          body_hash == o.body_hash &&
+          correlation_id == o.correlation_id &&
+          resource_id == o.resource_id
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Integer] Hash code
+    def hash
+      [blocks, body_hash, correlation_id, resource_id].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def self.build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      attributes = attributes.transform_keys(&:to_sym)
+      transformed_hash = {}
+      openapi_types.each_pair do |key, type|
+        if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil?
+          transformed_hash["#{key}"] = nil
+        elsif type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the attribute
+          # is documented as an array but the input is not
+          if attributes[attribute_map[key]].is_a?(Array)
+            transformed_hash["#{key}"] = attributes[attribute_map[key]].map { |v| _deserialize($1, v) }
+          end
+        elsif !attributes[attribute_map[key]].nil?
+          transformed_hash["#{key}"] = _deserialize(type, attributes[attribute_map[key]])
+        end
+      end
+      new(transformed_hash)
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        if value.nil?
+          is_nullable = self.class.openapi_nullable.include?(attr)
+          next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
+        end
+
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+  end
+
+end