nano-wait 1.3__py3-none-any.whl → 3.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/vision.py

@@ -0,0 +1,111 @@
+import time
+import pytesseract
+import pyautogui
+from pynput.mouse import Controller, Button
+from PIL import ImageGrab, ImageOps
+import re
+
+class VisionMode:
+    """
+    Classe para captura e interpretação visual da tela.
+    Modos disponíveis:
+      - "observe": apenas lê e exibe dados detectados.
+      - "decision": lê dados e toma decisões automáticas.
+      - "learn": registra padrões visuais para uso futuro.
+    """
+
+    def __init__(self, mode="observe"):
+        self.mode = mode
+        self.mouse = Controller()
+        print(f"🔍 VisionMode iniciado no modo '{self.mode}'")
+
+    def capture_numbers(self, regions=None):
+        results = {}
+        if not regions:
+            regions = [None]
+
+        for idx, region in enumerate(regions):
+            print(f"📸 Capturando região {idx + 1}...")
+            if region:
+                x, y, w, h = region
+                if w <= 0 or h <= 0:
+                    raise ValueError("Largura e altura devem ser maiores que 0")
+                bbox = (x, y, x + w, y + h)
+                img = ImageGrab.grab(bbox=bbox)
+            else:
+                img = ImageGrab.grab()
+
+            img = ImageOps.grayscale(img)
+            text = pytesseract.image_to_string(img)
+            print(f"🧠 Texto detectado na região {idx + 1}: {text}")
+
+            match = re.findall(r'\d+', text)
+            numbers = [int(m) for m in match] if match else [0]
+
+            results[region or f"full_screen_{idx}"] = numbers
+
+        return results
+
+    def perform_action(self, action):
+        if action == "like_post":
+            self.mouse.click(Button.left, 2)
+            print("❤️ Ação: clique duplo executado.")
+        elif action == "skip_post":
+            self.mouse.move(100, 0)
+            print("⏭ Ação: pulando item.")
+        else:
+            print(f"⚙️ Ação desconhecida: {action}")
+
+    def run(self, regions=None):
+        numbers_per_region = self.capture_numbers(regions)
+
+        if self.mode == "observe":
+            for reg, nums in numbers_per_region.items():
+                print(f"👁 Região {reg}: números detectados = {nums}")
+
+        elif self.mode == "decision":
+            for reg, nums in numbers_per_region.items():
+                for number in nums:
+                    if number > 1000:
+                        self.perform_action("like_post")
+                    else:
+                        self.perform_action("skip_post")
+
+        elif self.mode == "learn":
+            print("📚 Modo aprendizado ativado: coletando dados...")
+            for _ in range(3):
+                self.capture_numbers(regions)
+                time.sleep(2)
+        else:
+            print(f"❌ Modo '{self.mode}' inválido.")
+
+    # ------------------------
+    # Nova função: mark_region
+    # ------------------------
+    @staticmethod
+    def mark_region():
+        """
+        Captura região usando PyAutoGUI.
+        O usuário clica no canto superior esquerdo e inferior direito.
+        Retorna (x, y, largura, altura)
+        """
+        print("📌 Marque a região desejada:")
+        print("Clique no canto superior esquerdo da área desejada e pressione Enter...")
+        input("Pressione Enter quando estiver pronto...")
+        x1, y1 = pyautogui.position()
+        print(f"📍 Ponto superior esquerdo: ({x1}, {y1})")
+
+        print("Clique no canto inferior direito da área desejada e pressione Enter...")
+        input("Pressione Enter quando estiver pronto...")
+        x2, y2 = pyautogui.position()
+        print(f"📍 Ponto inferior direito: ({x2}, {y2})")
+
+        x, y = min(x1, x2), min(y1, y2)
+        w, h = abs(x2 - x1), abs(y2 - y1)
+
+        if w == 0 or h == 0:
+            print("❌ Largura ou altura inválida. Tente novamente.")
+            return None
+
+        print(f"✅ Região marcada: (x={x}, y={y}, largura={w}, altura={h})")
+        return (x, y, w, h)

nano_wait-3.0.dist-info/METADATA

@@ -0,0 +1,61 @@
+Metadata-Version: 2.4
+Name: nano_wait
+Version: 3.0
+Summary: Adaptive waiting and smart automation library — includes Wi-Fi, system context, and Vision Mode for screen-based decisions.
+Author: Luiz Filipe Seabra de Marco
+Author-email: luizfilipeseabra@icloud.com
+License: MIT License
+Keywords: automation automação wifi wait vision ocr screen adaptive ai
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Utilities
+Classifier: Intended Audience :: Developers
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: psutil
+Requires-Dist: pywifi
+Provides-Extra: vision
+Requires-Dist: pyautogui; extra == "vision"
+Requires-Dist: pytesseract; extra == "vision"
+Requires-Dist: pynput; extra == "vision"
+Requires-Dist: opencv-python; extra == "vision"
+Requires-Dist: numpy; extra == "vision"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Nano-Wait Vision Module
+
+Nano-Wait agora inclui um módulo de **Visão Inteligente**, capaz de ler números diretamente da tela e tomar decisões automáticas em aplicativos ou vídeos.
+
+## Funcionalidades principais
+
+- **Múltiplas regiões**: capture números de várias áreas da tela ao mesmo tempo.
+- **Marcação interativa**: selecione regiões da tela facilmente usando o mouse com `mark_region()`.
+- **Modos inteligentes**:
+  - `observe`: apenas lê e exibe números.
+  - `decision`: lê números e executa ações automáticas com base em valores.
+  - `learn`: registra padrões visuais para uso futuro.
+- **Ações automatizadas**: clique duplo, pular itens, etc.
+- Compatível com macOS, Windows e Linux.
+
+## Instalação
+
+```bash
+pip install -e .
+# Dependências para o módulo de visão
+pip install pyautogui pytesseract pynput opencv-python-headless
+# macOS: instale o Tesseract OCR
+brew install tesseract

nano_wait-3.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+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/vision.py,sha256=4lx4pfbbhHpNby83A1vJDB7k38YVBc3Sym5O0O7nUwc,3912
+nano_wait-3.0.dist-info/licenses/LICENSE,sha256=iu3NnVehM00ZoIpIVkl44-9mCgXVh9iGYMZYXtMv0Mc,1084
+nano_wait-3.0.dist-info/METADATA,sha256=Q2jmJS9M_NcWxZWFA8FiZsxS-ZC471i8MZ-XW21C2v0,2206
+nano_wait-3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nano_wait-3.0.dist-info/entry_points.txt,sha256=IISprKfo-qF43ML7ywqV22rUrTm0Gi2y_DpAN03kZhA,49
+nano_wait-3.0.dist-info/top_level.txt,sha256=dSiF3Wc3ZEB1pzcp_ubHZeb0OE7n1nPMntkL48uz6aI,10
+nano_wait-3.0.dist-info/RECORD,,

{nano_wait-1.3.dist-info → nano_wait-3.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-3.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+nano-wait = nano_wait.cli:main

{nano_wait-1.3.dist-info → nano_wait-3.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
-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-1.3.dist-info/METADATA

@@ -1,388 +0,0 @@
-Metadata-Version: 2.1
-Name: nano_wait
-Version: 1.3
-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
-
-"""
-nano_wait.py
-
-Official Nano-Wait Library: Precise and Adaptive Waiting in Python ⚡
-
-Description: This library allows you to perform adaptive waiting based on the current performance of your computer
-
-### 📦 Installation
-
-
-⚠️ To download it is necessary to have two libraries to work, run in the terminal 'pip install psutil pywifi⚠️ 
-
-### Compatibility
-
-⚠️ Compatibility: For now it only works on Windows, we are working on it now :) ⚠️ 
-
-### Version
-
-Version: 1.2
-License: MIT
-
-### formulas
-
-Formulas used in the NanoWait library:
-
-1) PC Score Calculation:
-Evaluates how "free" your computer is based on CPU and memory usage:: 
-
-cpu_score = max(0, min(10, 10 - cpu_usage / 10)) 
-
-memory_score = max(0, min(10, 10 - memory_usage / 10)) 
-
-pc_score = (cpu_score + memory_score) / 2
-
-2) Wi-Fi Score calculation:
-Converts Wi-Fi signal strength (in dBm) to a scale of 0 to 10: 
-
-wifi_score = max(0, min(10, (signal_strength + 100) / 10)) 
-
-Example: If the signal is -60 dBm, 
-wifi_score = (-60 + 100) / 10 = 4
-
-3) Combined Risk Score Calculation (PC + Wi-Fi): 
-
-risk_score = (pc_score + wifi_score) / 2
-
-4) Wi-Fi standby time (wait_wifi): 
-
-wait_time = max(1, (10 - risk_score) / speed)
-
-5) Waiting time without Wi-Fi (wait_n_wifi): 
-
-wait_time = max(1, (10 - pc_score) / speed)
-
-Variable legend:
-
-| Variable | Description |
-|------------------|---------------------------------------|
-| cpu_usage | Current CPU usage (%) |
-| memory_usage | Current RAM usage (%) |
-| signal_strength | Wi-Fi signal strength (in dBm) |
-| speed | Speed factor (example: 1 to 10) |
-"""
-
-import pywifi
-import psutil
-import time
-
-
-class NanoWait: 
-""" 
-Core class of the Nano-Wait library.
-Allows you to calculate wait times based on the machine's current performance and Wi-Fi quality. 
-""" 
-
-def __init__(self): 
-""" 
-Initializes Wi-Fi modules, if available.
-""" 
-self.wifi = pywifi.PyWiFi() 
-self.interface = self.wifi.interfaces()[0] 
-
-def get_wifi_signal(self, ssid: str) -> float:7 
-
-"""Returns a score from 0 to 10 based on the Wi-Fi signal strength for the given SSID. 
-
-Args: 
-ssid (str): Name of the Wi-Fi network to be analyzed. 
-
-Returns: 
-float: Wi-Fi quality rating between 0 (poor) and 10 (excellent). 
-""" 
-try: 
-self.interface.scan() 
-time.sleep(2) # Wait for the scan to complete 
-scan_results = self.interface.scan_results() 
-
-signal_strength = -100 # Default weak signal value 
-
-for network in scan_results: 
-if network.ssid == ssid: 
-signal_strength = network.signal 
-break 
-else: 
-raise ValueError(f"Wi-Fi network '{ssid}' not found.") 
-
-wifi_score = max(0, min(10, (signal_strength + 100) / 10)) 
-return wifi_score 
-
-except Exception as e: 
-print(f"[WiFi Error] {e}") 
-return 0 
-
-def get_pc_score(self) -> float: 
-""" 
-Returns a score from 0 to 10 based on current CPU and RAM usage. 
-
-Returns: 
-float: Rating between 0 (overload) and 10 (light performance). 
-""" 
-try: 
-cpu_usage = psutil.cpu_percent(interval=1) 
-memory_usage = psutil.virtual_memory().percent 
-
-cpu_score = max(0, min(10, 10 - cpu_usage / 10)) 
-memory_score = max(0, min(10, 10 - memory_usage / 10)) 
-
-pc_score = (cpu_score + memory_score) / 2 
-return pc_score 
-
-except Exception as e:
-print(f"[PC Score Error] {e}")
-return 0
-
-def wait_wifi(self, speed: float, ssid: str) -> float:
-"""
-Calculates the wait time based on PC performance and Wi-Fi quality.
-
-Args:
-speed (float): Speed factor. Higher values result in shorter wait times.
-ssid (str): Name of the Wi-Fi network to be analyzed.
-
-Returns:
-float: Recommended wait time.
-"""
-try:
-pc_score = self.get_pc_score()
-wifi_score = self.get_wifi_signal(ssid)
-
-risk_score = (pc_score + wifi_score) / 2
-wait_time = max(1, (10 - risk_score) / speed)
-return wait_time
-
-except Exception as e:
-print(f"[Wait_wifi Error] {e}")
-return 1
-
-def wait_n_wifi(self, speed: float) -> float:
-"""
-Calculates the wait time based only on the PC's performance (no Wi-Fi).
-
-Args:
-speed (float): Speed factor.
-
-Returns:
-float: Recommended wait time.
-"""
-try:
-pc_score = self.get_pc_score()
-wait_time = max(1, (10 - pc_score) / speed)
-return wait_time
-
-except Exception as e:
-print(f"[Error wait_n_wifi] {e}")
-return 1
-
-def nano_wait(self, t: float, use_wifi: bool = False, ssid: str = "", speed: float = 1.5) -> None:
-"""
-Main library function. Adaptively waits for precisely t seconds.
-
-The wait is divided between passive time (with time.sleep) and active time (status check).
-
-Args:
-t (float): Desired total wait time, in seconds.
-use_wifi (bool): If True, considers the Wi-Fi network status in the analysis.
-ssid (str): Wi-Fi network name (required if use_wifi=True).
-speed (float): Adaptive speed. Higher values result in shorter waits.
-"""
-try:
-if use_wifi:
-if not ssid:
-raise ValueError("SSID required when use_wifi=True")
-wait_time = self.wait_wifi(speed, ssid)
-else:
-wait_time = self.wait_n_wifi(speed)
-
-t_passive = max(0, t - wait_time)
-t_active = min(t, wait_time)
-
-time.sleep(t_passive)
-
-start = time.time()
-while (time.time() - start) < t_active:
-continue # Active wait — ensures accuracy at the end of the wait
-
-except Exception as e:
-print(f"[Error nano_wait] {e}")
-time.sleep(t) # fallback: simple wait
-
-# Usage examples (to put in a separate file or test interactively):
-
-# Usage example without Wi-Fi
-# import time
-# from nano_wait.nano_wait import NanoWait
-
-# automation = NanoWait()
-# speeds = 10
-# wait_time = automation.wait_n_wifi(speed=speeds)
-# time.sleep(wait_time)
-
-# Usage example with Wi-Fi
-# ssid = "WiFiNetworkName"
-# wait_time = automation.wait_wifi(speed=speeds, ssid=ssid)
-# time.sleep(wait_time)
-
-# How much more efficient would it be?
-# Efficiency Comparison: NanoWait vs. Fixed Wait (Guess)
-
-This snippet mathematically explains how much the NanoWait library can improve wait time efficiency compared to a fixed wait performed by "guessing."
-
----
-
-## Formula for calculating adaptive wait time (NanoWait)
-
-For Wi-Fi, the wait time is calculated by:
-
-\[
-wait\_time = \max\left(min\_wait, \frac{10 - risk\_score}{speed}\right)
-\]
-
-Where:
-
-- \( risk\_score = \frac{pc\_score + wifi\_score}{2} \) — combined score of the computer's performance and Wi-Fi network quality (varies between 0 and 10).
-- \( speed \) — configurable factor that indicates the desired speed (higher values generate shorter wait times).
-- \( min\_wait \) — minimum wait time allowed (example: 0.05 seconds).
-
----
-
-## Percentage Gain Calculation
-
-The percentage gain in efficiency, comparing the fixed wait \( t_{fixed} \) with the adaptive wait time \( wait\_time \), is:
-
-\[
-G = \frac{t_{fixed} - wait\_time}{t_{fixed}} \times 100\%
-\]
-
----
-
-## Example Scenarios
-
-### Scenario A — Very Good PC and Wi-Fi
-
-- \( pc\_score = 9 \)
-- \( wifi\_score = 9 \)
-- \( risk\_score = 9 \)
-- \( speed = 10 \)
-- \( min\_wait = 0.05 \) seconds
-
-Calculating the wait time:
-
-\[
-wait\_time = \max(0.05, \frac{10 - 9}{10}) = \max(0.05, 0.1) = 0.1 \text{ seconds}
-\]
-
-If the fixed time is 0.2 seconds, the gain is:
-
-\[
-G = \frac{0.2 - 0.1}{0.2} \times 100\% = 50\%
-\]
-
-**Conclusion:** NanoWait halves the wait time.
-
----
-
-### Scenario B — Reasonable PC and Poor Wi-Fi
-
-- \( pc\_score = 5 \)
-- \( wifi\_score = 3 \)
-- \( risk\_score = 4 \)
-- \( speed = 5 \)
-- \( min\_wait = 0.05 \) seconds
-
-Calculating the wait time:
-
-\[
-wait\_time = \max(0.05, \frac{10 - 4}{5}) = \max(0.05, 1.2) = 1.2 \text{ seconds}
-\]
-
-If the fixed time is 1 second, the gain is:
-
-\[
-G = \frac{1 - 1.2}{1} \times 100\% = -20\%
-\]
-
-**Conclusion:** Longer wait to ensure stability, which is important to avoid errors.
-
----
-
-### Scenario C — Good PC, Average Wi-Fi
-
-- \( pc\_score = 8 \)
-- \( wifi\_score = 5 \)
-- \( risk\_score = 6.5 \)
-- \( speed = 10 \)
-- \( min\_wait = 0.05 \) seconds
-
-Calculating the wait time:
-
-\[
-wait\_time = \max(0.05, \frac{10 - 6.5}{10}) = \max(0.05, 0.35) = 0.35 \text{ seconds}
-\]
-
-If the fixed time is 0.5 seconds, the gain is:
-
-\[
-G = \frac{0.5 - 0.35}{0.5} \times 100\% = 30%
-\]
-
-**Conclusion:** 30% savings in total wait time.
-
----
-## Summary
-
-| Condition | Estimated Gain (%) |
-|-------------------|-----------------------------------|
-| Very good PC and Wi-Fi | Up to 50% reduction in wait time |
-| Reasonable PC, poor Wi-Fi | Can increase the time for robustness |
-| Good PC, average Wi-Fi | Approximately 20% to 35% savings |
-
----
-
-## Practical Benefits of NanoWait
-
-- **Adaptive time savings**: wait time decreases when the system is under stress.
-- **Robustness**: time increases when the system is under stress, avoiding errors.
-- **Customization**: the `speed` parameter allows you to adjust the behavior to your needs.
-
----
-
-In other words, on average, it's a 20% to 50% increase in efficiency.
-
----
-
-### ⚠️ Error Handling
-
-The **Nano-Wait** library is designed with robust fallback mechanisms to ensure stability, even under unexpected conditions.
-
-#### ✅ How the library behaves in case of failures:
-
-| Scenario                        | Behavior                                                                 |
-|---------------------------------|--------------------------------------------------------------------------|
-| **Wi-Fi network not found**     | Returns a Wi-Fi score of `0` and logs: `[WiFi Error]`                   |
-| **CPU or RAM usage unavailable**| Returns a PC score of `0` and logs: `[PC Score Error]`                  |
-| **Unexpected internal error**   | Falls back to `time.sleep(t)` and logs: `[Error nano_wait]`            |
-
-#### 🔐 Why this matters:
-
-- Ensures **safe execution** even when the system is under high load or lacks necessary permissions.
-- Avoids crashes by using default behaviors in case of unexpected conditions.
-- Ideal for **automation scripts** and **real-time systems** that require reliability and resilience.
-
-### Authors
-
-Author: Luiz Filipe Seabra de Marco and Vitor Seabra
-(and optionally the Wi-Fi network), ideal for applications that disable more intelligent waiting time control.Official Nano-Wait Library: Accurate and Adaptive Waiting in Python ⚡

nano_wait-1.3.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-1.3.dist-info/LICENSE,sha256=h77N3ma56KwtT-tI-UQ8LntVneq5t506SCJXmdTx5-Y,1105
-nano_wait-1.3.dist-info/METADATA,sha256=be9LJw0AjtT9aoE8S5TeliTItQorq2kJJawpDm6pvsg,10719
-nano_wait-1.3.dist-info/WHEEL,sha256=cpQTJ5IWu9CdaPViMhC9YzF8gZuS5-vlfoFihTBC86A,91
-nano_wait-1.3.dist-info/top_level.txt,sha256=dSiF3Wc3ZEB1pzcp_ubHZeb0OE7n1nPMntkL48uz6aI,10
-nano_wait-1.3.dist-info/RECORD,,