Update Analysis

const API_KEY = "YOUR_API_KEY_HERE";
 
const response = await fetch("https://api.kruncher.ai/api/integration/analysis/detail", {
  method: "PUT",
  headers: {
    "Authorization": `${API_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    analysisId: "analysis_123",
    entityKey: "email",
    value: "contact@techstartup.com"
  })
});
 
const result = await response.json();
console.log("Update result:", result);

const API_KEY = "YOUR_API_KEY_HERE";
 
async function updateAnalysisEntity(analysisId, entityKey, value) {
  const response = await fetch("https://api.kruncher.ai/api/integration/analysis/detail", {
    method: "PUT",
    headers: {
      "Authorization": `${API_KEY}`,
      "Content-Type": "application/json"
    },
    body: JSON.stringify({ analysisId, entityKey, value })
  });
 
  if (!response.ok) {
    throw new Error(`Update failed: ${response.status} ${response.statusText}`);
  }
 
  return await response.json();
}
 
// Update multiple entities
async function updateMultipleEntities(analysisId, updates) {
  const results = [];
  
  for (const { entityKey, value } of updates) {
    try {
      const result = await updateAnalysisEntity(analysisId, entityKey, value);
      results.push({ entityKey, success: true, result });
      console.log(`✓ Updated ${entityKey}`);
    } catch (error) {
      results.push({ entityKey, success: false, error: error.message });
      console.error(`✗ Failed to update ${entityKey}:`, error.message);
    }
  }
  
  return results;
}
 
// Usage
const updates = [
  { entityKey: "email", value: "contact@techstartup.com" },
  { entityKey: "revenue", value: 5000000 },
  { entityKey: "employees", value: 50 },
  { entityKey: "stage", value: "seriesA" }
];
 
const results = await updateMultipleEntities("analysis_123", updates);
console.log("Update summary:", results);

const API_KEY = "YOUR_API_KEY_HERE";
const BASE_URL = "https://api.kruncher.ai/api";
 
class KruncherAnalysisAPI {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseURL = BASE_URL;
  }
 
  async updateEntity(analysisId, entityKey, value) {
    const response = await fetch(`${this.baseURL}/integration/analysis/detail`, {
      method: "PUT",
      headers: {
        "Authorization": `${this.apiKey}`,
        "Content-Type": "application/json"
      },
      body: JSON.stringify({ analysisId, entityKey, value })
    });
 
    if (!response.ok) {
      const error = await response.json().catch(() => ({ message: response.statusText }));
      throw new Error(`Update failed: ${error.message || error.description}`);
    }
 
    return await response.json();
  }
 
  async updateMultiple(analysisId, entityUpdates) {
    const results = {
      successful: [],
      failed: [],
      total: entityUpdates.length
    };
 
    for (const { entityKey, value } of entityUpdates) {
      try {
        const result = await this.updateEntity(analysisId, entityKey, value);
        results.successful.push({ entityKey, value, result });
      } catch (error) {
        results.failed.push({ entityKey, value, error: error.message });
      }
    }
 
    return results;
  }
 
  async updateCompanyInfo(analysisId, companyData) {
    const updates = Object.entries(companyData).map(([entityKey, value]) => ({
      entityKey,
      value
    }));
 
    return await this.updateMultiple(analysisId, updates);
  }
 
  async validateAndUpdate(analysisId, entityKey, value) {
    // Add validation logic
    const validators = {
      email: (v) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(v),
      revenue: (v) => typeof v === 'number' && v >= 0,
      employees: (v) => typeof v === 'number' && v >= 0,
      website: (v) => /^https?:\/\/.+/.test(v)
    };
 
    if (validators[entityKey] && !validators[entityKey](value)) {
      throw new Error(`Invalid value for ${entityKey}: ${value}`);
    }
 
    return await this.updateEntity(analysisId, entityKey, value);
  }
}
 
// Usage
const api = new KruncherAnalysisAPI("YOUR_API_KEY_HERE");
 
// Single update
await api.updateEntity("analysis_123", "email", "contact@techstartup.com");
 
// Multiple updates
const updates = [
  { entityKey: "email", value: "contact@techstartup.com" },
  { entityKey: "revenue", value: 5000000 },
  { entityKey: "employees", value: 50 }
];
const results = await api.updateMultiple("analysis_123", updates);
console.log(`Success: ${results.successful.length}/${results.total}`);
 
// Update with object
await api.updateCompanyInfo("analysis_123", {
  email: "contact@techstartup.com",
  revenue: 5000000,
  employees: 50,
  stage: "seriesA"
});
 
// Validated update
try {
  await api.validateAndUpdate("analysis_123", "email", "invalid-email");
} catch (error) {
  console.error("Validation failed:", error.message);
}

import requests
 
API_KEY = "YOUR_API_KEY_HERE"
url = "https://api.kruncher.ai/api/integration/analysis/detail"
 
headers = {
    "Authorization": f"{API_KEY}",
    "Content-Type": "application/json"
}
 
data = {
    "analysisId": "analysis_123",
    "entityKey": "email",
    "value": "contact@techstartup.com"
}
 
response = requests.put(url, headers=headers, json=data)
 
if response.status_code == 200:
    print("Update successful:", response.json())
else:
    print(f"Error: {response.status_code} {response.text}")

import requests
 
API_KEY = "YOUR_API_KEY_HERE"
BASE_URL = "https://api.kruncher.ai/api"
 
def update_analysis_entity(analysis_id, entity_key, value):
    """Update a single entity in an analysis."""
    url = f"{BASE_URL}/integration/analysis/detail"
    
    headers = {
        "Authorization": f"{API_KEY}",
        "Content-Type": "application/json"
    }
    
    payload = {
        "analysisId": analysis_id,
        "entityKey": entity_key,
        "value": value
    }
    
    response = requests.put(url, headers=headers, json=payload)
    response.raise_for_status()
    return response.json()
 
def update_multiple_entities(analysis_id, updates):
    """
    Update multiple entities in an analysis.
    
    Args:
        analysis_id: The analysis ID
        updates: List of dicts with 'entityKey' and 'value'
    
    Returns:
        Dict with successful and failed updates
    """
    results = {
        'successful': [],
        'failed': [],
        'total': len(updates)
    }
    
    for update in updates:
        entity_key = update['entityKey']
        value = update['value']
        
        try:
            result = update_analysis_entity(analysis_id, entity_key, value)
            results['successful'].append({
                'entityKey': entity_key,
                'value': value,
                'result': result
            })
            print(f"✓ Updated {entity_key}")
        except Exception as e:
            results['failed'].append({
                'entityKey': entity_key,
                'value': value,
                'error': str(e)
            })
            print(f"✗ Failed to update {entity_key}: {e}")
    
    return results
 
# Usage
updates = [
    {"entityKey": "email", "value": "contact@techstartup.com"},
    {"entityKey": "revenue", "value": 5000000},
    {"entityKey": "employees", "value": 50},
    {"entityKey": "stage", "value": "seriesA"}
]
 
results = update_multiple_entities("analysis_123", updates)
print(f"\nSuccess: {len(results['successful'])}/{results['total']}")
print(f"Failed: {len(results['failed'])}/{results['total']}")

import requests
from typing import Dict, List, Any, Optional
from dataclasses import dataclass
import re
 
API_KEY = "YOUR_API_KEY_HERE"
BASE_URL = "https://api.kruncher.ai/api"
 
@dataclass
class UpdateResult:
    entity_key: str
    value: Any
    success: bool
    result: Optional[Dict] = None
    error: Optional[str] = None
 
class KruncherAnalysisAPI:
    """Python client for Kruncher Analysis API."""
    
    def __init__(self, api_key: str = API_KEY):
        self.api_key = api_key
        self.base_url = BASE_URL
        self.session = requests.Session()
        self.session.headers.update({
            "Authorization": f"{api_key}",
            "Content-Type": "application/json"
        })
        
        # Validation rules
        self.validators = {
            'email': lambda v: bool(re.match(r'^[^\s@]+@[^\s@]+\.[^\s@]+$', v)),
            'revenue': lambda v: isinstance(v, (int, float)) and v >= 0,
            'employees': lambda v: isinstance(v, int) and v >= 0,
            'website': lambda v: bool(re.match(r'^https?://.+', v)),
            'fundingRaised': lambda v: isinstance(v, (int, float)) and v >= 0,
            'valuation': lambda v: isinstance(v, (int, float)) and v >= 0
        }
    
    def update_entity(
        self,
        analysis_id: str,
        entity_key: str,
        value: Any,
        validate: bool = True
    ) -> Dict:
        """
        Update a single entity in an analysis.
        
        Args:
            analysis_id: The analysis ID
            entity_key: The entity field to update
            value: The new value
            validate: Whether to validate before updating
        
        Returns:
            API response dict
        
        Raises:
            ValueError: If validation fails
            requests.HTTPError: If update fails
        """
        if validate and entity_key in self.validators:
            if not self.validators[entity_key](value):
                raise ValueError(f"Invalid value for {entity_key}: {value}")
        
        payload = {
            "analysisId": analysis_id,
            "entityKey": entity_key,
            "value": value
        }
        
        response = self.session.put(
            f"{self.base_url}/integration/analysis/detail",
            json=payload
        )
        response.raise_for_status()
        return response.json()
    
    def update_multiple(
        self,
        analysis_id: str,
        updates: List[Dict[str, Any]],
        validate: bool = True,
        stop_on_error: bool = False
    ) -> List[UpdateResult]:
        """
        Update multiple entities in an analysis.
        
        Args:
            analysis_id: The analysis ID
            updates: List of dicts with 'entityKey' and 'value'
            validate: Whether to validate before updating
            stop_on_error: Whether to stop on first error
        
        Returns:
            List of UpdateResult objects
        """
        results = []
        
        for update in updates:
            entity_key = update['entityKey']
            value = update['value']
            
            try:
                result = self.update_entity(
                    analysis_id,
                    entity_key,
                    value,
                    validate=validate
                )
                results.append(UpdateResult(
                    entity_key=entity_key,
                    value=value,
                    success=True,
                    result=result
                ))
            except Exception as e:
                results.append(UpdateResult(
                    entity_key=entity_key,
                    value=value,
                    success=False,
                    error=str(e)
                ))
                
                if stop_on_error:
                    break
        
        return results
    
    def update_from_dict(
        self,
        analysis_id: str,
        data: Dict[str, Any],
        validate: bool = True
    ) -> List[UpdateResult]:
        """
        Update multiple entities from a dictionary.
        
        Args:
            analysis_id: The analysis ID
            data: Dictionary of entity_key: value pairs
            validate: Whether to validate before updating
        
        Returns:
            List of UpdateResult objects
        """
        updates = [
            {"entityKey": key, "value": value}
            for key, value in data.items()
        ]
        return self.update_multiple(analysis_id, updates, validate=validate)
    
    def get_update_summary(self, results: List[UpdateResult]) -> Dict:
        """Get a summary of update results."""
        successful = [r for r in results if r.success]
        failed = [r for r in results if not r.success]
        
        return {
            'total': len(results),
            'successful': len(successful),
            'failed': len(failed),
            'success_rate': len(successful) / len(results) if results else 0,
            'failed_entities': [r.entity_key for r in failed]
        }
 
# Usage examples
api = KruncherAnalysisAPI()
 
# Single update
try:
    result = api.update_entity("analysis_123", "email", "contact@techstartup.com")
    print("Update successful:", result)
except ValueError as e:
    print(f"Validation error: {e}")
except requests.HTTPError as e:
    print(f"API error: {e}")
 
# Multiple updates
updates = [
    {"entityKey": "email", "value": "contact@techstartup.com"},
    {"entityKey": "revenue", "value": 5000000},
    {"entityKey": "employees", "value": 50},
    {"entityKey": "stage", "value": "seriesA"}
]
 
results = api.update_multiple("analysis_123", updates)
summary = api.get_update_summary(results)
print(f"\nUpdate Summary:")
print(f"Total: {summary['total']}")
print(f"Successful: {summary['successful']}")
print(f"Failed: {summary['failed']}")
if summary['failed_entities']:
    print(f"Failed entities: {', '.join(summary['failed_entities'])}")
 
# Update from dictionary
company_data = {
    "email": "contact@techstartup.com",
    "revenue": 5000000,
    "employees": 50,
    "website": "https://techstartup.com",
    "stage": "seriesA"
}
 
results = api.update_from_dict("analysis_123", company_data)
for result in results:
    if result.success:
        print(f"✓ {result.entity_key}: {result.value}")
    else:
        print(f"✗ {result.entity_key}: {result.error}")

curl -X PUT "https://api.kruncher.ai/api/integration/analysis/detail" \
  -H "Authorization: YOUR_API_KEY_HERE" \
  -H "Content-Type: application/json" \
  -d '{
    "analysisId": "analysis_123",
    "entityKey": "email",
    "value": "contact@techstartup.com"
  }'

curl -X PUT "https://api.kruncher.ai/api/integration/analysis/detail" \
  -H "Authorization: YOUR_API_KEY_HERE" \
  -H "Content-Type: application/json" \
  -d '{
    "analysisId": "analysis_123",
    "entityKey": "email",
    "value": "founders@techstartup.com"
  }'

curl -X PUT "https://api.kruncher.ai/api/integration/analysis/detail" \
  -H "Authorization: YOUR_API_KEY_HERE" \
  -H "Content-Type: application/json" \
  -d '{
    "analysisId": "analysis_123",
    "entityKey": "revenue",
    "value": 5000000
  }'