nano-wait 0.0.2__py3-none-any.whl → 2.0__py3-none-any.whl

nano_wait/__init__.py

@@ -1 +1,38 @@
-from .nano_wait import *
+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/__main__.py

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

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/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/nano_wait.py

@@ -1,76 +1,32 @@
-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
+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/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.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,11 @@
+nano_wait/__init__.py,sha256=e2HO0pyr_xEYzPE-FD-Sq8gL3qRWdaovvpYv4uG608U,1287
+nano_wait/__main__.py,sha256=MSmt_5Xg84uHqzTN38JwgseJK8rsJn_11A8WD99VtEo,61
+nano_wait/cli.py,sha256=clYKsF36N4Fij6bH5vkzC4kXdOelpz32RcjoloHoZdY,1854
+nano_wait/core.py,sha256=n8bp7EI6lNwd-uceclHVmF49ZuxQItbI7etdijB5zFQ,2551
+nano_wait/nano_wait.py,sha256=XfefZQ0RgT3lhC2UZ1rQS-UC9HoG8sP3XMH3RjZUoG4,1091
+nano_wait/utils.py,sha256=28qjlES2Yw69mvaj52mmnRqWjtpxu3aG1GwG29dvBYw,486
+nano_wait-2.0.dist-info/licenses/LICENSE,sha256=iu3NnVehM00ZoIpIVkl44-9mCgXVh9iGYMZYXtMv0Mc,1084
+nano_wait-2.0.dist-info/METADATA,sha256=A74-Ml-wmlLQm4avwwkn1gpFCJoYV01KGuGrXK24Oy0,1017
+nano_wait-2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nano_wait-2.0.dist-info/top_level.txt,sha256=dSiF3Wc3ZEB1pzcp_ubHZeb0OE7n1nPMntkL48uz6aI,10
+nano_wait-2.0.dist-info/RECORD,,

{nano_wait-0.0.2.dist-info → nano_wait-2.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (70.1.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

{nano_wait-0.0.2.dist-info → nano_wait-2.0.dist-info/licenses}/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
+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-0.0.2.dist-info/METADATA

@@ -1,114 +0,0 @@
-Metadata-Version: 2.1
-Name: nano_wait
-Version: 0.0.2
-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
-
-<<<<<<< HEAD
-# Nano-Wait Library Documentation
-
-## Overview
-
-The Nano-Wait library is designed to automate PC tasks by dynamically calculating the wait time between actions based on system performance and WiFi signal strength. This library is particularly useful for scripting and automation tasks where timing is critical, and variations in system resources and network conditions can impact the execution of actions.
-
-## Installation
-
-To use the Nano-Wait library, ensure that the necessary dependencies are installed:
-```bash
-pip install pywifi psutil
-```
-
-## Initialization
-
-Before using the Nano-Wait library, you need to create an instance of the PCAutomation class. This instance will provide methods to calculate wait times based on your PC's performance and WiFi signal strength.
-
-```
-from biblioteca import PCAutomation
-
-# Initialize the automation
-automation = PCAutomation()
-```
-## Parameters
-
-speed
-Type: int
-Range: 1 to 10
-Description: This parameter controls the desired speed of automation. A value of 1 represents the slowest speed with the longest wait times, while a value of 10 represents the fastest speed with the shortest wait times. Adjust this parameter based on your specific requirements and system performance.
-
-## Main Functions
-
-wait_wifi(speed)
-Description: Calculates the necessary wait time between actions when considering both PC performance and WiFi signal strength.
-Parameters:
-speed (int): A value between 1 and 10 that controls the speed of automation.
-Returns: The calculated wait time in seconds as a float.
-
-Below is an example of how to use the Nano-Wait library in a Python automation script:
-
-```
-import pyautogui
-import time
-from biblioteca import PCAutomation
-
-# Initialize the automation
-automation = PCAutomation()
-
-# Set the desired speed of automation
-speed = 1
-
-# Press the Windows key and wait for the appropriate time
-wait_time = automation.wait_n_wifi(speed=speed)
-pyautogui.press('win')
-time.sleep(wait_time)
-
-# Type 'chrome' and wait for the appropriate time
-wait_time = automation.wait_n_wifi(speed=speed)
-pyautogui.write('chrome', interval=0.1)
-time.sleep(wait_time)
-
-# Press 'Enter' to open Chrome and wait for the appropriate time
-wait_time = automation.wait_wifi(speed=speed)
-pyautogui.press('enter')
-time.sleep(wait_time)  # Wait for Chrome to open
-
-# Type the URL of YouTube and wait for the appropriate time
-wait_time = automation.wait_wifi(speed=speed)
-pyautogui.write('youtube.com', interval=0.1)
-time.sleep(wait_time)
-
-# Press 'Enter' to go to YouTube and wait for the appropriate time
-wait_time = automation.wait_n_wifi(speed=speed)
-pyautogui.press('enter')
-Detailed Functionality
-get_wifi_signal()
-Description: Scans the available WiFi networks and returns a score (0-10) based on the signal strength of a specified WiFi network.
-Internal Usage: Used within the wait_wifi function to determine the WiFi score.
-get_pc_score()
-Description: Computes a score (0-10) based on CPU and memory usage, indicating the PC's performance.
-Internal Usage: Used within both wait_wifi and wait_n_wifi functions to determine the PC performance score.
-Conclusion
-The Nano-Wait library provides a simple yet powerful way to manage wait times in PC automation scripts by dynamically adjusting based on system and network conditions. By configuring the speed parameter, users can control the pace of automation to match their specific needs.
-```
-=======
-# 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.
->>>>>>> 01ab9c961b388fc5b69865a3b28d04b4be6679c2

nano_wait-0.0.2.dist-info/RECORD

@@ -1,7 +0,0 @@
-nano_wait/__init__.py,sha256=I5jtVftNdesvR689O2eOz3CeTAtFs8ZP5GJhn7RrQvA,24
-nano_wait/nano_wait.py,sha256=k1ENwE77qY687iAdMGIVZYlrDpV_ErNpXeOIX7JdWH0,2431
-nano_wait-0.0.2.dist-info/LICENSE,sha256=xPiTfTb6bSRJa60ZARdG1oGnfnkIVJc0b-N-vdv1iSM,1104
-nano_wait-0.0.2.dist-info/METADATA,sha256=L6iSjnjXYxfev98D2RrTpemA75tgf4f4F4uwkSVQAcc,4920
-nano_wait-0.0.2.dist-info/WHEEL,sha256=cpQTJ5IWu9CdaPViMhC9YzF8gZuS5-vlfoFihTBC86A,91
-nano_wait-0.0.2.dist-info/top_level.txt,sha256=dSiF3Wc3ZEB1pzcp_ubHZeb0OE7n1nPMntkL48uz6aI,10
-nano_wait-0.0.2.dist-info/RECORD,,