# Complete data processing workflow
import os
import pandas as pd

def data_processing_workflow():
    """Complete data processing with file operations."""
    
    # 1. Upload data files
    upload_result = await uploadFile({
        'files': [
            {'name': 'sales_data.csv', 'path': '/local/data/sales.csv'},
            {'name': 'customer_data.json', 'path': '/local/data/customers.json'}
        ],
        'destination': '/sandbox/input/'
    })
    
    # 2. List uploaded files for verification
    uploaded_files = await listFiles({
        'path': '/sandbox/input/',
        'details': True
    })
    
    print(f"Uploaded {len(uploaded_files)} files")
    
    # 3. Read and process data
    sales_data = await readFile({
        'path': '/sandbox/input/sales_data.csv',
        'format': 'csv'
    })
    
    # Process data with pandas
    df = pd.read_csv('/sandbox/input/sales_data.csv')
    processed_df = df.groupby('category').agg({
        'sales': 'sum',
        'quantity': 'sum'
    }).reset_index()
    
    # 4. Write processed results
    await writeFile({
        'path': '/sandbox/output/sales_summary.csv',
        'content': processed_df.to_csv(index=False),
        'format': 'csv'
    })
    
    # 5. Create analysis report
    report_content = f"""
    Sales Analysis Report
    =====================
    
    Total Records Processed: {len(df)}
    Categories Analyzed: {len(processed_df)}
    Total Sales: ${processed_df['sales'].sum():,.2f}
    
    Top Categories:
    {processed_df.nlargest(5, 'sales').to_string(index=False)}
    """
    
    await writeFile({
        'path': '/sandbox/output/analysis_report.txt',
        'content': report_content
    })
    
    # 6. Package results for download
    await fileManipulation({
        'operation': 'compress',
        'source': '/sandbox/output/',
        'destination': '/sandbox/downloads/results.zip'
    })
    
    # 7. Download processed results
    download_result = await downloadFile({
        'path': '/sandbox/downloads/results.zip',
        'destination': '/local/downloads/'
    })
    
    return download_result

# Execute workflow
result = await data_processing_workflow()

// Document organization and management
class DocumentManager {
    constructor() {
        this.documentsPath = '/sandbox/documents/';
        this.archivePath = '/sandbox/archive/';
        this.tempPath = '/sandbox/temp/';
    }
    
    async uploadDocuments(documents) {
        """Upload and organize documents by type."""
        
        const uploadResults = [];
        
        for (const doc of documents) {
            // Determine document category
            const category = this.categorizeDocument(doc.name);
            const categoryPath = `${this.documentsPath}${category}/`;
            
            // Create category directory if needed
            await createDirectory({
                path: categoryPath,
                recursive: true
            });
            
            // Upload document to appropriate category
            const result = await uploadFile({
                files: [doc],
                destination: categoryPath
            });
            
            uploadResults.push(result);
        }
        
        return uploadResults;
    }
    
    async searchDocuments(query) {
        """Search documents by content and metadata."""
        
        // Search by filename
        const nameResults = await fileSearch({
            pattern: `*${query}*`,
            path: this.documentsPath,
            recursive: true
        });
        
        // Search by content
        const contentResults = await fileSearch({
            contentSearch: {
                query: query,
                fileTypes: ['.txt', '.md', '.docx', '.pdf']
            },
            path: this.documentsPath
        });
        
        // Combine and deduplicate results
        const allResults = [...nameResults, ...contentResults];
        const uniqueResults = allResults.filter((result, index, self) =>
            index === self.findIndex(r => r.path === result.path)
        );
        
        return uniqueResults;
    }
    
    async organizeDocuments() {
        """Organize documents by date and type."""
        
        // Get all documents
        const allDocs = await listFiles({
            path: this.documentsPath,
            recursive: true,
            filter: { type: 'file' }
        });
        
        for (const doc of allDocs) {
            const metadata = await fileMetadata({
                path: doc.path
            });
            
            // Organize by year/month
            const date = new Date(metadata.modified);
            const yearMonth = `${date.getFullYear()}/${String(date.getMonth() + 1).padStart(2, '0')}`;
            const newPath = `${this.archivePath}${yearMonth}/`;
            
            // Create archive directory
            await createDirectory({
                path: newPath,
                recursive: true
            });
            
            // Move old documents to archive
            if (this.isOldDocument(metadata.modified)) {
                await fileManipulation({
                    operation: 'move',
                    source: doc.path,
                    destination: `${newPath}${doc.name}`
                });
            }
        }
    }
    
    categorizeDocument(filename) {
        const ext = filename.split('.').pop().toLowerCase();
        
        if (['pdf', 'doc', 'docx'].includes(ext)) return 'documents';
        if (['jpg', 'png', 'gif'].includes(ext)) return 'images';
        if (['csv', 'xlsx', 'json'].includes(ext)) return 'data';
        if (['txt', 'md'].includes(ext)) return 'text';
        
        return 'misc';
    }
    
    isOldDocument(modifiedDate) {
        const sixMonthsAgo = new Date();
        sixMonthsAgo.setMonth(sixMonthsAgo.getMonth() - 6);
        return new Date(modifiedDate) < sixMonthsAgo;
    }
}

// Usage
const docManager = new DocumentManager();
await docManager.uploadDocuments(userDocuments);
const searchResults = await docManager.searchDocuments('quarterly report');
await docManager.organizeDocuments();

# Integration with data analysis workflow
def integrated_data_analysis():
    """Complete data analysis workflow with file management."""
    
    # 1. File upload and organization
    raw_data_files = await uploadFile({
        'files': user_selected_files,
        'destination': '/sandbox/raw_data/'
    })
    
    # 2. Data discovery and cataloging
    data_files = await listFiles({
        'path': '/sandbox/raw_data/',
        'filter': {'extensions': ['.csv', '.xlsx', '.json']}
    })
    
    # 3. Automated data profiling
    for file_info in data_files:
        # Read file metadata
        metadata = await fileMetadata({'path': file_info['path']})
        
        # Analyze data structure (using xlsx-analysis capabilities)
        if file_info['path'].endswith('.xlsx'):
            analysis_result = await xlsxAnalysis({
                'filePath': file_info['path'],
                'operation': 'profile'
            })
            
            # Save analysis report
            await writeFile({
                'path': f"/sandbox/analysis/{file_info['name']}_profile.json",
                'content': JSON.stringify(analysis_result, null, 2)
            })
    
    # 4. Process and transform data
    # (Code execution happens here)
    
    # 5. Generate and save reports
    report_files = await listFiles({
        'path': '/sandbox/analysis/',
        'filter': {'extensions': ['.json', '.csv', '.txt']}
    })
    
    # 6. Package all results for download
    await fileManipulation({
        'operation': 'compress',
        'source': '/sandbox/analysis/',
        'destination': '/sandbox/deliverables/analysis_package.zip'
    })
    
    return await downloadFile({
        'path': '/sandbox/deliverables/analysis_package.zip'
    })

# Execute integrated workflow
analysis_package = await integrated_data_analysis()