adapto 0.1.0__tar.gz → 0.1.2__tar.gz

{adapto-0.1.0 → adapto-0.1.2}/LICENSE

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

{adapto-0.1.0 → adapto-0.1.2}/PKG-INFO

@@ -1,17 +1,21 @@
-Metadata-Version: 2.1
-Name: adapto
-Version: 0.1.0
-Summary: AI-driven auto-scaling library for dynamic resource allocation.
-Home-page: https://github.com/hrshlmeht/adapto
-Author: Harshal Mehta
-Author-email: harshalmehta1998@gmail.com
-License: UNKNOWN
-Platform: UNKNOWN
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.7
-License-File: LICENSE
-
-UNKNOWN
-
+Metadata-Version: 2.2
+Name: adapto
+Version: 0.1.2
+Summary: AI-driven auto-scaling library for dynamic resource allocation.
+Home-page: https://github.com/hrshlmeht/adapto
+Author: Harshal Mehta
+Author-email: harshalmehta1998@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+License-File: LICENSE
+Requires-Dist: psutil
+Requires-Dist: numpy
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

adapto-0.1.2/README.md

@@ -0,0 +1,72 @@
+# Adapto - AI-Powered AutoScaler
+
+Adapto is an intelligent auto-scaling Python library that monitors system metrics like CPU, memory, and network usage. It uses machine learning to predict resource needs and proactively scale up or down.
+
+## Features
+- Real-time monitoring of CPU, memory, and network usage
+- Prediction-based scaling using machine learning
+- Automatic scale-up and scale-down based on thresholds
+- **Customizable Scaling Strategies** – Define custom rules for scaling based on your needs
+
+## Installation
+Install Adapto via pip:
+```sh
+pip install adapto
+```
+
+## Usage
+### Import the library
+```python
+from adapto.scaler import AutoScaler
+```
+
+### Create an instance of AutoScaler
+```python
+scaler = AutoScaler()
+```
+
+### Start monitoring and auto-scaling
+```python
+scaler.monitor()
+```
+
+### Fetch current system metrics
+```python
+metrics = scaler.get_system_metrics()
+print(metrics)
+```
+
+### Predict future resource usage
+```python
+predictions = scaler.predict_future_usage()
+print(predictions)
+```
+
+### Define Custom Scaling Strategies
+You can pass a custom scaling function to the `AutoScaler`:
+```python
+def my_scaling_strategy(metrics):
+    if metrics['cpu'] > 80 and metrics['memory'] > 75:
+        return 'scale_up'
+    elif metrics['cpu'] < 30 and metrics['memory'] < 40:
+        return 'scale_down'
+    return 'no_change'
+
+scaler = AutoScaler(custom_scaling=my_scaling_strategy)
+```
+
+## Configuration
+You can customize thresholds and instance limits:
+```python
+scaler = AutoScaler(
+    scale_up_threshold=75,
+    scale_down_threshold=30,
+    memory_threshold=70,
+    bandwidth_threshold=100000000,  # in bytes per second
+    min_instances=1,
+    max_instances=10
+)
+```
+
+## License
+This project is licensed under the MIT License.

{adapto-0.1.0 → adapto-0.1.2}/adapto/predictor.py

@@ -1,24 +1,24 @@
-import numpy as np
-from sklearn.linear_model import LinearRegression
-
-
-class Predictor:
-    def __init__(self):
-        pass
-
-    def train_predictor(self, history):
-        if len(history) < 2:
-            return history[-1] if history else 0
-
-        X = np.arange(len(history)).reshape(-1, 1)
-        y = np.array(history)
-        model = LinearRegression().fit(X, y)
-        return model.predict([[len(history)]])[0]
-
-    def predict(self, cpu_history, memory_history, network_sent_history, network_recv_history):
-        return {
-            "predicted_cpu": self.train_predictor(cpu_history),
-            "predicted_memory": self.train_predictor(memory_history),
-            "predicted_network_sent": self.train_predictor(network_sent_history),
-            "predicted_network_recv": self.train_predictor(network_recv_history)
-        }
+import numpy as np
+from sklearn.linear_model import LinearRegression
+
+
+class Predictor:
+    def __init__(self):
+        pass
+
+    def train_predictor(self, history):
+        if len(history) < 2:
+            return history[-1] if history else 0
+
+        X = np.arange(len(history)).reshape(-1, 1)
+        y = np.array(history)
+        model = LinearRegression().fit(X, y)
+        return model.predict([[len(history)]])[0]
+
+    def predict(self, cpu_history, memory_history, network_sent_history, network_recv_history):
+        return {
+            "predicted_cpu": self.train_predictor(cpu_history),
+            "predicted_memory": self.train_predictor(memory_history),
+            "predicted_network_sent": self.train_predictor(network_sent_history),
+            "predicted_network_recv": self.train_predictor(network_recv_history)
+        }

{adapto-0.1.0 → adapto-0.1.2}/adapto/scaler.py

@@ -1,112 +1,128 @@
-import psutil
-import time
-import logging
-from collections import deque
-from adapto.predictor import Predictor
-
-# Set up logging
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
-
-
-class AutoScaler:
-    def __init__(self, scale_up_threshold=80, scale_down_threshold=30, memory_threshold=75,
-                 bandwidth_threshold=100000000, min_instances=1, max_instances=10, history_size=10):
-        self.scale_up_threshold = scale_up_threshold
-        self.scale_down_threshold = scale_down_threshold
-        self.memory_threshold = memory_threshold
-        self.bandwidth_threshold = bandwidth_threshold  # in bytes per second
-        self.current_instances = min_instances
-        self.min_instances = min_instances
-        self.max_instances = max_instances
-        self.previous_network = psutil.net_io_counters()
-
-        # Data history for prediction
-        self.cpu_history = deque(maxlen=history_size)
-        self.memory_history = deque(maxlen=history_size)
-        self.network_sent_history = deque(maxlen=history_size)
-        self.network_recv_history = deque(maxlen=history_size)
-
-        self.predictor = Predictor()
-
-    def get_system_metrics(self):
-        cpu_usage = psutil.cpu_percent(interval=1)
-        memory_usage = psutil.virtual_memory().percent
-        load_avg = psutil.getloadavg()[0] if hasattr(psutil, "getloadavg") else 0  # Unix-only
-        disk_usage = psutil.disk_usage('/').percent
-        network_metrics = self.get_network_metrics()
-
-        # Store metrics in history
-        self.cpu_history.append(cpu_usage)
-        self.memory_history.append(memory_usage)
-        self.network_sent_history.append(network_metrics['network_sent'])
-        self.network_recv_history.append(network_metrics['network_recv'])
-
-        return {
-            "cpu_usage": cpu_usage,
-            "memory_usage": memory_usage,
-            "load_avg": load_avg,
-            "disk_usage": disk_usage,
-            **network_metrics
-        }
-
-    def get_network_metrics(self):
-        network_io = psutil.net_io_counters()
-        network_sent = network_io.bytes_sent - self.previous_network.bytes_sent
-        network_recv = network_io.bytes_recv - self.previous_network.bytes_recv
-        self.previous_network = network_io
-
-        return {
-            "network_sent": network_sent,
-            "network_recv": network_recv
-        }
-
-    def predict_future_usage(self):
-        return self.predictor.predict(
-            list(self.cpu_history),
-            list(self.memory_history),
-            list(self.network_sent_history),
-            list(self.network_recv_history)
-        )
-
-    def scale_up(self):
-        if self.current_instances < self.max_instances:
-            self.current_instances += 1
-            logging.info(f"Scaling up: New instance count = {self.current_instances}")
-        else:
-            logging.info("Max instances reached. Cannot scale up further.")
-
-    def scale_down(self):
-        if self.current_instances > self.min_instances:
-            self.current_instances -= 1
-            logging.info(f"Scaling down: New instance count = {self.current_instances}")
-        else:
-            logging.info("Min instances reached. Cannot scale down further.")
-
-    def monitor(self, interval=5):
-        while True:
-            metrics = self.get_system_metrics()
-            predictions = self.predict_future_usage()
-
-            logging.info(
-                f"CPU: {metrics['cpu_usage']}% | Memory: {metrics['memory_usage']}% | Load Avg: {metrics['load_avg']} | Disk: {metrics['disk_usage']}% | Network Sent: {metrics['network_sent']} bytes/s | Network Recv: {metrics['network_recv']} bytes/s")
-            logging.info(
-                f"Predicted CPU: {predictions['predicted_cpu']}% | Predicted Memory: {predictions['predicted_memory']}% | Predicted Network Sent: {predictions['predicted_network_sent']} bytes/s | Predicted Network Recv: {predictions['predicted_network_recv']} bytes/s")
-
-            if (predictions['predicted_cpu'] > self.scale_up_threshold or
-                    predictions['predicted_memory'] > self.memory_threshold or
-                    predictions['predicted_network_sent'] > self.bandwidth_threshold or
-                    predictions['predicted_network_recv'] > self.bandwidth_threshold):
-                self.scale_up()
-            elif (predictions['predicted_cpu'] < self.scale_down_threshold and
-                  predictions['predicted_memory'] < self.memory_threshold / 2 and
-                  predictions['predicted_network_sent'] < self.bandwidth_threshold / 2 and
-                  predictions['predicted_network_recv'] < self.bandwidth_threshold / 2):
-                self.scale_down()
-
-            time.sleep(interval)
-
-
-# Example usage
-if __name__ == "__main__":
-    scaler = AutoScaler()
-    scaler.monitor()
+import psutil
+import time
+import logging
+from collections import deque
+from adapto.predictor import Predictor
+
+# Set up logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+
+class AutoScaler:
+    def __init__(self, scale_up_threshold=80, scale_down_threshold=30, memory_threshold=75,
+                 bandwidth_threshold=100000000, min_instances=1, max_instances=10, history_size=10, custom_scaling=None):
+        self.scale_up_threshold = scale_up_threshold
+        self.scale_down_threshold = scale_down_threshold
+        self.memory_threshold = memory_threshold
+        self.bandwidth_threshold = bandwidth_threshold  # in bytes per second
+        self.current_instances = min_instances
+        self.min_instances = min_instances
+        self.max_instances = max_instances
+        self.previous_network = psutil.net_io_counters()
+
+        # Optional custom scaling function; should accept (metrics, predictions) and return 'scale_up', 'scale_down', or 'no_change'
+        self.custom_scaling = custom_scaling
+
+        # Data history for prediction
+        self.cpu_history = deque(maxlen=history_size)
+        self.memory_history = deque(maxlen=history_size)
+        self.network_sent_history = deque(maxlen=history_size)
+        self.network_recv_history = deque(maxlen=history_size)
+
+        self.predictor = Predictor()
+
+    def get_system_metrics(self):
+        cpu_usage = psutil.cpu_percent(interval=1)
+        memory_usage = psutil.virtual_memory().percent
+        load_avg = psutil.getloadavg()[0] if hasattr(psutil, "getloadavg") else 0  # Unix-only
+        disk_usage = psutil.disk_usage('/').percent
+        network_metrics = self.get_network_metrics()
+
+        # Store metrics in history
+        self.cpu_history.append(cpu_usage)
+        self.memory_history.append(memory_usage)
+        self.network_sent_history.append(network_metrics['network_sent'])
+        self.network_recv_history.append(network_metrics['network_recv'])
+
+        return {
+            "cpu_usage": cpu_usage,
+            "memory_usage": memory_usage,
+            "load_avg": load_avg,
+            "disk_usage": disk_usage,
+            **network_metrics
+        }
+
+    def get_network_metrics(self):
+        network_io = psutil.net_io_counters()
+        network_sent = network_io.bytes_sent - self.previous_network.bytes_sent
+        network_recv = network_io.bytes_recv - self.previous_network.bytes_recv
+        self.previous_network = network_io
+
+        return {
+            "network_sent": network_sent,
+            "network_recv": network_recv
+        }
+
+    def predict_future_usage(self):
+        return self.predictor.predict(
+            list(self.cpu_history),
+            list(self.memory_history),
+            list(self.network_sent_history),
+            list(self.network_recv_history)
+        )
+
+    def scale_up(self):
+        if self.current_instances < self.max_instances:
+            self.current_instances += 1
+            logging.info(f"Scaling up: New instance count = {self.current_instances}")
+        else:
+            logging.info("Max instances reached. Cannot scale up further.")
+
+    def scale_down(self):
+        if self.current_instances > self.min_instances:
+            self.current_instances -= 1
+            logging.info(f"Scaling down: New instance count = {self.current_instances}")
+        else:
+            logging.info("Min instances reached. Cannot scale down further.")
+
+    def monitor(self, interval=5):
+        while True:
+            metrics = self.get_system_metrics()
+            predictions = self.predict_future_usage()
+
+            logging.info(
+                f"CPU: {metrics['cpu_usage']}% | Memory: {metrics['memory_usage']}% | Load Avg: {metrics['load_avg']} | Disk: {metrics['disk_usage']}% | "
+                f"Network Sent: {metrics['network_sent']} bytes/s | Network Recv: {metrics['network_recv']} bytes/s"
+            )
+            logging.info(
+                f"Predicted CPU: {predictions['predicted_cpu']}% | Predicted Memory: {predictions['predicted_memory']}% | "
+                f"Predicted Network Sent: {predictions['predicted_network_sent']} bytes/s | Predicted Network Recv: {predictions['predicted_network_recv']} bytes/s"
+            )
+
+            # If a custom scaling strategy is provided, use it to decide the action
+            if self.custom_scaling:
+                action = self.custom_scaling(metrics, predictions)
+                if action == 'scale_up':
+                    self.scale_up()
+                elif action == 'scale_down':
+                    self.scale_down()
+            else:
+                # Default scaling strategy
+                if (predictions['predicted_cpu'] > self.scale_up_threshold or
+                    predictions['predicted_memory'] > self.memory_threshold or
+                    predictions['predicted_network_sent'] > self.bandwidth_threshold or
+                    predictions['predicted_network_recv'] > self.bandwidth_threshold):
+                    self.scale_up()
+                elif (predictions['predicted_cpu'] < self.scale_down_threshold and
+                      predictions['predicted_memory'] < self.memory_threshold / 2 and
+                      predictions['predicted_network_sent'] < self.bandwidth_threshold / 2 and
+                      predictions['predicted_network_recv'] < self.bandwidth_threshold / 2):
+                    self.scale_down()
+
+            time.sleep(interval)
+
+
+# Example usage
+if __name__ == "__main__":
+    scaler = AutoScaler()
+    scaler.monitor()

{adapto-0.1.0 → adapto-0.1.2}/adapto/utils.py

@@ -1,5 +1,5 @@
-import time
-
-def log_event(message):
-    """Log an event with a timestamp."""
+import time
+
+def log_event(message):
+    """Log an event with a timestamp."""
     print(f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] {message}")

{adapto-0.1.0 → adapto-0.1.2}/adapto.egg-info/PKG-INFO

@@ -1,17 +1,21 @@
-Metadata-Version: 2.1
-Name: adapto
-Version: 0.1.0
-Summary: AI-driven auto-scaling library for dynamic resource allocation.
-Home-page: https://github.com/hrshlmeht/adapto
-Author: Harshal Mehta
-Author-email: harshalmehta1998@gmail.com
-License: UNKNOWN
-Platform: UNKNOWN
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.7
-License-File: LICENSE
-
-UNKNOWN
-
+Metadata-Version: 2.2
+Name: adapto
+Version: 0.1.2
+Summary: AI-driven auto-scaling library for dynamic resource allocation.
+Home-page: https://github.com/hrshlmeht/adapto
+Author: Harshal Mehta
+Author-email: harshalmehta1998@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+License-File: LICENSE
+Requires-Dist: psutil
+Requires-Dist: numpy
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

{adapto-0.1.0 → adapto-0.1.2}/adapto.egg-info/SOURCES.txt

@@ -9,4 +9,6 @@ adapto.egg-info/PKG-INFO
 adapto.egg-info/SOURCES.txt
 adapto.egg-info/dependency_links.txt
 adapto.egg-info/requires.txt
-adapto.egg-info/top_level.txt
+adapto.egg-info/top_level.txt
+tests/test_predictor.py
+tests/test_scaler.py

{adapto-0.1.0 → adapto-0.1.2}/setup.cfg

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

{adapto-0.1.0 → adapto-0.1.2}/setup.py

@@ -1,18 +1,18 @@
-from setuptools import setup, find_packages
-
-setup(
-    name='adapto',
-    version='0.1.0',
-    packages=find_packages(),
-    install_requires=['psutil', 'numpy'],
-    description='AI-driven auto-scaling library for dynamic resource allocation.',
-    author='Harshal Mehta',
-    author_email='harshalmehta1998@gmail.com',
-    url='https://github.com/hrshlmeht/adapto',
-    classifiers=[
-        'Programming Language :: Python :: 3',
-        'License :: OSI Approved :: MIT License',
-        'Operating System :: OS Independent',
-    ],
-    python_requires='>=3.7',
-)
+from setuptools import setup, find_packages
+
+setup(
+    name='adapto',
+    version='0.1.2',
+    packages=find_packages(),
+    install_requires=['psutil', 'numpy'],
+    description='AI-driven auto-scaling library for dynamic resource allocation.',
+    author='Harshal Mehta',
+    author_email='harshalmehta1998@gmail.com',
+    url='https://github.com/hrshlmeht/adapto',
+    classifiers=[
+        'Programming Language :: Python :: 3',
+        'License :: OSI Approved :: MIT License',
+        'Operating System :: OS Independent',
+    ],
+    python_requires='>=3.7',
+)

adapto-0.1.2/tests/test_predictor.py

@@ -0,0 +1,18 @@
+import unittest
+from adapto.predictor import Predictor
+
+class TestPredictor(unittest.TestCase):
+    def setUp(self):
+        self.predictor = Predictor()
+
+    def test_prediction_with_data(self):
+        cpu_history = [10, 20, 30, 40, 50]
+        predicted_cpu = self.predictor.train_predictor(cpu_history)
+        self.assertIsInstance(predicted_cpu, float)
+
+    def test_prediction_with_empty_data(self):
+        predicted_cpu = self.predictor.train_predictor([])
+        self.assertEqual(predicted_cpu, 0)
+
+if __name__ == '__main__':
+    unittest.main()

adapto-0.1.2/tests/test_scaler.py

@@ -0,0 +1,11 @@
+import unittest
+from adapto.scaler import AutoScaler
+
+class TestAutoScaler(unittest.TestCase):
+    def test_default_thresholds(self):
+        scaler = AutoScaler()
+        self.assertEqual(scaler.cpu_threshold, 75)
+        self.assertEqual(scaler.memory_threshold, 80)
+
+if __name__ == '__main__':
+    unittest.main()

adapto-0.1.0/README.md

@@ -1,12 +0,0 @@
-# Adapto 🚀
-
-**Adapto** is an AI-driven auto-scaling Python library that dynamically adjusts resources based on real-time system usage.
-
-## Features
-- **Real-time monitoring** of CPU and memory usage
-- **Intelligent scaling** to optimize performance
-- **Easy integration** with Kubernetes and Docker
-
-## Installation
-```sh
-pip install adapto