1#[derive(Clone, PartialEq, ::prost::Message)]
3pub struct IngestSource {
4 #[prost(oneof = "ingest_source::Source", tags = "1, 2, 3, 4")]
5 pub source: ::core::option::Option<ingest_source::Source>,
6}
7pub mod ingest_source {
9 #[derive(Clone, PartialEq, ::prost::Oneof)]
10 pub enum Source {
11 #[prost(message, tag = "1")]
12 S3(super::S3IngestSource),
13 #[prost(message, tag = "2")]
14 Gcs(super::GcsIngestSource),
15 #[prost(message, tag = "3")]
16 PresignedFile(super::PresignedFileIngestSource),
17 #[prost(message, tag = "4")]
18 FileStore(super::FileStoreIngestSource),
19 }
20}
21#[derive(Clone, PartialEq, ::prost::Message)]
22pub struct S3IngestSource {
23 #[prost(string, tag = "1")]
24 pub path: ::prost::alloc::string::String,
25}
26#[derive(Clone, PartialEq, ::prost::Message)]
27pub struct GcsIngestSource {
28 #[prost(string, tag = "1")]
29 pub path: ::prost::alloc::string::String,
30}
31#[derive(Clone, PartialEq, ::prost::Message)]
32pub struct PresignedFileIngestSource {
33 #[prost(string, tag = "1")]
34 pub url: ::prost::alloc::string::String,
35}
36#[derive(Clone, PartialEq, ::prost::Message)]
37pub struct FileStoreIngestSource {
38 #[prost(string, tag = "1")]
39 pub file_revision_rid: ::prost::alloc::string::String,
40}
41#[derive(Clone, PartialEq, ::prost::Message)]
42pub struct TimestampMetadata {
43 #[prost(string, tag = "1")]
44 pub column: ::prost::alloc::string::String,
45 #[prost(message, optional, tag = "2")]
46 pub r#type: ::core::option::Option<super::super::types::time::TimestampType>,
47}
48#[derive(Clone, PartialEq, ::prost::Message)]
49pub struct ContainerizedExtractor {
50 #[prost(string, tag = "1")]
51 pub rid: ::prost::alloc::string::String,
52 #[prost(string, tag = "2")]
53 pub workspace_rid: ::prost::alloc::string::String,
54 #[prost(string, tag = "3")]
55 pub name: ::prost::alloc::string::String,
56 #[prost(string, optional, tag = "4")]
57 pub description: ::core::option::Option<::prost::alloc::string::String>,
58 #[prost(message, optional, tag = "5")]
59 pub created_at: ::core::option::Option<
60 super::super::super::google::protobuf::Timestamp,
61 >,
62 #[prost(bool, tag = "6")]
63 pub is_archived: bool,
64 #[prost(message, optional, tag = "7")]
65 pub active_container_image: ::core::option::Option<
66 super::super::registry::v2::ContainerImage,
67 >,
68}
69#[derive(Clone, PartialEq, ::prost::Message)]
70pub struct CreateContainerizedExtractorRequest {
71 #[prost(string, tag = "1")]
72 pub workspace_rid: ::prost::alloc::string::String,
73 #[prost(string, tag = "2")]
74 pub name: ::prost::alloc::string::String,
75 #[prost(string, optional, tag = "3")]
76 pub description: ::core::option::Option<::prost::alloc::string::String>,
77}
78#[derive(Clone, PartialEq, ::prost::Message)]
79pub struct CreateContainerizedExtractorResponse {
80 #[prost(message, optional, tag = "1")]
81 pub extractor: ::core::option::Option<ContainerizedExtractor>,
82}
83#[derive(Clone, PartialEq, ::prost::Message)]
84pub struct GetContainerizedExtractorRequest {
85 #[prost(string, tag = "1")]
86 pub rid: ::prost::alloc::string::String,
87 #[prost(string, tag = "2")]
88 pub workspace_rid: ::prost::alloc::string::String,
89}
90#[derive(Clone, PartialEq, ::prost::Message)]
91pub struct GetContainerizedExtractorResponse {
92 #[prost(message, optional, tag = "1")]
93 pub extractor: ::core::option::Option<ContainerizedExtractor>,
94}
95#[derive(Clone, PartialEq, ::prost::Message)]
96pub struct UpdateContainerizedExtractorRequest {
97 #[prost(string, tag = "1")]
98 pub rid: ::prost::alloc::string::String,
99 #[prost(string, tag = "2")]
100 pub workspace_rid: ::prost::alloc::string::String,
101 #[prost(string, optional, tag = "3")]
102 pub name: ::core::option::Option<::prost::alloc::string::String>,
103 #[prost(string, optional, tag = "4")]
104 pub description: ::core::option::Option<::prost::alloc::string::String>,
105 #[prost(bool, optional, tag = "5")]
106 pub is_archived: ::core::option::Option<bool>,
107 #[prost(string, optional, tag = "6")]
108 pub active_container_image_rid: ::core::option::Option<
109 ::prost::alloc::string::String,
110 >,
111}
112#[derive(Clone, PartialEq, ::prost::Message)]
113pub struct UpdateContainerizedExtractorResponse {
114 #[prost(message, optional, tag = "1")]
115 pub extractor: ::core::option::Option<ContainerizedExtractor>,
116}
117#[derive(Clone, PartialEq, ::prost::Message)]
118pub struct SearchContainerizedExtractorsRequest {
119 #[prost(string, tag = "1")]
120 pub workspace_rid: ::prost::alloc::string::String,
121 #[prost(bool, tag = "2")]
122 pub include_archived: bool,
123 #[prost(int32, tag = "3")]
124 pub page_size: i32,
125 #[prost(string, optional, tag = "4")]
126 pub next_page_token: ::core::option::Option<::prost::alloc::string::String>,
127 #[prost(string, optional, tag = "5")]
128 pub file_extension: ::core::option::Option<::prost::alloc::string::String>,
129}
130#[derive(Clone, PartialEq, ::prost::Message)]
131pub struct SearchContainerizedExtractorsResponse {
132 #[prost(message, repeated, tag = "1")]
133 pub extractors: ::prost::alloc::vec::Vec<ContainerizedExtractor>,
134 #[prost(string, optional, tag = "2")]
135 pub next_page_token: ::core::option::Option<::prost::alloc::string::String>,
136}
137pub mod containerized_extractor_service_client {
139 #![allow(
140 unused_variables,
141 dead_code,
142 missing_docs,
143 clippy::wildcard_imports,
144 clippy::let_unit_value,
145 )]
146 use tonic::codegen::*;
147 use tonic::codegen::http::Uri;
148 #[derive(Debug, Clone)]
149 pub struct ContainerizedExtractorServiceClient<T> {
150 inner: tonic::client::Grpc<T>,
151 }
152 impl ContainerizedExtractorServiceClient<tonic::transport::Channel> {
153 pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
155 where
156 D: TryInto<tonic::transport::Endpoint>,
157 D::Error: Into<StdError>,
158 {
159 let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
160 Ok(Self::new(conn))
161 }
162 }
163 impl<T> ContainerizedExtractorServiceClient<T>
164 where
165 T: tonic::client::GrpcService<tonic::body::Body>,
166 T::Error: Into<StdError>,
167 T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
168 <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
169 {
170 pub fn new(inner: T) -> Self {
171 let inner = tonic::client::Grpc::new(inner);
172 Self { inner }
173 }
174 pub fn with_origin(inner: T, origin: Uri) -> Self {
175 let inner = tonic::client::Grpc::with_origin(inner, origin);
176 Self { inner }
177 }
178 pub fn with_interceptor<F>(
179 inner: T,
180 interceptor: F,
181 ) -> ContainerizedExtractorServiceClient<InterceptedService<T, F>>
182 where
183 F: tonic::service::Interceptor,
184 T::ResponseBody: Default,
185 T: tonic::codegen::Service<
186 http::Request<tonic::body::Body>,
187 Response = http::Response<
188 <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
189 >,
190 >,
191 <T as tonic::codegen::Service<
192 http::Request<tonic::body::Body>,
193 >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
194 {
195 ContainerizedExtractorServiceClient::new(
196 InterceptedService::new(inner, interceptor),
197 )
198 }
199 #[must_use]
204 pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
205 self.inner = self.inner.send_compressed(encoding);
206 self
207 }
208 #[must_use]
210 pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
211 self.inner = self.inner.accept_compressed(encoding);
212 self
213 }
214 #[must_use]
218 pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
219 self.inner = self.inner.max_decoding_message_size(limit);
220 self
221 }
222 #[must_use]
226 pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
227 self.inner = self.inner.max_encoding_message_size(limit);
228 self
229 }
230 pub async fn create_containerized_extractor(
231 &mut self,
232 request: impl tonic::IntoRequest<super::CreateContainerizedExtractorRequest>,
233 ) -> std::result::Result<
234 tonic::Response<super::CreateContainerizedExtractorResponse>,
235 tonic::Status,
236 > {
237 self.inner
238 .ready()
239 .await
240 .map_err(|e| {
241 tonic::Status::unknown(
242 format!("Service was not ready: {}", e.into()),
243 )
244 })?;
245 let codec = tonic::codec::ProstCodec::default();
246 let path = http::uri::PathAndQuery::from_static(
247 "/nominal.ingest.v2.ContainerizedExtractorService/CreateContainerizedExtractor",
248 );
249 let mut req = request.into_request();
250 req.extensions_mut()
251 .insert(
252 GrpcMethod::new(
253 "nominal.ingest.v2.ContainerizedExtractorService",
254 "CreateContainerizedExtractor",
255 ),
256 );
257 self.inner.unary(req, path, codec).await
258 }
259 pub async fn get_containerized_extractor(
260 &mut self,
261 request: impl tonic::IntoRequest<super::GetContainerizedExtractorRequest>,
262 ) -> std::result::Result<
263 tonic::Response<super::GetContainerizedExtractorResponse>,
264 tonic::Status,
265 > {
266 self.inner
267 .ready()
268 .await
269 .map_err(|e| {
270 tonic::Status::unknown(
271 format!("Service was not ready: {}", e.into()),
272 )
273 })?;
274 let codec = tonic::codec::ProstCodec::default();
275 let path = http::uri::PathAndQuery::from_static(
276 "/nominal.ingest.v2.ContainerizedExtractorService/GetContainerizedExtractor",
277 );
278 let mut req = request.into_request();
279 req.extensions_mut()
280 .insert(
281 GrpcMethod::new(
282 "nominal.ingest.v2.ContainerizedExtractorService",
283 "GetContainerizedExtractor",
284 ),
285 );
286 self.inner.unary(req, path, codec).await
287 }
288 pub async fn update_containerized_extractor(
289 &mut self,
290 request: impl tonic::IntoRequest<super::UpdateContainerizedExtractorRequest>,
291 ) -> std::result::Result<
292 tonic::Response<super::UpdateContainerizedExtractorResponse>,
293 tonic::Status,
294 > {
295 self.inner
296 .ready()
297 .await
298 .map_err(|e| {
299 tonic::Status::unknown(
300 format!("Service was not ready: {}", e.into()),
301 )
302 })?;
303 let codec = tonic::codec::ProstCodec::default();
304 let path = http::uri::PathAndQuery::from_static(
305 "/nominal.ingest.v2.ContainerizedExtractorService/UpdateContainerizedExtractor",
306 );
307 let mut req = request.into_request();
308 req.extensions_mut()
309 .insert(
310 GrpcMethod::new(
311 "nominal.ingest.v2.ContainerizedExtractorService",
312 "UpdateContainerizedExtractor",
313 ),
314 );
315 self.inner.unary(req, path, codec).await
316 }
317 pub async fn search_containerized_extractors(
318 &mut self,
319 request: impl tonic::IntoRequest<super::SearchContainerizedExtractorsRequest>,
320 ) -> std::result::Result<
321 tonic::Response<super::SearchContainerizedExtractorsResponse>,
322 tonic::Status,
323 > {
324 self.inner
325 .ready()
326 .await
327 .map_err(|e| {
328 tonic::Status::unknown(
329 format!("Service was not ready: {}", e.into()),
330 )
331 })?;
332 let codec = tonic::codec::ProstCodec::default();
333 let path = http::uri::PathAndQuery::from_static(
334 "/nominal.ingest.v2.ContainerizedExtractorService/SearchContainerizedExtractors",
335 );
336 let mut req = request.into_request();
337 req.extensions_mut()
338 .insert(
339 GrpcMethod::new(
340 "nominal.ingest.v2.ContainerizedExtractorService",
341 "SearchContainerizedExtractors",
342 ),
343 );
344 self.inner.unary(req, path, codec).await
345 }
346 }
347}
348#[derive(Clone, PartialEq, ::prost::Message)]
349pub struct ContainerizedIngestItem {
350 #[prost(string, tag = "1")]
351 pub extractor_rid: ::prost::alloc::string::String,
352 #[prost(map = "string, message", tag = "2")]
353 pub sources: ::std::collections::HashMap<
354 ::prost::alloc::string::String,
355 IngestSource,
356 >,
357 #[prost(map = "string, string", tag = "3")]
358 pub arguments: ::std::collections::HashMap<
359 ::prost::alloc::string::String,
360 ::prost::alloc::string::String,
361 >,
362 #[prost(message, optional, tag = "4")]
363 pub timestamp_metadata: ::core::option::Option<TimestampMetadata>,
364}
365#[derive(Clone, PartialEq, ::prost::Message)]
366pub struct FileIngestItem {
367 #[prost(message, optional, tag = "1")]
368 pub source: ::core::option::Option<IngestSource>,
369 #[prost(message, optional, tag = "2")]
370 pub ingest: ::core::option::Option<FileIngestOptions>,
371}
372#[derive(Clone, PartialEq, ::prost::Message)]
373pub struct FileIngestOptions {
374 #[prost(message, optional, tag = "1")]
375 pub timestamp_metadata: ::core::option::Option<TimestampMetadata>,
376 #[prost(map = "string, string", tag = "2")]
377 pub units: ::std::collections::HashMap<
378 ::prost::alloc::string::String,
379 ::prost::alloc::string::String,
380 >,
381 #[prost(string, optional, tag = "3")]
382 pub channel_prefix: ::core::option::Option<::prost::alloc::string::String>,
383 #[prost(map = "string, string", tag = "7")]
384 pub channel_name_overrides: ::std::collections::HashMap<
385 ::prost::alloc::string::String,
386 ::prost::alloc::string::String,
387 >,
388 #[prost(oneof = "file_ingest_options::Ingest", tags = "4, 5, 6")]
389 pub ingest: ::core::option::Option<file_ingest_options::Ingest>,
390}
391pub mod file_ingest_options {
393 #[derive(Clone, PartialEq, ::prost::Oneof)]
394 pub enum Ingest {
395 #[prost(message, tag = "4")]
396 Csv(super::CsvIngestOptions),
397 #[prost(message, tag = "5")]
398 Parquet(super::ParquetIngestOptions),
399 #[prost(message, tag = "6")]
400 Avro(super::AvroIngestOptions),
401 }
402}
403#[derive(Clone, PartialEq, ::prost::Message)]
404pub struct CsvIngestOptions {
405 #[prost(message, optional, tag = "1")]
406 pub format: ::core::option::Option<CsvFormat>,
407}
408#[derive(Clone, PartialEq, ::prost::Message)]
409pub struct ParquetIngestOptions {
410 #[prost(message, optional, tag = "1")]
411 pub format: ::core::option::Option<ParquetFormat>,
412 #[prost(bool, tag = "2")]
413 pub is_archive: bool,
414}
415#[derive(Clone, Copy, PartialEq, ::prost::Message)]
416pub struct AvroIngestOptions {}
417#[derive(Clone, PartialEq, ::prost::Message)]
418pub struct CsvFormat {
419 #[prost(oneof = "csv_format::Format", tags = "1, 2")]
420 pub format: ::core::option::Option<csv_format::Format>,
421}
422pub mod csv_format {
424 #[derive(Clone, PartialEq, ::prost::Oneof)]
425 pub enum Format {
426 #[prost(message, tag = "1")]
427 Wide(super::WideFormat),
428 #[prost(message, tag = "2")]
429 Long(super::LongFormat),
430 }
431}
432#[derive(Clone, PartialEq, ::prost::Message)]
433pub struct ParquetFormat {
434 #[prost(oneof = "parquet_format::Format", tags = "1, 2")]
435 pub format: ::core::option::Option<parquet_format::Format>,
436}
437pub mod parquet_format {
439 #[derive(Clone, PartialEq, ::prost::Oneof)]
440 pub enum Format {
441 #[prost(message, tag = "1")]
442 Wide(super::WideFormat),
443 #[prost(message, tag = "2")]
444 Long(super::LongFormat),
445 }
446}
447#[derive(Clone, PartialEq, ::prost::Message)]
448pub struct WideFormat {
449 #[prost(map = "string, string", tag = "1")]
450 pub tag_columns: ::std::collections::HashMap<
451 ::prost::alloc::string::String,
452 ::prost::alloc::string::String,
453 >,
454 #[prost(string, repeated, tag = "2")]
455 pub exclude_columns: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
456}
457#[derive(Clone, PartialEq, ::prost::Message)]
458pub struct LongFormat {
459 #[prost(string, optional, tag = "1")]
460 pub channel_column: ::core::option::Option<::prost::alloc::string::String>,
461 #[prost(string, optional, tag = "2")]
462 pub value_column: ::core::option::Option<::prost::alloc::string::String>,
463 #[prost(string, optional, tag = "3")]
464 pub tags_column: ::core::option::Option<::prost::alloc::string::String>,
465}
466#[derive(Clone, PartialEq, ::prost::Message)]
467pub struct LogIngestItem {
468 #[prost(message, optional, tag = "1")]
469 pub source: ::core::option::Option<IngestSource>,
470 #[prost(string, optional, tag = "2")]
471 pub channel: ::core::option::Option<::prost::alloc::string::String>,
472 #[prost(message, optional, tag = "3")]
473 pub timestamp_metadata: ::core::option::Option<TimestampMetadata>,
474 #[prost(string, optional, tag = "4")]
475 pub message_field: ::core::option::Option<::prost::alloc::string::String>,
476}
477#[derive(Clone, PartialEq, ::prost::Message)]
478pub struct McapIngestItem {
479 #[prost(message, optional, tag = "1")]
480 pub source: ::core::option::Option<IngestSource>,
481 #[prost(message, optional, tag = "2")]
482 pub channels: ::core::option::Option<McapChannelSelection>,
483 #[prost(bool, tag = "3")]
484 pub ignore_invalid_topics: bool,
485}
486#[derive(Clone, PartialEq, ::prost::Message)]
487pub struct McapChannelSelection {
488 #[prost(oneof = "mcap_channel_selection::Selection", tags = "1, 2")]
489 pub selection: ::core::option::Option<mcap_channel_selection::Selection>,
490}
491pub mod mcap_channel_selection {
493 #[derive(Clone, PartialEq, ::prost::Oneof)]
494 pub enum Selection {
495 #[prost(message, tag = "1")]
496 IncludeTopics(super::McapTopicNames),
497 #[prost(message, tag = "2")]
498 ExcludeTopics(super::McapTopicNames),
499 }
500}
501#[derive(Clone, PartialEq, ::prost::Message)]
502pub struct McapTopicNames {
503 #[prost(string, repeated, tag = "1")]
504 pub topics: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
505}
506#[derive(Clone, PartialEq, ::prost::Message)]
507pub struct DataflashIngestItem {
508 #[prost(message, optional, tag = "1")]
509 pub source: ::core::option::Option<IngestSource>,
510}
511#[derive(Clone, PartialEq, ::prost::Message)]
512pub struct PointCloudIngestItem {
513 #[prost(message, optional, tag = "1")]
514 pub source: ::core::option::Option<IngestSource>,
515 #[prost(message, optional, tag = "2")]
516 pub ingest: ::core::option::Option<PointCloudIngestOptions>,
517}
518#[derive(Clone, PartialEq, ::prost::Message)]
519pub struct PointCloudIngestOptions {
520 #[prost(message, optional, tag = "1")]
521 pub sensor_metadata: ::core::option::Option<PointCloudSensorMetadata>,
522 #[prost(string, tag = "2")]
523 pub channel: ::prost::alloc::string::String,
524}
525#[derive(Clone, PartialEq, ::prost::Message)]
526pub struct PointCloudSensorMetadata {
527 #[prost(map = "string, string", tag = "1")]
528 pub properties: ::std::collections::HashMap<
529 ::prost::alloc::string::String,
530 ::prost::alloc::string::String,
531 >,
532}
533#[derive(Clone, PartialEq, ::prost::Message)]
534pub struct VideoIngestItem {
535 #[prost(message, optional, tag = "1")]
536 pub source: ::core::option::Option<IngestSource>,
537 #[prost(message, optional, tag = "2")]
538 pub ingest: ::core::option::Option<VideoIngestOptions>,
539}
540#[derive(Clone, PartialEq, ::prost::Message)]
541pub struct VideoIngestOptions {
542 #[prost(message, optional, tag = "1")]
543 pub timestamp_manifest: ::core::option::Option<VideoTimestampManifest>,
544 #[prost(string, tag = "2")]
545 pub channel: ::prost::alloc::string::String,
546 #[prost(bool, optional, tag = "3")]
547 pub overwrite_segments: ::core::option::Option<bool>,
548}
549#[derive(Clone, PartialEq, ::prost::Message)]
550pub struct VideoTimestampManifest {
551 #[prost(oneof = "video_timestamp_manifest::Manifest", tags = "1, 2")]
552 pub manifest: ::core::option::Option<video_timestamp_manifest::Manifest>,
553}
554pub mod video_timestamp_manifest {
556 #[derive(Clone, PartialEq, ::prost::Oneof)]
557 pub enum Manifest {
558 #[prost(message, tag = "1")]
559 NoManifest(super::NoTimestampManifest),
560 #[prost(message, tag = "2")]
561 TimestampManifestFiles(super::TimestampManifestFiles),
562 }
563}
564#[derive(Clone, Copy, PartialEq, ::prost::Message)]
565pub struct NoTimestampManifest {
566 #[prost(message, optional, tag = "1")]
567 pub starting_timestamp: ::core::option::Option<
568 super::super::super::google::protobuf::Timestamp,
569 >,
570 #[prost(message, optional, tag = "2")]
571 pub scale_parameter: ::core::option::Option<ScaleParameter>,
572}
573#[derive(Clone, PartialEq, ::prost::Message)]
574pub struct TimestampManifestFiles {
575 #[prost(message, repeated, tag = "1")]
576 pub sources: ::prost::alloc::vec::Vec<IngestSource>,
577}
578#[derive(Clone, Copy, PartialEq, ::prost::Message)]
579pub struct ScaleParameter {
580 #[prost(oneof = "scale_parameter::ScaleParameter", tags = "1, 2, 3")]
581 pub scale_parameter: ::core::option::Option<scale_parameter::ScaleParameter>,
582}
583pub mod scale_parameter {
585 #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
586 pub enum ScaleParameter {
587 #[prost(double, tag = "1")]
588 TrueFrameRate(f64),
589 #[prost(message, tag = "2")]
590 EndingTimestamp(super::super::super::super::google::protobuf::Timestamp),
591 #[prost(double, tag = "3")]
592 ScaleFactor(f64),
593 }
594}
595#[derive(Clone, PartialEq, ::prost::Message)]
596pub struct IngestRequest {
597 #[prost(string, tag = "1")]
598 pub dataset_rid: ::prost::alloc::string::String,
599 #[prost(string, repeated, tag = "2")]
600 pub runs_to_expand: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
601 #[prost(message, repeated, tag = "3")]
602 pub items: ::prost::alloc::vec::Vec<IngestItem>,
603 #[prost(map = "string, string", tag = "4")]
604 pub tags: ::std::collections::HashMap<
605 ::prost::alloc::string::String,
606 ::prost::alloc::string::String,
607 >,
608}
609#[derive(Clone, PartialEq, ::prost::Message)]
610pub struct IngestResponse {
611 #[prost(string, tag = "1")]
612 pub ingest_job_rid: ::prost::alloc::string::String,
613}
614#[derive(Clone, PartialEq, ::prost::Message)]
615pub struct IngestItem {
616 #[prost(map = "string, string", tag = "1")]
617 pub tags: ::std::collections::HashMap<
618 ::prost::alloc::string::String,
619 ::prost::alloc::string::String,
620 >,
621 #[prost(oneof = "ingest_item::Item", tags = "2, 3, 4, 5, 6, 7, 8")]
622 pub item: ::core::option::Option<ingest_item::Item>,
623}
624pub mod ingest_item {
626 #[derive(Clone, PartialEq, ::prost::Oneof)]
627 pub enum Item {
628 #[prost(message, tag = "2")]
629 File(super::FileIngestItem),
630 #[prost(message, tag = "3")]
631 Log(super::LogIngestItem),
632 #[prost(message, tag = "4")]
633 Containerized(super::ContainerizedIngestItem),
634 #[prost(message, tag = "5")]
635 Video(super::VideoIngestItem),
636 #[prost(message, tag = "6")]
637 PointCloud(super::PointCloudIngestItem),
638 #[prost(message, tag = "7")]
639 Mcap(super::McapIngestItem),
640 #[prost(message, tag = "8")]
641 Dataflash(super::DataflashIngestItem),
642 }
643}
644pub mod ingest_service_client {
646 #![allow(
647 unused_variables,
648 dead_code,
649 missing_docs,
650 clippy::wildcard_imports,
651 clippy::let_unit_value,
652 )]
653 use tonic::codegen::*;
654 use tonic::codegen::http::Uri;
655 #[derive(Debug, Clone)]
656 pub struct IngestServiceClient<T> {
657 inner: tonic::client::Grpc<T>,
658 }
659 impl IngestServiceClient<tonic::transport::Channel> {
660 pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
662 where
663 D: TryInto<tonic::transport::Endpoint>,
664 D::Error: Into<StdError>,
665 {
666 let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
667 Ok(Self::new(conn))
668 }
669 }
670 impl<T> IngestServiceClient<T>
671 where
672 T: tonic::client::GrpcService<tonic::body::Body>,
673 T::Error: Into<StdError>,
674 T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
675 <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
676 {
677 pub fn new(inner: T) -> Self {
678 let inner = tonic::client::Grpc::new(inner);
679 Self { inner }
680 }
681 pub fn with_origin(inner: T, origin: Uri) -> Self {
682 let inner = tonic::client::Grpc::with_origin(inner, origin);
683 Self { inner }
684 }
685 pub fn with_interceptor<F>(
686 inner: T,
687 interceptor: F,
688 ) -> IngestServiceClient<InterceptedService<T, F>>
689 where
690 F: tonic::service::Interceptor,
691 T::ResponseBody: Default,
692 T: tonic::codegen::Service<
693 http::Request<tonic::body::Body>,
694 Response = http::Response<
695 <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
696 >,
697 >,
698 <T as tonic::codegen::Service<
699 http::Request<tonic::body::Body>,
700 >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
701 {
702 IngestServiceClient::new(InterceptedService::new(inner, interceptor))
703 }
704 #[must_use]
709 pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
710 self.inner = self.inner.send_compressed(encoding);
711 self
712 }
713 #[must_use]
715 pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
716 self.inner = self.inner.accept_compressed(encoding);
717 self
718 }
719 #[must_use]
723 pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
724 self.inner = self.inner.max_decoding_message_size(limit);
725 self
726 }
727 #[must_use]
731 pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
732 self.inner = self.inner.max_encoding_message_size(limit);
733 self
734 }
735 pub async fn ingest(
736 &mut self,
737 request: impl tonic::IntoRequest<super::IngestRequest>,
738 ) -> std::result::Result<tonic::Response<super::IngestResponse>, tonic::Status> {
739 self.inner
740 .ready()
741 .await
742 .map_err(|e| {
743 tonic::Status::unknown(
744 format!("Service was not ready: {}", e.into()),
745 )
746 })?;
747 let codec = tonic::codec::ProstCodec::default();
748 let path = http::uri::PathAndQuery::from_static(
749 "/nominal.ingest.v2.IngestService/Ingest",
750 );
751 let mut req = request.into_request();
752 req.extensions_mut()
753 .insert(GrpcMethod::new("nominal.ingest.v2.IngestService", "Ingest"));
754 self.inner.unary(req, path, codec).await
755 }
756 }
757}