plexe 0.1.0__tar.gz

plexe-0.1.0/.gitignore

@@ -0,0 +1,31 @@
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+.idea/
+.vscode/
+plexe/__pycache__

plexe-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Plexe AI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

plexe-0.1.0/Makefile

@@ -0,0 +1,18 @@
+.PHONY: install clean build publish
+
+install:
+	pip install -e .
+
+clean:
+	rm -rf build/ dist/ *.egg-info __pycache__
+	find . -type d -name __pycache__ -exec rm -rf {} +
+
+build: clean
+	python -m build
+
+publish: build
+	python -m twine upload dist/*
+
+# Update version like: make version VERSION=0.1.1
+version:
+	sed -i 's/version="[0-9.]*"/version="$(VERSION)"/' setup.py

plexe-0.1.0/PKG-INFO

@@ -0,0 +1,164 @@
+Metadata-Version: 2.3
+Name: plexe
+Version: 0.1.0
+Summary: Create ML models from natural language descriptions
+Project-URL: Homepage, https://github.com/plexe-ai/plexe-python
+Project-URL: Repository, https://github.com/plexe-ai/plexe-python
+Author-email: Plexe AI <info@plexe.ai>
+Requires-Python: >=3.7
+Requires-Dist: aiofiles>=0.8.0
+Requires-Dist: httpx>=0.24.0
+Provides-Extra: dev
+Requires-Dist: black>=22.0.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.20.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0.0; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+<div align="center">
+
+# PlexeAI
+
+<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>
+
+---
+
+## 🚀 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 plexe
+```
+
+## 🏃‍♂️ Quickstart
+
+```python
+import plexe
+
+# Create a model in seconds
+model_version = plexe.build(
+    goal="predict customer churn based on usage patterns",
+    model_name="churn-predictor",
+    data_files="customer_data.csv"
+)
+
+# Make predictions
+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
+
+```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
+
+```python
+async def main():
+    model_version = await plexe.abuild(
+        goal="predict customer churn",
+        model_name="churn-predictor",
+        data_files="customer_data.csv"
+    )
+    
+    result = await plexe.ainfer(
+        model_name="churn-predictor",
+        model_version=model_version,
+        input_data={"usage": 100, "tenure": 12}
+    )
+```
+
+### 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
+```
+
+## 🤝 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)
+
+</div>

plexe-0.1.0/README.md

@@ -0,0 +1,147 @@
+<div align="center">
+
+# PlexeAI
+
+<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>
+
+---
+
+## 🚀 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 plexe
+```
+
+## 🏃‍♂️ Quickstart
+
+```python
+import plexe
+
+# Create a model in seconds
+model_version = plexe.build(
+    goal="predict customer churn based on usage patterns",
+    model_name="churn-predictor",
+    data_files="customer_data.csv"
+)
+
+# Make predictions
+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
+
+```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
+
+```python
+async def main():
+    model_version = await plexe.abuild(
+        goal="predict customer churn",
+        model_name="churn-predictor",
+        data_files="customer_data.csv"
+    )
+    
+    result = await plexe.ainfer(
+        model_name="churn-predictor",
+        model_version=model_version,
+        input_data={"usage": 100, "tenure": 12}
+    )
+```
+
+### 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
+```
+
+## 🤝 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)
+
+</div>

plexe-0.1.0/docs/img/plexe-logo.svg

@@ -0,0 +1,10 @@
+<svg width="29" height="28" viewBox="0 0 29 28" fill="none" xmlns="http://www.w3.org/2000/svg">
+<rect x="2.87109" y="8" width="23.2581" height="17" rx="8.5" stroke="black" stroke-width="2"/>
+<rect x="26.1938" y="13.9355" width="1.87097" height="5.12903" rx="0.935484" stroke="black" stroke-width="1.87097"/>
+<rect x="0.935484" y="13.9355" width="1.87097" height="5.12903" rx="0.935484" stroke="black" stroke-width="1.87097"/>
+<rect x="9.35492" y="12.9355" width="1.87097" height="5.12903" rx="0.935484" fill="black" stroke="black" stroke-width="1.87097"/>
+<rect x="17.7744" y="12.9355" width="1.87097" height="5.12903" rx="0.935484" fill="black" stroke="black" stroke-width="1.87097"/>
+<rect x="23.3228" y="25" width="2" height="17.6452" rx="1" transform="rotate(90 23.3228 25)" stroke="black" stroke-width="2"/>
+<line x1="14.4033" y1="7" x2="14.4033" y2="5" stroke="black" stroke-width="3"/>
+<path d="M13.3409 4.25L14.4998 2.1043L15.6587 4.25H13.3409Z" stroke="black" stroke-width="2"/>
+</svg>

plexe-0.1.0/plexe/__init__.py

@@ -0,0 +1,78 @@
+from pathlib import Path
+from typing import Optional, Union, List
+from .client import PlexeAI
+
+def build(goal: str,
+          model_name: str,
+          data_files: Optional[Union[str, Path, List[Union[str, Path]]]] = None,
+          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
+        upload_id: Optional upload_id if files were already uploaded
+        api_key: API key for authentication
+        eval_criteria: Optional evaluation criteria
+        
+    Returns:
+        model_version: Version ID of the created model
+    """
+    client = PlexeAI(api_key=api_key)
+    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,
+                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, model_name=model_name,
+                             data_files=data_files, upload_id=upload_id,
+                             eval_criteria=eval_criteria)
+
+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(model_name=model_name, model_version=model_version, input_data=input_data)
+
+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(model_name=model_name, model_version=model_version, input_data=input_data)
+
+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(model_name=model_name, model_version=model_version, inputs=inputs)
+
+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(model_name=model_name, model_version=model_version)
+
+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(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',
+           'cleanup_upload', 'acleanup_upload']

plexe-0.1.0/plexe/client.py

@@ -0,0 +1,222 @@
+import os
+import asyncio
+import httpx
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+
+class PlexeAI:
+    def __init__(self, api_key: Optional[str] = None, timeout: float = 120.0):
+        self.api_key = api_key
+        if not api_key:
+            self.api_key = os.environ.get("PLEXE_API_KEY")
+            if not self.api_key:
+                raise ValueError("PLEXE_API_KEY must be provided or set as environment variable")
+
+        self.base_url = "https://api.plexe.ai/v0"
+        self.client = httpx.Client(timeout=timeout)
+        self.async_client = httpx.AsyncClient(timeout=timeout)
+
+    def _get_headers(self) -> Dict[str, str]:
+        """Get basic headers with API key."""
+        return {
+            "x-api-key": self.api_key or "", 
+        }
+
+    def _get_json_headers(self) -> Dict[str, str]:
+        """Get headers for JSON content."""
+        headers = self._get_headers()
+        headers["Content-Type"] = "application/json"
+        return headers
+
+    def _ensure_list(self, data_files: Union[str, Path, List[Union[str, Path]]]) -> List[Path]:
+        """Convert single file path to list and ensure all paths are Path objects."""
+        if isinstance(data_files, (str, Path)):
+            data_files = [data_files]
+        return [Path(f) for f in data_files]
+
+    def upload_files(self, data_files: Union[str, Path, List[Union[str, Path]]]) -> str:
+        """Upload data files and return upload ID."""
+        files = self._ensure_list(data_files)
+        
+        upload_files = []
+        for f in files:
+            if not f.exists():
+                raise ValueError(f"File not found: {f}")
+            upload_files.append(('files', (f.name, open(f, 'rb'))))
+
+        response = self.client.post(
+            f"{self.base_url}/uploads",
+            files=upload_files,
+            headers=self._get_headers()
+        )
+        response.raise_for_status()
+        return response.json()["upload_id"]
+
+    async def aupload_files(self, data_files: Union[str, Path, List[Union[str, Path]]]) -> str:
+        """Upload data files asynchronously."""
+        files = self._ensure_list(data_files)
+        
+        upload_files = []
+        for f in files:
+            if not f.exists():
+                raise ValueError(f"File not found: {f}")
+            upload_files.append(('files', (f.name, open(f, 'rb'))))
+
+        response = await self.async_client.post(
+            f"{self.base_url}/uploads",
+            files=upload_files,
+            headers=self._get_headers()
+        )
+        response.raise_for_status()
+        return response.json()["upload_id"]
+
+    def build(self, 
+            goal: str,
+            model_name: str,
+            data_files: Optional[Union[str, Path, List[Union[str, Path]]]] = None,
+            upload_id: Optional[str] = None,
+            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
+            upload_id: Optional upload_id if files were already uploaded
+            eval_criteria: Optional evaluation criteria
+            
+        Returns:
+            model_version: Version ID of the created model
+        """
+        if data_files is None and upload_id is None:
+            raise ValueError("Either data_files or upload_id must be provided")
+            
+        if data_files is not None and upload_id is not None:
+            raise ValueError("Cannot provide both data_files and upload_id")
+            
+        # Get upload ID - either from new upload or use provided
+        if data_files is not None:
+            upload_id = self.upload_files(data_files)
+        
+        # Create model
+        response = self.client.post(
+            f"{self.base_url}/models/{model_name}/create",
+            json={
+                "upload_id": upload_id,
+                "goal": goal,
+                "eval": eval_criteria
+            },
+            headers=self._get_json_headers()
+        )
+        response.raise_for_status()
+        return response.json()["model_version"]
+
+    async def abuild(self,
+                    goal: str,
+                    model_name: str,
+                    data_files: Optional[Union[str, Path, List[Union[str, Path]]]] = None,
+                    upload_id: Optional[str] = None,
+                    eval_criteria: Optional[str] = None) -> str:
+        """Async version of build()"""
+        if data_files is None and upload_id is None:
+            raise ValueError("Either data_files or upload_id must be provided")
+            
+        if data_files is not None and upload_id is not None:
+            raise ValueError("Cannot provide both data_files and upload_id")
+        
+        # Get upload ID - either from new upload or use provided
+        if data_files is not None:
+            upload_id = await self.aupload_files(data_files)
+        
+        response = await self.async_client.post(
+            f"{self.base_url}/models/{model_name}/create",
+            json={
+                "upload_id": upload_id,
+                "goal": goal,
+                "eval": eval_criteria
+            },
+            headers=self._get_json_headers()
+        )
+        response.raise_for_status()
+        return response.json()["model_version"]
+
+    def get_status(self, model_name: str, model_version: str) -> Dict[str, Any]:
+        """Get status of a model build."""
+        response = self.client.get(
+            f"{self.base_url}/models/{model_name}/{model_version}/status",
+            headers=self._get_headers()
+        )
+        response.raise_for_status()
+        return response.json()
+
+    async def aget_status(self, model_name: str, model_version: str) -> Dict[str, Any]:
+        """Async version of get_status()"""
+        response = await self.async_client.get(
+            f"{self.base_url}/models/{model_name}/{model_version}/status",
+            headers=self._get_headers()
+        )
+        response.raise_for_status()
+        return response.json()
+
+    def infer(self, model_name: str, model_version: str, input_data: dict) -> Dict[str, Any]:
+        """Run inference using a model."""
+        response = self.client.post(
+            f"{self.base_url}/models/{model_name}/{model_version}/infer",
+            json=input_data,
+            headers=self._get_json_headers()
+        )
+        response.raise_for_status()
+        return response.json()
+
+    async def ainfer(self, model_name: str, model_version: str, input_data: dict) -> Dict[str, Any]:
+        """Async version of infer()"""
+        response = await self.async_client.post(
+            f"{self.base_url}/models/{model_name}/{model_version}/infer",
+            json=input_data,
+            headers=self._get_json_headers()
+        )
+        response.raise_for_status()
+        return response.json()
+
+    def batch_infer(self, model_name: str, model_version: str, inputs: List[dict]) -> List[Dict[str, Any]]:
+        """Run batch predictions."""
+        async def run_batch():
+            tasks = [
+                self.ainfer(model_name=model_name, model_version=model_version, input_data=x)
+                for x in inputs
+            ]
+            return await asyncio.gather(*tasks)
+
+        return asyncio.run(run_batch())
+
+    def cleanup_upload(self, upload_id: str) -> Dict[str, Any]:
+        """Clean up uploaded files."""
+        response = self.client.delete(
+            f"{self.base_url}/uploads/{upload_id}",
+            headers=self._get_headers()
+        )
+        response.raise_for_status()
+        return response.json()
+
+    async def acleanup_upload(self, upload_id: str) -> Dict[str, Any]:
+        """Async version of cleanup_upload()"""
+        response = await self.async_client.delete(
+            f"{self.base_url}/uploads/{upload_id}",
+            headers=self._get_headers()
+        )
+        response.raise_for_status()
+        return response.json()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.client.close()
+        asyncio.run(self.async_client.aclose())
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        self.client.close()
+        await self.async_client.aclose()

plexe-0.1.0/plexe/tests/test_integration.py

@@ -0,0 +1,183 @@
+import os
+import time
+import pytest
+import asyncio
+from pathlib import Path
+from plexe import PlexeAI, build, abuild, infer, ainfer, batch_infer
+
+API_KEY = os.getenv("PLEXE_API_KEY") or ""
+if not API_KEY:
+    pytest.skip("PLEXE_API_KEY environment variable not set", allow_module_level=True)
+
+TEST_MODEL_NAME = "test_prediction_model"
+TEST_GOAL = "Predict the outcomes of english premier league games based on prior results using the attached dataset"
+
+@pytest.fixture
+def client():
+    """Create a PlexeAI client instance for testing."""
+    return PlexeAI(api_key=API_KEY)
+
+@pytest.fixture
+def sample_data_file(tmp_path):
+    """Create a temporary sample data file for testing."""
+    data_file = tmp_path / "test_data.csv"
+    data_content = """text,sentiment
+This product is amazing!,positive
+I love this service,positive
+Terrible experience,negative
+Not worth the money,negative
+Pretty good overall,positive"""
+    data_file.write_text(data_content)
+    return data_file
+
+@pytest.fixture
+def sample_input_data():
+    """Sample input data for inference testing."""
+    return {"text": "This is a great product!"}
+
+def wait_for_model(client, model_name: str, model_version: str, timeout: int = 300):
+    """Wait for model to be ready."""
+    start_time = time.time()
+    while time.time() - start_time < timeout:
+        status = client.get_status(model_name, model_version)
+        if status["status"] == "completed":
+            return True
+        elif status["status"] == "failed":
+            raise Exception(f"Model failed: {status.get('error', 'Unknown error')}")
+        time.sleep(10)
+    raise TimeoutError(f"Model did not complete within {timeout} seconds")
+
+async def async_wait_for_model(client, model_name: str, model_version: str, timeout: int = 300):
+    """Wait for model to be ready asynchronously."""
+    start_time = time.time()
+    while time.time() - start_time < timeout:
+        status = await client.aget_status(model_name, model_version)
+        if status["status"] == "completed":
+            return True
+        elif status["status"] == "failed":
+            raise Exception(f"Model failed: {status.get('error', 'Unknown error')}")
+        await asyncio.sleep(10)
+    raise TimeoutError(f"Model did not complete within {timeout} seconds")
+
+class TestPlexeAIIntegration:
+    """Integration tests for PlexeAI client."""
+    
+    def test_client_initialization(self):
+        """Test client initialization with API key."""
+        client = PlexeAI(api_key=API_KEY)
+        assert client.api_key == API_KEY
+        assert client.base_url == "https://api.plexe.ai/v0"
+
+    def test_build_and_inference_flow(self, client, sample_data_file, sample_input_data):
+        """Test full flow: build model with direct data files to avoid timing issues."""
+        try:
+            model_version = build(
+                goal=TEST_GOAL,
+                model_name=TEST_MODEL_NAME,
+                upload_id="2d4da8f9-aaf1-4262-a36c-5e9167ca4d5b",
+                api_key=API_KEY
+            )
+            assert isinstance(model_version, str)
+            
+            # Wait for model to be ready
+            wait_for_model(client, TEST_MODEL_NAME, model_version)
+            
+            # Run inference
+            result = infer(
+                model_name=TEST_MODEL_NAME,
+                model_version=model_version,
+                input_data=sample_input_data,
+                api_key=API_KEY
+            )
+            assert isinstance(result, dict)
+            assert "prediction" in result
+
+            # Run batch inference
+            batch_inputs = [
+                {"text": "Great service!"},
+                {"text": "Not satisfied with the product"}
+            ]
+            results = batch_infer(
+                model_name=TEST_MODEL_NAME,
+                model_version=model_version,
+                inputs=batch_inputs,
+                api_key=API_KEY
+            )
+            assert isinstance(results, list)
+            assert len(results) == len(batch_inputs)
+                
+        except Exception as e:
+            raise e
+
+    @pytest.mark.asyncio
+    async def test_async_build_and_inference_flow(self, client, sample_data_file, sample_input_data):
+        """Test full async flow: build model with direct data files to avoid timing issues."""
+        try:
+            # Build model asynchronously using data_files directly
+            model_version = await abuild(
+                goal=TEST_GOAL,
+                model_name=f"{TEST_MODEL_NAME}_async",
+                upload_id="2d4da8f9-aaf1-4262-a36c-5e9167ca4d5b",
+                api_key=API_KEY
+            )
+            assert isinstance(model_version, str)
+            
+            # Wait for model to be ready
+            await async_wait_for_model(client, f"{TEST_MODEL_NAME}_async", model_version)
+            
+            # Run inference asynchronously
+            result = await ainfer(
+                model_name=f"{TEST_MODEL_NAME}_async",
+                model_version=model_version,
+                input_data=sample_input_data,
+                api_key=API_KEY
+            )
+            assert isinstance(result, dict)
+            assert "prediction" in result
+
+            # Optional batch inference test
+            batch_inputs = [
+                {"text": "Great service!"},
+                {"text": "Not satisfied with the product"}
+            ]
+            results = batch_infer(
+                model_name=TEST_MODEL_NAME,
+                model_version=model_version,
+                inputs=batch_inputs,
+                api_key=API_KEY
+            )
+            assert isinstance(results, list)
+            assert len(results) == len(batch_inputs)
+                
+        except Exception as e:
+            raise e
+
+    def test_file_upload_and_cleanup(self, client, sample_data_file):
+        """Test file upload and cleanup."""
+        upload_id = client.upload_files(sample_data_file)
+        assert isinstance(upload_id, str)
+        
+        # Wait a bit to ensure file is processed
+        time.sleep(2)
+        
+        cleanup_result = client.cleanup_upload(upload_id)
+        assert isinstance(cleanup_result, dict)
+
+    def test_error_handling(self, client):
+        """Test error handling for invalid requests."""
+        with pytest.raises(ValueError):
+            build(
+                goal=TEST_GOAL,
+                model_name=TEST_MODEL_NAME,
+                data_files=None,
+                upload_id=None,
+                api_key=API_KEY
+            )
+
+        with pytest.raises(ValueError):
+            build(
+                goal=TEST_GOAL,
+                model_name=TEST_MODEL_NAME,
+                data_files="nonexistent.csv",
+                api_key=API_KEY
+            )

plexe-0.1.0/pyproject.toml

@@ -0,0 +1,47 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "plexe"
+version = "0.1.0"
+description = "Create ML models from natural language descriptions"
+readme = "README.md"
+requires-python = ">=3.7"
+authors = [
+    { name = "Plexe AI", email = "info@plexe.ai" }
+]
+dependencies = [
+    "httpx>=0.24.0",
+    "aiofiles>=0.8.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "pytest-asyncio>=0.20.0",
+    "pytest-cov>=4.0.0",
+    "black>=22.0.0",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+
+[tool.coverage.run]
+source = ["plexe"]
+omit = ["tests/*"]
+
+[tool.coverage.report]
+exclude_lines = [
+    "pragma: no cover",
+    "def __repr__",
+    "raise NotImplementedError",
+    "if __name__ == .__main__.:",
+    "pass",
+    "raise ImportError"
+]
+
+[project.urls]
+Homepage = "https://github.com/plexe-ai/plexe-python"
+Repository = "https://github.com/plexe-ai/plexe-python"