Merge pull request #2 from plexe-ai/update

feat: Update lib to match Plexe endpoints

Author: vaibs-d

README.md

@@ -1,72 +1,147 @@
+<div align="center">
+
 # PlexeAI
 
-Create ML models from natural language descriptions. Upload your data and describe your ML problem - PlexeAI handles the rest.
+<img src="docs/img/plexe-logo.svg" alt="PlexeAI Logo" width="100" height="100"/>
+
+### Create ML models from natural language descriptions
+
+[![PyPI version](https://badge.fury.io/py/plexeai.svg)](https://badge.fury.io/py/plexeai)
+[![Python Versions](https://img.shields.io/pypi/pyversions/plexeai.svg)](https://pypi.org/project/plexeai/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+</div>
+
+---
 
-## Install
+## 🚀 Features
+
+- 🤖 **AI-Powered Model Creation** - Build ML models using natural language descriptions
+- 📊 **Automated Training** - Upload your data and let PlexeAI handle the rest
+- ⚡ **Async Support** - Built-in async interfaces for high-performance applications
+- 🔄 **Batch Processing** - Efficient batch prediction capabilities
+- 🛠️ **Simple API** - Intuitive interface for both beginners and experts
+
+## 📦 Installation
 
 ```bash
-pip install plexeai
+pip install plexe
 ```
 
-## Usage
+## 🏃‍♂️ Quickstart
 
 ```python
-import plexeai
+import plexe
 
-# Set via environment or pass to functions
-# export PLEXE_API_KEY=your_api_key_here
-
-# Build a model
-experiment_id = plexeai.build(
+# Create a model in seconds
+model_version = plexe.build(
     goal="predict customer churn based on usage patterns",
-    data_files="customer_data.csv",  # Single file or list of files
-    steps=3  # Number of improvement iterations
+    model_name="churn-predictor",
+    data_files="customer_data.csv"
 )
 
-# Check build status
-status = plexeai.get_status(experiment_id)
-# {"status": "completed", "result": {...}}
-
 # Make predictions
-result = plexeai.infer(
-    experiment_id=experiment_id,
+result = plexe.infer(
+    model_name="churn-predictor",
+    model_version=model_version,
     input_data={
         "usage": 100,
         "tenure": 12,
         "plan_type": "premium"
     }
 )
+```
+
+## 🎯 Example Use Cases
+
+- 📈 **Churn Prediction**: Predict customer churn using historical data
+- 🏷️ **Classification**: Categorize text, images, or any structured data
+- 📊 **Regression**: Predict numerical values like sales or pricing
+- 🔄 **Time Series**: Forecast trends and patterns in sequential data
+
+## 🔥 Advanced Usage
+
+### Batch Predictions
 
-# Batch predictions
-results = plexeai.batch_infer(
-    experiment_id=experiment_id,
+```python
+results = plexe.batch_infer(
+    model_name="churn-predictor",
+    model_version=model_version,
     inputs=[
         {"usage": 100, "tenure": 12, "plan_type": "premium"},
         {"usage": 50, "tenure": 6, "plan_type": "basic"}
     ]
 )
+```
 
-# Async support
+### Async Support
+
+```python
 async def main():
-    experiment_id = await plexeai.abuild(
+    model_version = await plexe.abuild(
         goal="predict customer churn",
+        model_name="churn-predictor",
         data_files="customer_data.csv"
     )
-    result = await plexeai.ainfer(
-        experiment_id=experiment_id,
+    
+    result = await plexe.ainfer(
+        model_name="churn-predictor",
+        model_version=model_version,
         input_data={"usage": 100, "tenure": 12}
     )
 ```
 
-## Local Development
+### Direct Client Usage
+
+```python
+from plexe import PlexeAI
+
+with PlexeAI(api_key="your_api_key_here") as client:
+    # Upload data
+    upload_id = client.upload_files("customer_data.csv")
+    
+    # Create and use model
+    model_version = client.build(
+        goal="predict customer churn",
+        model_name="churn-predictor",
+        upload_id=upload_id
+    )
+```
+
+## 📚 Documentation
+
+Check out our [comprehensive documentation](https://docs.plexe.ai) for:
+- Detailed API reference
+- Advanced usage examples
+- Best practices
+- Tutorials and guides
+
+## 🛠️ Development
 
 ```bash
+# Clone the repository
 git clone https://github.com/plexe-ai/plexe
 cd plexe
+
+# Install development dependencies
 pip install -e ".[dev]"
+
+# Run tests
 pytest
 ```
 
-## License
+## 🤝 Contributing
+
+We welcome contributions! Please see our [Contributing Guide](CONTRIBUTING.md) for details.
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+---
+
+<div align="center">
+
+Made with ❤️ by [Plexe AI](https://plexe.ai)
 
-MIT License
+</div>

docs/img/plexe-logo.svg

@@ -3,63 +3,76 @@
 from .client import PlexeAI
 
 def build(goal: str,
+          model_name: str,
           data_files: Optional[Union[str, Path, List[Union[str, Path]]]] = None,
-          data_dir: Optional[str] = None,
-          api_key: str = "", 
-          steps: int = 5, 
+          upload_id: Optional[str] = None,
+          api_key: str = "",
           eval_criteria: Optional[str] = None) -> str:
     """Build a new ML model.
     
     Args:
         goal: Description of what the model should do
+        model_name: Name for the model
         data_files: Optional path(s) to data file(s) to upload
-        data_dir: Optional data directory (if files already uploaded)
+        upload_id: Optional upload_id if files were already uploaded
         api_key: API key for authentication
-        steps: Number of improvement iterations
         eval_criteria: Optional evaluation criteria
         
     Returns:
-        experiment_id: ID of the created experiment
+        model_version: Version ID of the created model
     """
     client = PlexeAI(api_key=api_key)
-    return client.build(goal=goal, data_files=data_files, data_dir=data_dir,
-                       steps=steps, eval_criteria=eval_criteria)
+    return client.build(goal=goal, model_name=model_name,
+                       data_files=data_files, upload_id=upload_id,
+                       eval_criteria=eval_criteria)
 
 async def abuild(goal: str,
+                model_name: str,
                 data_files: Optional[Union[str, Path, List[Union[str, Path]]]] = None,
-                data_dir: Optional[str] = None,
-                api_key: str = "", 
-                steps: int = 5, 
+                upload_id: Optional[str] = None,
+                api_key: str = "",
                 eval_criteria: Optional[str] = None) -> str:
     """Build a new ML model asynchronously."""
     client = PlexeAI(api_key=api_key)
-    return await client.abuild(goal=goal, data_files=data_files, data_dir=data_dir,
-                             steps=steps, eval_criteria=eval_criteria)
+    return await client.abuild(goal=goal, model_name=model_name,
+                             data_files=data_files, upload_id=upload_id,
+                             eval_criteria=eval_criteria)
 
-def infer(experiment_id: str, input_data: dict, api_key: str = "") -> dict:
+def infer(model_name: str, model_version: str, input_data: dict, api_key: str = "") -> dict:
     """Run inference using a built model."""
     client = PlexeAI(api_key=api_key)
-    return client.infer(experiment_id=experiment_id, input_data=input_data)
+    return client.infer(model_name=model_name, model_version=model_version, input_data=input_data)
 
-async def ainfer(experiment_id: str, input_data: dict, api_key: str = "") -> dict:
+async def ainfer(model_name: str, model_version: str, input_data: dict, api_key: str = "") -> dict:
     """Run inference using a model asynchronously."""
     client = PlexeAI(api_key=api_key)
-    return await client.ainfer(experiment_id=experiment_id, input_data=input_data)
+    return await client.ainfer(model_name=model_name, model_version=model_version, input_data=input_data)
 
-def batch_infer(experiment_id: str, inputs: List[dict], api_key: str = "") -> List[dict]:
+def batch_infer(model_name: str, model_version: str, inputs: List[dict], api_key: str = "") -> List[dict]:
     """Run batch predictions."""
     client = PlexeAI(api_key=api_key)
-    return client.batch_infer(experiment_id=experiment_id, inputs=inputs)
+    return client.batch_infer(model_name=model_name, model_version=model_version, inputs=inputs)
 
-def get_status(experiment_id: str, api_key: str = "") -> dict:
-    """Get status of an experiment build."""
+def get_status(model_name: str, model_version: str, api_key: str = "") -> dict:
+    """Get status of a model build."""
     client = PlexeAI(api_key=api_key)
-    return client.get_status(experiment_id=experiment_id)
+    return client.get_status(model_name=model_name, model_version=model_version)
 
-async def aget_status(experiment_id: str, api_key: str = "") -> dict:
-    """Get status of an experiment build asynchronously."""
+async def aget_status(model_name: str, model_version: str, api_key: str = "") -> dict:
+    """Get status of a model build asynchronously."""
     client = PlexeAI(api_key=api_key)
-    return await client.aget_status(experiment_id=experiment_id)
+    return await client.aget_status(model_name=model_name, model_version=model_version)
+
+def cleanup_upload(upload_id: str, api_key: str = "") -> dict:
+    """Clean up uploaded files."""
+    client = PlexeAI(api_key=api_key)
+    return client.cleanup_upload(upload_id=upload_id)
+
+async def acleanup_upload(upload_id: str, api_key: str = "") -> dict:
+    """Clean up uploaded files asynchronously."""
+    client = PlexeAI(api_key=api_key)
+    return await client.acleanup_upload(upload_id=upload_id)
 
 __all__ = ['PlexeAI', 'build', 'abuild', 'infer', 'ainfer', 
-           'batch_infer', 'get_status', 'aget_status']
+           'batch_infer', 'get_status', 'aget_status',
+           'cleanup_upload', 'acleanup_upload']