modulecapabilities

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

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

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

type AdditionalPropertyWithSearchVector interface {
	SetSearchVector(vector []float32)
}

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

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

type ArgumentVectorForParams = map[string]VectorForParams

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 home directory of all backup files
	HomeDir(backupID string) string

	// GetObject giving backupID and key
	GetObject(ctx context.Context, backupID, key string) ([]byte, error)

	// WriteToFile writes an object in the specified file with path destPath
	// The file will be created if it doesn't exist
	// The file will be overwritten if it exists
	WriteToFile(ctx context.Context, backupID, key, destPath string) error

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

	// PutFile reads a file from srcPath and uploads it to the destination folder
	PutFile(ctx context.Context, backupID, key, srcPath string) error
	// PutObject writes bytes to the object with key `key`
	PutObject(ctx context.Context, backupID, key 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 string) error

	Write(ctx context.Context, backupID, key string, r io.ReadCloser) (int64, error)
	Read(ctx context.Context, backupID, key 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]interface{}

	// 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]interface{}

	// 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 interface {
	ModuleName() string
	Argument() string
	GraphQLArgument() GraphQLArgument
	VectorSearch() VectorForParams
}

type DependencySearcher interface {
	VectorSearches() ModuleArgumentVectorForParams
}

type ExploreArgumentsFn = func() *graphql.ArgumentConfig

type ExtractAdditionalFn = func(param []*ast.Argument) interface{}

type ExtractFn = func(param map[string]interface{}) interface{}

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 = func(ctx context.Context, className string, id strfmt.UUID, tenant, targetVector string) ([]float32, string, error)

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 InputVectorizer interface {
	VectorizeInput(ctx context.Context, input string,
		cfg moduletools.ClassConfig) ([]float32, error)
}

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

type Module interface {
	Name() string
	Init(ctx context.Context, params moduletools.ModuleInitParams) error
	RootHandler() http.Handler // TODO: remove from overall module, this is a capability
	Type() ModuleType
}

type ModuleArgumentVectorForParams = map[string]ArgumentVectorForParams

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 NearParam interface {
	GetCertainty() float64
	GetDistance() float64
	GetTargetVectors() []string
	SimilarityMetricProvided() bool
}

type ReferenceVectorizer 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) ([]float32, error)
}

type Searcher interface {
	VectorSearches() ArgumentVectorForParams
}

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

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

type ValidateFn = func(param interface{}) 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 = func(ctx context.Context, params interface{},
	className string, findVectorFn FindVectorFn, cfg moduletools.ClassConfig) ([]float32, error)

type Vectorizer 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) ([]float32, 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) ([][]float32, []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
}