_go

type Algorithm struct {

	// Name of the algorithm - must be globally unique
	// This identifies the algorithm across the system
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Version of the algorithm - must follow semantic versioning
	// Allows for algorithm evolution while maintaining compatibility
	Version string `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"`
	// Type of window that triggers this algorithm
	// References a WindowType that will cause this algorithm to execute
	WindowType *WindowType `protobuf:"bytes,3,opt,name=window_type,json=windowType,proto3" json:"window_type,omitempty"`
	// Other algorithms that this algorithm depends on
	// The algorithm won't execute until all dependencies have completed
	// Dependencies must not form cycles - this is statically checked on processor registration
	Dependencies []*AlgorithmDependency `protobuf:"bytes,4,rep,name=dependencies,proto3" json:"dependencies,omitempty"`
	// The type of result that the algorithm produces. This is specified upfront
	// rather than introspected, to allow for validation
	ResultType ResultType `protobuf:"varint,5,opt,name=result_type,json=resultType,proto3,enum=ResultType" json:"result_type,omitempty"`
	// A freeform description of the algorithm
	Description string `protobuf:"bytes,6,opt,name=description,proto3" json:"description,omitempty"`
	// contains filtered or unexported fields
}

type AlgorithmDependency struct {

	// Name of the required algorithm
	// Must reference an existing algorithm name in the system
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Version of the required algorithm
	// Must follow semantic versioning (e.g., "1.0.0")
	Version string `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"`
	// Name of the processor that the algorithm is associated with
	ProcessorName string `protobuf:"bytes,3,opt,name=processor_name,json=processorName,proto3" json:"processor_name,omitempty"`
	// Runtime of the processor that the algorithm is associated with
	ProcessorRuntime string `protobuf:"bytes,4,opt,name=processor_runtime,json=processorRuntime,proto3" json:"processor_runtime,omitempty"`
	// A lookback field that specifies whether this dependency
	// depends on past results of this algorithm
	//
	// Types that are assignable to Lookback:
	//
	//	*AlgorithmDependency_LookbackNum
	//	*AlgorithmDependency_LookbackTimeDelta
	Lookback isAlgorithmDependency_Lookback `protobuf_oneof:"lookback"`
	// contains filtered or unexported fields
}

type AlgorithmDependencyResult struct {

	// The Algorithm
	Algorithm *Algorithm `protobuf:"bytes,1,opt,name=algorithm,proto3" json:"algorithm,omitempty"`
	// The result
	Result []*AlgorithmDependencyResultRow `protobuf:"bytes,2,rep,name=result,proto3" json:"result,omitempty"`
	// contains filtered or unexported fields
}

type AlgorithmDependencyResultRow struct {

	// The result
	Result *Result `protobuf:"bytes,1,opt,name=result,proto3" json:"result,omitempty"`
	// The window that triggered the result
	Window *Window `protobuf:"bytes,2,opt,name=window,proto3" json:"window,omitempty"`
	// contains filtered or unexported fields
}

type AlgorithmDependency_LookbackNum struct {
	// Number of past results to depend on (if at all)
	LookbackNum uint32 `protobuf:"varint,5,opt,name=lookback_num,json=lookbackNum,proto3,oneof"`
}

type AlgorithmDependency_LookbackTimeDelta struct {
	// Timeframe of past results to depend on (in nanoseconds)
	LookbackTimeDelta uint64 `protobuf:"varint,6,opt,name=lookback_time_delta,json=lookbackTimeDelta,proto3,oneof"`
}

type AlgorithmResult struct {
	Algorithm *Algorithm `protobuf:"bytes,1,opt,name=algorithm,proto3" json:"algorithm,omitempty"`
	Result    *Result    `protobuf:"bytes,2,opt,name=result,proto3" json:"result,omitempty"`
	Window    *Window    `protobuf:"bytes,3,opt,name=window,proto3" json:"window,omitempty"`
	// contains filtered or unexported fields
}

type ExecuteAlgorithm struct {

	// The algorithm to execute
	Algorithm *Algorithm `protobuf:"bytes,1,opt,name=algorithm,proto3" json:"algorithm,omitempty"`
	// The results of a dependent algorithm
	Dependencies []*AlgorithmDependencyResult `protobuf:"bytes,2,rep,name=dependencies,proto3" json:"dependencies,omitempty"`
	// contains filtered or unexported fields
}

type ExecutionRequest struct {

	// The exec_id
	ExecId string `protobuf:"bytes,1,opt,name=exec_id,json=execId,proto3" json:"exec_id,omitempty"`
	// The window that triggered the algorithm
	Window *Window `protobuf:"bytes,2,opt,name=window,proto3" json:"window,omitempty"`
	// Results from dependant algorithms
	//
	// Deprecated: Marked as deprecated in service.proto.
	AlgorithmResults []*AlgorithmResult `protobuf:"bytes,3,rep,name=algorithm_results,json=algorithmResults,proto3" json:"algorithm_results,omitempty"`
	// The algorithms to execute
	//
	// Deprecated: Marked as deprecated in service.proto.
	Algorithms          []*Algorithm        `protobuf:"bytes,4,rep,name=algorithms,proto3" json:"algorithms,omitempty"` // FIXME:
	AlgorithmExecutions []*ExecuteAlgorithm `protobuf:"bytes,5,rep,name=algorithm_executions,json=algorithmExecutions,proto3" json:"algorithm_executions,omitempty"`
	// contains filtered or unexported fields
}

type ExecutionResult struct {

	// Exec ID
	ExecId string `protobuf:"bytes,1,opt,name=exec_id,json=execId,proto3" json:"exec_id,omitempty"`
	// The algorithn result
	AlgorithmResult *AlgorithmResult `protobuf:"bytes,3,opt,name=algorithm_result,json=algorithmResult,proto3" json:"algorithm_result,omitempty"`
	// contains filtered or unexported fields
}

type ExposeSettings struct {
	ExcludeProject string `protobuf:"bytes,1,opt,name=exclude_project,json=excludeProject,proto3" json:"exclude_project,omitempty"`
	// contains filtered or unexported fields
}

type FloatArray struct {
	Values []float32 `protobuf:"fixed32,1,rep,packed,name=values,proto3" json:"values,omitempty"`
	// contains filtered or unexported fields
}

type HealthCheckRequest struct {

	// Timestamp of the request in unix epoch milliseconds
	// Used to measure response latency
	Timestamp int64 `protobuf:"varint,1,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	// contains filtered or unexported fields
}

type HealthCheckResponse struct {

	// Current health status
	Status HealthCheckResponse_Status `protobuf:"varint,1,opt,name=status,proto3,enum=HealthCheckResponse_Status" json:"status,omitempty"`
	// Optional message providing more detail about the health status
	Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	// System metrics about the processor
	Metrics *ProcessorMetrics `protobuf:"bytes,3,opt,name=metrics,proto3" json:"metrics,omitempty"`
	// contains filtered or unexported fields
}

type HealthCheckResponse_Status int32

type InternalState struct {

	// Global list of all registered processors and their metadata
	Processors []*ProcessorRegistration `protobuf:"bytes,1,rep,name=processors,proto3" json:"processors,omitempty"`
	// contains filtered or unexported fields
}

type MetadataField struct {

	// Name of the metadata field
	// Examples: "AssetID"
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Description of the field
	// Examples: "Unique ID of the asset"
	Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
	// contains filtered or unexported fields
}

type OrcaCoreClient interface {
	// Register a processor node and its supported algorithms
	RegisterProcessor(ctx context.Context, in *ProcessorRegistration, opts ...grpc.CallOption) (*Status, error)
	// Submit a window for processing
	EmitWindow(ctx context.Context, in *Window, opts ...grpc.CallOption) (*WindowEmitStatus, error)
	// Expose the internal Orca state
	Expose(ctx context.Context, in *ExposeSettings, opts ...grpc.CallOption) (*InternalState, error)
}

type OrcaCoreServer interface {
	// Register a processor node and its supported algorithms
	RegisterProcessor(context.Context, *ProcessorRegistration) (*Status, error)
	// Submit a window for processing
	EmitWindow(context.Context, *Window) (*WindowEmitStatus, error)
	// Expose the internal Orca state
	Expose(context.Context, *ExposeSettings) (*InternalState, error)
	// contains filtered or unexported methods
}

type OrcaProcessorClient interface {
	// Execute part of a DAG with streaming results
	// Server streams back execution results as they become available
	ExecuteDagPart(ctx context.Context, in *ExecutionRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ExecutionResult], error)
	// Check health/status of processor. i.e. a heartbeat
	HealthCheck(ctx context.Context, in *HealthCheckRequest, opts ...grpc.CallOption) (*HealthCheckResponse, error)
}

type OrcaProcessorServer interface {
	// Execute part of a DAG with streaming results
	// Server streams back execution results as they become available
	ExecuteDagPart(*ExecutionRequest, grpc.ServerStreamingServer[ExecutionResult]) error
	// Check health/status of processor. i.e. a heartbeat
	HealthCheck(context.Context, *HealthCheckRequest) (*HealthCheckResponse, error)
	// contains filtered or unexported methods
}

type OrcaProcessor_ExecuteDagPartClient = grpc.ServerStreamingClient[ExecutionResult]

type OrcaProcessor_ExecuteDagPartServer = grpc.ServerStreamingServer[ExecutionResult]

type ProcessorMetrics struct {

	// Number of algorithms currently being executed
	ActiveTasks int32 `protobuf:"varint,1,opt,name=active_tasks,json=activeTasks,proto3" json:"active_tasks,omitempty"`
	// Memory usage in bytes
	MemoryBytes int64 `protobuf:"varint,2,opt,name=memory_bytes,json=memoryBytes,proto3" json:"memory_bytes,omitempty"`
	// CPU usage percentage (0-100)
	CpuPercent float32 `protobuf:"fixed32,3,opt,name=cpu_percent,json=cpuPercent,proto3" json:"cpu_percent,omitempty"`
	// Time since processor started in seconds
	UptimeSeconds int64 `protobuf:"varint,4,opt,name=uptime_seconds,json=uptimeSeconds,proto3" json:"uptime_seconds,omitempty"`
	// contains filtered or unexported fields
}

type ProcessorRegistration struct {

	// Unique name of the runtime
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Language/runtime of the processor
	// Examples: "python3.9", "go1.19", "Rust4.1"
	Runtime string `protobuf:"bytes,2,opt,name=runtime,proto3" json:"runtime,omitempty"`
	// The connection string of the processor
	// e.g. grpc://localhost:5433
	ConnectionStr string `protobuf:"bytes,3,opt,name=connection_str,json=connectionStr,proto3" json:"connection_str,omitempty"`
	// Algorithms this processor can execute
	// The processor must implement all listed algorithms
	SupportedAlgorithms []*Algorithm `protobuf:"bytes,4,rep,name=supported_algorithms,json=supportedAlgorithms,proto3" json:"supported_algorithms,omitempty"`
	// A name that can be attached to a group of processors. Describes the project in which
	// they are defined (typically a single git repository)
	ProjectName string `protobuf:"bytes,5,opt,name=project_name,json=projectName,proto3" json:"project_name,omitempty"`
	// contains filtered or unexported fields
}

type Result struct {

	// Status of the result execution
	Status ResultStatus `protobuf:"varint,1,opt,name=status,proto3,enum=ResultStatus" json:"status,omitempty"`
	// The actual result data - can be either an array of floats or a structured object
	//
	// Types that are assignable to ResultData:
	//
	//	*Result_SingleValue
	//	*Result_FloatValues
	//	*Result_StructValue
	ResultData isResult_ResultData `protobuf_oneof:"result_data"`
	// Timestamp when the result was produced
	Timestamp int64 `protobuf:"varint,5,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	// contains filtered or unexported fields
}

type ResultStatus int32

type ResultType int32

type Result_FloatValues struct {
	// For numeric array results
	FloatValues *FloatArray `protobuf:"bytes,3,opt,name=float_values,json=floatValues,proto3,oneof"`
}

type Result_SingleValue struct {
	// for single number results
	SingleValue float32 `protobuf:"fixed32,2,opt,name=single_value,json=singleValue,proto3,oneof"`
}

type Result_StructValue struct {
	// For structured data results (JSON-like)
	// Must follow a map<string, value> schema where value corresponds to https://protobuf.dev/reference/protobuf/google.protobuf/#value
	StructValue *structpb.Struct `protobuf:"bytes,4,opt,name=struct_value,json=structValue,proto3,oneof"`
}

type Status struct {
	Received bool   `protobuf:"varint,1,opt,name=received,proto3" json:"received,omitempty"`
	Message  string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	// contains filtered or unexported fields
}

type UnimplementedOrcaCoreServer struct{}

type UnimplementedOrcaProcessorServer struct{}

type UnsafeOrcaCoreServer interface {
	// contains filtered or unexported methods
}

type UnsafeOrcaProcessorServer interface {
	// contains filtered or unexported methods
}

type Window struct {

	// Time that the window starts - nanoseconds since epoch
	// Required: Must be > Unix epoch (1970-01-01T00:00:00Z)
	TimeFrom *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=time_from,json=timeFrom,proto3" json:"time_from,omitempty"`
	// Time that the window ends - nanoseconds since epoch
	// Required: Must be > time_from (validated at message level)
	TimeTo *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=time_to,json=timeTo,proto3" json:"time_to,omitempty"`
	// The canonical name of the window that uniquely identifies it
	WindowTypeName string `protobuf:"bytes,3,opt,name=window_type_name,json=windowTypeName,proto3" json:"window_type_name,omitempty"`
	// The version of the window type
	WindowTypeVersion string `protobuf:"bytes,4,opt,name=window_type_version,json=windowTypeVersion,proto3" json:"window_type_version,omitempty"`
	// A unique identifier that defines where the window came from
	Origin string `protobuf:"bytes,5,opt,name=origin,proto3" json:"origin,omitempty"`
	// Additional metadata to attach to this window
	// The schema of this metadata is determined by the combination of
	// window_type_name and window_type_version. Each window type version
	// defines its own required and optional metadata fields, as defined
	// at the time of registration.
	Metadata *structpb.Struct `protobuf:"bytes,6,opt,name=metadata,proto3" json:"metadata,omitempty"`
	// contains filtered or unexported fields
}

type WindowEmitStatus struct {
	Status WindowEmitStatus_StatusEnum `protobuf:"varint,1,opt,name=status,proto3,enum=WindowEmitStatus_StatusEnum" json:"status,omitempty"`
	// contains filtered or unexported fields
}

type WindowEmitStatus_StatusEnum int32

type WindowType struct {

	// Name of the window type - must be globally unique
	// Examples: "daily", "hourly", "market_close", "event_triggered"
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Version of the algorithm. Follows basic semver and allows window
	// types to be changed over time, with traceability
	Version string `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"`
	// Description of the window
	// E.g. "Emitted every day, at noon"
	Description string `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"`
	// Metadata fields that are carried along with this window type
	MetadataFields []*MetadataField `protobuf:"bytes,4,rep,name=metadataFields,proto3" json:"metadataFields,omitempty"`
	// contains filtered or unexported fields
}