@things-factory/integration-label-studio 9.1.19

package/test-dataset-integration.js

@@ -0,0 +1,449 @@
+/**
+ * Test script for Dataset-Label Studio Integration
+ *
+ * Tests:
+ * 1. Query existing DataSets
+ * 2. Query DataSamples from a DataSet
+ * 3. Create Label Studio tasks from DataSamples
+ * 4. Query labeling status
+ * 5. Generate AI predictions for tasks
+ * 6. Sync annotations back to DataSamples
+ */
+
+const axios = require('axios')
+
+// Configuration
+// NOTE: With subdomain cookie-sharing approach, services run on separate subdomains
+const THINGS_FACTORY_GRAPHQL = process.env.THINGS_FACTORY_GRAPHQL || 'http://dataset.localhost:3000/graphql'
+const LABEL_STUDIO_URL = process.env.LABEL_STUDIO_URL || 'http://label.dataset.localhost:8080'
+const LABEL_STUDIO_PROJECT_ID = process.env.LABEL_STUDIO_PROJECT_ID || 2 // Change to your project ID
+
+async function queryDataSets() {
+  console.log('\n📊 Step 1: Querying DataSets...')
+  console.log('='.repeat(60))
+
+  try {
+    const query = `
+      query {
+        dataSets(params: { pagination: { page: 1, limit: 10 } }) {
+          items {
+            id
+            name
+            description
+            active
+          }
+          total
+        }
+      }
+    `
+
+    const response = await axios.post(THINGS_FACTORY_GRAPHQL, { query })
+
+    if (response.data.errors) {
+      console.error('❌ GraphQL errors:', response.data.errors)
+      return null
+    }
+
+    const dataSets = response.data.data.dataSets
+    console.log(`✅ Found ${dataSets.total} DataSet(s)`)
+
+    if (dataSets.items.length > 0) {
+      console.log('\nAvailable DataSets:')
+      dataSets.items.forEach((ds, i) => {
+        console.log(`   ${i + 1}. ${ds.name} (${ds.id})`)
+        console.log(`      Active: ${ds.active}`)
+        if (ds.description) console.log(`      Description: ${ds.description}`)
+      })
+      return dataSets.items[0] // Return first dataset for testing
+    } else {
+      console.log('⚠️  No DataSets found. Please create a DataSet first.')
+      return null
+    }
+  } catch (error) {
+    console.error('❌ Failed to query DataSets:', error.message)
+    return null
+  }
+}
+
+async function queryDataSamples(dataSetId) {
+  console.log(`\n📦 Step 2: Querying DataSamples from DataSet ${dataSetId}...`)
+  console.log('='.repeat(60))
+
+  try {
+    const query = `
+      query DataSamplesByDataSet($dataSetId: String!) {
+        dataSamplesByDataSet(
+          dataSetId: $dataSetId
+          params: { pagination: { page: 1, limit: 10 } }
+        ) {
+          items {
+            id
+            name
+            data
+            rawData
+            collectedAt
+          }
+          total
+        }
+      }
+    `
+
+    const response = await axios.post(THINGS_FACTORY_GRAPHQL, {
+      query,
+      variables: { dataSetId }
+    })
+
+    if (response.data.errors) {
+      console.error('❌ GraphQL errors:', response.data.errors)
+      return []
+    }
+
+    const samples = response.data.data.dataSamplesByDataSet
+    console.log(`✅ Found ${samples.total} DataSample(s)`)
+
+    if (samples.items.length > 0) {
+      console.log('\nDataSample details:')
+      samples.items.forEach((sample, i) => {
+        console.log(`   ${i + 1}. ${sample.name || sample.id}`)
+        console.log(`      ID: ${sample.id}`)
+        console.log(`      Collected: ${sample.collectedAt}`)
+
+        // Check for image URL
+        let imageUrl = null
+        if (sample.data && typeof sample.data === 'object' && sample.data.image) {
+          imageUrl = sample.data.image
+        } else if (sample.rawData) {
+          try {
+            const rawData = typeof sample.rawData === 'string' ? JSON.parse(sample.rawData) : sample.rawData
+            if (rawData.image) imageUrl = rawData.image
+            else if (typeof rawData === 'string' && rawData.startsWith('http')) imageUrl = rawData
+          } catch (e) {
+            if (sample.rawData.startsWith('http')) imageUrl = sample.rawData
+          }
+        }
+
+        if (imageUrl) {
+          console.log(`      Image: ${imageUrl}`)
+        } else {
+          console.log(`      Image: ⚠️  No image URL found`)
+        }
+      })
+      return samples.items
+    } else {
+      console.log('⚠️  No DataSamples found in this DataSet.')
+      console.log('💡 Create some DataSamples with image URLs for testing.')
+      return []
+    }
+  } catch (error) {
+    console.error('❌ Failed to query DataSamples:', error.message)
+    return []
+  }
+}
+
+async function createLabelingTasks(dataSetId) {
+  console.log(`\n🏷️  Step 3: Creating Label Studio tasks from DataSet ${dataSetId}...`)
+  console.log('='.repeat(60))
+
+  try {
+    const mutation = `
+      mutation CreateLabelingTasks($input: CreateLabelingTasksRequest!) {
+        createLabelingTasksFromDataset(input: $input) {
+          totalSamples
+          tasksCreated
+          tasksFailed
+          tasksSkipped
+          predictionsCreated
+          taskIds
+          error
+        }
+      }
+    `
+
+    const response = await axios.post(THINGS_FACTORY_GRAPHQL, {
+      query: mutation,
+      variables: {
+        input: {
+          projectId: LABEL_STUDIO_PROJECT_ID,
+          dataSetId: dataSetId,
+          imageField: 'image',
+          autoGeneratePredictions: true,
+          confidenceThreshold: 0.5,
+          limit: 10
+        }
+      }
+    })
+
+    if (response.data.errors) {
+      console.error('❌ GraphQL errors:', response.data.errors)
+      return null
+    }
+
+    const result = response.data.data.createLabelingTasksFromDataset
+
+    console.log('✅ Task creation completed!')
+    console.log(`\n📊 Results:`)
+    console.log(`   Total samples processed: ${result.totalSamples}`)
+    console.log(`   Tasks created: ${result.tasksCreated}`)
+    console.log(`   Tasks failed: ${result.tasksFailed}`)
+    console.log(`   Tasks skipped: ${result.tasksSkipped}`)
+    if (result.predictionsCreated !== undefined) {
+      console.log(`   AI predictions created: ${result.predictionsCreated}`)
+    }
+
+    if (result.taskIds && result.taskIds.length > 0) {
+      console.log(`\n🎯 Created task IDs:`)
+      result.taskIds.forEach(taskId => {
+        console.log(`   - Task ${taskId}`)
+      })
+    }
+
+    if (result.error) {
+      console.log(`\n⚠️  Errors: ${result.error}`)
+    }
+
+    return result
+  } catch (error) {
+    console.error('❌ Failed to create labeling tasks:', error.message)
+    if (error.response?.data) {
+      console.error('   Response:', JSON.stringify(error.response.data, null, 2))
+    }
+    return null
+  }
+}
+
+async function queryLabelingStatus(dataSetId) {
+  console.log(`\n📈 Step 4: Querying labeling status for DataSet ${dataSetId}...`)
+  console.log('='.repeat(60))
+
+  try {
+    const query = `
+      query DatasetLabelingStatus($input: DatasetLabelingStatusRequest!) {
+        datasetLabelingStatus(input: $input) {
+          dataSetId
+          dataSetName
+          totalSamples
+          tasksCreated
+          withPredictions
+          withAnnotations
+          annotationsCompleted
+          notProcessed
+          completionRate
+          projectId
+        }
+      }
+    `
+
+    const response = await axios.post(THINGS_FACTORY_GRAPHQL, {
+      query,
+      variables: {
+        input: {
+          dataSetId: dataSetId,
+          projectId: LABEL_STUDIO_PROJECT_ID
+        }
+      }
+    })
+
+    if (response.data.errors) {
+      console.error('❌ GraphQL errors:', response.data.errors)
+      return null
+    }
+
+    const status = response.data.data.datasetLabelingStatus
+
+    console.log('✅ Labeling status retrieved!')
+    console.log(`\n📊 Status for "${status.dataSetName}":`)
+    console.log(`   Total samples: ${status.totalSamples}`)
+    console.log(`   Tasks created: ${status.tasksCreated}`)
+    console.log(`   With AI predictions: ${status.withPredictions}`)
+    console.log(`   With annotations: ${status.withAnnotations}`)
+    console.log(`   Annotations completed: ${status.annotationsCompleted}`)
+    console.log(`   Not yet processed: ${status.notProcessed}`)
+    console.log(`   Completion rate: ${(status.completionRate * 100).toFixed(1)}%`)
+
+    return status
+  } catch (error) {
+    console.error('❌ Failed to query labeling status:', error.message)
+    return null
+  }
+}
+
+async function generatePredictions(dataSetId) {
+  console.log(`\n🤖 Step 5: Generating AI predictions for DataSet ${dataSetId}...`)
+  console.log('='.repeat(60))
+
+  try {
+    const mutation = `
+      mutation GeneratePredictions($input: GeneratePredictionsForDatasetRequest!) {
+        generatePredictionsForDataset(input: $input) {
+          total
+          succeeded
+          failed
+          modelVersion
+          results {
+            taskId
+            predictionId
+            success
+            objectCount
+            avgConfidence
+            error
+          }
+        }
+      }
+    `
+
+    const response = await axios.post(THINGS_FACTORY_GRAPHQL, {
+      query: mutation,
+      variables: {
+        input: {
+          dataSetId: dataSetId,
+          projectId: LABEL_STUDIO_PROJECT_ID,
+          confidenceThreshold: 0.5,
+          forceRegenerate: false
+        }
+      }
+    })
+
+    if (response.data.errors) {
+      console.error('❌ GraphQL errors:', response.data.errors)
+      return null
+    }
+
+    const result = response.data.data.generatePredictionsForDataset
+
+    console.log('✅ Prediction generation completed!')
+    console.log(`\n📊 Results:`)
+    console.log(`   Total tasks: ${result.total}`)
+    console.log(`   Succeeded: ${result.succeeded}`)
+    console.log(`   Failed: ${result.failed}`)
+    console.log(`   Model version: ${result.modelVersion}`)
+
+    if (result.results && result.results.length > 0) {
+      console.log(`\n🎯 Prediction details:`)
+      result.results.forEach((res, i) => {
+        if (res.success && res.objectCount > 0) {
+          console.log(`   Task ${res.taskId}: ${res.objectCount} objects (avg conf: ${(res.avgConfidence * 100).toFixed(1)}%)`)
+        } else if (res.error) {
+          console.log(`   Task ${res.taskId}: ${res.error}`)
+        }
+      })
+    }
+
+    return result
+  } catch (error) {
+    console.error('❌ Failed to generate predictions:', error.message)
+    return null
+  }
+}
+
+async function syncAnnotations(dataSetId) {
+  console.log(`\n🔄 Step 6: Syncing annotations back to DataSet ${dataSetId}...`)
+  console.log('='.repeat(60))
+
+  try {
+    const mutation = `
+      mutation SyncAnnotations($input: SyncAnnotationsRequest!) {
+        syncAnnotationsToDataset(input: $input) {
+          totalAnnotations
+          samplesUpdated
+          updatesFailed
+          skipped
+          error
+        }
+      }
+    `
+
+    const response = await axios.post(THINGS_FACTORY_GRAPHQL, {
+      query: mutation,
+      variables: {
+        input: {
+          projectId: LABEL_STUDIO_PROJECT_ID,
+          dataSetId: dataSetId,
+          completedOnly: false
+        }
+      }
+    })
+
+    if (response.data.errors) {
+      console.error('❌ GraphQL errors:', response.data.errors)
+      return null
+    }
+
+    const result = response.data.data.syncAnnotationsToDataset
+
+    console.log('✅ Annotation sync completed!')
+    console.log(`\n📊 Results:`)
+    console.log(`   Total annotations processed: ${result.totalAnnotations}`)
+    console.log(`   DataSamples updated: ${result.samplesUpdated}`)
+    console.log(`   Updates failed: ${result.updatesFailed}`)
+    console.log(`   Skipped: ${result.skipped}`)
+
+    if (result.error) {
+      console.log(`\n⚠️  Errors: ${result.error}`)
+    }
+
+    return result
+  } catch (error) {
+    console.error('❌ Failed to sync annotations:', error.message)
+    return null
+  }
+}
+
+async function main() {
+  console.log('🚀 Dataset-Label Studio Integration Test\n')
+  console.log('='.repeat(60))
+  console.log(`   Things Factory GraphQL: ${THINGS_FACTORY_GRAPHQL}`)
+  console.log(`   Label Studio URL: ${LABEL_STUDIO_URL}`)
+  console.log(`   Label Studio Project ID: ${LABEL_STUDIO_PROJECT_ID}`)
+  console.log('='.repeat(60))
+
+  try {
+    // Step 1: Query DataSets
+    const dataSet = await queryDataSets()
+    if (!dataSet) {
+      console.log('\n💡 Please create a DataSet with DataSamples first.')
+      process.exit(1)
+    }
+
+    // Step 2: Query DataSamples
+    const samples = await queryDataSamples(dataSet.id)
+    if (samples.length === 0) {
+      console.log('\n💡 Please add DataSamples with image URLs to the DataSet.')
+      process.exit(1)
+    }
+
+    // Step 3: Create Label Studio tasks
+    const createResult = await createLabelingTasks(dataSet.id)
+    if (!createResult || createResult.tasksCreated === 0) {
+      console.log('\n⚠️  No tasks were created. Check if images are properly configured.')
+      process.exit(1)
+    }
+
+    // Step 4: Query labeling status
+    await queryLabelingStatus(dataSet.id)
+
+    // Step 5: Generate predictions (if not already done)
+    await generatePredictions(dataSet.id)
+
+    // Step 6: Sync annotations (if any exist)
+    await syncAnnotations(dataSet.id)
+
+    console.log('\n' + '='.repeat(60))
+    console.log('✨ Integration test completed successfully!')
+    console.log('\n📝 Next steps:')
+    console.log(`   1. Open Label Studio: ${LABEL_STUDIO_URL}/projects/${LABEL_STUDIO_PROJECT_ID}`)
+    console.log(`   2. Review AI-generated predictions`)
+    console.log(`   3. Complete annotations`)
+    console.log(`   4. Run syncAnnotations again to update DataSamples`)
+    console.log('='.repeat(60))
+
+  } catch (error) {
+    console.error('\n💥 Test failed with error:', error)
+    process.exit(1)
+  }
+}
+
+// Run the test
+main().catch(error => {
+  console.error('💥 Unexpected error:', error)
+  process.exit(1)
+})

package/test-simple.js

@@ -0,0 +1,89 @@
+/**
+ * Simple test for AI inference (without Label Studio API token)
+ * Tests just the AI detection functionality
+ */
+
+const axios = require('axios')
+
+const THINGS_FACTORY_GRAPHQL = process.env.THINGS_FACTORY_GRAPHQL || 'http://dataset.localhost:3000/graphql'
+
+// Sample image URL for testing
+const TEST_IMAGE_URL = 'https://example.com/test.jpg'
+
+async function testAIDetection() {
+  console.log('🤖 Testing AI Object Detection\n')
+  console.log('='.repeat(60))
+  console.log(`   GraphQL: ${THINGS_FACTORY_GRAPHQL}`)
+  console.log(`   Test Image: ${TEST_IMAGE_URL}`)
+  console.log('='.repeat(60))
+
+  try {
+    const query = `
+      query DetectObjects($input: InferenceRequest!) {
+        detectObjects(input: $input) {
+          className
+          confidence
+          bbox {
+            x
+            y
+            width
+            height
+          }
+        }
+      }
+    `
+
+    console.log('\n📤 Sending GraphQL request...')
+
+    const response = await axios.post(THINGS_FACTORY_GRAPHQL, {
+      query,
+      variables: {
+        input: {
+          imageUrl: TEST_IMAGE_URL,
+          confidenceThreshold: 0.5
+        }
+      }
+    })
+
+    if (response.data.errors) {
+      console.error('\n❌ GraphQL errors:')
+      response.data.errors.forEach(err => {
+        console.error(`   - ${err.message}`)
+      })
+      return false
+    }
+
+    const objects = response.data.data.detectObjects
+
+    console.log('\n✅ AI Detection successful!')
+    console.log(`\n🎯 Detected ${objects.length} objects:\n`)
+
+    objects.forEach((obj, i) => {
+      console.log(`   ${i + 1}. ${obj.className}`)
+      console.log(`      Confidence: ${(obj.confidence * 100).toFixed(1)}%`)
+      console.log(`      BBox: x=${obj.bbox.x}, y=${obj.bbox.y}, w=${obj.bbox.width}, h=${obj.bbox.height}`)
+      console.log()
+    })
+
+    console.log('='.repeat(60))
+    console.log('✨ Mock AI is working correctly!')
+    console.log('\n📝 This confirms:')
+    console.log('   ✓ ai-inference module is loaded')
+    console.log('   ✓ GraphQL API is accessible')
+    console.log('   ✓ Mock AI client is functioning')
+    console.log('\n💡 Next step: Configure Label Studio API token to test full integration')
+
+    return true
+  } catch (error) {
+    console.error('\n❌ Test failed:', error.message)
+    if (error.response?.data) {
+      console.error('\n   Response:', JSON.stringify(error.response.data, null, 2))
+    }
+    return false
+  }
+}
+
+// Run test
+testAIDetection().then(success => {
+  process.exit(success ? 0 : 1)
+})

package/things-factory.config.js

@@ -0,0 +1,12 @@
+import route from './dist-client/route'
+import bootstrap from './dist-client/bootstrap'
+
+export default {
+  route,
+  routes: [
+    { tagname: 'label-studio-project-list', page: 'label-studio-project-list' },
+    { tagname: 'label-studio-project-create', page: 'label-studio-project-create' },
+    { tagname: 'label-studio-label-page', page: 'label-studio-label' }
+  ],
+  bootstrap
+}