Class: Legion::Extensions::Absorbers::Base

Inherits:
Object
  • Object
show all
Extended by:
Definitions
Includes:
Helpers::Lex
Defined in:
lib/legion/extensions/absorbers/base.rb

Direct Known Subclasses

Matchers::Url

Defined Under Namespace

Classes: TokenRevocationError, TokenUnavailableError

Constant Summary

Constants included from Definitions

Definitions::DEFAULTS

Constants included from Helpers::Base

Helpers::Base::NAMESPACE_BOUNDARIES

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Definitions

definition, definition_for, definitions

Methods included from Helpers::Lex

#default_settings, included, #runner_desc

Methods included from Helpers::Base

#actor_class, #actor_const, #actor_name, #amqp_prefix, #calling_class, #calling_class_array, #from_json, #full_path, #lex_class, #lex_const, #lex_name, #lex_slug, #log_tag, #normalize, #runner_class, #runner_const, #runner_name, #segments, #settings_path, #table_prefix, #to_dotted_hash

Methods included from Helpers::Task

#generate_task_id, #generate_task_log, #task_update

Methods included from Helpers::Logger

#handle_runner_exception

Methods included from Helpers::Secret

reset_identity!, resolve_identity!, #secret

Methods included from Helpers::Core

#find_setting

Instance Attribute Details

#job_id ⇒ Object

Returns the value of attribute job_id.



19
20
21
 
# File 'lib/legion/extensions/absorbers/base.rb', line 19

def job_id
  @job_id
end

#runners ⇒ Object

Returns the value of attribute runners.



19
20
21
 
# File 'lib/legion/extensions/absorbers/base.rb', line 19

def runners
  @runners
end

Class Method Details

.description(text = nil) ⇒ Object 



31
32
33
 
# File 'lib/legion/extensions/absorbers/base.rb', line 31

def description(text = nil)
  text ? @description = text : @description
end

.pattern(type, value, priority: 100) ⇒ Object 



22
23
24
25
 
# File 'lib/legion/extensions/absorbers/base.rb', line 22

def pattern(type, value, priority: 100)
  @patterns ||= []
  @patterns << { type: type, value: value, priority: priority }
end

.patterns ⇒ Object 



27
28
29
 
# File 'lib/legion/extensions/absorbers/base.rb', line 27

def patterns
  @patterns || []
end

Instance Method Details

#absorb(url: nil, content: nil, metadata: {}, context: {}) ⇒ Object

Raises:

  • (NotImplementedError) 


36
37
38
 
# File 'lib/legion/extensions/absorbers/base.rb', line 36

def absorb(url: nil, content: nil, metadata: {}, context: {})
  raise NotImplementedError, "#{self.class.name} must implement #absorb"
end

#absorb_raw(content:, tags: [], scope: :global) ⇒ Object 



61
62
63
64
65
66
67
68
69
 
# File 'lib/legion/extensions/absorbers/base.rb', line 61

def absorb_raw(content:, tags: [], scope: :global, **)
  target = resolve_apollo_target(scope)
  unless target
    Legion::Logging.warn("absorb_raw: Apollo not available for scope=#{scope}") if defined?(Legion::Logging)
    return { success: false, error: :apollo_not_available }
  end

  target.ingest(content: content, tags: Array(tags), scope: scope, **)
end

#absorb_to_knowledge(content:, tags: [], scope: :global, **opts) ⇒ Object 



46
47
48
49
50
51
52
53
54
55
56
57
58
59
 
# File 'lib/legion/extensions/absorbers/base.rb', line 46

def absorb_to_knowledge(content:, tags: [], scope: :global, **opts)
  return fallback_absorb(:chunker, content, tags, scope, opts) unless chunker_available?

  target = resolve_apollo_target(scope)
  return fallback_absorb(:apollo, content, tags, scope, opts) unless target

  sections = [{ heading:      opts.delete(:heading) || 'absorbed',
                content:      content,
                section_path: opts.delete(:section_path) || 'absorbed',
                source_file:  opts.delete(:source_file) || 'absorber' }]
  chunks     = Legion::Extensions::Knowledge::Helpers::Chunker.chunk(sections: sections)
  embeddings = fetch_embeddings(chunks)
  ingest_chunks(chunks, embeddings, tags, scope, opts)
end

#handle(url: nil, content: nil, metadata: {}, context: {}) ⇒ Object

Deprecated.

Use #absorb instead. Will be removed in a future major release.



41
42
43
44
 
# File 'lib/legion/extensions/absorbers/base.rb', line 41

def handle(url: nil, content: nil, metadata: {}, context: {})
  Legion::Logging.warn("#{self.class.name}#handle is deprecated — use #absorb instead") if defined?(Legion::Logging)
  absorb(url: url, content: content, metadata: metadata, context: context)
end

#query_knowledge(text:, limit: 5, scope: :all) ⇒ Object 



71
72
73
74
75
76
77
78
79
80
81
82
83
84
 
# File 'lib/legion/extensions/absorbers/base.rb', line 71

def query_knowledge(text:, limit: 5, scope: :all, **)
  case scope.to_sym
  when :local
    return { success: false, error: :apollo_not_available } unless apollo_local_available?

    Legion::Apollo::Local.query(text: text, limit: limit, **)
  when :global
    return { success: false, error: :apollo_not_available } unless apollo_available?

    Legion::Apollo.query(text: text, limit: limit, **)
  else
    query_all_scopes(text: text, limit: limit, **)
  end
end

#report_progress(message:, percent: nil) ⇒ Object 



92
93
94
95
96
97
 
# File 'lib/legion/extensions/absorbers/base.rb', line 92

def report_progress(message:, percent: nil)
  return unless job_id
  return unless defined?(Legion::Logging)

  Legion::Logging.info("absorb[#{job_id}] #{"#{percent}% " if percent}#{message}")
end

#translate(source, type: :auto) ⇒ Object 



86
87
88
89
90
 
# File 'lib/legion/extensions/absorbers/base.rb', line 86

def translate(source, type: :auto)
  raise 'legion-data is required for translate — add it to your Gemfile' unless defined?(Legion::Data::Extract)

  Legion::Data::Extract.extract(source, type: type)
end

#with_token(provider:) ⇒ Object 



99
100
101
102
103
104
105
106
107
108
109
 
# File 'lib/legion/extensions/absorbers/base.rb', line 99

def with_token(provider:)
  raise TokenUnavailableError, "#{provider} token not available" unless token_manager_for(provider).token_valid?
  raise TokenRevocationError, "#{provider} token has been revoked" if token_manager_for(provider).revoked?

  token = token_manager_for(provider).ensure_valid_token
  raise TokenUnavailableError, "#{provider} token refresh failed" unless token

  yield token
rescue Legion::Auth::TokenManager::TokenExpiredError => e
  raise TokenUnavailableError, e.message
end