chelo 0.0.1__tar.gz

chelo-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Nikolaos Passalis
+
+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.

chelo-0.0.1/MANIFEST.in

@@ -0,0 +1,4 @@
+include README.md
+include LICENSE
+include requirements.txt
+recursive-include src *

chelo-0.0.1/PKG-INFO

@@ -0,0 +1,249 @@
+Metadata-Version: 2.2
+Name: chelo
+Version: 0.0.1
+Summary: Chemical Engineering Dataset Loader Library
+Author-email: Nikolaos Passalis <passalis@auth.gr>
+License: MIT License
+        
+        Copyright (c) 2025 Nikolaos Passalis
+        
+        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.
+        
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: tqdm
+Requires-Dist: requests
+
+# CheLo (Chemical Engineering Dataset Loader) Library
+
+## Overview
+The CheLo Library is a Python library designed to simplify the exploration of data-driven modeling for students studying chemical engineering and researchers working on related projects. 
+This library provides a standardized framework for accessing, managing, and utilizing chemical engineering datasets for machine learning and statistical analysis.
+
+## Key Features
+- **Dataset Standardization**: Unified API for accessing and exploring datasets.
+- **Multiple Data Formats**: Provides ready to use loaders for numpy, PyTorch, and Keras.
+- **Preprocessing Tools**: Methods for feature/target selection, statistics, and previewing datasets.
+- **Dataset Management**: Automated downloading, caching, and registry of datasets.
+- **Extensibility**: Abstract base class for easy addition of new datasets.
+
+## Installation
+
+To install the library, run the following command:
+
+```bash
+pip install chelo
+```
+
+To install the library in editable mode for development purposes:
+
+```bash
+git clone https://github.com/your-repo/chelo.git
+cd chelo
+pip install -e .
+```
+
+## Package Structure
+
+```plaintext
+chelo/                   # Root package
+├── __init__.py          # Exposes core components
+├── base.py              # Abstract base class and shared utilities
+├── datasets/            # Dataset-specific implementations
+│   └── ...              # Dataset implementations
+├── utils/               # Utility functions and helpers
+│   ├── __init__.py      # Utility imports
+│   └──  download.py      # Dataset downloader and caching
+├── registry.py          # Dataset registry
+└── tests/               # Unit and integration tests
+    ├── __init__.py      # Makes this directory a package
+    ├── test_base.py     # Tests for the base class
+    └── test_X.py        # Tests for X dataset
+```
+
+## Usage Guide
+
+### Loading a Dataset
+
+```python
+from chelo.datasets.wine_quality import WineQualityDataset
+
+# Instantiate the dataset
+dataset = WineQualityDataset(wine_type="red", selected_features=["alcohol", "pH"], selected_targets=["quality"])
+
+# Load data (downloads if not cached)
+dataset.load_data()
+
+# Access dataset information
+info = dataset.get_dataset_info()
+print("Dataset Info:", info)
+```
+
+### Accessing Data
+
+```python
+# Convert to numpy arrays
+features, targets = dataset.to_numpy()
+print("Features shape:", features.shape)
+print("Targets shape:", targets.shape)
+
+# Convert to PyTorch Dataset
+pytorch_dataset = dataset.to_pytorch()
+print("Number of samples in PyTorch Dataset:", len(pytorch_dataset))
+
+# Convert to Keras Sequence
+keras_sequence = dataset.to_keras(batch_size=32)
+for batch_features, batch_targets in keras_sequence:
+    print("Batch Features:", batch_features.shape)
+    print("Batch Targets:", batch_targets.shape)
+```
+
+### Dataset Statistics and Preview
+
+```python
+# Get basic statistics
+stats = dataset.statistics()
+print("Statistics:", stats)
+
+# Preview the dataset
+preview = dataset.preview(n=5)
+print("Preview:", preview)
+```
+
+### Registering and Accessing Datasets
+
+```python
+from chelo.registry import DatasetRegistry
+
+# List available datasets
+print("Available Datasets:", DatasetRegistry.list_datasets())
+
+# Retrieve and load a dataset by name
+dataset = DatasetRegistry.get_dataset("WineQualityDataset", wine_type="red")
+dataset.load_data()
+```
+
+## Extending the Library
+
+To add a new dataset, create a new class that inherits from `ChemicalEngineeringDataset` and implement the required methods:
+
+1. **Create a new dataset module:**
+
+```plaintext
+chelo/datasets/my_new_dataset.py
+```
+
+2. **Implement the dataset class:**
+
+```python
+from ..base import ChemicalEngineeringDataset
+
+class MyNewDataset(ChemicalEngineeringDataset):
+    def __init__(self, selected_features=None, selected_targets=None):
+        super().__init__(selected_features, selected_targets)
+        self.dataset_name = "My New Dataset"
+
+    def load_data(self):
+        # Load dataset into self.raw_features and self.raw_targets
+        pass
+
+    def list_features(self):
+        return list(self.raw_features.keys())
+
+    def list_targets(self):
+        return list(self.raw_targets.keys())
+
+    def get_dataset_info(self):
+        return {"name": self.dataset_name, "description": "Description of the dataset."}
+```
+
+3. **Register the dataset:**
+
+Add the following line to `chelo/datasets/__init__.py`:
+
+```python
+from .my_new_dataset import MyNewDataset
+DatasetRegistry.register(MyNewDataset)
+```
+
+## Advanced Features
+
+### Downloader Utility
+
+The library includes a downloader utility for downloading and caching datasets. Files are stored in a structured cache directory (default: `~/.chelo`).
+
+#### Example Usage
+
+```python
+from chelo.utils.download import DatasetDownloader
+
+downloader = DatasetDownloader()
+
+# Download a dataset file
+url = "https://example.com/dataset.csv"
+file_path = downloader.download(url, dataset_name="example_dataset", filename="example.csv")
+print("Downloaded file path:", file_path)
+```
+
+### Dataset Registry
+
+The registry dynamically manages available datasets, allowing users to list and retrieve datasets by name.
+
+#### Example Usage
+
+```python
+from chelo.registry import DatasetRegistry
+
+# List all registered datasets
+print("Available Datasets:", DatasetRegistry.list_datasets())
+
+# Retrieve a dataset by name
+dataset = DatasetRegistry.get_dataset("WineQualityDataset", wine_type="white")
+```
+
+## Testing
+
+The library includes comprehensive unit tests to ensure correctness and reliability. Run tests using `pytest`:
+
+```bash
+pytest tests/
+```
+
+## Contributing
+
+Contributions are welcome! To contribute:
+
+1. Fork the repository.
+2. Create a feature branch.
+3. Implement your changes and add tests.
+4. Submit a pull request with a detailed description of your changes.
+
+## License
+
+This library is licensed under the MIT License. See the `LICENSE` file for more details.
+
+## Contact
+
+For questions or feedback, please contact [your email or project contact].
+

chelo-0.0.1/README.md

@@ -0,0 +1,212 @@
+# CheLo (Chemical Engineering Dataset Loader) Library
+
+## Overview
+The CheLo Library is a Python library designed to simplify the exploration of data-driven modeling for students studying chemical engineering and researchers working on related projects. 
+This library provides a standardized framework for accessing, managing, and utilizing chemical engineering datasets for machine learning and statistical analysis.
+
+## Key Features
+- **Dataset Standardization**: Unified API for accessing and exploring datasets.
+- **Multiple Data Formats**: Provides ready to use loaders for numpy, PyTorch, and Keras.
+- **Preprocessing Tools**: Methods for feature/target selection, statistics, and previewing datasets.
+- **Dataset Management**: Automated downloading, caching, and registry of datasets.
+- **Extensibility**: Abstract base class for easy addition of new datasets.
+
+## Installation
+
+To install the library, run the following command:
+
+```bash
+pip install chelo
+```
+
+To install the library in editable mode for development purposes:
+
+```bash
+git clone https://github.com/your-repo/chelo.git
+cd chelo
+pip install -e .
+```
+
+## Package Structure
+
+```plaintext
+chelo/                   # Root package
+├── __init__.py          # Exposes core components
+├── base.py              # Abstract base class and shared utilities
+├── datasets/            # Dataset-specific implementations
+│   └── ...              # Dataset implementations
+├── utils/               # Utility functions and helpers
+│   ├── __init__.py      # Utility imports
+│   └──  download.py      # Dataset downloader and caching
+├── registry.py          # Dataset registry
+└── tests/               # Unit and integration tests
+    ├── __init__.py      # Makes this directory a package
+    ├── test_base.py     # Tests for the base class
+    └── test_X.py        # Tests for X dataset
+```
+
+## Usage Guide
+
+### Loading a Dataset
+
+```python
+from chelo.datasets.wine_quality import WineQualityDataset
+
+# Instantiate the dataset
+dataset = WineQualityDataset(wine_type="red", selected_features=["alcohol", "pH"], selected_targets=["quality"])
+
+# Load data (downloads if not cached)
+dataset.load_data()
+
+# Access dataset information
+info = dataset.get_dataset_info()
+print("Dataset Info:", info)
+```
+
+### Accessing Data
+
+```python
+# Convert to numpy arrays
+features, targets = dataset.to_numpy()
+print("Features shape:", features.shape)
+print("Targets shape:", targets.shape)
+
+# Convert to PyTorch Dataset
+pytorch_dataset = dataset.to_pytorch()
+print("Number of samples in PyTorch Dataset:", len(pytorch_dataset))
+
+# Convert to Keras Sequence
+keras_sequence = dataset.to_keras(batch_size=32)
+for batch_features, batch_targets in keras_sequence:
+    print("Batch Features:", batch_features.shape)
+    print("Batch Targets:", batch_targets.shape)
+```
+
+### Dataset Statistics and Preview
+
+```python
+# Get basic statistics
+stats = dataset.statistics()
+print("Statistics:", stats)
+
+# Preview the dataset
+preview = dataset.preview(n=5)
+print("Preview:", preview)
+```
+
+### Registering and Accessing Datasets
+
+```python
+from chelo.registry import DatasetRegistry
+
+# List available datasets
+print("Available Datasets:", DatasetRegistry.list_datasets())
+
+# Retrieve and load a dataset by name
+dataset = DatasetRegistry.get_dataset("WineQualityDataset", wine_type="red")
+dataset.load_data()
+```
+
+## Extending the Library
+
+To add a new dataset, create a new class that inherits from `ChemicalEngineeringDataset` and implement the required methods:
+
+1. **Create a new dataset module:**
+
+```plaintext
+chelo/datasets/my_new_dataset.py
+```
+
+2. **Implement the dataset class:**
+
+```python
+from ..base import ChemicalEngineeringDataset
+
+class MyNewDataset(ChemicalEngineeringDataset):
+    def __init__(self, selected_features=None, selected_targets=None):
+        super().__init__(selected_features, selected_targets)
+        self.dataset_name = "My New Dataset"
+
+    def load_data(self):
+        # Load dataset into self.raw_features and self.raw_targets
+        pass
+
+    def list_features(self):
+        return list(self.raw_features.keys())
+
+    def list_targets(self):
+        return list(self.raw_targets.keys())
+
+    def get_dataset_info(self):
+        return {"name": self.dataset_name, "description": "Description of the dataset."}
+```
+
+3. **Register the dataset:**
+
+Add the following line to `chelo/datasets/__init__.py`:
+
+```python
+from .my_new_dataset import MyNewDataset
+DatasetRegistry.register(MyNewDataset)
+```
+
+## Advanced Features
+
+### Downloader Utility
+
+The library includes a downloader utility for downloading and caching datasets. Files are stored in a structured cache directory (default: `~/.chelo`).
+
+#### Example Usage
+
+```python
+from chelo.utils.download import DatasetDownloader
+
+downloader = DatasetDownloader()
+
+# Download a dataset file
+url = "https://example.com/dataset.csv"
+file_path = downloader.download(url, dataset_name="example_dataset", filename="example.csv")
+print("Downloaded file path:", file_path)
+```
+
+### Dataset Registry
+
+The registry dynamically manages available datasets, allowing users to list and retrieve datasets by name.
+
+#### Example Usage
+
+```python
+from chelo.registry import DatasetRegistry
+
+# List all registered datasets
+print("Available Datasets:", DatasetRegistry.list_datasets())
+
+# Retrieve a dataset by name
+dataset = DatasetRegistry.get_dataset("WineQualityDataset", wine_type="white")
+```
+
+## Testing
+
+The library includes comprehensive unit tests to ensure correctness and reliability. Run tests using `pytest`:
+
+```bash
+pytest tests/
+```
+
+## Contributing
+
+Contributions are welcome! To contribute:
+
+1. Fork the repository.
+2. Create a feature branch.
+3. Implement your changes and add tests.
+4. Submit a pull request with a detailed description of your changes.
+
+## License
+
+This library is licensed under the MIT License. See the `LICENSE` file for more details.
+
+## Contact
+
+For questions or feedback, please contact [your email or project contact].
+

chelo-0.0.1/chelo.egg-info/PKG-INFO

@@ -0,0 +1,249 @@
+Metadata-Version: 2.2
+Name: chelo
+Version: 0.0.1
+Summary: Chemical Engineering Dataset Loader Library
+Author-email: Nikolaos Passalis <passalis@auth.gr>
+License: MIT License
+        
+        Copyright (c) 2025 Nikolaos Passalis
+        
+        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.
+        
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: tqdm
+Requires-Dist: requests
+
+# CheLo (Chemical Engineering Dataset Loader) Library
+
+## Overview
+The CheLo Library is a Python library designed to simplify the exploration of data-driven modeling for students studying chemical engineering and researchers working on related projects. 
+This library provides a standardized framework for accessing, managing, and utilizing chemical engineering datasets for machine learning and statistical analysis.
+
+## Key Features
+- **Dataset Standardization**: Unified API for accessing and exploring datasets.
+- **Multiple Data Formats**: Provides ready to use loaders for numpy, PyTorch, and Keras.
+- **Preprocessing Tools**: Methods for feature/target selection, statistics, and previewing datasets.
+- **Dataset Management**: Automated downloading, caching, and registry of datasets.
+- **Extensibility**: Abstract base class for easy addition of new datasets.
+
+## Installation
+
+To install the library, run the following command:
+
+```bash
+pip install chelo
+```
+
+To install the library in editable mode for development purposes:
+
+```bash
+git clone https://github.com/your-repo/chelo.git
+cd chelo
+pip install -e .
+```
+
+## Package Structure
+
+```plaintext
+chelo/                   # Root package
+├── __init__.py          # Exposes core components
+├── base.py              # Abstract base class and shared utilities
+├── datasets/            # Dataset-specific implementations
+│   └── ...              # Dataset implementations
+├── utils/               # Utility functions and helpers
+│   ├── __init__.py      # Utility imports
+│   └──  download.py      # Dataset downloader and caching
+├── registry.py          # Dataset registry
+└── tests/               # Unit and integration tests
+    ├── __init__.py      # Makes this directory a package
+    ├── test_base.py     # Tests for the base class
+    └── test_X.py        # Tests for X dataset
+```
+
+## Usage Guide
+
+### Loading a Dataset
+
+```python
+from chelo.datasets.wine_quality import WineQualityDataset
+
+# Instantiate the dataset
+dataset = WineQualityDataset(wine_type="red", selected_features=["alcohol", "pH"], selected_targets=["quality"])
+
+# Load data (downloads if not cached)
+dataset.load_data()
+
+# Access dataset information
+info = dataset.get_dataset_info()
+print("Dataset Info:", info)
+```
+
+### Accessing Data
+
+```python
+# Convert to numpy arrays
+features, targets = dataset.to_numpy()
+print("Features shape:", features.shape)
+print("Targets shape:", targets.shape)
+
+# Convert to PyTorch Dataset
+pytorch_dataset = dataset.to_pytorch()
+print("Number of samples in PyTorch Dataset:", len(pytorch_dataset))
+
+# Convert to Keras Sequence
+keras_sequence = dataset.to_keras(batch_size=32)
+for batch_features, batch_targets in keras_sequence:
+    print("Batch Features:", batch_features.shape)
+    print("Batch Targets:", batch_targets.shape)
+```
+
+### Dataset Statistics and Preview
+
+```python
+# Get basic statistics
+stats = dataset.statistics()
+print("Statistics:", stats)
+
+# Preview the dataset
+preview = dataset.preview(n=5)
+print("Preview:", preview)
+```
+
+### Registering and Accessing Datasets
+
+```python
+from chelo.registry import DatasetRegistry
+
+# List available datasets
+print("Available Datasets:", DatasetRegistry.list_datasets())
+
+# Retrieve and load a dataset by name
+dataset = DatasetRegistry.get_dataset("WineQualityDataset", wine_type="red")
+dataset.load_data()
+```
+
+## Extending the Library
+
+To add a new dataset, create a new class that inherits from `ChemicalEngineeringDataset` and implement the required methods:
+
+1. **Create a new dataset module:**
+
+```plaintext
+chelo/datasets/my_new_dataset.py
+```
+
+2. **Implement the dataset class:**
+
+```python
+from ..base import ChemicalEngineeringDataset
+
+class MyNewDataset(ChemicalEngineeringDataset):
+    def __init__(self, selected_features=None, selected_targets=None):
+        super().__init__(selected_features, selected_targets)
+        self.dataset_name = "My New Dataset"
+
+    def load_data(self):
+        # Load dataset into self.raw_features and self.raw_targets
+        pass
+
+    def list_features(self):
+        return list(self.raw_features.keys())
+
+    def list_targets(self):
+        return list(self.raw_targets.keys())
+
+    def get_dataset_info(self):
+        return {"name": self.dataset_name, "description": "Description of the dataset."}
+```
+
+3. **Register the dataset:**
+
+Add the following line to `chelo/datasets/__init__.py`:
+
+```python
+from .my_new_dataset import MyNewDataset
+DatasetRegistry.register(MyNewDataset)
+```
+
+## Advanced Features
+
+### Downloader Utility
+
+The library includes a downloader utility for downloading and caching datasets. Files are stored in a structured cache directory (default: `~/.chelo`).
+
+#### Example Usage
+
+```python
+from chelo.utils.download import DatasetDownloader
+
+downloader = DatasetDownloader()
+
+# Download a dataset file
+url = "https://example.com/dataset.csv"
+file_path = downloader.download(url, dataset_name="example_dataset", filename="example.csv")
+print("Downloaded file path:", file_path)
+```
+
+### Dataset Registry
+
+The registry dynamically manages available datasets, allowing users to list and retrieve datasets by name.
+
+#### Example Usage
+
+```python
+from chelo.registry import DatasetRegistry
+
+# List all registered datasets
+print("Available Datasets:", DatasetRegistry.list_datasets())
+
+# Retrieve a dataset by name
+dataset = DatasetRegistry.get_dataset("WineQualityDataset", wine_type="white")
+```
+
+## Testing
+
+The library includes comprehensive unit tests to ensure correctness and reliability. Run tests using `pytest`:
+
+```bash
+pytest tests/
+```
+
+## Contributing
+
+Contributions are welcome! To contribute:
+
+1. Fork the repository.
+2. Create a feature branch.
+3. Implement your changes and add tests.
+4. Submit a pull request with a detailed description of your changes.
+
+## License
+
+This library is licensed under the MIT License. See the `LICENSE` file for more details.
+
+## Contact
+
+For questions or feedback, please contact [your email or project contact].
+

chelo-0.0.1/chelo.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+chelo.egg-info/PKG-INFO
+chelo.egg-info/SOURCES.txt
+chelo.egg-info/dependency_links.txt
+chelo.egg-info/requires.txt
+chelo.egg-info/top_level.txt
+src/__init__.py
+src/base.py
+src/registry.py
+src/datasets/__init__.py
+src/datasets/wine_quality.py
+src/utils/__init__.py
+src/utils/downloader.py
+tests/test_base.py

chelo-0.0.1/chelo.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

chelo-0.0.1/chelo.egg-info/requires.txt

@@ -0,0 +1,4 @@
+numpy
+pandas
+tqdm
+requests

chelo-0.0.1/chelo.egg-info/top_level.txt

@@ -0,0 +1 @@
+chelo

chelo-0.0.1/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+package-dir = {"chelo" = "src"}
+
+[project]
+name = "chelo"
+version = "0.0.1"
+description = "Chemical Engineering Dataset Loader Library"
+readme = "README.md"
+license = {file = "LICENSE"}
+authors = [
+    { name = "Nikolaos Passalis", email = "passalis@auth.gr" }
+]
+dependencies = [
+    "numpy",
+    "pandas",
+    "tqdm",
+    "requests",
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]

chelo-0.0.1/setup.cfg

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

chelo-0.0.1/src/base.py

@@ -0,0 +1,166 @@
+from abc import ABC, abstractmethod
+import numpy as np
+
+
+
+
+class CheLoDataset(ABC):
+    """
+    Abstract Base Class for datasets.
+    """
+
+    def __init__(self, selected_features=None, selected_targets=None):
+        """
+        Initialize the dataset with optional selected features and targets.
+        :param selected_features: List of features to select (default: all).
+        :param selected_targets: List of targets to select (default: all).
+        """
+        self.raw_features = None  # Immutable raw feature data
+        self.raw_targets = None  # Immutable raw target data
+        self.features = None  # Subset of features to use
+        self.targets = None  # Subset of targets to use
+        self.dataset_name = None  # Name of the dataset
+
+        self._selected_features = selected_features
+        self._selected_targets = selected_targets
+
+    @abstractmethod
+    def load_data(self):
+        """
+        Load the dataset and populate self.raw_features and self.raw_targets.
+        """
+        pass
+
+    @abstractmethod
+    def list_features(self):
+        """
+        List available features in the dataset.
+        """
+        pass
+
+    @abstractmethod
+    def list_targets(self):
+        """
+        List available targets in the dataset.
+        """
+        pass
+
+    @abstractmethod
+    def get_dataset_info(self):
+        """
+        Provide metadata about the dataset (e.g., source, size, description).
+        """
+        pass
+
+    def select_features(self, feature_names):
+        """
+        Dynamically select features from the dataset.
+        :param feature_names: List of feature names to select.
+        """
+        if not self.raw_features:
+            raise ValueError(f"Dataset {self.dataset_name} not loaded yet!")
+        self.features = {name: self.raw_features[name] for name in feature_names}
+
+    def select_targets(self, target_names):
+        """
+        Dynamically select targets from the dataset.
+        :param target_names: List of target names to select.
+        """
+        if not self.raw_targets:
+            raise ValueError(f"Dataset {self.dataset_name} not loaded yet!")
+        self.targets = {name: self.raw_targets[name] for name in target_names}
+
+    def _apply_initial_selections(self):
+        """
+        Apply initial selections if specified during initialization.
+        """
+        if self._selected_features:
+            self.select_features(self._selected_features)
+        else:
+            self.features = self.raw_features
+
+        if self._selected_targets:
+            self.select_targets(self._selected_targets)
+        else:
+            self.targets = self.raw_targets
+
+    def size(self):
+        """
+        Get the size of the dataset (number of samples).
+        """
+        return len(next(iter(self.features.values())))
+
+    def statistics(self):
+        """
+        Compute basic statistics for the features and targets.
+        :return: A dictionary of statistics (mean, std, min, max) for each feature and target.
+        """
+        stats = {}
+        for key, values in {**self.features, **self.targets}.items():
+            stats[key] = {
+                "mean": np.mean(values),
+                "std": np.std(values),
+                "min": np.min(values),
+                "max": np.max(values),
+            }
+        return stats
+
+    def to_numpy(self):
+        """
+        Convert the dataset to numpy arrays.
+        :return: Tuple of (features, targets) in numpy format.
+        """
+        return np.array(list(self.features.values())).T, np.array(list(self.targets.values())).T
+
+    def to_pytorch(self):
+        """
+        Provide a PyTorch Dataset object.
+        :return: A PyTorch Dataset containing features and targets.
+        """
+        from torch.utils.data import Dataset
+        class PyTorchDataset(Dataset):
+            def __init__(self, features, targets):
+                self.features = features
+                self.targets = targets
+
+            def __len__(self):
+                return len(self.features)
+
+            def __getitem__(self, idx):
+                return self.features[idx], self.targets[idx]
+
+        return PyTorchDataset(np.array(list(self.features.values())).T,
+                              np.array(list(self.targets.values())).T)
+
+    def to_keras(self, batch_size=32):
+        """
+        Provide a Keras Sequence object for training.
+        :param batch_size: Number of samples per batch.
+        :return: A Keras Sequence containing features and targets.
+        """
+        from tensorflow.keras.utils import Sequence
+        class KerasSequence(Sequence):
+            def __init__(self, features, targets, batch_size):
+                self.features = np.array(list(features.values())).T
+                self.targets = np.array(list(targets.values())).T
+                self.batch_size = batch_size
+
+            def __len__(self):
+                return int(np.ceil(len(self.features) / self.batch_size))
+
+            def __getitem__(self, idx):
+                start_idx = idx * self.batch_size
+                end_idx = start_idx + self.batch_size
+                return self.features[start_idx:end_idx], self.targets[start_idx:end_idx]
+
+        return KerasSequence(self.features, self.targets, batch_size)
+
+    def preview(self, n=5):
+        """
+        Preview the first n rows of the dataset.
+        """
+        preview_data = {
+            "features": {key: values[:n] for key, values in self.features.items()},
+            "targets": {key: values[:n] for key, values in self.targets.items()},
+        }
+        return preview_data

chelo-0.0.1/src/datasets/__init__.py

@@ -0,0 +1,17 @@
+# import pkgutil
+# import importlib
+# from ..registry import DatasetRegistry
+# from ..base import CheLoDataset
+
+# def auto_register_datasets():
+#     """
+#     Automatically discover and register datasets in the `datasets` package.
+#     """
+#     for _, module_name, _ in pkgutil.iter_modules(__path__):
+#         module = importlib.import_module(f"{__name__}.{module_name}")
+#         for attr_name in dir(module):
+#             attr = getattr(module, attr_name)
+#             if isinstance(attr, type) and issubclass(attr, CheLoDataset) and attr is not CheLoDataset:
+#                 DatasetRegistry.register(attr)
+#
+# auto_register_datasets()

chelo-0.0.1/src/datasets/wine_quality.py

@@ -0,0 +1,71 @@
+from ..base import CheLoDataset
+from ..registry import register_dataset
+from ..utils.downloader import DatasetDownloader
+import pandas as pd
+
+@register_dataset
+class WineQualityDataset(CheLoDataset):
+
+    BASE_URL = "https://archive.ics.uci.edu/ml/machine-learning-databases/wine-quality/"
+    FILES = {
+        "red": "winequality-red.csv",
+        "white": "winequality-white.csv",
+    }
+    CHECKSUMS ={
+        "red": "2daeecee174368f8a33b82c8cccae3a5",
+        "white": "5d9ff0f7f716dace19e3ab4578775fd7",
+    }
+
+    def __init__(self, wine_type="red", selected_features=None, selected_targets=None):
+        """
+        Initialize the Wine Quality Dataset.
+        :param wine_type: Type of wine ('red' or 'white').
+        :param selected_features: Features to select (default: all).
+        :param selected_targets: Targets to select (default: all).
+        """
+        super().__init__(selected_features, selected_targets)
+        if wine_type not in self.FILES:
+            raise ValueError(f"Invalid wine_type '{wine_type}'. Must be 'red' or 'white'.")
+        self.wine_type = wine_type
+        self.dataset_name = f"Wine Quality ({wine_type.capitalize()})"
+
+    def load_data(self):
+        """
+        Load the dataset from the UCI repository or cache.
+        """
+        downloader = DatasetDownloader()
+        file_url = self.BASE_URL + self.FILES[self.wine_type]
+        file_path = downloader.download(file_url, dataset_name="wine_quality", filename=self.FILES[self.wine_type],
+                                        checksum=self.CHECKSUMS[self.wine_type])
+
+        data = pd.read_csv(file_path, sep=";")
+        self.raw_features = data.drop(columns=["quality"]).to_dict(orient="list")
+        self.raw_targets = {"quality": data["quality"].tolist()}
+        self._apply_initial_selections()
+
+    def list_features(self):
+        """
+        List the available features in the dataset.
+        :return: List of feature names.
+        """
+        return list(self.raw_features.keys())
+
+    def list_targets(self):
+        """
+        List the available targets in the dataset.
+        :return: List of target names.
+        """
+        return list(self.raw_targets.keys())
+
+    def get_dataset_info(self):
+        """
+        Get metadata about the dataset.
+        :return: A dictionary containing dataset metadata.
+        """
+        return {
+            "name": self.dataset_name,
+            "description": "Dataset containing physicochemical attributes and quality ratings of wines.",
+            "wine_type": self.wine_type,
+            "features": self.list_features(),
+            "targets": self.list_targets(),
+        }

chelo-0.0.1/src/registry.py

@@ -0,0 +1,45 @@
+
+class DatasetRegistry:
+    """
+    A registry to manage available datasets in CheLo
+    """
+    _datasets = {}
+
+    @classmethod
+    def register(cls, dataset_cls):
+        """
+        Register a dataset class with the registry.
+        :param dataset_cls: The dataset class to register.
+        """
+        dataset_name = dataset_cls.__name__
+        if dataset_name in cls._datasets:
+            raise ValueError(f"Dataset {dataset_name} is already registered.")
+        cls._datasets[dataset_name] = dataset_cls
+
+    @classmethod
+    def list_datasets(cls):
+        """
+        List all registered datasets.
+        :return: A list of names of registered datasets.
+        """
+        return list(cls._datasets.keys())
+
+    @classmethod
+    def get_dataset(cls, name, **kwargs):
+        """
+        Retrieve an instance of the specified dataset by name.
+        :param name: Name of the dataset to retrieve.
+        :param kwargs: Additional arguments to pass to the dataset constructor.
+        :return: An instance of the dataset.
+        """
+        if name not in cls._datasets:
+            raise ValueError(f"Dataset {name} not found! Available datasets: {cls.list_datasets()}")
+        return cls._datasets[name](**kwargs)
+
+
+def register_dataset(cls):
+    """
+    A decorator to register a dataset class with the registry.
+    """
+    DatasetRegistry.register(cls)
+    return cls

chelo-0.0.1/src/utils/downloader.py

@@ -0,0 +1,118 @@
+import os
+import hashlib
+import requests
+from tqdm import tqdm
+import tarfile
+import zipfile
+
+class DatasetDownloader:
+    """
+    Utility class for downloading and caching datasets.
+    """
+
+    def __init__(self, cache_dir=None):
+        """
+        Initialize the downloader with an optional cache directory.
+        :param cache_dir: Directory to store downloaded datasets
+        """
+        self.cache_dir = cache_dir or os.getenv("CHELO_DATASET_CACHE", os.path.expanduser("~/.chelo_datasets"))
+        os.makedirs(self.cache_dir, exist_ok=True)
+
+
+    def _get_dataset_dir(self, dataset_name):
+        """
+        Get the directory path for a specific dataset.
+        :param dataset_name: Name of the dataset.
+        :return: Path to the dataset's directory.
+        """
+        dataset_dir = os.path.join(self.cache_dir, dataset_name)
+        os.makedirs(dataset_dir, exist_ok=True)
+        return dataset_dir
+
+    def _get_file_path(self, dataset_name, filename):
+        """
+        Get the full path for a file in the dataset's directory.
+        :param dataset_name: Name of the dataset.
+        :param filename: Name of the file.
+        :return: Full path to the file.
+        """
+        dataset_dir = self._get_dataset_dir(dataset_name)
+        return os.path.join(dataset_dir, filename)
+
+    def download(self, url, dataset_name, filename=None, checksum=None):
+        """
+        Download a file for a specific dataset and save it in the dataset's folder.
+        :param url: URL of the file to download.
+        :param dataset_name: Name of the dataset.
+        :param filename: Local filename (default: inferred from the URL).
+        :param checksum: Expected checksum (MD5 or SHA256) to validate the file (optional).
+        :return: Path to the downloaded file.
+        """
+        filename = filename or os.path.basename(url)
+        file_path = self._get_file_path(dataset_name, filename)
+
+        # Check if the file already exists
+        if os.path.exists(file_path):
+            if checksum and not self._verify_checksum(file_path, checksum):
+                print("Checksum mismatch! Redownloading the file.")
+            else:
+                return file_path
+
+        # Download the file
+        print(f"Downloading '{filename}' for dataset '{dataset_name}' from {url}...")
+        response = requests.get(url, stream=True)
+        response.raise_for_status()
+
+        # Save the file with progress bar
+        with open(file_path, "wb") as file, tqdm(
+                total=int(response.headers.get("content-length", 0)),
+                unit="B",
+                unit_scale=True,
+                desc=f"Downloading {filename}",
+        ) as progress:
+            for chunk in response.iter_content(chunk_size=1024):
+                file.write(chunk)
+                progress.update(len(chunk))
+
+        # Verify checksum
+        if checksum and not self._verify_checksum(file_path, checksum):
+            raise ValueError(f"Checksum verification failed for '{filename}'.")
+
+        print(f"File downloaded and saved at '{file_path}'.")
+        return file_path
+
+    def _verify_checksum(self, file_path, checksum):
+        """
+        Verify the checksum of a file.
+        :param file_path: Path to the file.
+        :param checksum: Expected checksum (MD5 or SHA256).
+        :return: True if the checksum matches, False otherwise.
+        """
+        hash_func = hashlib.sha256 if len(checksum) == 64 else hashlib.md5
+        with open(file_path, "rb") as file:
+            file_hash = hash_func(file.read()).hexdigest()
+        return file_hash == checksum
+
+
+
+def extract_file(self, file_path, extract_to=None):
+    """
+    Extract a compressed file (.zip or .tar.gz).
+    :param file_path: Path to the compressed file.
+    :param extract_to: Directory to extract to (default: same as file location).
+    :return: Path to the extracted directory.
+    """
+    extract_to = extract_to or os.path.splitext(file_path)[0]
+    os.makedirs(extract_to, exist_ok=True)
+
+    if file_path.endswith(".zip"):
+        with zipfile.ZipFile(file_path, "r") as zip_ref:
+            zip_ref.extractall(extract_to)
+    elif file_path.endswith(".tar.gz"):
+        with tarfile.open(file_path, "r:gz") as tar_ref:
+            tar_ref.extractall(extract_to)
+    else:
+        raise ValueError(f"Unsupported file format: {file_path}")
+
+    print(f"File extracted to '{extract_to}'.")
+    return extract_to

chelo-0.0.1/tests/test_base.py

@@ -0,0 +1,50 @@
+import pytest
+import os
+import numpy as np
+from chelo.base import CheLoDataset
+from chelo.utils.downloader import DatasetDownloader
+
+# Mock Base Class Implementation for Testing
+class MockDataset(CheLoDataset):
+    def __init__(self, selected_features=None, selected_targets=None):
+        super().__init__(selected_features, selected_targets)
+        self.dataset_name = "Mock Dataset"
+
+    def load_data(self):
+        self.raw_features = {
+            "Temperature": [300, 310, 320],
+            "Pressure": [101.3, 98.6, 102.5],
+        }
+        self.raw_targets = {"Reaction Rate": [1.2, 1.5, 1.3]}
+        self._apply_initial_selections()
+
+    def list_features(self):
+        return list(self.raw_features.keys())
+
+    def list_targets(self):
+        return list(self.raw_targets.keys())
+
+    def get_dataset_info(self):
+        return {
+            "name": self.dataset_name,
+            "description": "A mock dataset for testing.",
+            "size": self.size(),
+        }
+
+# Test Cases for Base Class
+def test_mock_dataset():
+    dataset = MockDataset(selected_features=["Temperature"], selected_targets=["Reaction Rate"])
+    dataset.load_data()
+
+    # Verify dataset information
+    assert dataset.get_dataset_info()["name"] == "Mock Dataset"
+    assert dataset.list_features() == ["Temperature", "Pressure"]
+    assert dataset.list_targets() == ["Reaction Rate"]
+
+    # Verify feature and target selection
+    features, targets = dataset.to_numpy()
+    assert features.shape == (3, 1)
+    assert targets.shape == (3, 1)
+
+if __name__ == "__main__":
+    pytest.main()