Custom Code

// Function to transform data
function processData(data) {
  // Data processing logic
  const result = data.map(item => {
    return {
      id: item.id,
      name: item.name.toUpperCase(),
      value: item.amount * 1.1
    };
  });
  
  return result;
}

// Export the function result
return processData(data);

functions:
  processData:
    code: |
      // Function code here
    parameters:
      data:
        type: array
        description: Array of items to process
        default: []

// Function to classify text
function classifyText(text, categories) {
  // Simple classification logic
  const lowerText = text.toLowerCase();
  
  // Check each category for matches
  for (const category of categories) {
    for (const keyword of category.keywords) {
      if (lowerText.includes(keyword.toLowerCase())) {
        return {
          category: category.name,
          confidence: 0.8,
          keyword: keyword
        };
      }
    }
  }
  
  // Default classification
  return {
    category: 'unclassified',
    confidence: 0.5,
    keyword: null
  };
}

// Export the function result
return classifyText(text, categories);

// Example using libraries
const _ = require('lodash');
const moment = require('moment');
const axios = require('axios');

async function processData(data) {
  // Group data by date
  const grouped = _.groupBy(data, item => 
    moment(item.timestamp).format('YYYY-MM-DD')
  );
  
  // Enrich with external data
  for (const date in grouped) {
    try {
      const response = await axios.get(`https://api.example.com/data/${date}`);
      grouped[date].externalData = response.data;
    } catch (error) {
      console.error(`Error fetching data for ${date}:`, error.message);
    }
  }
  
  return grouped;
}

// Export the function result
return processData(data);

# Function to analyze numeric data
def analyze_data(data):
    # Data analysis logic
    result = {
        'count': len(data),
        'sum': sum(data),
        'average': sum(data) / len(data) if data else 0,
        'min': min(data) if data else None,
        'max': max(data) if data else None
    }
    
    return result

# Execute the function and return result
result = analyze_data(data)

functions:
  analyze_data:
    code: |
      # Python code here
    parameters:
      data:
        type: array
        description: Array of numeric values to analyze
        default: []

import pandas as pd
from sklearn.cluster import KMeans
import numpy as np

def cluster_data(data, num_clusters=3):
    # Convert to DataFrame if not already
    if not isinstance(data, pd.DataFrame):
        df = pd.DataFrame(data)
    else:
        df = data
        
    # Select numeric columns
    numeric_cols = df.select_dtypes(include=[np.number]).columns
    features = df[numeric_cols].fillna(0)
    
    # Perform clustering
    kmeans = KMeans(n_clusters=num_clusters, random_state=42)
    df['cluster'] = kmeans.fit_predict(features)
    
    # Compute cluster statistics
    cluster_stats = df.groupby('cluster').agg({
        col: ['mean', 'min', 'max', 'count'] for col in numeric_cols
    })
    
    return {
        'clustered_data': df.to_dict(orient='records'),
        'cluster_centers': kmeans.cluster_centers_.tolist(),
        'cluster_stats': cluster_stats.to_dict()
    }

# Execute and return result
result = cluster_data(data, num_clusters)

import pandas as pd
import numpy as np
from nltk.sentiment import SentimentIntensityAnalyzer
import requests

def analyze_sentiment(texts):
    # Initialize sentiment analyzer
    sia = SentimentIntensityAnalyzer()
    
    # Analyze each text
    results = []
    for text in texts:
        sentiment = sia.polarity_scores(text)
        results.append({
            'text': text,
            'sentiment': sentiment,
            'classification': 'positive' if sentiment['compound'] > 0.05 
                              else 'negative' if sentiment['compound'] < -0.05 
                              else 'neutral'
        })
        
    # Get overall statistics
    df = pd.DataFrame(results)
    stats = {
        'positive_count': sum(df['classification'] == 'positive'),
        'negative_count': sum(df['classification'] == 'negative'),
        'neutral_count': sum(df['classification'] == 'neutral'),
        'average_compound': np.mean(df['sentiment'].apply(lambda x: x['compound']))
    }
    
    return {
        'detailed_results': results,
        'statistics': stats
    }

# Execute the function
result = analyze_sentiment(texts)