@things-factory/integration-label-studio 9.1.19

package/server/types/scenario-types.ts.deprecated

@@ -0,0 +1,362 @@
+import { Field, InputType, ObjectType, Int, Float, registerEnumType } from 'type-graphql'
+
+/**
+ * Labeling Workflow Scenario Types
+ *
+ * Defines end-to-end labeling workflows with multiple steps
+ */
+
+// ============================================================================
+// Enums
+// ============================================================================
+
+export enum ScenarioStepType {
+  ImportData = 'import_data',
+  GeneratePredictions = 'generate_predictions',
+  WaitForAnnotations = 'wait_for_annotations',
+  SyncAnnotations = 'sync_annotations',
+  ValidateQuality = 'validate_quality',
+  ExportResults = 'export_results',
+  Notification = 'notification'
+}
+
+registerEnumType(ScenarioStepType, {
+  name: 'ScenarioStepType',
+  description: 'Type of workflow step'
+})
+
+export enum ScenarioStatus {
+  Draft = 'draft',
+  Active = 'active',
+  Paused = 'paused',
+  Completed = 'completed',
+  Failed = 'failed'
+}
+
+registerEnumType(ScenarioStatus, {
+  name: 'ScenarioStatus',
+  description: 'Status of workflow scenario'
+})
+
+export enum TriggerType {
+  Manual = 'manual',
+  Schedule = 'schedule',
+  DatasetUpdate = 'dataset_update',
+  ExternalEvent = 'external_event'
+}
+
+registerEnumType(TriggerType, {
+  name: 'TriggerType',
+  description: 'How the scenario is triggered'
+})
+
+// ============================================================================
+// Scenario Step Types
+// ============================================================================
+
+@InputType()
+export class ImportDataStepConfig {
+  @Field({ description: 'Data source type: dataset, api, file' })
+  sourceType: 'dataset' | 'api' | 'file'
+
+  @Field({ nullable: true, description: 'DataSet ID if sourceType is dataset' })
+  dataSetId?: string
+
+  @Field({ nullable: true, description: 'External source URL if sourceType is api/file' })
+  sourceUrl?: string
+
+  @Field({ nullable: true, description: 'Image field name' })
+  imageField?: string
+
+  @Field({ nullable: true, description: 'Maximum items to import' })
+  limit?: number
+}
+
+@InputType()
+export class GeneratePredictionsStepConfig {
+  @Field({ nullable: true, description: 'AI model ID to use' })
+  modelId?: string
+
+  @Field(type => Float, { nullable: true, description: 'Confidence threshold' })
+  confidenceThreshold?: number
+
+  @Field({ nullable: true, defaultValue: false, description: 'Force regenerate existing predictions' })
+  forceRegenerate?: boolean
+}
+
+@InputType()
+export class WaitForAnnotationsStepConfig {
+  @Field(type => Int, { nullable: true, description: 'Minimum number of annotations required' })
+  minAnnotations?: number
+
+  @Field(type => Float, { nullable: true, description: 'Minimum completion rate (0-1)' })
+  minCompletionRate?: number
+
+  @Field(type => Int, { nullable: true, description: 'Maximum wait time in minutes' })
+  maxWaitMinutes?: number
+
+  @Field({ nullable: true, defaultValue: true, description: 'Auto-proceed when criteria met' })
+  autoProceed?: boolean
+}
+
+@InputType()
+export class SyncAnnotationsStepConfig {
+  @Field({ nullable: true, defaultValue: true, description: 'Only sync completed annotations' })
+  completedOnly?: boolean
+
+  @Field({ nullable: true, description: 'Sync annotations updated after this date' })
+  sinceDate?: Date
+}
+
+@InputType()
+export class ValidateQualityStepConfig {
+  @Field(type => Float, { nullable: true, description: 'Minimum required quality score (0-1)' })
+  minQualityScore?: number
+
+  @Field({ nullable: true, description: 'Validation rules in JSON format' })
+  validationRules?: string
+}
+
+@InputType()
+export class NotificationStepConfig {
+  @Field({ description: 'Notification message template' })
+  message: string
+
+  @Field(type => [String], { nullable: true, description: 'Email recipients' })
+  recipients?: string[]
+
+  @Field({ nullable: true, description: 'Webhook URL to call' })
+  webhookUrl?: string
+}
+
+// ============================================================================
+// Scenario Step Definition
+// ============================================================================
+
+@InputType()
+export class ScenarioStepInput {
+  @Field({ description: 'Step name' })
+  name: string
+
+  @Field(type => ScenarioStepType, { description: 'Step type' })
+  type: ScenarioStepType
+
+  @Field({ description: 'Step configuration as JSON string' })
+  config: string
+
+  @Field({ nullable: true, description: 'Condition to execute this step (JSON logic)' })
+  condition?: string
+
+  @Field({ nullable: true, defaultValue: true, description: 'Continue on error' })
+  continueOnError?: boolean
+
+  @Field(type => Int, { nullable: true, description: 'Max retry attempts' })
+  maxRetries?: number
+}
+
+@ObjectType()
+export class ScenarioStep {
+  @Field({ description: 'Step name' })
+  name: string
+
+  @Field(type => ScenarioStepType, { description: 'Step type' })
+  type: ScenarioStepType
+
+  @Field({ description: 'Step configuration' })
+  config: string
+
+  @Field({ nullable: true, description: 'Execution condition' })
+  condition?: string
+
+  @Field({ defaultValue: true, description: 'Continue on error' })
+  continueOnError: boolean
+
+  @Field(type => Int, { nullable: true, description: 'Max retry attempts' })
+  maxRetries?: number
+
+  @Field(type => Int, { description: 'Step order' })
+  order: number
+}
+
+// ============================================================================
+// Scenario Definition
+// ============================================================================
+
+@InputType()
+export class CreateScenarioRequest {
+  @Field({ description: 'Scenario name' })
+  name: string
+
+  @Field({ nullable: true, description: 'Scenario description' })
+  description?: string
+
+  @Field(type => Int, { description: 'Label Studio project ID' })
+  projectId: number
+
+  @Field(type => TriggerType, { description: 'How to trigger this scenario' })
+  triggerType: TriggerType
+
+  @Field({ nullable: true, description: 'Trigger configuration (schedule, event, etc.)' })
+  triggerConfig?: string
+
+  @Field(type => [ScenarioStepInput], { description: 'Workflow steps' })
+  steps: ScenarioStepInput[]
+
+  @Field({ nullable: true, defaultValue: true, description: 'Auto-start scenario after creation' })
+  autoStart?: boolean
+}
+
+@ObjectType()
+export class LabelingScenario {
+  @Field({ description: 'Scenario ID' })
+  id: string
+
+  @Field({ description: 'Scenario name' })
+  name: string
+
+  @Field({ nullable: true, description: 'Description' })
+  description?: string
+
+  @Field(type => Int, { description: 'Label Studio project ID' })
+  projectId: number
+
+  @Field(type => TriggerType, { description: 'Trigger type' })
+  triggerType: TriggerType
+
+  @Field({ nullable: true, description: 'Trigger configuration' })
+  triggerConfig?: string
+
+  @Field(type => [ScenarioStep], { description: 'Workflow steps' })
+  steps: ScenarioStep[]
+
+  @Field(type => ScenarioStatus, { description: 'Current status' })
+  status: ScenarioStatus
+
+  @Field({ nullable: true, description: 'Last execution time' })
+  lastExecutedAt?: Date
+
+  @Field({ nullable: true, description: 'Next scheduled execution' })
+  nextExecutionAt?: Date
+
+  @Field({ description: 'Created at' })
+  createdAt: Date
+
+  @Field({ description: 'Updated at' })
+  updatedAt: Date
+}
+
+// ============================================================================
+// Scenario Execution
+// ============================================================================
+
+@InputType()
+export class ExecuteScenarioRequest {
+  @Field({ description: 'Scenario ID to execute' })
+  scenarioId: string
+
+  @Field({ nullable: true, description: 'Override parameters as JSON' })
+  parameters?: string
+}
+
+@ObjectType()
+export class ScenarioExecutionStep {
+  @Field({ description: 'Step name' })
+  stepName: string
+
+  @Field(type => ScenarioStepType, { description: 'Step type' })
+  stepType: ScenarioStepType
+
+  @Field({ description: 'Step status: pending, running, completed, failed, skipped' })
+  status: string
+
+  @Field({ nullable: true, description: 'Step output data' })
+  output?: string
+
+  @Field({ nullable: true, description: 'Error message if failed' })
+  error?: string
+
+  @Field({ nullable: true, description: 'Started at' })
+  startedAt?: Date
+
+  @Field({ nullable: true, description: 'Completed at' })
+  completedAt?: Date
+
+  @Field(type => Int, { nullable: true, description: 'Duration in milliseconds' })
+  durationMs?: number
+}
+
+@ObjectType()
+export class ScenarioExecution {
+  @Field({ description: 'Execution ID' })
+  id: string
+
+  @Field({ description: 'Scenario ID' })
+  scenarioId: string
+
+  @Field({ description: 'Scenario name' })
+  scenarioName: string
+
+  @Field({ description: 'Execution status: running, completed, failed' })
+  status: string
+
+  @Field(type => [ScenarioExecutionStep], { description: 'Step executions' })
+  steps: ScenarioExecutionStep[]
+
+  @Field({ nullable: true, description: 'Overall result summary' })
+  summary?: string
+
+  @Field({ description: 'Started at' })
+  startedAt: Date
+
+  @Field({ nullable: true, description: 'Completed at' })
+  completedAt?: Date
+
+  @Field(type => Int, { nullable: true, description: 'Total duration in milliseconds' })
+  totalDurationMs?: number
+
+  @Field({ nullable: true, description: 'Error message if failed' })
+  error?: string
+}
+
+@ObjectType()
+export class ScenarioExecutionResult {
+  @Field({ description: 'Execution ID' })
+  executionId: string
+
+  @Field({ description: 'Execution status' })
+  status: string
+
+  @Field({ nullable: true, description: 'Execution summary' })
+  summary?: string
+
+  @Field({ nullable: true, description: 'Error if failed' })
+  error?: string
+}
+
+// ============================================================================
+// Scenario List and Status
+// ============================================================================
+
+@ObjectType()
+export class LabelingScenarioList {
+  @Field(type => [LabelingScenario], { description: 'List of scenarios' })
+  items: LabelingScenario[]
+
+  @Field(type => Int, { description: 'Total count' })
+  total: number
+}
+
+@ObjectType()
+export class ScenarioExecutionList {
+  @Field(type => [ScenarioExecution], { description: 'List of executions' })
+  items: ScenarioExecution[]
+
+  @Field(type => Int, { description: 'Total count' })
+  total: number
+}
+
+@InputType()
+export class ScenarioStatusRequest {
+  @Field({ description: 'Scenario ID' })
+  scenarioId: string
+}

package/server/utils/annotation-exporter.ts

@@ -0,0 +1,340 @@
+/**
+ * Annotation Exporter
+ *
+ * Flexible annotation export system with pluggable format converters.
+ * Supports custom export formats for different use cases.
+ */
+
+export interface LabelStudioAnnotation {
+  id: number
+  task: number
+  project: number
+  completed_by: {
+    id: number
+    email: string
+    first_name: string
+    last_name: string
+  }
+  result: Array<{
+    from_name: string
+    to_name: string
+    type: string
+    value: any
+  }>
+  created_at: string
+  updated_at: string
+  lead_time?: number
+}
+
+export interface ExportContext {
+  projectId: number
+  projectTitle?: string
+  exportedAt: string
+  metadata?: any
+}
+
+/**
+ * Export format converter function type
+ * Converts Label Studio annotations to custom format
+ */
+export type FormatConverter<T = any> = (
+  annotations: LabelStudioAnnotation[],
+  context: ExportContext
+) => T | Promise<T>
+
+/**
+ * Registry for custom export formats
+ */
+const formatConverters: Map<string, FormatConverter> = new Map()
+
+/**
+ * Register a custom export format converter
+ *
+ * @param formatName - Unique format identifier (e.g., "csv", "coco", "yolo")
+ * @param converter - Converter function
+ *
+ * @example
+ * registerExportFormat('csv', (annotations, context) => {
+ *   const rows = annotations.map(a => ({
+ *     id: a.id,
+ *     task: a.task,
+ *     result: JSON.stringify(a.result)
+ *   }))
+ *   return Papa.unparse(rows)
+ * })
+ */
+export function registerExportFormat<T = any>(formatName: string, converter: FormatConverter<T>): void {
+  formatConverters.set(formatName.toLowerCase(), converter)
+}
+
+/**
+ * Unregister an export format
+ */
+export function unregisterExportFormat(formatName: string): void {
+  formatConverters.delete(formatName.toLowerCase())
+}
+
+/**
+ * Get all registered format names
+ */
+export function getRegisteredFormats(): string[] {
+  return Array.from(formatConverters.keys())
+}
+
+/**
+ * Export annotations to specified format
+ *
+ * @param annotations - Label Studio annotations
+ * @param format - Export format name
+ * @param context - Export context
+ * @returns Converted data in requested format
+ */
+export async function exportAnnotations<T = any>(
+  annotations: LabelStudioAnnotation[],
+  format: string,
+  context: ExportContext
+): Promise<T> {
+  const converter = formatConverters.get(format.toLowerCase())
+
+  if (!converter) {
+    throw new Error(`Unknown export format: ${format}. Available formats: ${getRegisteredFormats().join(', ')}`)
+  }
+
+  return await converter(annotations, context)
+}
+
+/**
+ * Pre-built export formats
+ */
+export class ExportFormats {
+  /**
+   * Export as JSON (default Label Studio format)
+   */
+  static json(): FormatConverter<string> {
+    return (annotations, context) => {
+      return JSON.stringify(
+        {
+          meta: context,
+          annotations
+        },
+        null,
+        2
+      )
+    }
+  }
+
+  /**
+   * Export as JSON Lines (one annotation per line)
+   */
+  static jsonl(): FormatConverter<string> {
+    return annotations => {
+      return annotations.map(a => JSON.stringify(a)).join('\n')
+    }
+  }
+
+  /**
+   * Export image classification results as CSV
+   */
+  static imageClassificationCSV(): FormatConverter<string> {
+    return annotations => {
+      const rows: string[] = ['task_id,annotation_id,label,annotator,lead_time,created_at']
+
+      for (const annotation of annotations) {
+        const label = annotation.result.find(r => r.type === 'choices')
+        if (label && label.value.choices) {
+          const choice = label.value.choices[0]
+          rows.push(
+            [
+              annotation.task,
+              annotation.id,
+              choice,
+              annotation.completed_by?.email || 'unknown',
+              annotation.lead_time || 0,
+              annotation.created_at
+            ].join(',')
+          )
+        }
+      }
+
+      return rows.join('\n')
+    }
+  }
+
+  /**
+   * Export Rank N classification results
+   */
+  static rankNClassificationCSV(ranks: number = 3): FormatConverter<string> {
+    return annotations => {
+      const rankHeaders = Array.from({ length: ranks }, (_, i) => `rank${i + 1}`).join(',')
+      const rows: string[] = [`task_id,annotation_id,${rankHeaders},annotator,lead_time,created_at`]
+
+      for (const annotation of annotations) {
+        const rankValues: string[] = []
+
+        for (let i = 1; i <= ranks; i++) {
+          const rankResult = annotation.result.find(r => r.from_name === `rank${i}`)
+          rankValues.push(rankResult?.value?.choices?.[0] || '')
+        }
+
+        rows.push(
+          [
+            annotation.task,
+            annotation.id,
+            ...rankValues,
+            annotation.completed_by?.email || 'unknown',
+            annotation.lead_time || 0,
+            annotation.created_at
+          ].join(',')
+        )
+      }
+
+      return rows.join('\n')
+    }
+  }
+
+  /**
+   * Export object detection results as COCO format
+   */
+  static coco(): FormatConverter<any> {
+    return (annotations, context) => {
+      const images: any[] = []
+      const cocoAnnotations: any[] = []
+      const categories: Map<string, number> = new Map()
+
+      let imageId = 1
+      let annotationId = 1
+      let categoryId = 1
+
+      for (const annotation of annotations) {
+        // Add image
+        images.push({
+          id: imageId,
+          file_name: `task_${annotation.task}.jpg`,
+          width: 0, // TODO: extract from annotation if available
+          height: 0
+        })
+
+        // Process bounding boxes
+        for (const result of annotation.result) {
+          if (result.type === 'rectanglelabels') {
+            const label = result.value.rectanglelabels[0]
+
+            // Register category
+            if (!categories.has(label)) {
+              categories.set(label, categoryId++)
+            }
+
+            // Add annotation
+            cocoAnnotations.push({
+              id: annotationId++,
+              image_id: imageId,
+              category_id: categories.get(label),
+              bbox: [result.value.x, result.value.y, result.value.width, result.value.height],
+              area: result.value.width * result.value.height,
+              iscrowd: 0
+            })
+          }
+        }
+
+        imageId++
+      }
+
+      return {
+        info: {
+          description: context.projectTitle || 'Label Studio Export',
+          date_created: context.exportedAt
+        },
+        images,
+        annotations: cocoAnnotations,
+        categories: Array.from(categories.entries()).map(([name, id]) => ({
+          id,
+          name,
+          supercategory: 'none'
+        }))
+      }
+    }
+  }
+
+  /**
+   * Export object detection results as YOLO format
+   */
+  static yolo(): FormatConverter<Map<number, string>> {
+    return annotations => {
+      const taskAnnotations: Map<number, string> = new Map()
+      const categoryIndex: Map<string, number> = new Map()
+      let nextCategoryId = 0
+
+      for (const annotation of annotations) {
+        const lines: string[] = []
+
+        for (const result of annotation.result) {
+          if (result.type === 'rectanglelabels') {
+            const label = result.value.rectanglelabels[0]
+
+            // Register category
+            if (!categoryIndex.has(label)) {
+              categoryIndex.set(label, nextCategoryId++)
+            }
+
+            const classId = categoryIndex.get(label)!
+
+            // Convert to YOLO format (normalized center x, center y, width, height)
+            const x = result.value.x / 100
+            const y = result.value.y / 100
+            const w = result.value.width / 100
+            const h = result.value.height / 100
+
+            const centerX = x + w / 2
+            const centerY = y + h / 2
+
+            lines.push(`${classId} ${centerX} ${centerY} ${w} ${h}`)
+          }
+        }
+
+        if (lines.length > 0) {
+          taskAnnotations.set(annotation.task, lines.join('\n'))
+        }
+      }
+
+      return taskAnnotations
+    }
+  }
+
+  /**
+   * Export NER (Named Entity Recognition) results
+   */
+  static nerJSON(): FormatConverter<any[]> {
+    return annotations => {
+      return annotations.map(annotation => {
+        const entities: any[] = []
+
+        for (const result of annotation.result) {
+          if (result.type === 'labels') {
+            entities.push({
+              start: result.value.start,
+              end: result.value.end,
+              text: result.value.text,
+              label: result.value.labels[0]
+            })
+          }
+        }
+
+        return {
+          task_id: annotation.task,
+          annotation_id: annotation.id,
+          entities,
+          annotator: annotation.completed_by?.email
+        }
+      })
+    }
+  }
+}
+
+// Register default formats
+registerExportFormat('json', ExportFormats.json())
+registerExportFormat('jsonl', ExportFormats.jsonl())
+registerExportFormat('csv', ExportFormats.imageClassificationCSV())
+registerExportFormat('rank-csv', ExportFormats.rankNClassificationCSV())
+registerExportFormat('coco', ExportFormats.coco())
+registerExportFormat('yolo', ExportFormats.yolo())
+registerExportFormat('ner-json', ExportFormats.nerJSON())