py/facett_demo/proto/korp_pb2_grpc.py
# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
"""Client and server classes corresponding to protobuf-defined services."""
import grpc
import warnings
from . import korp_pb2 as korp__pb2
GRPC_GENERATED_VERSION = '1.83.0'
GRPC_VERSION = grpc.__version__
_version_not_supported = False
try:
from grpc._utilities import first_version_is_lower
_version_not_supported = first_version_is_lower(GRPC_VERSION, GRPC_GENERATED_VERSION)
except ImportError:
_version_not_supported = True
if _version_not_supported:
raise RuntimeError(
f'The grpc package installed is at version {GRPC_VERSION},'
+ ' but the generated code in korp_pb2_grpc.py depends on'
+ f' grpcio>={GRPC_GENERATED_VERSION}.'
+ f' Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}'
+ f' or downgrade your generated code using grpcio-tools<={GRPC_VERSION}.'
)
class KorpControlStub:
"""Korp control plane — Odin's ravens over the wire.
Hugin (live): stream the app's $KORP_STATE. Munin (memory): the investigations.
Beyond the two ravens, KorpControl also exposes the QUERY RPCs the desktop
panes need so a `korp --server <url>` thin client fills the SAME views a fat
(in-process LocalKorp) build does — one RPC per pane, mirroring nornir's
Viz/Warehouse read services. The server answers each by delegating to an
in-process LocalKorp (the fat node), so there is ONE reads implementation.
"""
def __init__(self, channel):
"""Constructor.
Args:
channel: A grpc.Channel.
"""
self.StreamState = channel.unary_stream(
'/korp.KorpControl/StreamState',
request_serializer=korp__pb2.StreamRequest.SerializeToString,
response_deserializer=korp__pb2.StateUpdate.FromString,
_registered_method=True)
self.ListCases = channel.unary_unary(
'/korp.KorpControl/ListCases',
request_serializer=korp__pb2.CasesRequest.SerializeToString,
response_deserializer=korp__pb2.CasesReply.FromString,
_registered_method=True)
self.PopulateDemoCases = channel.unary_unary(
'/korp.KorpControl/PopulateDemoCases',
request_serializer=korp__pb2.PopulateDemoCasesRequest.SerializeToString,
response_deserializer=korp__pb2.PopulateDemoCasesReply.FromString,
_registered_method=True)
self.Health = channel.unary_unary(
'/korp.KorpControl/Health',
request_serializer=korp__pb2.HealthRequest.SerializeToString,
response_deserializer=korp__pb2.HealthReply.FromString,
_registered_method=True)
self.Search = channel.unary_unary(
'/korp.KorpControl/Search',
request_serializer=korp__pb2.SearchRequest.SerializeToString,
response_deserializer=korp__pb2.SearchReply.FromString,
_registered_method=True)
self.Timeline = channel.unary_unary(
'/korp.KorpControl/Timeline',
request_serializer=korp__pb2.TimelineRequest.SerializeToString,
response_deserializer=korp__pb2.TimelineReply.FromString,
_registered_method=True)
self.Graph = channel.unary_unary(
'/korp.KorpControl/Graph',
request_serializer=korp__pb2.GraphRequest.SerializeToString,
response_deserializer=korp__pb2.GraphReply.FromString,
_registered_method=True)
self.Tables = channel.unary_unary(
'/korp.KorpControl/Tables',
request_serializer=korp__pb2.TablesRequest.SerializeToString,
response_deserializer=korp__pb2.TablesReply.FromString,
_registered_method=True)
self.Assets = channel.unary_unary(
'/korp.KorpControl/Assets',
request_serializer=korp__pb2.AssetsRequest.SerializeToString,
response_deserializer=korp__pb2.AssetsReply.FromString,
_registered_method=True)
self.MapQuery = channel.unary_unary(
'/korp.KorpControl/MapQuery',
request_serializer=korp__pb2.MapQueryRequest.SerializeToString,
response_deserializer=korp__pb2.MapQueryReply.FromString,
_registered_method=True)
self.MapQueryStream = channel.unary_stream(
'/korp.KorpControl/MapQueryStream',
request_serializer=korp__pb2.MapQueryViewport.SerializeToString,
response_deserializer=korp__pb2.MapQueryReply.FromString,
_registered_method=True)
self.MapFile = channel.unary_unary(
'/korp.KorpControl/MapFile',
request_serializer=korp__pb2.MapFileRequest.SerializeToString,
response_deserializer=korp__pb2.MapFileReply.FromString,
_registered_method=True)
self.Populate = channel.unary_stream(
'/korp.KorpControl/Populate',
request_serializer=korp__pb2.PopulateRequest.SerializeToString,
response_deserializer=korp__pb2.GenProgressUpdate.FromString,
_registered_method=True)
self.IcebergTables = channel.unary_unary(
'/korp.KorpControl/IcebergTables',
request_serializer=korp__pb2.IcebergTablesRequest.SerializeToString,
response_deserializer=korp__pb2.IcebergTablesReply.FromString,
_registered_method=True)
self.TablePreview = channel.unary_unary(
'/korp.KorpControl/TablePreview',
request_serializer=korp__pb2.TablePreviewRequest.SerializeToString,
response_deserializer=korp__pb2.TablePreviewReply.FromString,
_registered_method=True)
self.AdhocSql = channel.unary_unary(
'/korp.KorpControl/AdhocSql',
request_serializer=korp__pb2.AdhocSqlRequest.SerializeToString,
response_deserializer=korp__pb2.AdhocSqlReply.FromString,
_registered_method=True)
self.Population = channel.unary_unary(
'/korp.KorpControl/Population',
request_serializer=korp__pb2.PopulationRequest.SerializeToString,
response_deserializer=korp__pb2.PopulationReply.FromString,
_registered_method=True)
self.ListGraphs = channel.unary_unary(
'/korp.KorpControl/ListGraphs',
request_serializer=korp__pb2.ListGraphsRequest.SerializeToString,
response_deserializer=korp__pb2.ListGraphsReply.FromString,
_registered_method=True)
self.GraphSchema = channel.unary_unary(
'/korp.KorpControl/GraphSchema',
request_serializer=korp__pb2.GraphSchemaRequest.SerializeToString,
response_deserializer=korp__pb2.GraphSchemaReply.FromString,
_registered_method=True)
self.ListPipelines = channel.unary_unary(
'/korp.KorpControl/ListPipelines',
request_serializer=korp__pb2.ListPipelinesRequest.SerializeToString,
response_deserializer=korp__pb2.ListPipelinesReply.FromString,
_registered_method=True)
self.PipelinesFor = channel.unary_unary(
'/korp.KorpControl/PipelinesFor',
request_serializer=korp__pb2.PipelinesForRequest.SerializeToString,
response_deserializer=korp__pb2.PipelinesForReply.FromString,
_registered_method=True)
self.RunPipelineFor = channel.unary_unary(
'/korp.KorpControl/RunPipelineFor',
request_serializer=korp__pb2.RunPipelineForRequest.SerializeToString,
response_deserializer=korp__pb2.RunPipelineForReply.FromString,
_registered_method=True)
self.RecordJob = channel.unary_unary(
'/korp.KorpControl/RecordJob',
request_serializer=korp__pb2.RecordJobRequest.SerializeToString,
response_deserializer=korp__pb2.RecordJobReply.FromString,
_registered_method=True)
self.JobLedger = channel.unary_unary(
'/korp.KorpControl/JobLedger',
request_serializer=korp__pb2.JobLedgerRequest.SerializeToString,
response_deserializer=korp__pb2.JobLedgerReply.FromString,
_registered_method=True)
self.RunPipeline = channel.unary_stream(
'/korp.KorpControl/RunPipeline',
request_serializer=korp__pb2.RunPipelineRequest.SerializeToString,
response_deserializer=korp__pb2.PipelineUpdate.FromString,
_registered_method=True)
self.SetInfra = channel.unary_unary(
'/korp.KorpControl/SetInfra',
request_serializer=korp__pb2.SetInfraRequest.SerializeToString,
response_deserializer=korp__pb2.SetInfraReply.FromString,
_registered_method=True)
self.Backends = channel.unary_unary(
'/korp.KorpControl/Backends',
request_serializer=korp__pb2.BackendsRequest.SerializeToString,
response_deserializer=korp__pb2.BackendsReply.FromString,
_registered_method=True)
self.StartBackend = channel.unary_unary(
'/korp.KorpControl/StartBackend',
request_serializer=korp__pb2.StartBackendRequest.SerializeToString,
response_deserializer=korp__pb2.StartBackendReply.FromString,
_registered_method=True)
self.Objects = channel.unary_unary(
'/korp.KorpControl/Objects',
request_serializer=korp__pb2.ObjectsRequest.SerializeToString,
response_deserializer=korp__pb2.ObjectsReply.FromString,
_registered_method=True)
self.PopulateOpenData = channel.unary_unary(
'/korp.KorpControl/PopulateOpenData',
request_serializer=korp__pb2.PopulateOpenDataRequest.SerializeToString,
response_deserializer=korp__pb2.LandReply.FromString,
_registered_method=True)
self.Collect = channel.unary_unary(
'/korp.KorpControl/Collect',
request_serializer=korp__pb2.CollectRequest.SerializeToString,
response_deserializer=korp__pb2.LandReply.FromString,
_registered_method=True)
self.LoadIceberg = channel.unary_unary(
'/korp.KorpControl/LoadIceberg',
request_serializer=korp__pb2.LoadIcebergRequest.SerializeToString,
response_deserializer=korp__pb2.LandReply.FromString,
_registered_method=True)
self.RoadGraph = channel.unary_unary(
'/korp.KorpControl/RoadGraph',
request_serializer=korp__pb2.RoadGraphRequest.SerializeToString,
response_deserializer=korp__pb2.RoadGraphReply.FromString,
_registered_method=True)
self.GraphSlice = channel.unary_unary(
'/korp.KorpControl/GraphSlice',
request_serializer=korp__pb2.GraphSliceRequest.SerializeToString,
response_deserializer=korp__pb2.GraphSliceReply.FromString,
_registered_method=True)
self.GeoHotspots = channel.unary_unary(
'/korp.KorpControl/GeoHotspots',
request_serializer=korp__pb2.GeoHotspotsRequest.SerializeToString,
response_deserializer=korp__pb2.GeoHotspotsReply.FromString,
_registered_method=True)
self.MapLayerRows = channel.unary_unary(
'/korp.KorpControl/MapLayerRows',
request_serializer=korp__pb2.MapLayerRowsRequest.SerializeToString,
response_deserializer=korp__pb2.MapLayerRowsReply.FromString,
_registered_method=True)
self.Geocode = channel.unary_unary(
'/korp.KorpControl/Geocode',
request_serializer=korp__pb2.GeocodeRequest.SerializeToString,
response_deserializer=korp__pb2.GeocodeReply.FromString,
_registered_method=True)
self.RevGeocode = channel.unary_unary(
'/korp.KorpControl/RevGeocode',
request_serializer=korp__pb2.RevGeocodeRequest.SerializeToString,
response_deserializer=korp__pb2.RevGeocodeReply.FromString,
_registered_method=True)
self.WarehouseCatalog = channel.unary_unary(
'/korp.KorpControl/WarehouseCatalog',
request_serializer=korp__pb2.WarehouseCatalogRequest.SerializeToString,
response_deserializer=korp__pb2.WarehouseCatalogReply.FromString,
_registered_method=True)
self.Collectors = channel.unary_unary(
'/korp.KorpControl/Collectors',
request_serializer=korp__pb2.CollectorsRequest.SerializeToString,
response_deserializer=korp__pb2.CollectorsReply.FromString,
_registered_method=True)
self.SetCollectorEnabled = channel.unary_unary(
'/korp.KorpControl/SetCollectorEnabled',
request_serializer=korp__pb2.SetCollectorEnabledRequest.SerializeToString,
response_deserializer=korp__pb2.SetCollectorEnabledReply.FromString,
_registered_method=True)
class KorpControlServicer:
"""Korp control plane — Odin's ravens over the wire.
Hugin (live): stream the app's $KORP_STATE. Munin (memory): the investigations.
Beyond the two ravens, KorpControl also exposes the QUERY RPCs the desktop
panes need so a `korp --server <url>` thin client fills the SAME views a fat
(in-process LocalKorp) build does — one RPC per pane, mirroring nornir's
Viz/Warehouse read services. The server answers each by delegating to an
in-process LocalKorp (the fat node), so there is ONE reads implementation.
"""
def StreamState(self, request, context):
"""Hugin — server-streams the live state JSON on an interval (a heartbeat).
"""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def ListCases(self, request, context):
"""Munin — the investigation cases from the redb store.
"""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def PopulateDemoCases(self, request, context):
"""Munin — SERVER-SIDE demo-case populate (lane F): create N fictional persons
(clearly-fake names) at REAL addresses read off the region cut, one case
each, deterministic under `seed`. A thin client TRIGGERS this and writes
nothing locally. proto3-additive — an older server safely ignores it.
"""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def Health(self, request, context):
"""── the pane query RPCs (thin-client reads; mirror nornir Viz/Warehouse) ──
Engine health / version / uptime.
"""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def Search(self, request, context):
"""Global object search (SearchPane): ranked hits for a query.
"""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def Timeline(self, request, context):
"""Timeline histogram + cross-filter subjects (TimelinePane).
"""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def Graph(self, request, context):
"""Graph scene for a Cypher query (GraphPane).
"""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def Tables(self, request, context):
"""Warehouse table names, sorted (the 🧊 Tables list).
"""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def Assets(self, request, context):
"""Map ASSETS — the region datasets the server serves from MinIO/S3, so a thin
client SELECTS a region by NAME (default `sweden`) and renders it from S3 with
ZERO local files. proto3-additive: an older running server safely ignores this
new RPC + its messages (the 🗺 Map / 📍 Geo viewers then show the empty state).
"""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def MapQuery(self, request, context):
"""Map QUERY — the VIA-SERVER map render path. The server reads the region asset's
GeoParquet (co-located with MinIO on oden), PRUNES row-groups whose covering
`bbox` misses the viewport, per-row-culls + LOD-simplifies, and returns ONLY the
visible geometry as a small payload. The thin client never touches S3 and never
pulls the whole dataset — each pan/zoom is a small RPC (like the pane queries).
"""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def MapQueryStream(self, request, context):
"""── MapQueryStream: ONE viewport, ONE read plan, cells streamed in PAINT order ──
Lane GG #20. The tile lane asks for a viewport as its missing CELLS; the server
reads their hull ONCE (one prune per table -- three for a full cut -- instead of
one per cell), slices the reply per cell and streams the cells back GROUND FIRST:
every cell's area fills (forest, water, landuse) before any cell's roads, so the
first frames a thin client can paint are the ground of the whole viewport and the
roads land on top of it. Each streamed message is a `MapQueryReply` carrying which
cell it is (`cell`), which paint phase (`phase`) and whether that cell is now
complete (`cell_complete`) -- additive fields, so the decoder is the one MapQuery
already has.
The reply cache in front of `MapQuery` (lane GG #16) sits in front of this too: a
second identical viewport re-prunes nothing.
proto3-additive: an OLD server does not have it (tonic answers UNIMPLEMENTED and
the client falls back to the unary `MapQuery` runs it fetched with before); an
OLD client never calls it. `MapQuery` itself is unchanged.
"""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def MapFile(self, request, context):
"""── MapFile: RAW BYTE RANGES of the region cut's parquet tables ─────────────
The transport under the PARQUET MIRROR (`korp::map_mirror`, off by default):
a client that holds a sparse copy of the server's `ways.parquet` fills it in
by asking for the byte ranges of the row-group column chunks its viewport
needs, and thereafter answers that ground itself -- at any budget, offline,
with no reply to cook. The client decides WHICH ranges (its own footer, its
own prune); this RPC only hands over bytes at offsets. That is why it has no
notion of a viewport: the same call serves an HTTP range GET, an S3 read or
a USB stick, and the shared leaf that plans the ranges
(`nornir-parquet-delta`) knows nothing about korp.
`length = 0` is the DESCRIBE call: the reply carries `file_len` + `version`
and no body, which is how a client learns the file's size before it can even
ask for the footer. RBAC is the same Reader role on the same asset MapQuery
takes -- these are the same bytes MapQuery already serves, uncooked.
proto3-additive: an older server does not have it (the client falls back to
the cooked MapQuery path, which is what it does today anyway), and an older
client never calls it.
"""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def Populate(self, request, context):
"""── server-side GENERATE (Populate) ──────────────────────────────────────
Run a zone DATA GENERATE on the SERVER, streaming staged progress back. The
server (the FAT node — it owns the `containers`/draupnir OCI engine) brings up
the zone's FalkorDB (+ Spark), then runs knut's parallel graph fill and verifies
it — the SAME work a fat `korp-ui` does in-process, but SERVER-SIDE. A THIN
`korp --server` (which may be a phone/laptop with NO container engine) TRIGGERS
this instead of spinning its own cores/containers: its UI stays idle while the
server generates. proto3-additive — an older server safely ignores this new RPC.
"""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def IcebergTables(self, request, context):
"""── Analysis-mode reads: the Iceberg browser + Population diagrams ────────
The Iceberg CATALOG — every table with its schema + row/snapshot stats (the
📊 Population browser's table list). The server reads its bound skade warehouse
through korp's trait'd Warehouse seam, so a THIN client fills the browser with
ZERO local scan. proto3-additive — an older server safely ignores it (the pane
then shows the honest empty state).
"""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def TablePreview(self, request, context):
"""A selected table's SCHEMA + a capped ROW PREVIEW of its current snapshot, cells
formatted to display strings server-side (no Arrow on the thin client).
"""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def AdhocSql(self, request, context):
"""AD-HOC SQL over the server's bound Iceberg warehouse — the 🧮 query editor beside
the 📊 Population browser. The server runs the SQL through korp's trait'd Warehouse
seam (skade's embedded DataFusion engine), caps the returned rows, and hands back a
ready-stringified result set (columns + types + rows) with the scanned row count and
wall-clock timing — so a THIN client renders the table with ZERO local SQL engine and
ZERO warehouse scan. A rejected query comes back as an HONEST TYPED error in `error`
(a tagged `DiagCode`, never a blank/false-green). proto3-additive — an older server
safely ignores this new RPC (the pane then shows the honest "not available" state).
"""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def Population(self, request, context):
"""POPULATION aggregates over the demo population warehouse — row-count-by-table
across the whole population + a group-by over the largest table — the feed for
the 📊 Population diagrams (aggregate tables + bar charts).
"""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def ListGraphs(self, request, context):
"""── Analysis-mode: FalkorDB graph SCHEMA browser + graph LIST (thin path) ──
The FalkorDB graphs available on the server's connection — the 🕸 schema
browser's graph picker. The server runs `GRAPH.LIST` against its bound FalkorDB
(or names the demo graph when no live backend is bound), so a THIN client fills
the picker with ZERO local FalkorDB — it never dials its own dead localhost.
proto3-additive — an older server safely ignores this new RPC (the picker then
shows the honest empty state).
"""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def GraphSchema(self, request, context):
"""One graph's SCHEMA + size (node labels / relationship types / property keys /
node+edge counts) — the schema pane's "what's in here?" summary before a query.
Read SERVER-SIDE (LIVE FalkorDB, or the seed-derived schema with the reason in
`error`), so a THIN client shows the SAME schema a fat build reads. Twin of
korp's `GraphSchemaView`. proto3-additive — an older server safely ignores it.
"""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def ListPipelines(self, request, context):
"""── the PIPELINES RELAY — a THIN client's Spark ───────────────────────────
korp's control plane had SIXTEEN RPCs and not one of them was a pipeline verb
(`grep -i pipeline` over control.rs + this file returned nothing), so the ⭐
thin `korp-ui` could never see a Spark pipeline no matter which atom declared
`live-pipelines`. That is not an oversight about a niche pane: korp-server runs
on the box where the Spark container actually is, published on THAT box's
loopback, so a laptop client cannot dial `sc://` at all. The server reaching
and the client receiving is how every other pane here already works.
WHAT the server can run — the authored pipeline PLANS it carries, plus its own
sc:// endpoint and whether this BUILD can run one at all. An older server
ignores this RPC (proto3-additive) and the pane shows the honest empty state.
"""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def PipelinesFor(self, request, context):
"""The pipelines a configured backend ROW holds, with state — the 🏬 Warehouse ▸
🧵 Pipelines explorer's list (`KorpObject::list_pipelines_for`): SDPs on a Spark
row (list over Spark Connect), knut plans on a skade row. proto3-additive.
"""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def RunPipelineFor(self, request, context):
"""▶ RUN one KNUT PLAN on a configured backend ROW, in-process on the server, as
a TRACKED JOB — the jobs ledger is the ONE writer of its state, and
`PipelinesFor` reads it back (`running` / `done` / `failed`). The reply is the
RECEIPT (the job was accepted, its ledger target), never the outcome. A Spark
row refuses (`korp-warehouse-35` — SDP is its run path); a roster with no
falkor row refuses (`korp-warehouse-36` — the LAND step has no graph sink).
Writer role, scoped to the row key. proto3-additive. (`RunPipeline` below is
the SDP relay STREAM — a different verb for a different engine.)
"""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def RecordJob(self, request, context):
"""**APPEND one job-ledger row**, written by a THIN client whose own local store is
withheld by design. korp-v2 row 1: ONE SERVER OWNS THE JOBS.
Until this verb existed a thin korp had no door to the ledger at all — `jobs::sink()`
fell to `JobSink::noop()` and every tracked op's running/done/failed row was dropped,
while the 🧰 Jobs banner said so in prose ("N local jobs ran in this session, recorded
nowhere"). Reading already worked: the server's own rows ride the Hugin state blob.
`record_json` is a serialized jera `JobRecord`, NOT a mirrored proto message. That is
deliberate: the record's own doc says `detail_json`/`result_ref` are free-form "so the
record never needs a schema migration as new ops adopt the ledger", and mirroring the
struct field-for-field would import exactly the migration problem that shape exists to
avoid. The server upserts it into its OWN ledger and stamps the node, so a reader can
tell a client's row from the server's.
Best-effort by contract: `error` non-empty means the row was NOT recorded, and the
caller counts it as lost rather than retrying — a ledger hiccup must never abort the
op it tracks. Writer role. proto3-additive.
"""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def JobLedger(self, request, context):
"""**READ the server's job ledger** — lane JJ, 2026-09-05.
`RecordJob` above is WRITE-only, and until this verb existed that was the whole
jobs surface: a thin client could put its own rows INTO the server's ledger and
had no way to read any row back. So the 🧰 Jobs tab listed the collector STEP
BOARD off the Hugin stream and nothing else, while its banner promised "the job
ledger lives on the server" — an empty list under a sentence claiming otherwise.
Reader role. proto3-additive: an older server ignores it and the tab then shows
exactly what it showed before, rather than an error.
"""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def RunPipeline(self, request, context):
"""RUN one, server-side, streaming the fold back tick by tick — the same shape
`Populate` uses for the server-side generate. The SERVER owns the
`PipelinesClient` connection; the client never dials `sc://`.
"""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def SetInfra(self, request, context):
"""── the INFRA CHOICE — the first-start popup's Confirm, on the SERVER ──────
A thin `korp-ui --server` used to write the popup's choice into the CLIENT's
config file and start nothing: korp-server read its own config as its own user
and never heard. This RPC is that Confirm where the backends actually live: the
server persists `chosen_infra` (+ the roster it implies) into ITS config and walks
the roster through the ONE policy engine (`korp::backend::ensure_all_started`),
returning what every row did — started / reused / refused, with the endpoint and
the typed reason. A Writer-role mutation. It never restarts korp-server.
proto3-additive — an older server safely ignores it (the popup then says so).
"""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def Backends(self, request, context):
"""The SERVER's backend roster — its chosen infra + one section per configured row,
PROBED FROM THE SERVER. A thin client's 🏬 Backends section used to be built from
the CLIENT's config and probed from the client machine (spark41 ○ down on t14s
while the container was up on oden). One source of truth: this. proto3-additive.
"""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def StartBackend(self, request, context):
"""Start ONE configured row on the server through the SAME policy engine `SetInfra`
uses (`korp::backend::ensure_kind_started`) — the 🏬 `[start]` chip of a thin
client. `start = no` on the row is a typed refusal, nothing started. Writer role.
"""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def Objects(self, request, context):
"""── the OBJECT REGISTRY (lane OR) ──────────────────────────────────────────
ONE roster of every object korp holds, replacing nine "tell me about family X"
verbs with one. Measured 2026-09-04: of those nine, exactly ONE carried a state
on the wire (`BackendSection.status`), so a collector's readiness, a region's cut
depth and a graph's reachability each had their own shape or none at all.
A REGISTRY, never a transport: it answers what exists and what state it is in,
and it NEVER reads data — `MapQuery`, `AdhocSql`, `Collect`, `RunPipelineFor`,
`Geocode` take an object id and do the work. Reader role. proto3-additive.
"""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def PopulateOpenData(self, request, context):
"""── the data-WRITING tools — they land where the views list ─────────────────
The owner, 2026-09-01: "the tools generate data and tables, you need to make the
tab find the tables." Each of these runs on the SERVER as the service user and
lands through `Streaming::land` into the CONFIGURED ROW named by `backend`
(empty ⇒ the chosen infra's lake row) — the same row, the same location, the
`Tables { backend }` view lists. A thin client writes NOTHING on its own
machine. The reply names the tables + rows AS THE WAREHOUSE COUNTED THEM.
Writer role. proto3-additive — an older server safely ignores them.
🌐 Populate — the Sweden open-data catalogue (fixtures, or live collectors).
"""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def Collect(self, request, context):
"""📡 Collect ONE source: `what` = `demo:<feed>` (boats · planes · energy · roads)
or a registry collector name (`polisen-events`, …).
"""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def LoadIceberg(self, request, context):
"""🧊 knut ▸ Spark 4.1 + Iceberg load against the configured `spark41` row.
"""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def RoadGraph(self, request, context):
"""── the ROAD/RAIL GRAPH QUESTIONS (lane d-road-graph) — READ-ONLY ──────────
One RPC, eight questions (`question` = route · isochrone · nearest · follow ·
crossings · chokepoints · components · catchment, plus the cheap `stats`): the
server answers off the region's graph_edges/graph_nodes cut through the ONE
in-process engine (`korp::roadgraph`, CSR memoised), so a thin client asks
"what subway station is nearest" with zero local parquet. Reader role — no
question writes anything. A refusal is a typed `korp-roadgraph-<n>` carried in
the reply's `error` (LAW #6 loud, never blank). proto3-additive — an older
server safely ignores it (the pane then says the server predates the verb).
"""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def GraphSlice(self, request, context):
"""── GRAPH SLICE — the viewport's roads and rails, landed in the graph store ──
The one WRITE on the road-graph surface, and its own RPC for exactly that
reason: RoadGraph is Reader-role and must stay so. The server cuts the bbox
sub-graph out of the memoised CSR, prices it against the FalkorDB
container's cgroup `memory.max` through the SAME model the zone generate
uses (a projection that does not fit is `korp-infra-9`, refused before a
single blob is encoded), then bulk-loads it through knut's GRAPH.BULK
loader. The reply is a RECEIPT — counts, milliseconds, blob bytes, the
truncation and its reason — never the sub-graph: it lands in the STORE, and
the explorer finds it there because FalkorDB lists it. Writer role, scoped
to the region. proto3-additive.
"""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def GeoHotspots(self, request, context):
"""── GEO HOTSPOTS — the 📍 Geo view's load+cluster, SERVER-SIDE (lane W2a) ──
The client used to run korp::geo::load_from_iceberg/falkor IN-PROCESS from
free-text fields, assuming a `Person` table wherever $KORP_WAREHOUSE
pointed. The server now reads the BOUND LAKE ROW's landed person-typed
table (presence-gated via the row's own catalog — a missing table is an
honest "not landed", never a read fault), clusters server-side, and the
thin client renders the reply. Reader role. proto3-additive.
"""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def MapLayerRows(self, request, context):
"""── LANDED MAP LAYERS — a collector layer's rows off the bound row (W2a) ───
The map's collector layers used to synthesise rows CLIENT-SIDE from the
sample generator; this reads what `Streaming::land` actually wrote
(`demo_ais_positions` …), presence-gated per layer — an absent table is an
honest "not landed" the client greys the toggle with. Reader role.
"""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def Geocode(self, request, context):
"""── ADDRESS GEOCODING — read-only over the cut's address index (step g) ────
The 🗺 Map pane's address box: free text ("storgatan 5 uppsala") → ranked
street+number+city matches with lonlat (distance-free scoring: exact number
> street prefix > city filter — a wrong city is REFUSED, see
`.nornir/address-design.md`). Served from the server's own
`<cut>/address.parquet` + its memoised in-RAM index, so a thin client holds
no address file. Reader role. proto3-additive — an older server safely
ignores both RPCs (the address box then surfaces the transport's refusal).
"""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def RevGeocode(self, request, context):
"""The same book read backwards: a lonlat → the nearest address + its distance.
"""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def WarehouseCatalog(self, request, context):
"""── the CATALOG BROWSE (lane w2b) — READ-ONLY ──────────────────────────────
One configured row's whole catalog: every table the row's Warehouse lists,
with rows/snapshots/schema (the 🧊 attach-and-browse lane). The server opens
ITS row; the catalog name comes from the ROW's config (DEFAULT_SPARK_CATALOG
on a Spark row, the row's skade location otherwise), never a client literal.
Reader role. proto3-additive — an older server safely ignores it.
"""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def Collectors(self, request, context):
"""── the COLLECTOR REGISTRY (lane w2b) — READ-ONLY ──────────────────────────
The registered collectors of the process that RUNS them (the server, on a
thin client): the Ingest/Facets roster rows (name·source·target·direction,
the leaf descriptors' own words) plus the ⚙ Settings sections with each
collector's live status. A thin korp-ui carries no `collectors` feature —
without this verb its Collectors pane and Facets tree were permanently
empty. Reader role. proto3-additive — an older server safely ignores it.
"""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def SetCollectorEnabled(self, request, context):
"""**Flip ONE collector's enable flag on the SERVER**, and start/stop it now.
The checkbox in the 📡 pane used to write only the CLIENT's own config file, so on
a thin client (korp-ui, which links no collector crate at all) it changed nothing
that runs anything — the box moved and the server never heard. Writer role.
"""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def add_KorpControlServicer_to_server(servicer, server):
rpc_method_handlers = {
'StreamState': grpc.unary_stream_rpc_method_handler(
servicer.StreamState,
request_deserializer=korp__pb2.StreamRequest.FromString,
response_serializer=korp__pb2.StateUpdate.SerializeToString,
),
'ListCases': grpc.unary_unary_rpc_method_handler(
servicer.ListCases,
request_deserializer=korp__pb2.CasesRequest.FromString,
response_serializer=korp__pb2.CasesReply.SerializeToString,
),
'PopulateDemoCases': grpc.unary_unary_rpc_method_handler(
servicer.PopulateDemoCases,
request_deserializer=korp__pb2.PopulateDemoCasesRequest.FromString,
response_serializer=korp__pb2.PopulateDemoCasesReply.SerializeToString,
),
'Health': grpc.unary_unary_rpc_method_handler(
servicer.Health,
request_deserializer=korp__pb2.HealthRequest.FromString,
response_serializer=korp__pb2.HealthReply.SerializeToString,
),
'Search': grpc.unary_unary_rpc_method_handler(
servicer.Search,
request_deserializer=korp__pb2.SearchRequest.FromString,
response_serializer=korp__pb2.SearchReply.SerializeToString,
),
'Timeline': grpc.unary_unary_rpc_method_handler(
servicer.Timeline,
request_deserializer=korp__pb2.TimelineRequest.FromString,
response_serializer=korp__pb2.TimelineReply.SerializeToString,
),
'Graph': grpc.unary_unary_rpc_method_handler(
servicer.Graph,
request_deserializer=korp__pb2.GraphRequest.FromString,
response_serializer=korp__pb2.GraphReply.SerializeToString,
),
'Tables': grpc.unary_unary_rpc_method_handler(
servicer.Tables,
request_deserializer=korp__pb2.TablesRequest.FromString,
response_serializer=korp__pb2.TablesReply.SerializeToString,
),
'Assets': grpc.unary_unary_rpc_method_handler(
servicer.Assets,
request_deserializer=korp__pb2.AssetsRequest.FromString,
response_serializer=korp__pb2.AssetsReply.SerializeToString,
),
'MapQuery': grpc.unary_unary_rpc_method_handler(
servicer.MapQuery,
request_deserializer=korp__pb2.MapQueryRequest.FromString,
response_serializer=korp__pb2.MapQueryReply.SerializeToString,
),
'MapQueryStream': grpc.unary_stream_rpc_method_handler(
servicer.MapQueryStream,
request_deserializer=korp__pb2.MapQueryViewport.FromString,
response_serializer=korp__pb2.MapQueryReply.SerializeToString,
),
'MapFile': grpc.unary_unary_rpc_method_handler(
servicer.MapFile,
request_deserializer=korp__pb2.MapFileRequest.FromString,
response_serializer=korp__pb2.MapFileReply.SerializeToString,
),
'Populate': grpc.unary_stream_rpc_method_handler(
servicer.Populate,
request_deserializer=korp__pb2.PopulateRequest.FromString,
response_serializer=korp__pb2.GenProgressUpdate.SerializeToString,
),
'IcebergTables': grpc.unary_unary_rpc_method_handler(
servicer.IcebergTables,
request_deserializer=korp__pb2.IcebergTablesRequest.FromString,
response_serializer=korp__pb2.IcebergTablesReply.SerializeToString,
),
'TablePreview': grpc.unary_unary_rpc_method_handler(
servicer.TablePreview,
request_deserializer=korp__pb2.TablePreviewRequest.FromString,
response_serializer=korp__pb2.TablePreviewReply.SerializeToString,
),
'AdhocSql': grpc.unary_unary_rpc_method_handler(
servicer.AdhocSql,
request_deserializer=korp__pb2.AdhocSqlRequest.FromString,
response_serializer=korp__pb2.AdhocSqlReply.SerializeToString,
),
'Population': grpc.unary_unary_rpc_method_handler(
servicer.Population,
request_deserializer=korp__pb2.PopulationRequest.FromString,
response_serializer=korp__pb2.PopulationReply.SerializeToString,
),
'ListGraphs': grpc.unary_unary_rpc_method_handler(
servicer.ListGraphs,
request_deserializer=korp__pb2.ListGraphsRequest.FromString,
response_serializer=korp__pb2.ListGraphsReply.SerializeToString,
),
'GraphSchema': grpc.unary_unary_rpc_method_handler(
servicer.GraphSchema,
request_deserializer=korp__pb2.GraphSchemaRequest.FromString,
response_serializer=korp__pb2.GraphSchemaReply.SerializeToString,
),
'ListPipelines': grpc.unary_unary_rpc_method_handler(
servicer.ListPipelines,
request_deserializer=korp__pb2.ListPipelinesRequest.FromString,
response_serializer=korp__pb2.ListPipelinesReply.SerializeToString,
),
'PipelinesFor': grpc.unary_unary_rpc_method_handler(
servicer.PipelinesFor,
request_deserializer=korp__pb2.PipelinesForRequest.FromString,
response_serializer=korp__pb2.PipelinesForReply.SerializeToString,
),
'RunPipelineFor': grpc.unary_unary_rpc_method_handler(
servicer.RunPipelineFor,
request_deserializer=korp__pb2.RunPipelineForRequest.FromString,
response_serializer=korp__pb2.RunPipelineForReply.SerializeToString,
),
'RecordJob': grpc.unary_unary_rpc_method_handler(
servicer.RecordJob,
request_deserializer=korp__pb2.RecordJobRequest.FromString,
response_serializer=korp__pb2.RecordJobReply.SerializeToString,
),
'JobLedger': grpc.unary_unary_rpc_method_handler(
servicer.JobLedger,
request_deserializer=korp__pb2.JobLedgerRequest.FromString,
response_serializer=korp__pb2.JobLedgerReply.SerializeToString,
),
'RunPipeline': grpc.unary_stream_rpc_method_handler(
servicer.RunPipeline,
request_deserializer=korp__pb2.RunPipelineRequest.FromString,
response_serializer=korp__pb2.PipelineUpdate.SerializeToString,
),
'SetInfra': grpc.unary_unary_rpc_method_handler(
servicer.SetInfra,
request_deserializer=korp__pb2.SetInfraRequest.FromString,
response_serializer=korp__pb2.SetInfraReply.SerializeToString,
),
'Backends': grpc.unary_unary_rpc_method_handler(
servicer.Backends,
request_deserializer=korp__pb2.BackendsRequest.FromString,
response_serializer=korp__pb2.BackendsReply.SerializeToString,
),
'StartBackend': grpc.unary_unary_rpc_method_handler(
servicer.StartBackend,
request_deserializer=korp__pb2.StartBackendRequest.FromString,
response_serializer=korp__pb2.StartBackendReply.SerializeToString,
),
'Objects': grpc.unary_unary_rpc_method_handler(
servicer.Objects,
request_deserializer=korp__pb2.ObjectsRequest.FromString,
response_serializer=korp__pb2.ObjectsReply.SerializeToString,
),
'PopulateOpenData': grpc.unary_unary_rpc_method_handler(
servicer.PopulateOpenData,
request_deserializer=korp__pb2.PopulateOpenDataRequest.FromString,
response_serializer=korp__pb2.LandReply.SerializeToString,
),
'Collect': grpc.unary_unary_rpc_method_handler(
servicer.Collect,
request_deserializer=korp__pb2.CollectRequest.FromString,
response_serializer=korp__pb2.LandReply.SerializeToString,
),
'LoadIceberg': grpc.unary_unary_rpc_method_handler(
servicer.LoadIceberg,
request_deserializer=korp__pb2.LoadIcebergRequest.FromString,
response_serializer=korp__pb2.LandReply.SerializeToString,
),
'RoadGraph': grpc.unary_unary_rpc_method_handler(
servicer.RoadGraph,
request_deserializer=korp__pb2.RoadGraphRequest.FromString,
response_serializer=korp__pb2.RoadGraphReply.SerializeToString,
),
'GraphSlice': grpc.unary_unary_rpc_method_handler(
servicer.GraphSlice,
request_deserializer=korp__pb2.GraphSliceRequest.FromString,
response_serializer=korp__pb2.GraphSliceReply.SerializeToString,
),
'GeoHotspots': grpc.unary_unary_rpc_method_handler(
servicer.GeoHotspots,
request_deserializer=korp__pb2.GeoHotspotsRequest.FromString,
response_serializer=korp__pb2.GeoHotspotsReply.SerializeToString,
),
'MapLayerRows': grpc.unary_unary_rpc_method_handler(
servicer.MapLayerRows,
request_deserializer=korp__pb2.MapLayerRowsRequest.FromString,
response_serializer=korp__pb2.MapLayerRowsReply.SerializeToString,
),
'Geocode': grpc.unary_unary_rpc_method_handler(
servicer.Geocode,
request_deserializer=korp__pb2.GeocodeRequest.FromString,
response_serializer=korp__pb2.GeocodeReply.SerializeToString,
),
'RevGeocode': grpc.unary_unary_rpc_method_handler(
servicer.RevGeocode,
request_deserializer=korp__pb2.RevGeocodeRequest.FromString,
response_serializer=korp__pb2.RevGeocodeReply.SerializeToString,
),
'WarehouseCatalog': grpc.unary_unary_rpc_method_handler(
servicer.WarehouseCatalog,
request_deserializer=korp__pb2.WarehouseCatalogRequest.FromString,
response_serializer=korp__pb2.WarehouseCatalogReply.SerializeToString,
),
'Collectors': grpc.unary_unary_rpc_method_handler(
servicer.Collectors,
request_deserializer=korp__pb2.CollectorsRequest.FromString,
response_serializer=korp__pb2.CollectorsReply.SerializeToString,
),
'SetCollectorEnabled': grpc.unary_unary_rpc_method_handler(
servicer.SetCollectorEnabled,
request_deserializer=korp__pb2.SetCollectorEnabledRequest.FromString,
response_serializer=korp__pb2.SetCollectorEnabledReply.SerializeToString,
),
}
generic_handler = grpc.method_handlers_generic_handler(
'korp.KorpControl', rpc_method_handlers)
server.add_generic_rpc_handlers((generic_handler,))
server.add_registered_method_handlers('korp.KorpControl', rpc_method_handlers)
# This class is part of an EXPERIMENTAL API.
class KorpControl:
"""Korp control plane — Odin's ravens over the wire.
Hugin (live): stream the app's $KORP_STATE. Munin (memory): the investigations.
Beyond the two ravens, KorpControl also exposes the QUERY RPCs the desktop
panes need so a `korp --server <url>` thin client fills the SAME views a fat
(in-process LocalKorp) build does — one RPC per pane, mirroring nornir's
Viz/Warehouse read services. The server answers each by delegating to an
in-process LocalKorp (the fat node), so there is ONE reads implementation.
"""
@staticmethod
def StreamState(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.unary_stream(
request,
target,
'/korp.KorpControl/StreamState',
korp__pb2.StreamRequest.SerializeToString,
korp__pb2.StateUpdate.FromString,
options,
channel_credentials,
insecure,
call_credentials,
compression,
wait_for_ready,
timeout,
metadata,
_registered_method=True)
@staticmethod
def ListCases(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.unary_unary(
request,
target,
'/korp.KorpControl/ListCases',
korp__pb2.CasesRequest.SerializeToString,
korp__pb2.CasesReply.FromString,
options,
channel_credentials,
insecure,
call_credentials,
compression,
wait_for_ready,
timeout,
metadata,
_registered_method=True)
@staticmethod
def PopulateDemoCases(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.unary_unary(
request,
target,
'/korp.KorpControl/PopulateDemoCases',
korp__pb2.PopulateDemoCasesRequest.SerializeToString,
korp__pb2.PopulateDemoCasesReply.FromString,
options,
channel_credentials,
insecure,
call_credentials,
compression,
wait_for_ready,
timeout,
metadata,
_registered_method=True)
@staticmethod
def Health(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.unary_unary(
request,
target,
'/korp.KorpControl/Health',
korp__pb2.HealthRequest.SerializeToString,
korp__pb2.HealthReply.FromString,
options,
channel_credentials,
insecure,
call_credentials,
compression,
wait_for_ready,
timeout,
metadata,
_registered_method=True)
@staticmethod
def Search(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.unary_unary(
request,
target,
'/korp.KorpControl/Search',
korp__pb2.SearchRequest.SerializeToString,
korp__pb2.SearchReply.FromString,
options,
channel_credentials,
insecure,
call_credentials,
compression,
wait_for_ready,
timeout,
metadata,
_registered_method=True)
@staticmethod
def Timeline(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.unary_unary(
request,
target,
'/korp.KorpControl/Timeline',
korp__pb2.TimelineRequest.SerializeToString,
korp__pb2.TimelineReply.FromString,
options,
channel_credentials,
insecure,
call_credentials,
compression,
wait_for_ready,
timeout,
metadata,
_registered_method=True)
@staticmethod
def Graph(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.unary_unary(
request,
target,
'/korp.KorpControl/Graph',
korp__pb2.GraphRequest.SerializeToString,
korp__pb2.GraphReply.FromString,
options,
channel_credentials,
insecure,
call_credentials,
compression,
wait_for_ready,
timeout,
metadata,
_registered_method=True)
@staticmethod
def Tables(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.unary_unary(
request,
target,
'/korp.KorpControl/Tables',
korp__pb2.TablesRequest.SerializeToString,
korp__pb2.TablesReply.FromString,
options,
channel_credentials,
insecure,
call_credentials,
compression,
wait_for_ready,
timeout,
metadata,
_registered_method=True)
@staticmethod
def Assets(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.unary_unary(
request,
target,
'/korp.KorpControl/Assets',
korp__pb2.AssetsRequest.SerializeToString,
korp__pb2.AssetsReply.FromString,
options,
channel_credentials,
insecure,
call_credentials,
compression,
wait_for_ready,
timeout,
metadata,
_registered_method=True)
@staticmethod
def MapQuery(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.unary_unary(
request,
target,
'/korp.KorpControl/MapQuery',
korp__pb2.MapQueryRequest.SerializeToString,
korp__pb2.MapQueryReply.FromString,
options,
channel_credentials,
insecure,
call_credentials,
compression,
wait_for_ready,
timeout,
metadata,
_registered_method=True)
@staticmethod
def MapQueryStream(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.unary_stream(
request,
target,
'/korp.KorpControl/MapQueryStream',
korp__pb2.MapQueryViewport.SerializeToString,
korp__pb2.MapQueryReply.FromString,
options,
channel_credentials,
insecure,
call_credentials,
compression,
wait_for_ready,
timeout,
metadata,
_registered_method=True)
@staticmethod
def MapFile(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.unary_unary(
request,
target,
'/korp.KorpControl/MapFile',
korp__pb2.MapFileRequest.SerializeToString,
korp__pb2.MapFileReply.FromString,
options,
channel_credentials,
insecure,
call_credentials,
compression,
wait_for_ready,
timeout,
metadata,
_registered_method=True)
@staticmethod
def Populate(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.unary_stream(
request,
target,
'/korp.KorpControl/Populate',
korp__pb2.PopulateRequest.SerializeToString,
korp__pb2.GenProgressUpdate.FromString,
options,
channel_credentials,
insecure,
call_credentials,
compression,
wait_for_ready,
timeout,
metadata,
_registered_method=True)
@staticmethod
def IcebergTables(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.unary_unary(
request,
target,
'/korp.KorpControl/IcebergTables',
korp__pb2.IcebergTablesRequest.SerializeToString,
korp__pb2.IcebergTablesReply.FromString,
options,
channel_credentials,
insecure,
call_credentials,
compression,
wait_for_ready,
timeout,
metadata,
_registered_method=True)
@staticmethod
def TablePreview(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.unary_unary(
request,
target,
'/korp.KorpControl/TablePreview',
korp__pb2.TablePreviewRequest.SerializeToString,
korp__pb2.TablePreviewReply.FromString,
options,
channel_credentials,
insecure,
call_credentials,
compression,
wait_for_ready,
timeout,
metadata,
_registered_method=True)
@staticmethod
def AdhocSql(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.unary_unary(
request,
target,
'/korp.KorpControl/AdhocSql',
korp__pb2.AdhocSqlRequest.SerializeToString,
korp__pb2.AdhocSqlReply.FromString,
options,
channel_credentials,
insecure,
call_credentials,
compression,
wait_for_ready,
timeout,
metadata,
_registered_method=True)
@staticmethod
def Population(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.unary_unary(
request,
target,
'/korp.KorpControl/Population',
korp__pb2.PopulationRequest.SerializeToString,
korp__pb2.PopulationReply.FromString,
options,
channel_credentials,
insecure,
call_credentials,
compression,
wait_for_ready,
timeout,
metadata,
_registered_method=True)
@staticmethod
def ListGraphs(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.unary_unary(
request,
target,
'/korp.KorpControl/ListGraphs',
korp__pb2.ListGraphsRequest.SerializeToString,
korp__pb2.ListGraphsReply.FromString,
options,
channel_credentials,
insecure,
call_credentials,
compression,
wait_for_ready,
timeout,
metadata,
_registered_method=True)
@staticmethod
def GraphSchema(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.unary_unary(
request,
target,
'/korp.KorpControl/GraphSchema',
korp__pb2.GraphSchemaRequest.SerializeToString,
korp__pb2.GraphSchemaReply.FromString,
options,
channel_credentials,
insecure,
call_credentials,
compression,
wait_for_ready,
timeout,
metadata,
_registered_method=True)
@staticmethod
def ListPipelines(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.unary_unary(
request,
target,
'/korp.KorpControl/ListPipelines',
korp__pb2.ListPipelinesRequest.SerializeToString,
korp__pb2.ListPipelinesReply.FromString,
options,
channel_credentials,
insecure,
call_credentials,
compression,
wait_for_ready,
timeout,
metadata,
_registered_method=True)
@staticmethod
def PipelinesFor(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.unary_unary(
request,
target,
'/korp.KorpControl/PipelinesFor',
korp__pb2.PipelinesForRequest.SerializeToString,
korp__pb2.PipelinesForReply.FromString,
options,
channel_credentials,
insecure,
call_credentials,
compression,
wait_for_ready,
timeout,
metadata,
_registered_method=True)
@staticmethod
def RunPipelineFor(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.unary_unary(
request,
target,
'/korp.KorpControl/RunPipelineFor',
korp__pb2.RunPipelineForRequest.SerializeToString,
korp__pb2.RunPipelineForReply.FromString,
options,
channel_credentials,
insecure,
call_credentials,
compression,
wait_for_ready,
timeout,
metadata,
_registered_method=True)
@staticmethod
def RecordJob(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.unary_unary(
request,
target,
'/korp.KorpControl/RecordJob',
korp__pb2.RecordJobRequest.SerializeToString,
korp__pb2.RecordJobReply.FromString,
options,
channel_credentials,
insecure,
call_credentials,
compression,
wait_for_ready,
timeout,
metadata,
_registered_method=True)
@staticmethod
def JobLedger(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.unary_unary(
request,
target,
'/korp.KorpControl/JobLedger',
korp__pb2.JobLedgerRequest.SerializeToString,
korp__pb2.JobLedgerReply.FromString,
options,
channel_credentials,
insecure,
call_credentials,
compression,
wait_for_ready,
timeout,
metadata,
_registered_method=True)
@staticmethod
def RunPipeline(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.unary_stream(
request,
target,
'/korp.KorpControl/RunPipeline',
korp__pb2.RunPipelineRequest.SerializeToString,
korp__pb2.PipelineUpdate.FromString,
options,
channel_credentials,
insecure,
call_credentials,
compression,
wait_for_ready,
timeout,
metadata,
_registered_method=True)
@staticmethod
def SetInfra(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.unary_unary(
request,
target,
'/korp.KorpControl/SetInfra',
korp__pb2.SetInfraRequest.SerializeToString,
korp__pb2.SetInfraReply.FromString,
options,
channel_credentials,
insecure,
call_credentials,
compression,
wait_for_ready,
timeout,
metadata,
_registered_method=True)
@staticmethod
def Backends(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.unary_unary(
request,
target,
'/korp.KorpControl/Backends',
korp__pb2.BackendsRequest.SerializeToString,
korp__pb2.BackendsReply.FromString,
options,
channel_credentials,
insecure,
call_credentials,
compression,
wait_for_ready,
timeout,
metadata,
_registered_method=True)
@staticmethod
def StartBackend(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.unary_unary(
request,
target,
'/korp.KorpControl/StartBackend',
korp__pb2.StartBackendRequest.SerializeToString,
korp__pb2.StartBackendReply.FromString,
options,
channel_credentials,
insecure,
call_credentials,
compression,
wait_for_ready,
timeout,
metadata,
_registered_method=True)
@staticmethod
def Objects(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.unary_unary(
request,
target,
'/korp.KorpControl/Objects',
korp__pb2.ObjectsRequest.SerializeToString,
korp__pb2.ObjectsReply.FromString,
options,
channel_credentials,
insecure,
call_credentials,
compression,
wait_for_ready,
timeout,
metadata,
_registered_method=True)
@staticmethod
def PopulateOpenData(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.unary_unary(
request,
target,
'/korp.KorpControl/PopulateOpenData',
korp__pb2.PopulateOpenDataRequest.SerializeToString,
korp__pb2.LandReply.FromString,
options,
channel_credentials,
insecure,
call_credentials,
compression,
wait_for_ready,
timeout,
metadata,
_registered_method=True)
@staticmethod
def Collect(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.unary_unary(
request,
target,
'/korp.KorpControl/Collect',
korp__pb2.CollectRequest.SerializeToString,
korp__pb2.LandReply.FromString,
options,
channel_credentials,
insecure,
call_credentials,
compression,
wait_for_ready,
timeout,
metadata,
_registered_method=True)
@staticmethod
def LoadIceberg(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.unary_unary(
request,
target,
'/korp.KorpControl/LoadIceberg',
korp__pb2.LoadIcebergRequest.SerializeToString,
korp__pb2.LandReply.FromString,
options,
channel_credentials,
insecure,
call_credentials,
compression,
wait_for_ready,
timeout,
metadata,
_registered_method=True)
@staticmethod
def RoadGraph(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.unary_unary(
request,
target,
'/korp.KorpControl/RoadGraph',
korp__pb2.RoadGraphRequest.SerializeToString,
korp__pb2.RoadGraphReply.FromString,
options,
channel_credentials,
insecure,
call_credentials,
compression,
wait_for_ready,
timeout,
metadata,
_registered_method=True)
@staticmethod
def GraphSlice(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.unary_unary(
request,
target,
'/korp.KorpControl/GraphSlice',
korp__pb2.GraphSliceRequest.SerializeToString,
korp__pb2.GraphSliceReply.FromString,
options,
channel_credentials,
insecure,
call_credentials,
compression,
wait_for_ready,
timeout,
metadata,
_registered_method=True)
@staticmethod
def GeoHotspots(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.unary_unary(
request,
target,
'/korp.KorpControl/GeoHotspots',
korp__pb2.GeoHotspotsRequest.SerializeToString,
korp__pb2.GeoHotspotsReply.FromString,
options,
channel_credentials,
insecure,
call_credentials,
compression,
wait_for_ready,
timeout,
metadata,
_registered_method=True)
@staticmethod
def MapLayerRows(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.unary_unary(
request,
target,
'/korp.KorpControl/MapLayerRows',
korp__pb2.MapLayerRowsRequest.SerializeToString,
korp__pb2.MapLayerRowsReply.FromString,
options,
channel_credentials,
insecure,
call_credentials,
compression,
wait_for_ready,
timeout,
metadata,
_registered_method=True)
@staticmethod
def Geocode(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.unary_unary(
request,
target,
'/korp.KorpControl/Geocode',
korp__pb2.GeocodeRequest.SerializeToString,
korp__pb2.GeocodeReply.FromString,
options,
channel_credentials,
insecure,
call_credentials,
compression,
wait_for_ready,
timeout,
metadata,
_registered_method=True)
@staticmethod
def RevGeocode(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.unary_unary(
request,
target,
'/korp.KorpControl/RevGeocode',
korp__pb2.RevGeocodeRequest.SerializeToString,
korp__pb2.RevGeocodeReply.FromString,
options,
channel_credentials,
insecure,
call_credentials,
compression,
wait_for_ready,
timeout,
metadata,
_registered_method=True)
@staticmethod
def WarehouseCatalog(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.unary_unary(
request,
target,
'/korp.KorpControl/WarehouseCatalog',
korp__pb2.WarehouseCatalogRequest.SerializeToString,
korp__pb2.WarehouseCatalogReply.FromString,
options,
channel_credentials,
insecure,
call_credentials,
compression,
wait_for_ready,
timeout,
metadata,
_registered_method=True)
@staticmethod
def Collectors(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.unary_unary(
request,
target,
'/korp.KorpControl/Collectors',
korp__pb2.CollectorsRequest.SerializeToString,
korp__pb2.CollectorsReply.FromString,
options,
channel_credentials,
insecure,
call_credentials,
compression,
wait_for_ready,
timeout,
metadata,
_registered_method=True)
@staticmethod
def SetCollectorEnabled(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.unary_unary(
request,
target,
'/korp.KorpControl/SetCollectorEnabled',
korp__pb2.SetCollectorEnabledRequest.SerializeToString,
korp__pb2.SetCollectorEnabledReply.FromString,
options,
channel_credentials,
insecure,
call_credentials,
compression,
wait_for_ready,
timeout,
metadata,
_registered_method=True)