optimus

type AbsolutePriceThreshold struct {
	*sonm.Price
}

type AxeModel struct {
	Log *zap.SugaredLogger
	// contains filtered or unexported fields
}

type AxeModelConfig struct{}

type AxeModelFactory struct {
	AxeModelConfig
}

type BatchModel struct {
	Methods []OptimizationMethod
	Log     *zap.SugaredLogger
}

type BatchModelConfig struct {
	Brute   bruteConfig                 `yaml:"brute"`
	Methods []optimizationMethodFactory `yaml:"models"`
}

type BatchModelFactory struct {
	BatchModelConfig
}

type Blacklist interface {
	Update(ctx context.Context) error
	IsAllowed(addr common.Address) bool
}

type BranchBoundModel struct {
	Log *zap.SugaredLogger
}

type BranchBoundModelConfig struct {
	HeightLimit int `yaml:"height_limit" default:"6"`
}

type BranchBoundModelFactory struct {
	BranchBoundModelConfig
}

type Config struct {
	Restrictions *RestrictionsConfig         `yaml:"restrictions"`
	Blockchain   *blockchain.Config          `yaml:"blockchain"`
	PrivateKey   privateKey                  `yaml:"ethereum" json:"-"`
	Logging      logging.Config              `yaml:"logging"`
	Node         nodeConfig                  `yaml:"node"`
	Workers      map[auth.Addr]*workerConfig `yaml:"workers"`
	Benchmarks   benchmarks.Config           `yaml:"benchmarks"`
	Marketplace  marketplaceConfig           `yaml:"marketplace"`
	Debug        *debug.Config               `yaml:"debug"`
}

type Consumer interface {
	LowerBound() []float64
	DeviceType() sonm.DeviceType
	DeviceBenchmark(id int) (*sonm.Benchmark, bool)
	SplittingAlgorithm() sonm.SplittingAlgorithm
	Result(criteria float64) interface{}
}

type DealRequestFactory func() *sonm.DealsRequest

type DecisionVec []float64

type Deleter interface {
	Delete() error
}

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

type FittingFunc struct {
	Filters []func(order *sonm.Order) error
}

type GeneticModel struct {
	NewGenomeLab NewGenomeLab
	// PopulationSize specifies the number of individuals per Population.
	PopulationSize int
	// MaxGenerations specifies the number of population generations.
	MaxGenerations int
	// MaxAge specifies the maximum age of the entire evolution process.
	MaxAge time.Duration
	// Log is used for internal logging.
	Log *zap.SugaredLogger
}

type GeneticModelConfig struct {
	Genome         GenomeConfig  `yaml:"genome"`
	PopulationSize int           `yaml:"population_size" default:"256"`
	MaxGenerations int           `yaml:"max_generations" default:"128"`
	MaxAge         time.Duration `yaml:"max_age" default:"5m"`
}

type GeneticModelFactory struct {
	GeneticModelConfig
}

type GenomeConfig struct {
	NewGenomeLab `json:"-"`
	Type         string
}

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

type GreedyLinearRegressionModelConfig struct {
	WeightLimit     float64                `yaml:"weight_limit" default:"1e-3"`
	ExhaustionLimit int                    `yaml:"exhaustion_limit" default:"128"`
	Model           regressionModelFactory `yaml:"regression"`
}

type GreedyLinearRegressionModelFactory struct {
	GreedyLinearRegressionModelConfig
}

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

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

type MarketOrder = sonm.DWHOrder

type MarketScanner interface {
	ActiveOrders(ctx context.Context) ([]*MarketOrder, error)
	ExecutedOrders(ctx context.Context, orderType sonm.OrderType) ([]*MarketOrder, error)
}

type Model interface {
	// Train runs the training process, returning the trained model on success.
	// The "trainingSet" argument is a MxN matrix, while "expectation" must be
	// a M-length vector.
	Train(trainingSet [][]float64, expectation []float64) (TrainedModel, error)
}

type NewGenomeLab func(knapsack *Knapsack, orders []*MarketOrder) gago.NewGenome

type Normalizer interface {
	Normalize(x float64) float64
	NormalizeBatch(x []float64)
	Denormalize(x float64) float64
	IsDegenerated() bool
}

type OptimizationConfig struct {
	Model optimizationMethodFactory `yaml:"model"`
}

type OptimizationMethod interface {
	Optimize(ctx context.Context, knapsack *Knapsack, orders []*MarketOrder) error
}

type OptimizationMethodFactory interface {
	Config() interface{}
	Create(orders, matchedOrders []*MarketOrder, log *zap.SugaredLogger) OptimizationMethod
}

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

type Option func(o *options)

type OrderClassification struct {
	WeightedOrders []WeightedOrder
	Predictor      *OrderPredictor
}

type OrderClassifier interface {
	Classify(orders []*MarketOrder) ([]WeightedOrder, error)
}

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

type OrderRequestFactory func() *sonm.OrdersRequest

type Orders []*MarketOrder

type PredefinedMarketCache struct {
	Orders []*MarketOrder
}

type PredictorConfig struct {
	Blockchain     *blockchain.Config
	DWH            *dwh.DWHConfig
	Marketplace    marketplaceConfig
	BruteThreshold uint `yaml:"brute_threshold" default:"6"`
}

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

type PriceThreshold interface {
	// Exceeds returns "true" if the "price" exceeds "otherPrice" according to
	// the implementation's threshold policy.
	Exceeds(price, otherPrice *big.Int) bool
}

type ReadOnlyWorker struct {
	WorkerManagementClientAPI
	// contains filtered or unexported fields
}

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

type RegressionModelFactory interface {
	Config() interface{}
	Create(log *zap.SugaredLogger) Model
}

type RelativePriceThreshold struct {
	*big.Int
}

type RestrictionsConfig struct {
	Name     string  `yaml:"cgroup_name" default:"/optimus"`
	CPUCount float64 `yaml:"cpu_count" default:"1.0"`
	// Upper RSS threshold in megabytes.
	//
	// Zero value, which is default, means no limit.
	MemoryLimit uint64 `yaml:"memory_limit"`
}

type SCAKKTModel struct {
	MaxIterations int
	Log           *zap.SugaredLogger
}

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

type TrainedModel interface {
	Predict(vec []float64) (float64, error)
}

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

type Watcher interface {
	OnRun()
	OnShutdown()
	Execute(ctx context.Context)
}

type WeightedOrder struct {
	// Order is an initial market order.
	Order *MarketOrder
	// Price is an order price in USD/s.
	Price float64
	// PredictedPrice is a order price in USD/s, that is calculated during
	// scanning and analysing the market.
	PredictedPrice float64
	// Weight represents some specific order weight.
	//
	// It fits in [0; +Inf] range and is used to reduce an order attractiveness
	// if it has been laying on the market for a long time without being sold.
	Weight float64
}

type WorkerManagementClientAPI interface {
	Devices(ctx context.Context, request *sonm.Empty, opts ...grpc.CallOption) (*sonm.DevicesReply, error)
	AskPlans(ctx context.Context, request *sonm.Empty, opts ...grpc.CallOption) (*sonm.AskPlansReply, error)
	CreateAskPlan(ctx context.Context, request *sonm.AskPlan, opts ...grpc.CallOption) (*sonm.ID, error)
	RemoveAskPlan(ctx context.Context, request *sonm.ID, opts ...grpc.CallOption) (*sonm.Empty, error)
	NextMaintenance(ctx context.Context, request *sonm.Empty, opts ...grpc.CallOption) (*sonm.Timestamp, error)
}

type WorkerManagementClientExt interface {
	WorkerManagementClientAPI
	RemoveAskPlans(ctx context.Context, ids []string) error
}