outdatedLabs 0.1.0__tar.gz

outdatedlabs-0.1.0/PKG-INFO

@@ -0,0 +1,115 @@
+Metadata-Version: 2.4
+Name: outdatedLabs
+Version: 0.1.0
+Summary: A secure package for training machine learning models
+Home-page: https://github.com/Mouli51ch/OutDated
+Author: OutDated Team
+Author-email: your.email@example.com
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.31.0
+Requires-Dist: joblib>=1.3.0
+Requires-Dist: pandas>=2.0.0
+Requires-Dist: scikit-learn>=1.0.0
+Requires-Dist: tqdm>=4.65.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# OutDatedLabs - Secure Machine Learning Training Package
+
+A Python package for secure machine learning model training using the ML training server.
+
+## Installation
+
+```bash
+pip install outdatedLabs
+```
+
+## Quick Start
+
+```python
+from outdatedLabs import SecureModel
+
+# Create a linear regression model
+model = SecureModel.linearRegression()
+
+# Optionally set a custom server URL
+model.set_server_url("http://your-server:8000")
+
+# Train the model
+model.fit(
+    dataset_hash="your_dataset_hash",
+    features=["feature1", "feature2"],
+    target="target_column"
+)
+
+# Make predictions
+predictions = model.predict(X)
+
+# Get training metrics
+metrics = model.get_metrics()
+print(metrics)
+```
+
+## Features
+
+- Secure model training using encrypted datasets
+- Support for linear regression models
+- Progress tracking with tqdm
+- Comprehensive error handling and logging
+- Easy-to-use interface
+- Configurable server URL
+
+## API Reference
+
+### SecureModel
+
+The main class for secure model training.
+
+#### Methods
+
+- `linearRegression(server_url: str = "http://localhost:8000") -> SecureModel`
+  - Create a new linear regression model instance
+  
+- `set_server_url(server_url: str) -> SecureModel`
+  - Set a custom URL for the ML training server
+  
+- `fit(dataset_hash: str, features: List[str] = None, target: str = None, params: Dict[str, Any] = None) -> SecureModel`
+  - Train the model using the specified dataset
+  
+- `predict(X: Union[pd.DataFrame, List[List[float]]]) -> List[float]`
+  - Make predictions using the trained model
+  
+- `score(X: Union[pd.DataFrame, List[List[float]]], y: List[float]) -> Dict[str, float]`
+  - Calculate model performance metrics
+  
+- `get_metrics() -> Dict[str, Any]`
+  - Get training metrics
+
+## Requirements
+
+- Python 3.7+
+- requests
+- joblib
+- pandas
+- scikit-learn
+- tqdm
+
+## License
+
+MIT License 

outdatedlabs-0.1.0/README.md

@@ -0,0 +1,83 @@
+# OutDatedLabs - Secure Machine Learning Training Package
+
+A Python package for secure machine learning model training using the ML training server.
+
+## Installation
+
+```bash
+pip install outdatedLabs
+```
+
+## Quick Start
+
+```python
+from outdatedLabs import SecureModel
+
+# Create a linear regression model
+model = SecureModel.linearRegression()
+
+# Optionally set a custom server URL
+model.set_server_url("http://your-server:8000")
+
+# Train the model
+model.fit(
+    dataset_hash="your_dataset_hash",
+    features=["feature1", "feature2"],
+    target="target_column"
+)
+
+# Make predictions
+predictions = model.predict(X)
+
+# Get training metrics
+metrics = model.get_metrics()
+print(metrics)
+```
+
+## Features
+
+- Secure model training using encrypted datasets
+- Support for linear regression models
+- Progress tracking with tqdm
+- Comprehensive error handling and logging
+- Easy-to-use interface
+- Configurable server URL
+
+## API Reference
+
+### SecureModel
+
+The main class for secure model training.
+
+#### Methods
+
+- `linearRegression(server_url: str = "http://localhost:8000") -> SecureModel`
+  - Create a new linear regression model instance
+  
+- `set_server_url(server_url: str) -> SecureModel`
+  - Set a custom URL for the ML training server
+  
+- `fit(dataset_hash: str, features: List[str] = None, target: str = None, params: Dict[str, Any] = None) -> SecureModel`
+  - Train the model using the specified dataset
+  
+- `predict(X: Union[pd.DataFrame, List[List[float]]]) -> List[float]`
+  - Make predictions using the trained model
+  
+- `score(X: Union[pd.DataFrame, List[List[float]]], y: List[float]) -> Dict[str, float]`
+  - Calculate model performance metrics
+  
+- `get_metrics() -> Dict[str, Any]`
+  - Get training metrics
+
+## Requirements
+
+- Python 3.7+
+- requests
+- joblib
+- pandas
+- scikit-learn
+- tqdm
+
+## License
+
+MIT License 

outdatedlabs-0.1.0/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta" 

outdatedlabs-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

outdatedlabs-0.1.0/setup.py

@@ -0,0 +1,32 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="outdatedLabs",
+    version="0.1.0",
+    packages=find_packages(where="src"),
+    package_dir={"": "src"},
+    install_requires=[
+        "requests>=2.31.0",
+        "joblib>=1.3.0",
+        "pandas>=2.0.0",
+        "scikit-learn>=1.0.0",
+        "tqdm>=4.65.0",
+    ],
+    python_requires=">=3.8",
+    author="OutDated Team",
+    author_email="your.email@example.com",
+    description="A secure package for training machine learning models",
+    long_description=open("README.md").read(),
+    long_description_content_type="text/markdown",
+    url="https://github.com/Mouli51ch/OutDated",
+    classifiers=[
+        "Development Status :: 3 - Alpha",
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: MIT License",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+    ],
+) 

outdatedlabs-0.1.0/src/outdatedLabs/__init__.py

@@ -0,0 +1,8 @@
+"""
+OutDated - Secure Machine Learning Training Package
+"""
+
+from .secure_model import SecureModel
+
+__version__ = "0.1.0"
+__all__ = ["SecureModel"] 

outdatedlabs-0.1.0/src/outdatedLabs/secure_model.py

@@ -0,0 +1,220 @@
+"""
+Secure Model Training Module
+"""
+import os
+import time
+import logging
+import requests
+import joblib
+from typing import Optional, List, Dict, Any, Union
+from pathlib import Path
+from tqdm import tqdm
+import pandas as pd
+from sklearn.linear_model import LinearRegression
+from sklearn.metrics import mean_squared_error, r2_score
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+class SecureModel:
+    """Secure Model Training Class"""
+    
+    def __init__(self, server_url: str = "http://localhost:8000"):
+        """
+        Initialize the SecureModel.
+        
+        Args:
+            server_url (str): URL of the ML training server
+        """
+        self.server_url = server_url.rstrip('/')
+        self.job_id = None
+        self.model = None
+        self.metrics = None
+        
+    def set_server_url(self, server_url: str) -> 'SecureModel':
+        """
+        Set the training server URL.
+        
+        Args:
+            server_url (str): New URL for the ML training server
+            
+        Returns:
+            SecureModel: Self for method chaining
+        """
+        self.server_url = server_url.rstrip('/')
+        logger.info(f"Server URL set to: {self.server_url}")
+        return self
+        
+    @classmethod
+    def linearRegression(cls, server_url: str = "http://localhost:8000") -> 'SecureModel':
+        """
+        Create a Linear Regression model.
+        
+        Args:
+            server_url (str): URL of the ML training server
+            
+        Returns:
+            SecureModel: A new SecureModel instance configured for linear regression
+        """
+        instance = cls(server_url)
+        instance.algorithm = "linear_regression"
+        return instance
+    
+    def fit(self, 
+            dataset_hash: str,
+            features: Optional[List[str]] = None,
+            target: Optional[str] = None,
+            params: Optional[Dict[str, Any]] = None) -> 'SecureModel':
+        """
+        Train the model using the specified dataset.
+        
+        Args:
+            dataset_hash (str): The dataset hash in format "walrus://dataset_hash"
+            features (List[str], optional): List of feature column names
+            target (str, optional): Target column name
+            params (Dict[str, Any], optional): Model parameters
+            
+        Returns:
+            SecureModel: Self for method chaining
+        """
+        try:
+            # Extract hash from walrus:// format
+            if dataset_hash.startswith("walrus://"):
+                dataset_hash = dataset_hash[9:]
+            
+            # Prepare training request
+            request_data = {
+                "dataset_hash": dataset_hash,
+                "algorithm": self.algorithm,
+                "params": params or {},
+                "features": features,
+                "target": target
+            }
+            
+            logger.info(f"Starting training with parameters: {request_data}")
+            
+            # Start training job
+            response = requests.post(
+                f"{self.server_url}/train",
+                json=request_data
+            )
+            response.raise_for_status()
+            
+            # Get job ID
+            self.job_id = response.json()["job_id"]
+            logger.info(f"Training job started with ID: {self.job_id}")
+            
+            # Wait for training to complete
+            self._wait_for_completion()
+            
+            # Download and load the model
+            self._download_model()
+            
+            return self
+            
+        except Exception as e:
+            logger.error(f"Training failed: {str(e)}")
+            raise
+    
+    def _wait_for_completion(self, check_interval: int = 2) -> None:
+        """Wait for the training job to complete."""
+        with tqdm(desc="Training", unit="s") as pbar:
+            while True:
+                response = requests.get(f"{self.server_url}/train/{self.job_id}/status")
+                response.raise_for_status()
+                status = response.json()
+                
+                if status["status"] == "COMPLETE":
+                    logger.info("Training completed successfully")
+                    self.metrics = requests.get(f"{self.server_url}/train/{self.job_id}/metrics").json()
+                    break
+                elif status["status"] == "FAILED":
+                    error = status.get("error", "Unknown error")
+                    raise Exception(f"Training failed: {error}")
+                
+                time.sleep(check_interval)
+                pbar.update(check_interval)
+    
+    def _download_model(self) -> None:
+        """Download the trained model."""
+        try:
+            response = requests.get(
+                f"{self.server_url}/train/{self.job_id}/model",
+                stream=True
+            )
+            response.raise_for_status()
+            
+            # Save model to temporary file
+            temp_path = Path(f"model_{self.job_id}.joblib")
+            with open(temp_path, 'wb') as f:
+                for chunk in response.iter_content(chunk_size=8192):
+                    if chunk:
+                        f.write(chunk)
+            
+            # Load the model
+            self.model = joblib.load(temp_path)
+            
+            # Clean up
+            temp_path.unlink()
+            
+            logger.info("Model downloaded and loaded successfully")
+            
+        except Exception as e:
+            logger.error(f"Failed to download model: {str(e)}")
+            raise
+    
+    def predict(self, X: Union[pd.DataFrame, List[List[float]]]) -> List[float]:
+        """
+        Make predictions using the trained model.
+        
+        Args:
+            X: Input features as DataFrame or list of lists
+            
+        Returns:
+            List[float]: Predicted values
+        """
+        if self.model is None:
+            raise Exception("Model not trained. Call fit() first.")
+        
+        if isinstance(X, list):
+            X = pd.DataFrame(X)
+        
+        return self.model.predict(X).tolist()
+    
+    def score(self, X: Union[pd.DataFrame, List[List[float]]], y: List[float]) -> Dict[str, float]:
+        """
+        Calculate model performance metrics.
+        
+        Args:
+            X: Input features as DataFrame or list of lists
+            y: True target values
+            
+        Returns:
+            Dict[str, float]: Dictionary of metrics
+        """
+        if self.model is None:
+            raise Exception("Model not trained. Call fit() first.")
+        
+        if isinstance(X, list):
+            X = pd.DataFrame(X)
+        
+        y_pred = self.model.predict(X)
+        return {
+            "mse": mean_squared_error(y, y_pred),
+            "r2": r2_score(y, y_pred)
+        }
+    
+    def get_metrics(self) -> Dict[str, Any]:
+        """
+        Get training metrics.
+        
+        Returns:
+            Dict[str, Any]: Training metrics
+        """
+        if self.metrics is None:
+            raise Exception("Model not trained. Call fit() first.")
+        return self.metrics 

outdatedlabs-0.1.0/src/outdatedLabs.egg-info/PKG-INFO

@@ -0,0 +1,115 @@
+Metadata-Version: 2.4
+Name: outdatedLabs
+Version: 0.1.0
+Summary: A secure package for training machine learning models
+Home-page: https://github.com/Mouli51ch/OutDated
+Author: OutDated Team
+Author-email: your.email@example.com
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.31.0
+Requires-Dist: joblib>=1.3.0
+Requires-Dist: pandas>=2.0.0
+Requires-Dist: scikit-learn>=1.0.0
+Requires-Dist: tqdm>=4.65.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# OutDatedLabs - Secure Machine Learning Training Package
+
+A Python package for secure machine learning model training using the ML training server.
+
+## Installation
+
+```bash
+pip install outdatedLabs
+```
+
+## Quick Start
+
+```python
+from outdatedLabs import SecureModel
+
+# Create a linear regression model
+model = SecureModel.linearRegression()
+
+# Optionally set a custom server URL
+model.set_server_url("http://your-server:8000")
+
+# Train the model
+model.fit(
+    dataset_hash="your_dataset_hash",
+    features=["feature1", "feature2"],
+    target="target_column"
+)
+
+# Make predictions
+predictions = model.predict(X)
+
+# Get training metrics
+metrics = model.get_metrics()
+print(metrics)
+```
+
+## Features
+
+- Secure model training using encrypted datasets
+- Support for linear regression models
+- Progress tracking with tqdm
+- Comprehensive error handling and logging
+- Easy-to-use interface
+- Configurable server URL
+
+## API Reference
+
+### SecureModel
+
+The main class for secure model training.
+
+#### Methods
+
+- `linearRegression(server_url: str = "http://localhost:8000") -> SecureModel`
+  - Create a new linear regression model instance
+  
+- `set_server_url(server_url: str) -> SecureModel`
+  - Set a custom URL for the ML training server
+  
+- `fit(dataset_hash: str, features: List[str] = None, target: str = None, params: Dict[str, Any] = None) -> SecureModel`
+  - Train the model using the specified dataset
+  
+- `predict(X: Union[pd.DataFrame, List[List[float]]]) -> List[float]`
+  - Make predictions using the trained model
+  
+- `score(X: Union[pd.DataFrame, List[List[float]]], y: List[float]) -> Dict[str, float]`
+  - Calculate model performance metrics
+  
+- `get_metrics() -> Dict[str, Any]`
+  - Get training metrics
+
+## Requirements
+
+- Python 3.7+
+- requests
+- joblib
+- pandas
+- scikit-learn
+- tqdm
+
+## License
+
+MIT License 

outdatedlabs-0.1.0/src/outdatedLabs.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+setup.py
+src/outdatedLabs/__init__.py
+src/outdatedLabs/secure_model.py
+src/outdatedLabs.egg-info/PKG-INFO
+src/outdatedLabs.egg-info/SOURCES.txt
+src/outdatedLabs.egg-info/dependency_links.txt
+src/outdatedLabs.egg-info/requires.txt
+src/outdatedLabs.egg-info/top_level.txt

outdatedlabs-0.1.0/src/outdatedLabs.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

outdatedlabs-0.1.0/src/outdatedLabs.egg-info/requires.txt

@@ -0,0 +1,5 @@
+requests>=2.31.0
+joblib>=1.3.0
+pandas>=2.0.0
+scikit-learn>=1.0.0
+tqdm>=4.65.0

outdatedlabs-0.1.0/src/outdatedLabs.egg-info/top_level.txt

@@ -0,0 +1 @@
+outdatedLabs