modulecapabilities

type AdditionalGenerativeProperties interface {
	AdditionalGenerativeProperties() map[string]GenerativeProperty
}

type AdditionalProperties interface {
	AdditionalProperties() map[string]AdditionalProperty
}

type AdditionalProperty struct {
	RestNames              []string
	DefaultValue           any
	GraphQLNames           []string
	GraphQLFieldFunction   GraphQLFieldFn
	GraphQLExtractFunction ExtractAdditionalFn
	SearchFunctions        AdditionalSearch
}

type AdditionalPropertyFn = func(ctx context.Context,
	in []search.Result, params any, limit *int,
	argumentModuleParams map[string]any, cfg moduletools.ClassConfig) ([]search.Result, error)

type AdditionalPropertyWithSearchVector[T dto.Embedding] interface {
	SetSearchVector(vector T)
}

type AdditionalSearch struct {
	ObjectGet   AdditionalPropertyFn
	ObjectList  AdditionalPropertyFn
	ExploreGet  AdditionalPropertyFn
	ExploreList AdditionalPropertyFn
}

type AggregateArgumentsFn = func(classname string) *graphql.ArgumentConfig

type BackendUseCase int

type BackupBackend interface {
	// IsExternal returns whether the storage is an external storage (e.g. gcs, s3)
	IsExternal() bool
	// Name returns backend's name
	Name() string
	// HomeDir is the base storage location of all backup files, which can be a bucket, a directory, etc.
	HomeDir(backupID, overrideBucket, overridePath string) string

	// GetObject giving backupID and key
	GetObject(ctx context.Context, backupID, key, overrideBucket, overridePath string) ([]byte, error)
	// AllBackups returns the top level metadata for all attempted backups
	AllBackups(ctx context.Context) ([]*backup.DistributedBackupDescriptor, error)

	// SourceDataPath is data path of all source files
	SourceDataPath() string

	// PutObject writes bytes to the object with key `key`
	// bucketName and bucketPath override the initialised bucketName and bucketPath
	PutObject(ctx context.Context, backupID, key, overrideBucket, overridePath string, byes []byte) error

	// Initialize initializes backup provider and make sure that app have access rights to write into the object store.
	Initialize(ctx context.Context, backupID, overrideBucket, overridePath string) error

	// Write writes the content of the reader to the object with key
	// bucketName and bucketPath override the initialised bucketName and bucketPath
	// Allows restores from a different bucket to the designated backup bucket
	Write(ctx context.Context, backupID, key, overrideBucket, overridePath string, r backup.ReadCloserWithError) (int64, error)
	Read(ctx context.Context, backupID, key, overrideBucket, overridePath string, w io.WriteCloser) (int64, error)
}

type ClassConfigurator interface {
	// ClassDefaults provides the defaults for a per-class module config. The
	// module provider will merge the props into the user-specified config with
	// the user-provided values taking precedence
	ClassConfigDefaults() map[string]any

	// PropertyConfigDefaults provides the defaults for a per-property module
	// config. The module provider will merge the props into the user-specified
	// config with the user-provided values taking precedence. The property's
	// dataType MAY be taken into consideration when deciding defaults.
	// dataType is not guaranteed to be non-nil, it might be nil in the case a
	// user specified an invalid dataType, as some validation only occurs after
	// defaults are set.
	PropertyConfigDefaults(dataType *schema.DataType) map[string]any

	// ValidateClass MAY validate anything about the class, except the config of
	// another module. The specified ClassConfig can be used to easily retrieve
	// the config specific for the module. For example, a module could iterate
	// over class.Properties and call classConfig.Property(prop.Name) to validate
	// the per-property config. A module MUST NOT extract another module's config
	// from class.ModuleConfig["other-modules-name"].
	ValidateClass(ctx context.Context, class *models.Class,
		classConfig moduletools.ClassConfig) error
}

type ClassificationProvider interface {
	Classifiers() []Classifier
}

type Classifier interface {
	Name() string
	ClassifyFn(params ClassifyParams) (ClassifyItemFn, error)
	ParseClassifierSettings(params *models.Classification) error
}

type ClassifyItemFn func(item search.Result, itemIndex int,
	params models.Classification, filters Filters, writer Writer) error

type ClassifyParams struct {
	GetClass          func(string) *models.Class
	Params            models.Classification
	Filters           Filters
	UnclassifiedItems []search.Result
	VectorRepo        VectorClassSearchRepo
}

type Client interface {
	Vectorizers() map[string]VectorizerClient
}

type Dependency[T dto.Embedding] interface {
	ModuleName() string
	Argument() string
	GraphQLArgument() GraphQLArgument
	VectorSearch() VectorForParams[T]
}

type DependencySearcher[T dto.Embedding] interface {
	VectorSearches() map[string]map[string]VectorForParams[T]
}

type ExploreArgumentsFn = func() *graphql.ArgumentConfig

type ExportBackendProvider interface {
	ExportBackend() BackupBackend
}

type ExtractAdditionalFn = func(param []*ast.Argument, class *models.Class) any

type ExtractFn = func(param map[string]any) (any, *dto.TargetCombination, error)

type ExtractRequestParamsFn = func(field *ast.ObjectField) any

type Filters interface {
	Source() *filters.LocalFilter
	Target() *filters.LocalFilter
	TrainingSet() *filters.LocalFilter
}

type FindObjectFn = func(ctx context.Context, class string, id strfmt.UUID,
	props search.SelectProperties, adds additional.Properties, tenant string) (*search.Result, error)

type FindVectorFn[T dto.Embedding] = func(ctx context.Context,
	className string, id strfmt.UUID, tenant, targetVector string) (T, string, error)

type GenerateDebugInformation struct {
	Prompt string
}

type GenerateProperties struct {
	Text map[string]string
	Blob map[string]*string
}

type GenerateResponse struct {
	Result *string
	Params map[string]any
	Debug  *GenerateDebugInformation
}

type GenerativeClient interface {
	GenerateSingleResult(ctx context.Context,
		properties *GenerateProperties, prompt string, requestParams any, debug bool, cfg moduletools.ClassConfig,
	) (*GenerateResponse, error)
	GenerateAllResults(ctx context.Context,
		properties []*GenerateProperties, task string, requestParams any, debug bool, cfg moduletools.ClassConfig,
	) (*GenerateResponse, error)
}

type GenerativeProperty struct {
	Client                       GenerativeClient
	RequestParamsFunction        GraphQLInputFieldFn
	ResponseParamsFunction       GraphQLFieldFn
	ExtractRequestParamsFunction ExtractRequestParamsFn
}

type GetArgumentsFn = func(classname string) *graphql.ArgumentConfig

type GraphQLArgument struct {
	GetArgumentsFunction       GetArgumentsFn
	AggregateArgumentsFunction AggregateArgumentsFn
	ExploreArgumentsFunction   ExploreArgumentsFn
	ExtractFunction            ExtractFn
	ValidateFunction           ValidateFn
}

type GraphQLArguments interface {
	Arguments() map[string]GraphQLArgument
}

type GraphQLFieldFn = func(classname string) *graphql.Field

type GraphQLInputFieldFn = func(classname string) *graphql.InputObjectFieldConfig

type InputVectorizer[T dto.Embedding] interface {
	VectorizeInput(ctx context.Context, input string,
		cfg moduletools.ClassConfig) (T, error)
}

type MetaProvider interface {
	MetaInfo() (map[string]any, error)
}

type MigrateProperties interface {
	MigrateProperties() []MigrateProperty
}

type MigrateProperty struct {
	Name, NewName string
	IsDeleted     bool
}

type MockBackupBackend struct {
	mock.Mock
}

type MockBackupBackend_AllBackups_Call struct {
	*mock.Call
}

type MockBackupBackend_Expecter struct {
	// contains filtered or unexported fields
}

type MockBackupBackend_GetObject_Call struct {
	*mock.Call
}

type MockBackupBackend_HomeDir_Call struct {
	*mock.Call
}

type MockBackupBackend_Initialize_Call struct {
	*mock.Call
}

type MockBackupBackend_IsExternal_Call struct {
	*mock.Call
}

type MockBackupBackend_Name_Call struct {
	*mock.Call
}

type MockBackupBackend_PutObject_Call struct {
	*mock.Call
}

type MockBackupBackend_Read_Call struct {
	*mock.Call
}

type MockBackupBackend_SourceDataPath_Call struct {
	*mock.Call
}

type MockBackupBackend_Write_Call struct {
	*mock.Call
}

type Module interface {
	Name() string
	Init(ctx context.Context, params moduletools.ModuleInitParams) error
	Type() ModuleType
}

type ModuleDependency interface {
	Module
	InitDependency(modules []Module) error
}

type ModuleExtension interface {
	Module
	InitExtension(modules []Module) error
}

type ModuleHasAltNames interface {
	AltNames() []string
}

type ModuleType string

type ModuleWithClose interface {
	Module
	Close() error
}

type ModuleWithUsageService interface {
	Module
	Logger() logrus.FieldLogger
	SetUsageService(usageService any) // Using interface{} to avoid circular dependency
}

type MutableSettings interface {
	MutableSettings(current, updated moduletools.ClassConfig) bool
}

type NearParam interface {
	GetCertainty() float64
	GetDistance() float64
	GetTargetVectors() []string
	SimilarityMetricProvided() bool
}

type OffloadCloud interface {
	// VerifyBucket verify if the offload bucket is created
	VerifyBucket(ctx context.Context) error
	// Upload uploads the content of a shard assigned to specific node to
	// cloud provider (S3, Azure Blob storage, Google cloud storage)
	// {cloud_provider}://{configured_bucket}/{className}/{shardName}/{nodeName}/{shard content}
	Upload(ctx context.Context, className, shardName, nodeName string) error
	// Download downloads the content of a shard to desired node from
	// cloud provider (S3, Azure Blob storage, Google cloud storage)
	// {dataPath}/{className}/{shardName}/{content}
	Download(ctx context.Context, className, shardName, nodeName string) error
	// Delete deletes content of a shard assigned to specific node in
	// cloud provider (S3, Azure Blob storage, Google cloud storage)
	// Careful: if shardName and nodeName is passed empty it will delete all class frozen shards in cloud storage
	// {cloud_provider}://{configured_bucket}/{className}/{shardName}/{nodeName}/{shard content}
	Delete(ctx context.Context, className, shardName, nodeName string) error
}

type ReferenceVectorizer[T dto.Embedding] interface {
	// VectorizeObject should mutate the object which is passed in as a pointer-type
	// by extending it with the desired vector, which is calculated by the module
	VectorizeObject(ctx context.Context, object *models.Object,
		cfg moduletools.ClassConfig, findObjectFn FindObjectFn) (T, error)
}

type Searcher[T dto.Embedding] interface {
	VectorSearches() map[string]VectorForParams[T]
}

type TextTransform interface {
	Transform(in []string) ([]string, error)
}

type TextTransformers interface {
	TextTransformers() map[string]TextTransform
}

type ValidateFn = func(param any) error

type VectorClassSearchParams struct {
	Filters    *filters.LocalFilter
	Pagination *filters.Pagination
	ClassName  string
	Properties []string
}

type VectorClassSearchRepo interface {
	VectorClassSearch(ctx context.Context, params VectorClassSearchParams) ([]search.Result, error)
}

type VectorForParams[T dto.Embedding] = func(ctx context.Context, params any,
	className string, findVectorFn FindVectorFn[T], cfg moduletools.ClassConfig) (T, error)

type Vectorizer[T dto.Embedding] interface {
	// VectorizeObject takes an object and returns a vector and - if applicable - any meta
	// information as part of _additional properties
	VectorizeObject(ctx context.Context, obj *models.Object,
		cfg moduletools.ClassConfig) (T, models.AdditionalProperties, error)
	// VectorizableProperties returns which properties the vectorizer looks at.
	// If the vectorizer is capable of vectorizing all text properties, the first bool is true.
	// Any additional "media"-properties are explicitly mentioned in the []string return
	VectorizableProperties(cfg moduletools.ClassConfig) (bool, []string, error)
	VectorizeBatch(ctx context.Context, objs []*models.Object, skipObject []bool, cfg moduletools.ClassConfig) ([]T, []models.AdditionalProperties, map[int]error)
}

type VectorizerClient interface {
	MultiVectorForWord(ctx context.Context,
		words []string) ([][]float32, error)
	VectorOnlyForCorpi(ctx context.Context, corpi []string,
		overrides map[string]string) ([]float32, error)
}

type Writer interface {
	Start()
	Store(item search.Result) error
	Stop() WriterResults
}

type WriterResults interface {
	SuccessCount() int64
	ErrorCount() int64
	Err() error
}