nano-wait 0.0.1__tar.gz → 2.0__tar.gz

{nano_wait-0.0.1 → nano_wait-2.0}/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2024 Luiz Filipe Seabra de marco
-
-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) 2024 Luiz Filipe Seabra de marco
+
+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.

nano_wait-2.0/PKG-INFO

@@ -0,0 +1,40 @@
+Metadata-Version: 2.4
+Name: nano_wait
+Version: 2.0
+Summary: Waiting Time Calculation for Automations Based on WiFi and PC Processing
+Author: Luiz Filipe Seabra de Marco
+Author-email: luizfilipeseabra@icloud.com
+License: MIT License
+Keywords: automation automação wifi wait
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: psutil
+Requires-Dist: pywifi
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: summary
+
+# ⚡ Nano-Wait v2.0
+
+**Adaptive smart wait for Python — replaces `time.sleep()` with intelligence.**
+
+---
+
+## 🚀 Features
+- Adjusts wait time based on CPU, RAM, and Wi-Fi quality.
+- Simple API: `wait(2.5, wifi="Office", speed="fast")`
+- CLI support: `nano-wait 2.5 --wifi "Office" --speed fast`
+- Built-in presets: `slow`, `normal`, `fast`, `ultra`
+- Optional logs and verbose mode.
+
+---
+
+## 📦 Installation
+```bash
+pip install nano-wait

nano_wait-2.0/README.md

@@ -0,0 +1,18 @@
+# ⚡ Nano-Wait v2.0
+
+**Adaptive smart wait for Python — replaces `time.sleep()` with intelligence.**
+
+---
+
+## 🚀 Features
+- Adjusts wait time based on CPU, RAM, and Wi-Fi quality.
+- Simple API: `wait(2.5, wifi="Office", speed="fast")`
+- CLI support: `nano-wait 2.5 --wifi "Office" --speed fast`
+- Built-in presets: `slow`, `normal`, `fast`, `ultra`
+- Optional logs and verbose mode.
+
+---
+
+## 📦 Installation
+```bash
+pip install nano-wait

nano_wait-2.0/nano_wait/__init__.py

@@ -0,0 +1,38 @@
+from .core import NanoWait
+
+def wait(t: float, wifi: str = None, speed: float = 1.5, smart: bool = False, verbose: bool = False, log: bool = False):
+    """
+    Main API function to wait adaptively.
+    
+    Args:
+        t (float): Base wait time in seconds
+        wifi (str, optional): Wi-Fi SSID to consider
+        speed (float, optional): Speed factor (ignored if smart=True)
+        smart (bool, optional): Enable Smart Context Mode
+        verbose (bool): Print debug info
+        log (bool): Save log
+    """
+    nw = NanoWait()
+
+    if smart:
+        pc_score = nw.get_pc_score()
+        wifi_score = nw.get_wifi_signal(wifi) if wifi else 5
+        risk_score = (pc_score + wifi_score) / 2
+        speed = max(0.5, min(5.0, risk_score))
+        if verbose:
+            print(f"[Smart Context] PC={pc_score:.2f}, Wi-Fi={wifi_score:.2f}, risk={risk_score:.2f}, speed={speed:.2f}")
+
+    if wifi:
+        wait_time = nw.wait_wifi(speed=speed, ssid=wifi)
+    else:
+        wait_time = nw.wait_n_wifi(speed=speed)
+
+    if verbose:
+        print(f"[NanoWait] PC+WiFi wait = {wait_time:.2f}s")
+
+    import time
+    time.sleep(wait_time)
+
+    if log:
+        with open("nano_wait.log", "a") as f:
+            f.write(f"{time.strftime('%Y-%m-%d %H:%M:%S')} - Waited {wait_time:.2f}s\n")

nano_wait-2.0/nano_wait/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    main()

nano_wait-2.0/nano_wait/cli.py

@@ -0,0 +1,58 @@
+import argparse
+from . import wait as nano_wait_func
+from .core import NanoWait
+
+# Presets tradicionais
+SPEED_PRESETS = {
+    "slow": 0.5,
+    "normal": 1.5,
+    "fast": 3.0,
+    "ultra": 5.0
+}
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Nano-Wait — Adaptive smart wait for Python."
+    )
+    parser.add_argument("time", type=float, help="Base time in seconds (e.g. 2.5)")
+    parser.add_argument("--wifi", type=str, help="Wi-Fi SSID to use (optional)")
+    parser.add_argument(
+        "--speed",
+        type=str,
+        default="auto",
+        help="Speed preset (slow, normal, fast, ultra) or 'auto'"
+    )
+    parser.add_argument("--smart", action="store_true", help="Enable Smart Context Mode")
+    parser.add_argument("--verbose", action="store_true", help="Show debug output")
+    parser.add_argument("--log", action="store_true", help="Write result to log file")
+
+    args = parser.parse_args()
+
+    nw = NanoWait()
+
+    # Determina o speed
+    if args.smart:
+        # Smart Context Mode
+        pc_score = nw.get_pc_score()
+        wifi_score = nw.get_wifi_signal(args.wifi) if args.wifi else 5
+        risk_score = (pc_score + wifi_score) / 2
+        # Quanto maior o risco (pior PC/Wi-Fi), menor o speed → espera maior
+        speed_value = max(0.5, min(5.0, risk_score))
+        if args.verbose:
+            print(f"[Smart Context] PC={pc_score:.2f}, Wi-Fi={wifi_score:.2f}, risk={risk_score:.2f}, speed={speed_value:.2f}")
+    elif args.speed.lower() == "auto":
+        # Auto-speed simples (sem Smart Context Mode)
+        speed_value = 1.5
+    else:
+        speed_value = SPEED_PRESETS.get(args.speed.lower(), 1.5)
+
+    nano_wait_func(
+        t=args.time,
+        wifi=args.wifi,
+        speed=speed_value,
+        verbose=args.verbose,
+        log=args.log
+    )
+
+if __name__ == "__main__":
+    main()

nano_wait-2.0/nano_wait/core.py

@@ -0,0 +1,68 @@
+class NanoWait:
+    def __init__(self):
+        import platform
+        self.system = platform.system().lower()
+        # Apenas Windows precisa de pywifi
+        if self.system == "windows":
+            import pywifi
+            self.wifi = pywifi.PyWiFi()
+            self.interface = self.wifi.interfaces()[0]
+        else:
+            self.wifi = None
+            self.interface = None
+
+    def get_pc_score(self):
+        import psutil
+        try:
+            cpu = psutil.cpu_percent(interval=1)
+            mem = psutil.virtual_memory().percent
+            return (max(0, min(10, 10 - cpu / 10)) + max(0, min(10, 10 - mem / 10))) / 2
+        except:
+            return 0
+
+    def get_wifi_signal(self, ssid=None):
+        # Retorna 0 se Wi-Fi não disponível
+        if self.system == "windows" and self.interface:
+            try:
+                self.interface.scan()
+                import time
+                time.sleep(2)
+                for net in self.interface.scan_results():
+                    if ssid is None or net.ssid == ssid:
+                        return max(0, min(10, (net.signal + 100) / 10))
+            except:
+                return 0
+        elif self.system == "darwin":
+            import subprocess
+            try:
+                out = subprocess.check_output([
+                    "/System/Library/PrivateFrameworks/Apple80211.framework/Versions/Current/Resources/airport",
+                    "-I"
+                ], text=True)
+                line = [l for l in out.split("\n") if "agrCtlRSSI" in l][0]
+                rssi = int(line.split(":")[1].strip())
+                return max(0, min(10, (rssi + 100) / 10))
+            except:
+                return 0
+        elif self.system == "linux":
+            import subprocess
+            try:
+                out = subprocess.check_output(["nmcli", "-t", "-f", "ACTIVE,SSID,SIGNAL", "dev", "wifi"], text=True)
+                for l in out.splitlines():
+                    active, name, sig = l.split(":")
+                    if active == "yes" or (ssid and name == ssid):
+                        return max(0, min(10, int(sig)/10))
+            except:
+                return 0
+        return 0
+
+    def wait_wifi(self, speed=1.5, ssid=None):
+        """Sempre disponível, mesmo sem pywifi"""
+        pc = self.get_pc_score()
+        wifi = self.get_wifi_signal(ssid)
+        risk = (pc + wifi) / 2
+        return max(0.2, (10 - risk)/speed)
+
+    def wait_n_wifi(self, speed=1.5):
+        pc = self.get_pc_score()
+        return max(0.2, (10 - pc)/speed)

nano_wait-2.0/nano_wait/nano_wait.py

@@ -0,0 +1,32 @@
+from .core import NanoWait
+from .utils import log_message, get_speed_value
+
+def wait(t: float, wifi: str = None, speed: str | float = "normal", verbose=False, log=False) -> float:
+    """
+    Adaptive smart wait — replaces time.sleep() with intelligence.
+
+    Args:
+        t (float): Base wait time in seconds.
+        wifi (str, optional): Wi-Fi SSID to evaluate. Defaults to None.
+        speed (str|float): 'slow', 'normal', 'fast', 'ultra', or custom float.
+        verbose (bool): Print details. Defaults to False.
+        log (bool): Write log to file. Defaults to False.
+
+    Returns:
+        float: Wait time executed (seconds).
+    """
+    speed_value = get_speed_value(speed)
+    nw = NanoWait()
+
+    factor = nw.wait_wifi(speed_value, wifi) if wifi else nw.wait_n_wifi(speed_value)
+    wait_time = round(max(0.05, min(t / factor, t)), 3)
+
+    if verbose:
+        print(f"[NanoWait] 🧠 speed={speed_value}, wait={wait_time:.3f}s")
+
+    if log:
+        log_message(f"Wait={wait_time:.3f}s | speed={speed_value}")
+
+    import time
+    time.sleep(wait_time)
+    return wait_time

nano_wait-2.0/nano_wait/utils.py

@@ -0,0 +1,13 @@
+from datetime import datetime
+
+def get_speed_value(speed):
+    """Converts speed preset or numeric input to float."""
+    speed_map = {"slow": 0.8, "normal": 1.5, "fast": 3.0, "ultra": 6.0}
+    if isinstance(speed, str):
+        return speed_map.get(speed.lower(), 1.5)
+    return float(speed)
+
+def log_message(text: str):
+    """Saves messages to nano_wait.log."""
+    with open("nano_wait.log", "a") as f:
+        f.write(f"[{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}] {text}\n")

nano_wait-2.0/nano_wait.egg-info/PKG-INFO

@@ -0,0 +1,40 @@
+Metadata-Version: 2.4
+Name: nano_wait
+Version: 2.0
+Summary: Waiting Time Calculation for Automations Based on WiFi and PC Processing
+Author: Luiz Filipe Seabra de Marco
+Author-email: luizfilipeseabra@icloud.com
+License: MIT License
+Keywords: automation automação wifi wait
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: psutil
+Requires-Dist: pywifi
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: summary
+
+# ⚡ Nano-Wait v2.0
+
+**Adaptive smart wait for Python — replaces `time.sleep()` with intelligence.**
+
+---
+
+## 🚀 Features
+- Adjusts wait time based on CPU, RAM, and Wi-Fi quality.
+- Simple API: `wait(2.5, wifi="Office", speed="fast")`
+- CLI support: `nano-wait 2.5 --wifi "Office" --speed fast`
+- Built-in presets: `slow`, `normal`, `fast`, `ultra`
+- Optional logs and verbose mode.
+
+---
+
+## 📦 Installation
+```bash
+pip install nano-wait

{nano_wait-0.0.1 → nano_wait-2.0}/nano_wait.egg-info/SOURCES.txt

@@ -2,7 +2,11 @@ LICENSE
 README.md
 setup.py
 nano_wait/__init__.py
+nano_wait/__main__.py
+nano_wait/cli.py
+nano_wait/core.py
 nano_wait/nano_wait.py
+nano_wait/utils.py
 nano_wait.egg-info/PKG-INFO
 nano_wait.egg-info/SOURCES.txt
 nano_wait.egg-info/dependency_links.txt

{nano_wait-0.0.1 → nano_wait-2.0}/nano_wait.egg-info/requires.txt

@@ -1,3 +1,2 @@
 psutil
 pywifi
-time

{nano_wait-0.0.1 → nano_wait-2.0}/setup.cfg

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

{nano_wait-0.0.1 → nano_wait-2.0}/setup.py

@@ -1,16 +1,17 @@
-from setuptools import setup
-
-with open("README.md", "r") as arq:
-    readme = arq.read()
-
-setup(name='nano_wait',
-    version='0.0.1',
-    license='MIT License',
-    author='Luiz Filipe Seabra de Marco',
-    long_description=readme,
-    long_description_content_type="text/markdown",
-    author_email='luizfilipeseabra@icloud.com',
-    keywords='automation automação wifi wait',
-    description=u'Waiting Time Calculation for Automations Based on WiFi and PC Processing',
-    packages=['nano_wait'],
-    install_requires=['psutil','pywifi','time'],)
+from setuptools import setup
+
+with open("README.md", "r", encoding="utf-8") as arq:
+    readme = arq.read()
+
+
+setup(name='nano_wait',
+    version='2.0',
+    license='MIT License',
+    author='Luiz Filipe Seabra de Marco',
+    long_description=readme,
+    long_description_content_type="text/markdown",
+    author_email='luizfilipeseabra@icloud.com',
+    keywords='automation automação wifi wait',
+    description=u'Waiting Time Calculation for Automations Based on WiFi and PC Processing',
+    packages=['nano_wait'],
+    install_requires=['psutil','pywifi'],)

nano_wait-0.0.1/PKG-INFO

@@ -1,28 +0,0 @@
-Metadata-Version: 2.1
-Name: nano_wait
-Version: 0.0.1
-Summary: Waiting Time Calculation for Automations Based on WiFi and PC Processing
-Author: Luiz Filipe Seabra de Marco
-Author-email: luizfilipeseabra@icloud.com
-License: MIT License
-Keywords: automation automação wifi wait
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: psutil
-Requires-Dist: pywifi
-Requires-Dist: time
-
-# NanoWait
-
-**NanoWait** é uma biblioteca Python para automação de tarefas com ajuste dinâmico do tempo de espera com base na qualidade da conexão WiFi e no desempenho do computador. É ideal para situações onde o tempo de espera deve ser ajustado de acordo com a condição da rede e do sistema para garantir que as operações de automação sejam executadas suavemente.
-
-**Requisitos**
-Antes de usar o NanoWait, você deve instalar as seguintes bibliotecas:
-
-    pywifi: Para verificar a qualidade do sinal WiFi.
-    psutil: Para monitorar o desempenho do sistema.
-    pyautogui: Para realizar ações de automação no computador.
-
-**Principais Funções**
-wait_wifi: Ela deve ser passada junto com speed e ssid. Ela calcula o tempo de espera considerando o Wifi e o processamento do PC.
-wait_n_wifi: Ela deve ser passada junto com speed. Ela calcula o tempo de espera considerando o processamento do PC no momento.

nano_wait-0.0.1/README.md

@@ -1,14 +0,0 @@
-# NanoWait
-
-**NanoWait** é uma biblioteca Python para automação de tarefas com ajuste dinâmico do tempo de espera com base na qualidade da conexão WiFi e no desempenho do computador. É ideal para situações onde o tempo de espera deve ser ajustado de acordo com a condição da rede e do sistema para garantir que as operações de automação sejam executadas suavemente.
-
-**Requisitos**
-Antes de usar o NanoWait, você deve instalar as seguintes bibliotecas:
-
-    pywifi: Para verificar a qualidade do sinal WiFi.
-    psutil: Para monitorar o desempenho do sistema.
-    pyautogui: Para realizar ações de automação no computador.
-
-**Principais Funções**
-wait_wifi: Ela deve ser passada junto com speed e ssid. Ela calcula o tempo de espera considerando o Wifi e o processamento do PC.
-wait_n_wifi: Ela deve ser passada junto com speed. Ela calcula o tempo de espera considerando o processamento do PC no momento.

nano_wait-0.0.1/nano_wait/__init__.py

@@ -1 +0,0 @@
-from .nano_wait import *

nano_wait-0.0.1/nano_wait/nano_wait.py

@@ -1,76 +0,0 @@
-import pywifi
-import psutil
-import time
-
-class NanoWait:
-    def __init__(self):
-        self.wifi = pywifi.PyWiFi()
-        self.interface = self.wifi.interfaces()[0]
-
-    def get_wifi_signal(self, ssid):
-        try:
-            self.interface.scan()
-            time.sleep(2)  # Wait for WiFi scan
-            scan_results = self.interface.scan_results()
-
-            signal_strength = -100  # Default value for poor signal
-
-            for network in scan_results:
-                if network.ssid == ssid:
-                    signal_strength = network.signal
-                    break
-            else:
-                raise ValueError(f"WiFi network '{ssid}' not found.")
-
-            # Convert signal strength to a scale of 0 to 10
-            wifi_score = max(0, min(10, (signal_strength + 100) / 10))
-            return wifi_score
-
-        except Exception as e:
-            print(f"Error getting WiFi signal: {e}")
-            return 0
-
-    def get_pc_score(self):
-        try:
-            cpu_usage = psutil.cpu_percent(interval=1)
-            memory_usage = psutil.virtual_memory().percent
-
-            # Convert CPU and memory usage to a scale of 0 to 10
-            cpu_score = max(0, min(10, 10 - cpu_usage / 10))
-            memory_score = max(0, min(10, 10 - memory_usage / 10))
-
-            # Average score of CPU and memory
-            pc_score = (cpu_score + memory_score) / 2
-            return pc_score
-
-        except Exception as e:
-            print(f"Error getting PC score: {e}")
-            return 0
-
-    def wait_wifi(self, speed, ssid):
-        try:
-            pc_score = self.get_pc_score()
-            wifi_score = self.get_wifi_signal(ssid)
-
-            # Combined risk score
-            risk_score = (pc_score + wifi_score) / 2
-
-            # Calculate wait time based on speed and risk score
-            wait_time = max(1, (10 - risk_score) / speed)
-            return wait_time
-
-        except Exception as e:
-            print(f"Error in wait_wifi: {e}")
-            return 1
-
-    def wait_n_wifi(self, speed):
-        try:
-            pc_score = self.get_pc_score()
-
-            # Calculate wait time based on speed and risk score
-            wait_time = max(1, (10 - pc_score) / speed)
-            return wait_time
-
-        except Exception as e:
-            print(f"Error in wait_n_wifi: {e}")
-            return 1

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

@@ -1,28 +0,0 @@
-Metadata-Version: 2.1
-Name: nano_wait
-Version: 0.0.1
-Summary: Waiting Time Calculation for Automations Based on WiFi and PC Processing
-Author: Luiz Filipe Seabra de Marco
-Author-email: luizfilipeseabra@icloud.com
-License: MIT License
-Keywords: automation automação wifi wait
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: psutil
-Requires-Dist: pywifi
-Requires-Dist: time
-
-# NanoWait
-
-**NanoWait** é uma biblioteca Python para automação de tarefas com ajuste dinâmico do tempo de espera com base na qualidade da conexão WiFi e no desempenho do computador. É ideal para situações onde o tempo de espera deve ser ajustado de acordo com a condição da rede e do sistema para garantir que as operações de automação sejam executadas suavemente.
-
-**Requisitos**
-Antes de usar o NanoWait, você deve instalar as seguintes bibliotecas:
-
-    pywifi: Para verificar a qualidade do sinal WiFi.
-    psutil: Para monitorar o desempenho do sistema.
-    pyautogui: Para realizar ações de automação no computador.
-
-**Principais Funções**
-wait_wifi: Ela deve ser passada junto com speed e ssid. Ela calcula o tempo de espera considerando o Wifi e o processamento do PC.
-wait_n_wifi: Ela deve ser passada junto com speed. Ela calcula o tempo de espera considerando o processamento do PC no momento.