Initial commit: Plexe Python client library

Author: vaibs-d

.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__

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

README.md

@@ -0,0 +1,50 @@
+# Plexe
+
+Create ML models from natural language descriptions.
+
+## Installation
+
+```bash
+pip install plexe
+```
+
+## Usage
+
+First, set your API key:
+```bash
+export PLEXE_API_KEY=your_api_key_here
+```
+
+Then use it in your code:
+
+```python
+import plexe
+
+# Create a model
+model_id, version, desc = plexe.create(
+    "Create a model that predicts sentiment from text"
+)
+
+# Make predictions
+result = plexe.run(
+    model_id=model_id,
+    text_input="This product is amazing!"
+)
+print(result)
+
+# Batch predictions
+results = plexe.batch_run(
+    model_id=model_id,
+    inputs=[
+        {"text": "This is great"},
+        {"text": "This is terrible"}
+    ]
+)
+
+# Async support
+async def main():
+    model_id, version, desc = await plexe.acreate(
+        "Create a classifier for text"
+    )
+    result = await plexe.arun(model_id, text_input="Test")
+```

plexe/__init__.py

@@ -0,0 +1,28 @@
+from .client import PlexeClient
+
+def create(task_description: str, api_key: str = "") -> tuple[str, int, str]:
+    """Create a new ML model."""
+    client = PlexeClient(api_key=api_key)
+    return client.create(task_description=task_description)
+
+async def acreate(task_description: str, api_key: str = "") -> tuple[str, int, str]:
+    """Create a new ML model asynchronously."""
+    client = PlexeClient(api_key=api_key)
+    return await client.acreate(task_description=task_description)
+
+def run(model_id: str, text_input: str = "", version: int = -1, api_key: str = "") -> dict:
+    """Run predictions using a model."""
+    client = PlexeClient(api_key=api_key)
+    return client.run(model_id=model_id, text_input=text_input, version=version)
+
+async def arun(model_id: str, text_input: str = "", version: int = -1, api_key: str = "") -> dict:
+    """Run predictions using a model asynchronously."""
+    client = PlexeClient(api_key=api_key)
+    return await client.arun(model_id=model_id, text_input=text_input, version=version)
+
+def batch_run(model_id: str, inputs: list, version: int = -1, api_key: str = "") -> list:
+    """Run batch predictions."""
+    client = PlexeClient(api_key=api_key)
+    return client.batch_run(model_id=model_id, inputs=inputs, version=version)
+
+__all__ = ['PlexeClient', 'create', 'acreate', 'run', 'arun', 'batch_run']

plexe/client.py

@@ -0,0 +1,115 @@
+import asyncio
+from typing import Any, Dict, List, Optional, Union
+
+import httpx
+
+class PlexeClient:
+    def __init__(self, api_key: Optional[str] = None, timeout: float = 120.0):
+        self.api_key = api_key
+        if not api_key:
+            import os
+            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/v1"
+        self.client = httpx.Client(timeout=timeout)
+        self.async_client = httpx.AsyncClient(timeout=timeout)
+
+    def _headers(self):
+        return {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+        }
+
+    def create(self, task_description: str) -> tuple[str, int, str]:
+        """Create a new ML model from a task description.
+        
+        Args:
+            task_description: Description of what the model should do
+            
+        Returns:
+            Tuple of (model_id, version, description)
+        """
+        if not task_description:
+            raise ValueError("Task description must be provided")
+            
+        response = self.client.post(
+            f"{self.base_url}/create",
+            json={"description": task_description},
+            headers=self._headers()
+        )
+        response.raise_for_status()
+        data = response.json()
+        return data["model_id"], data["version"], data["description"]
+
+    async def acreate(self, task_description: str) -> tuple[str, int, str]:
+        """Async version of create()"""
+        if not task_description:
+            raise ValueError("Task description must be provided")
+            
+        response = await self.async_client.post(
+            f"{self.base_url}/create",
+            json={"description": task_description},
+            headers=self._headers()
+        )
+        response.raise_for_status()
+        data = response.json()
+        return data["model_id"], data["version"], data["description"]
+
+    def run(self, model_id: str, text_input: str = "", version: int = -1) -> Dict[str, Any]:
+        """Run predictions using a model.
+        
+        Args:
+            model_id: ID of the model to use
+            text_input: Input text for the model
+            version: Model version to use (-1 for latest)
+            
+        Returns:
+            Dictionary containing prediction results
+        """
+        response = self.client.post(
+            f"{self.base_url}/run",
+            json={
+                "model_id": model_id,
+                "text": text_input,
+                "version": version
+            },
+            headers=self._headers()
+        )
+        response.raise_for_status()
+        return response.json()
+
+    async def arun(self, model_id: str, text_input: str = "", version: int = -1) -> Dict[str, Any]:
+        """Async version of run()"""
+        response = await self.async_client.post(
+            f"{self.base_url}/run",
+            json={
+                "model_id": model_id,
+                "text": text_input,
+                "version": version
+            },
+            headers=self._headers()
+        )
+        response.raise_for_status()
+        return response.json()
+
+    def batch_run(self, model_id: str, inputs: List[Dict[str, Any]], version: int = -1) -> List[Dict[str, Any]]:
+        """Run batch predictions.
+        
+        Args:
+            model_id: ID of the model to use
+            inputs: List of input dictionaries
+            version: Model version to use (-1 for latest)
+            
+        Returns:
+            List of prediction results
+        """
+        async def run_batch():
+            tasks = [
+                self.arun(model_id=model_id, text_input=x.get("text", ""), version=version)
+                for x in inputs
+            ]
+            return await asyncio.gather(*tasks)
+            
+        return asyncio.run(run_batch())

setup.cfg

@@ -0,0 +1,17 @@
+[tool:pytest]
+testpaths = tests
+python_files = test_*.py
+addopts = -v --cov=plexe --cov-report=term-missing
+
+[coverage:run]
+source = plexe
+omit = tests/*
+
+[coverage:report]
+exclude_lines =
+    pragma: no cover
+    def __repr__
+    raise NotImplementedError
+    if __name__ == .__main__.:
+    pass
+    raise ImportError

setup.py

@@ -0,0 +1,32 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="plexe",
+    version="0.1.0",
+    packages=find_packages(),
+    install_requires=[
+        "httpx>=0.24.0",
+        "asyncio>=3.4.3",
+    ],
+    author="Plexe AI",
+    author_email="support@plexe.ai",
+    description="Create ML models from natural language descriptions",
+    long_description=open("README.md").read(),
+    long_description_content_type="text/markdown",
+    url="https://github.com/plexe-ai/plexe",
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    python_requires=">=3.7",
+    extras_require={
+        "dev": [
+            "pytest>=7.0",
+            "pytest-asyncio>=0.20.0",
+            "pytest-cov>=4.0.0",
+            "black>=22.0.0",
+            "isort>=5.0.0",
+        ]
+    },
+)