quastt-show 0.1.2__py3-none-any.whl → 0.2.25__py3-none-any.whl

quastt_show/__init__.py

@@ -1 +1,3 @@
-from .game import Game
+from .game import TriviaShow   
+from .logger import SimpleQLogger
+from .resources import LFMTracker,AutoRefactoringPrompter

quastt_show/game.py

@@ -78,7 +78,7 @@ class RoundedButton(tk.Canvas):
 # Main Game class
 # ------------------------------
 
-class Game:
+class TriviaShow:
     def __init__(self, difficulty="medium"):
         self.difficulty = difficulty
         self.app = TriviaApp(difficulty)
@@ -384,5 +384,5 @@ class StatsFrame(tk.Frame):
 # ------------------------------
 
 if __name__ == "__main__":
-    game = Game(difficulty="medium")
+    game = TriviaShow(difficulty="medium")
     game.run()

quastt_show/logger.py

@@ -0,0 +1,241 @@
+import time
+import traceback
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from threading import Lock
+
+
+class SimpleQLogger:
+    """
+    Logger & Profiler performant pentru quastt_show.
+    - Profilează funcții (decorator) cu timp de execuție precis (perf_counter)
+    - Loghează mesaje (INFO, DEBUG, ERROR) cu timestamp
+    - Suportă execuție paralelă a mai multor funcții profile (n_jobs)
+    - Raport complet erori, timpi, mesaje
+    """
+
+    LEVELS = {"DEBUG": 10, "INFO": 20, "ERROR": 30}
+
+    def __init__(
+        self,
+        logfile="simpleqlogger.log",
+        n_jobs=1,
+        log_level="INFO",
+        log_to_console=True,
+        max_log_memory=1000,
+    ):
+        self.logfile = logfile
+        self.n_jobs = n_jobs if n_jobs != 0 else 1
+        self.log_level = log_level.upper() if log_level.upper() in self.LEVELS else "INFO"
+        self.log_to_console = log_to_console
+        self.max_log_memory = max_log_memory  # nr max mesaje in memorie
+
+        self._lock = Lock()
+        self._logs = []
+        self._errors = []
+        self._profiles = {}  # {func_name: [exec_times]}
+
+    # ---------------- Timestamp ----------------
+
+    def _timestamp(self):
+        return time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
+
+    # ---------------- Logging ----------------
+
+    def _should_log(self, level):
+        return self.LEVELS[level] >= self.LEVELS[self.log_level]
+
+    def _write_to_file(self, entry):
+        try:
+            with open(self.logfile, "a", encoding="utf-8") as f:
+                f.write(entry + "\n")
+        except Exception as e:
+            print(f"[SimpleQLogger ERROR] Cannot write to file: {e}")
+
+    def _add_log(self, entry, level):
+        with self._lock:
+            if len(self._logs) >= self.max_log_memory:
+                self._logs.pop(0)
+            self._logs.append((level, entry))
+        self._write_to_file(entry)
+        if self.log_to_console and level != "DEBUG":
+            print(entry)
+
+    def debug(self, message):
+        if self._should_log("DEBUG"):
+            self._add_log(f"[{self._timestamp()}] DEBUG: {message}", "DEBUG")
+
+    def info(self, message):
+        if self._should_log("INFO"):
+            self._add_log(f"[{self._timestamp()}] INFO: {message}", "INFO")
+
+    def error(self, message, exc: Exception = None):
+        ts = self._timestamp()
+        base_msg = f"[{ts}] ERROR: {message}"
+        if exc:
+            tb = traceback.format_exc()
+            entry = f"{base_msg}\nException:\n{tb}"
+        else:
+            entry = base_msg
+        with self._lock:
+            self._errors.append(entry)
+        self._add_log(entry, "ERROR")
+
+    # ---------------- Profilare funcții ----------------
+
+    def profile(self, func=None):
+        """
+        Decorator pentru profilare timp execuție.
+        Poate fi folosit cu sau fără paranteze.
+        """
+
+        def decorator(f):
+            def wrapper(*args, **kwargs):
+                start = time.perf_counter()
+                try:
+                    result = f(*args, **kwargs)
+                except Exception as e:
+                    self.error(f"Exception in '{f.__name__}'", e)
+                    raise
+                elapsed = time.perf_counter() - start
+                with self._lock:
+                    if f.__name__ not in self._profiles:
+                        self._profiles[f.__name__] = []
+                    self._profiles[f.__name__].append(elapsed)
+                self.debug(f"Func '{f.__name__}' exec time: {elapsed:.6f}s")
+                return result
+
+            return wrapper
+
+        if func:
+            return decorator(func)
+        return decorator
+
+    # -------------- Profilare paralelă (ThreadPool) --------------
+
+    def profile_parallel(self, funcs_with_args):
+        """
+        Execută funcții în paralel și profilează execuția.
+        funcs_with_args: listă de tuple (func, args, kwargs)
+        Returnează lista cu rezultatele.
+        """
+        n_workers = min(self.n_jobs, len(funcs_with_args))
+        results = [None] * len(funcs_with_args)
+        with ThreadPoolExecutor(max_workers=n_workers) as executor:
+            futures = {
+                executor.submit(self._profile_wrapper, f, *a, **kw): idx
+                for idx, (f, a, kw) in enumerate(funcs_with_args)
+            }
+            for future in as_completed(futures):
+                idx = futures[future]
+                try:
+                    results[idx] = future.result()
+                except Exception as e:
+                    self.error(f"Error in parallel func idx={idx}", e)
+                    results[idx] = None
+        return results
+
+    def _profile_wrapper(self, func, *args, **kwargs):
+        """
+        Wrapper intern pentru profilare în execuții paralele.
+        """
+        start = time.perf_counter()
+        try:
+            result = func(*args, **kwargs)
+        except Exception as e:
+            self.error(f"Exception in parallel func '{func.__name__}'", e)
+            raise
+        elapsed = time.perf_counter() - start
+        with self._lock:
+            if func.__name__ not in self._profiles:
+                self._profiles[func.__name__] = []
+            self._profiles[func.__name__].append(elapsed)
+        self.debug(f"[Parallel] Func '{func.__name__}' exec time: {elapsed:.6f}s")
+        return result
+
+    # ---------------- Rapoarte ----------------
+
+    def get_profile_report(self):
+        lines = ["=== Profile Report ==="]
+        with self._lock:
+            if not self._profiles:
+                lines.append("No profiling data.")
+            else:
+                for f, times in self._profiles.items():
+                    count = len(times)
+                    total = sum(times)
+                    avg = total / count if count > 0 else 0
+                    mn = min(times) if times else 0
+                    mx = max(times) if times else 0
+                    lines.append(
+                        f"{f}: calls={count}, total={total:.6f}s, avg={avg:.6f}s, min={mn:.6f}s, max={mx:.6f}s"
+                    )
+        return "\n".join(lines)
+
+    def get_error_report(self):
+        lines = ["=== Error Report ==="]
+        with self._lock:
+            if not self._errors:
+                lines.append("No errors logged.")
+            else:
+                lines.extend(self._errors)
+        return "\n".join(lines)
+
+    def get_log_report(self, level_filter=None):
+        """
+        level_filter: None (toate), "INFO", "DEBUG", "ERROR"
+        """
+        lines = ["=== Log Report ==="]
+        with self._lock:
+            filtered = (
+                [entry for lvl, entry in self._logs if lvl == level_filter]
+                if level_filter
+                else [entry for _, entry in self._logs]
+            )
+            if not filtered:
+                lines.append("No logs found.")
+            else:
+                lines.extend(filtered)
+        return "\n".join(lines)
+
+    # ---------------- Reset ----------------
+
+    def clear(self):
+        with self._lock:
+            self._logs.clear()
+            self._errors.clear()
+            self._profiles.clear()
+        self.info("Logger cleared all data.")
+
+
+# --------------------- Exemplu de utilizare ---------------------
+
+if __name__ == "__main__":
+    logger = SimpleQLogger(n_jobs=4, log_level="DEBUG", log_to_console=True)
+
+    @logger.profile
+    def slow_square(x):
+        time.sleep(0.1)
+        return x * x
+
+    @logger.profile
+    def might_fail(x):
+        time.sleep(0.05)
+        if x == 3:
+            raise ValueError("Intentional error!")
+        return x + 10
+
+    # Rulez funcții normal
+    for i in range(5):
+        try:
+            print(f"slow_square({i}) = {slow_square(i)}")
+        except Exception as e:
+            print(f"Caught error: {e}")
+
+    # Rulez funcții în paralel
+    funcs = [(might_fail, (i,), {}) for i in range(5)]
+    results = logger.profile_parallel(funcs)
+    print("Parallel results:", results)
+
+    print("\n" + logger.get_profile_report())
+    print("\n" + logger.get_error_report())
+    print("\n" + logger.get_log_report())

quastt_show/monitoring.py

@@ -0,0 +1,333 @@
+import threading
+import time
+import os
+import sys
+import traceback
+from datetime import datetime
+
+# Optional GPU check - we'll try to import pynvml, if fails skip GPU monitoring
+try:
+    import ctypes
+    import platform
+    if platform.system() == 'Windows':
+        _lib_name = "nvml.dll"
+    elif platform.system() == 'Linux':
+        _lib_name = "libnvidia-ml.so.1"
+    else:
+        _lib_name = None
+    if _lib_name:
+        from ctypes import byref, c_uint, c_ulonglong, c_char_p, c_int
+        _nvml = ctypes.cdll.LoadLibrary(_lib_name)
+
+        # Nvml constants & functions:
+        NVML_SUCCESS = 0
+
+        class nvmlUtilization_t(ctypes.Structure):
+            _fields_ = [("gpu", c_uint), ("memory", c_uint)]
+
+        def nvml_init():
+            return _nvml.nvmlInit()
+
+        def nvml_shutdown():
+            return _nvml.nvmlShutdown()
+
+        def nvml_device_get_handle_by_index(index, handle_ptr):
+            return _nvml.nvmlDeviceGetHandleByIndex(index, handle_ptr)
+
+        def nvml_device_get_utilization_rates(handle, util_ptr):
+            return _nvml.nvmlDeviceGetUtilizationRates(handle, util_ptr)
+
+        def nvml_device_get_memory_info(handle, mem_info_ptr):
+            return _nvml.nvmlDeviceGetMemoryInfo(handle, mem_info_ptr)
+
+        class nvmlMemory_t(ctypes.Structure):
+            _fields_ = [("total", c_ulonglong), ("free", c_ulonglong), ("used", c_ulonglong)]
+    else:
+        _nvml = None
+
+except Exception:
+    _nvml = None
+
+
+def get_cpu_usage_percent():
+    """Return CPU usage percent over 0.1 seconds"""
+    try:
+        if sys.platform == "win32":
+            import psutil
+            return psutil.cpu_percent(interval=0.1)
+        else:
+            # Linux/Mac - approximate by reading /proc/stat or use os.times
+            import subprocess
+            output = subprocess.check_output("top -bn2 | grep 'Cpu(s)'", shell=True).decode()
+            lines = output.strip().split("\n")
+            if len(lines) < 2:
+                return None
+            # Parse 2nd sample line
+            line = lines[1]
+            # format: Cpu(s):  3.5%us,  1.1%sy,  0.0%ni, 94.9%id,  0.5%wa,  0.0%hi,  0.0%si,  0.0%st
+            parts = line.split(',')
+            for part in parts:
+                if 'id' in part:
+                    idle = float(part.strip().split('%')[0])
+                    usage = 100.0 - idle
+                    return round(usage, 2)
+            return None
+    except Exception:
+        return None
+
+
+def get_ram_usage_mb():
+    """Return RAM used in MB"""
+    try:
+        if sys.platform == "win32":
+            import psutil
+            mem = psutil.virtual_memory()
+            used_mb = (mem.total - mem.available) / (1024 * 1024)
+            return round(used_mb, 2)
+        else:
+            with open('/proc/meminfo', 'r') as f:
+                meminfo = f.read()
+            lines = meminfo.split('\n')
+            mem_total_kb = None
+            mem_free_kb = None
+            buffers_kb = None
+            cached_kb = None
+            for line in lines:
+                if line.startswith("MemTotal:"):
+                    mem_total_kb = int(line.split()[1])
+                elif line.startswith("MemFree:"):
+                    mem_free_kb = int(line.split()[1])
+                elif line.startswith("Buffers:"):
+                    buffers_kb = int(line.split()[1])
+                elif line.startswith("Cached:"):
+                    cached_kb = int(line.split()[1])
+            if None in (mem_total_kb, mem_free_kb, buffers_kb, cached_kb):
+                return None
+            used_kb = mem_total_kb - (mem_free_kb + buffers_kb + cached_kb)
+            used_mb = used_kb / 1024
+            return round(used_mb, 2)
+    except Exception:
+        return None
+
+
+class ResourceMonitor:
+    """
+    ResourceMonitor: Monitors CPU, RAM and optionally GPU usage with configurable thresholds,
+    periodic checks, logging, and customizable alerts.
+
+    Parameters:
+    ----------
+    cpu_threshold : float (0-100)
+        CPU usage percentage above which alert triggers (default 90.0)
+    ram_threshold_mb : float
+        RAM used in MB above which alert triggers (default 4000.0 MB)
+    gpu_threshold : float (0-100)
+        GPU usage percentage above which alert triggers (default 90.0)
+    monitor_interval_sec : float
+        How often to check resource usage in seconds (default 5.0)
+    log_to_console : bool
+        If True, print logs to console (default True)
+    log_to_file : bool
+        If True, save logs to file (default False)
+    log_file_path : str
+        File path for logs (default "resource_monitor.log")
+    max_log_lines : int
+        Maximum lines to keep in log file before rotation (default 10000)
+    alert_callback : callable
+        Function called on alert with signature func(resource:str, usage:float)
+    stop_on_alert : bool
+        If True, stops monitoring on first alert (default False)
+    n_jobs : int
+        Number of threads to use for parallel monitoring (default 1)
+
+    Usage:
+    ------
+    monitor = ResourceMonitor(cpu_threshold=80, ram_threshold_mb=3000,
+                              monitor_interval_sec=2, log_to_console=True,
+                              stop_on_alert=True)
+    monitor.start()
+    # ... do work ...
+    monitor.stop()
+    """
+
+    def __init__(self,
+                 cpu_threshold=90.0,
+                 ram_threshold_mb=4000.0,
+                 gpu_threshold=90.0,
+                 monitor_interval_sec=5.0,
+                 log_to_console=True,
+                 log_to_file=False,
+                 log_file_path="resource_monitor.log",
+                 max_log_lines=10000,
+                 alert_callback=None,
+                 stop_on_alert=False,
+                 n_jobs=1):
+        self.cpu_threshold = cpu_threshold
+        self.ram_threshold_mb = ram_threshold_mb
+        self.gpu_threshold = gpu_threshold
+        self.monitor_interval_sec = monitor_interval_sec
+        self.log_to_console = log_to_console
+        self.log_to_file = log_to_file
+        self.log_file_path = log_file_path
+        self.max_log_lines = max_log_lines
+        self.alert_callback = alert_callback
+        self.stop_on_alert = stop_on_alert
+        self.n_jobs = max(1, n_jobs)
+
+        self._stop_event = threading.Event()
+        self._thread = None
+        self._log_lines = []
+
+        # GPU related
+        self.gpu_available = False
+        self._gpu_handle = None
+        self._init_gpu()
+
+    def _init_gpu(self):
+        if _nvml:
+            try:
+                ret = nvml_init()
+                if ret == NVML_SUCCESS:
+                    # get handle for GPU 0 (first GPU)
+                    handle = ctypes.c_void_p()
+                    if nvml_device_get_handle_by_index(0, byref(handle)) == NVML_SUCCESS:
+                        self.gpu_available = True
+                        self._gpu_handle = handle
+                    else:
+                        self.gpu_available = False
+                else:
+                    self.gpu_available = False
+            except Exception:
+                self.gpu_available = False
+        else:
+            self.gpu_available = False
+
+    def _log(self, msg):
+        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        full_msg = f"[{timestamp}] {msg}"
+        self._log_lines.append(full_msg)
+        if self.log_to_console:
+            print(full_msg)
+        if self.log_to_file:
+            self._write_log_file(full_msg)
+
+        # Rotate log lines if too long
+        if len(self._log_lines) > self.max_log_lines:
+            self._log_lines = self._log_lines[-self.max_log_lines:]
+
+    def _write_log_file(self, line):
+        try:
+            with open(self.log_file_path, "a", encoding="utf-8") as f:
+                f.write(line + "\n")
+        except Exception:
+            pass
+
+    def _check_alerts(self, cpu_usage, ram_usage, gpu_usage):
+        alert_triggered = False
+        if cpu_usage is not None and cpu_usage > self.cpu_threshold:
+            self._log(f"ALERT: CPU usage high: {cpu_usage}% > threshold {self.cpu_threshold}%")
+            if self.alert_callback:
+                self.alert_callback("CPU", cpu_usage)
+            alert_triggered = True
+
+        if ram_usage is not None and ram_usage > self.ram_threshold_mb:
+            self._log(f"ALERT: RAM usage high: {ram_usage}MB > threshold {self.ram_threshold_mb}MB")
+            if self.alert_callback:
+                self.alert_callback("RAM", ram_usage)
+            alert_triggered = True
+
+        if self.gpu_available and gpu_usage is not None and gpu_usage > self.gpu_threshold:
+            self._log(f"ALERT: GPU usage high: {gpu_usage}% > threshold {self.gpu_threshold}%")
+            if self.alert_callback:
+                self.alert_callback("GPU", gpu_usage)
+            alert_triggered = True
+
+        if alert_triggered and self.stop_on_alert:
+            self._log("Stopping monitor due to alert.")
+            self.stop()
+
+    def _get_gpu_usage(self):
+        if not self.gpu_available or not self._gpu_handle:
+            return None
+        try:
+            util = nvmlUtilization_t()
+            if nvml_device_get_utilization_rates(self._gpu_handle, byref(util)) == NVML_SUCCESS:
+                return util.gpu
+        except Exception:
+            return None
+        return None
+
+    def _snapshot(self):
+        cpu = get_cpu_usage_percent()
+        ram = get_ram_usage_mb()
+        gpu = self._get_gpu_usage()
+        return cpu, ram, gpu
+
+    def _monitor_loop(self):
+        self._log("ResourceMonitor started.")
+        while not self._stop_event.is_set():
+            cpu, ram, gpu = self._snapshot()
+            self._log(f"Snapshot - CPU: {cpu}%, RAM: {ram}MB, GPU: {gpu}%")
+            self._check_alerts(cpu, ram, gpu)
+            time.sleep(self.monitor_interval_sec)
+        self._log("ResourceMonitor stopped.")
+
+    def start(self):
+        """Start monitoring resources in a background thread."""
+        if self._thread and self._thread.is_alive():
+            self._log("Monitor already running.")
+            return
+        self._stop_event.clear()
+        if self.n_jobs == 1:
+            self._thread = threading.Thread(target=self._monitor_loop, daemon=True)
+            self._thread.start()
+        else:
+            # For multiple threads monitoring (e.g. for different resources)
+            self._log(f"Starting {self.n_jobs} monitor threads.")
+            self._threads = []
+            for i in range(self.n_jobs):
+                t = threading.Thread(target=self._monitor_loop, daemon=True)
+                self._threads.append(t)
+                t.start()
+
+    def stop(self):
+        """Stop monitoring."""
+        self._stop_event.set()
+        if self._thread:
+            self._thread.join()
+        if hasattr(self, "_threads"):
+            for t in self._threads:
+                t.join()
+
+    def get_snapshot(self):
+        """
+        Return current usage snapshot as a dict:
+            {'cpu': float, 'ram': float, 'gpu': float or None}
+        """
+        cpu, ram, gpu = self._snapshot()
+        return {"cpu": cpu, "ram": ram, "gpu": gpu}
+
+    def get_report(self):
+        """Return a summary report string with last logged lines."""
+        return "\n".join(self._log_lines[-20:])
+
+
+if __name__ == "__main__":
+    # Demo usage
+    def alert_fn(resource, usage):
+        print(f"*** ALERT callback: {resource} usage high: {usage}")
+
+    monitor = ResourceMonitor(cpu_threshold=10,
+                              ram_threshold_mb=500,
+                              monitor_interval_sec=2,
+                              alert_callback=alert_fn,
+                              stop_on_alert=False,
+                              log_to_console=True,
+                              n_jobs=1)
+
+    monitor.start()
+    time.sleep(10)
+    print("Snapshot:", monitor.get_snapshot())
+    monitor.stop()
+    print("Final Report:")
+    print(monitor.get_report())

quastt_show/resources.py

@@ -0,0 +1,319 @@
+import time
+import traceback
+import numpy as np
+
+class SimpleNeuralNet:
+    """
+    A very simple feed-forward neural network for demonstration.
+    Input: vectorized error features
+    Output: vector representing categories/suggestions
+    """
+    def __init__(self, input_size, hidden_sizes, output_size, lr=0.01):
+        self.lr = lr
+        self.weights = []
+        self.biases = []
+        layer_sizes = [input_size] + hidden_sizes + [output_size]
+        for i in range(len(layer_sizes) - 1):
+            w = np.random.randn(layer_sizes[i], layer_sizes[i+1]) * 0.1
+            b = np.zeros(layer_sizes[i+1])
+            self.weights.append(w)
+            self.biases.append(b)
+
+    def relu(self, x):
+        return np.maximum(0, x)
+
+    def softmax(self, x):
+        e_x = np.exp(x - np.max(x))
+        return e_x / e_x.sum(axis=-1, keepdims=True)
+
+    def forward(self, x):
+        self.zs = []
+        self.activations = [x]
+        a = x
+        for i in range(len(self.weights) - 1):
+            z = a @ self.weights[i] + self.biases[i]
+            a = self.relu(z)
+            self.zs.append(z)
+            self.activations.append(a)
+        # Output layer
+        z = a @ self.weights[-1] + self.biases[-1]
+        self.zs.append(z)
+        a = self.softmax(z)
+        self.activations.append(a)
+        return a
+
+    def predict(self, x):
+        return self.forward(x)
+
+    def train(self, x, y_true):
+        """
+        Simple one-step training (cross-entropy loss)
+        x: input vector (numpy)
+        y_true: one-hot vector for target
+        """
+        output = self.forward(x)
+        loss = -np.sum(y_true * np.log(output + 1e-8))
+
+        # Backpropagation
+        delta = output - y_true  # derivative of loss wrt softmax input
+        for i in reversed(range(len(self.weights))):
+            a_prev = self.activations[i]
+            dw = np.outer(a_prev, delta)
+            db = delta
+
+            self.weights[i] -= self.lr * dw
+            self.biases[i] -= self.lr * db
+
+            if i > 0:
+                dz = delta @ self.weights[i].T
+                delta = dz * (self.zs[i-1] > 0)  # relu derivative
+
+        return loss
+
+
+class LFMTracker:
+    """
+    Learning-From-Mistakes Tracker.
+    Tracks and learns from errors/exceptions in user code,
+    provides detailed explanations and suggestions
+    """
+
+    def __init__(self,
+                 max_history=100,
+                 error_vector_size=50,
+                 hidden_sizes=[64, 32],
+                 suggestion_categories=5,
+                 learning_rate=0.01,
+                 verbose=True):
+        """
+        Parameters:
+        - max_history: max number of tracked errors to store
+        - error_vector_size: size of input vector 
+        - hidden_sizes: list of hidden layers sizes 
+        - suggestion_categories: number of suggestion types outputs
+        - learning_rate: training rate
+        - verbose: print tracking info
+        """
+        self.max_history = max_history
+        self.error_vector_size = error_vector_size
+        self.verbose = verbose
+        self.history = []
+        self.nn = SimpleNeuralNet(input_size=error_vector_size,
+                                  hidden_sizes=hidden_sizes,
+                                  output_size=suggestion_categories,
+                                  lr=learning_rate)
+
+    def _vectorize_error(self, error: Exception) -> np.ndarray:
+        """
+        Vectorizes the error into a fixed-size numerical vector.
+        Uses traceback and error type information.
+        """
+        tb_str = ''.join(traceback.format_exception_only(type(error), error))
+        tb_hash = hash(tb_str) % (10 ** 8)
+        tb_vec = np.zeros(self.error_vector_size)
+
+        # Simple vectorization: encode hash bits into vector
+        for i in range(min(self.error_vector_size, 32)):
+            tb_vec[i] = (tb_hash >> i) & 1
+
+        # Add error type info (one hot for common types)
+        error_types = ['ValueError', 'TypeError', 'IndexError', 'KeyError', 'ZeroDivisionError']
+        for i, etype in enumerate(error_types):
+            if etype == type(error).__name__:
+                if i + 32 < self.error_vector_size:
+                    tb_vec[i + 32] = 1
+
+        return tb_vec
+
+    def track_error(self, error: Exception, custom_msg: str = None):
+        """
+        Track an error occurrence and update model with feedback.
+        """
+        vec = self._vectorize_error(error)
+
+        # Predict suggestions (softmax output)
+        suggestions = self.nn.predict(vec)
+
+        if self.verbose:
+            print(f"[LFMTracker] Tracked error: {type(error).__name__}: {error}")
+            print(f"[LFMTracker] suggestions (probabilities): {suggestions}")
+
+        # Store history with timestamp and message
+        if len(self.history) >= self.max_history:
+            self.history.pop(0)
+        self.history.append({'error': error, 'vector': vec, 'time': time.time(), 'msg': custom_msg})
+
+        return suggestions
+
+    def give_feedback(self, error: Exception, correct_category: int):
+        """
+        Train based on user feedback for the error category.
+        correct_category: index of the correct suggestion category (0-based)
+        """
+        vec = self._vectorize_error(error)
+        y_true = np.zeros(self.nn.biases[-1].shape)
+        y_true[correct_category] = 1
+        loss = self.nn.train(vec, y_true)
+        if self.verbose:
+            print(f"[LFMTracker] trained with feedback. Loss: {loss:.5f}")
+
+    def report(self):
+        """
+        Prints a summary report of tracked errors.
+        """
+        print(f"\n[LFMTracker] Total errors tracked: {len(self.history)}")
+        counts = {}
+        for entry in self.history:
+            etype = type(entry['error']).__name__
+            counts[etype] = counts.get(etype, 0) + 1
+        print("[LFMTracker] Error type counts:")
+        for etype, count in counts.items():
+            print(f"  {etype}: {count}")
+
+
+class AutoRefactoringPrompter:
+    """
+    AutoRefactoringPrompter suggests refactorings for code smells and complexity,
+    and can apply automated fixes (conceptual, not real code parsing).
+    Uses a simple heuristic to rank suggestions.
+    """
+
+    def __init__(self,
+                 max_function_length=50,
+                 max_variable_name_length=20,
+                 min_duplication_length=5,
+                 max_duplicate_occurrences=3,
+                 suggestion_categories=4,
+                 hidden_sizes=[32, 16],
+                 learning_rate=0.005,
+                 verbose=True):
+        """
+        Parameters:
+        - max_function_length: max allowed lines in a function before suggestion
+        - max_variable_name_length: max allowed variable name length
+        - min_duplication_length: min lines duplicated to suggest extraction
+        - max_duplicate_occurrences: max duplicated occurrences to flag
+        - suggestion_categories: number of refactor suggestions
+        - hidden_sizes: hidden layers sizes for AI
+        - learning_rate: training rate
+        - verbose: print info
+        """
+        self.max_function_length = max_function_length
+        self.max_variable_name_length = max_variable_name_length
+        self.min_duplication_length = min_duplication_length
+        self.max_duplicate_occurrences = max_duplicate_occurrences
+        self.verbose = verbose
+        self.nn = SimpleNeuralNet(input_size=5,
+                                  hidden_sizes=hidden_sizes,
+                                  output_size=suggestion_categories,
+                                  lr=learning_rate)
+
+    def analyze_code(self, code_str: str):
+        """
+        Analyzes code string to detect smells:
+        - long functions
+        - long variable names
+        - duplicated lines (simple count)
+        Returns a dict with analysis data.
+        """
+        lines = code_str.split('\n')
+        functions = self._extract_functions(lines)
+        long_funcs = [f for f in functions if len(f['lines']) > self.max_function_length]
+
+        long_var_names = []
+        for line in lines:
+            words = line.strip().split()
+            for w in words:
+                if w.isidentifier() and len(w) > self.max_variable_name_length:
+                    long_var_names.append(w)
+
+        duplicates = self._detect_duplicates(lines)
+
+        analysis = {
+            'long_functions': len(long_funcs),
+            'long_var_names': len(long_var_names),
+            'duplicates': duplicates['count'],
+            'duplicate_lines': duplicates['lines']
+        }
+        if self.verbose:
+            print(f"[AutoRefactoring] Long funcs: {analysis['long_functions']}, Long vars: {analysis['long_var_names']}, Duplicates: {analysis['duplicates']}")
+        return analysis
+
+    def _extract_functions(self, lines):
+        """
+        Extracts function code blocks (very basic heuristic)
+        Returns list of dict {name, lines}
+        """
+        functions = []
+        current_func = None
+        func_lines = []
+        for line in lines:
+            if line.strip().startswith("def "):
+                if current_func is not None:
+                    functions.append({'name': current_func, 'lines': func_lines})
+                current_func = line.strip()
+                func_lines = []
+            elif current_func:
+                func_lines.append(line)
+        if current_func is not None:
+            functions.append({'name': current_func, 'lines': func_lines})
+        return functions
+
+    def _detect_duplicates(self, lines):
+        """
+        Detects duplicated lines and their counts (naive).
+        Returns dict with count and lines.
+        """
+        counts = {}
+        for line in lines:
+            line = line.strip()
+            if len(line) > 0:
+                counts[line] = counts.get(line, 0) + 1
+        duplicates = {line: cnt for line, cnt in counts.items() if cnt > 1}
+        return {'count': len(duplicates), 'lines': duplicates}
+
+    def suggest_refactors(self, code_str: str):
+        """
+        Uses to suggest best refactor action based on code analysis.
+        Categories:
+          0 - Extract Method
+          1 - Rename Variables
+          2 - Remove Duplicates
+          3 - General Cleanup
+        Returns category index and explanation.
+        """
+        analysis = self.analyze_code(code_str)
+        feature_vector = np.array([
+            analysis['long_functions'],
+            analysis['long_var_names'],
+            analysis['duplicates'],
+            len(code_str),
+            len(code_str.split('\n'))
+        ], dtype=float)
+
+        # Normalize features for AI input roughly
+        feature_vector = feature_vector / (np.max(feature_vector) + 1e-5)
+
+        prediction = self.nn.predict(feature_vector)
+        suggestion_idx = int(np.argmax(prediction))
+
+        suggestions_map = {
+            0: "Extract long functions into smaller methods.",
+            1: "Rename long or unclear variable names to concise ones.",
+            2: "Remove duplicated code blocks by abstraction.",
+            3: "Perform general code cleanup and formatting."
+        }
+        if self.verbose:
+            print(f"[AutoRefactoring] suggestion: {suggestions_map[suggestion_idx]} (confidence {prediction[suggestion_idx]:.2f})")
+
+        return suggestion_idx, suggestions_map[suggestion_idx]
+
+    def train_feedback(self, feature_vector: np.ndarray, correct_suggestion: int):
+        """
+        Train  with feedback vector and correct category.
+        """
+        y_true = np.zeros(self.nn.biases[-1].shape)
+        y_true[correct_suggestion] = 1
+        loss = self.nn.train(feature_vector, y_true)
+        if self.verbose:
+            print(f"[AutoRefactoring] trained with feedback. Loss: {loss:.5f}")

quastt_show-0.2.25.dist-info/METADATA

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: quastt_show
+Version: 0.2.25
+Summary: Useful tools for monitoring,tracking,learning from mistakes.Just check our docs: https://quastt.com/
+Author: RVA
+Requires-Python: >=3.7
+Requires-Dist: requests
+Requires-Dist: traceback
+Requires-Dist: time
+Requires-Dist: threading
+Requires-Dist: concurrent
+Dynamic: author
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

quastt_show-0.2.25.dist-info/RECORD

@@ -0,0 +1,10 @@
+quastt_show/__init__.py,sha256=CSa1uI0HJworr0D8ONRuPOMgZgjSAmkrffCPmkO2ojw,127
+quastt_show/game.py,sha256=sfwC0O1Cc7Eg-A4_ykxvdgYj8je-Rl_hP41CNIfn4hE,13701
+quastt_show/logger.py,sha256=lKqU6v36eUyY0GaUFRD2Cu-A24KX2MZAZORacyZOqZo,8368
+quastt_show/monitoring.py,sha256=xBbZG5_pNLuotoATzFAkYS6bZP0IabRZIPXZyIRsEIE,12254
+quastt_show/resources.py,sha256=t-FWPGcmV5wKC_j5Nt2CxrHrrYs6q564666F-DzrKFQ,12076
+quastt_show-0.2.25.dist-info/METADATA,sha256=IbpMM9WobEGWgPhDnXgs0ifOqBw4hwBzxvhomjG7cGI,417
+quastt_show-0.2.25.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+quastt_show-0.2.25.dist-info/entry_points.txt,sha256=qLcSh8ANs-GHsS2TCzOciVdEyy-25IyVCujHZmG2S-I,54
+quastt_show-0.2.25.dist-info/top_level.txt,sha256=BtMM1888oCrruk37yJGnahqbhyirtsL6d9ES0pK081g,12
+quastt_show-0.2.25.dist-info/RECORD,,

quastt_show-0.1.2.dist-info/METADATA

@@ -1,11 +0,0 @@
-Metadata-Version: 2.4
-Name: quastt_show
-Version: 0.1.2
-Summary: A trivia game with AI stats.
-Author: RVA
-Requires-Python: >=3.7
-Requires-Dist: requests
-Dynamic: author
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary

quastt_show-0.1.2.dist-info/RECORD

@@ -1,7 +0,0 @@
-quastt_show/__init__.py,sha256=eMgN52YNlIhpHGDEdg7q2HV8d-bZBvoYQ4VY9Tk1BVY,24
-quastt_show/game.py,sha256=jKPgruUttd0YTTqRNPeNmSNTqNadYZDL8vjCcmYTalU,13689
-quastt_show-0.1.2.dist-info/METADATA,sha256=b_y5BTgojWawI6Kj4adP_LxVKJYXyUURPo6oCL-1LAU,244
-quastt_show-0.1.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-quastt_show-0.1.2.dist-info/entry_points.txt,sha256=qLcSh8ANs-GHsS2TCzOciVdEyy-25IyVCujHZmG2S-I,54
-quastt_show-0.1.2.dist-info/top_level.txt,sha256=BtMM1888oCrruk37yJGnahqbhyirtsL6d9ES0pK081g,12
-quastt_show-0.1.2.dist-info/RECORD,,