py2ls 0.2.6.2__py3-none-any.whl → 0.2.6.3__py3-none-any.whl

py2ls/ips.py

@@ -11,6 +11,7 @@ from datetime import datetime, date, time
 import re # built-in
 import stat
 import platform
+import subprocess
 
 from typing import Dict, List, Optional, Union, Any, Tuple, Literal,Callable
 from regex import X
@@ -32,6 +33,15 @@ except ImportError:
     pkg_resources = None
 import glob  # built-in
 import pkg_resources # built-in
+import importlib
+import inspect
+import pkgutil
+import pytest
+try:
+    import importlib.metadata as metadata  # Python 3.8+
+except ImportError:
+    import importlib_metadata as metadata  # For older versions via backport
+
 class PkgManager:
     """
     PkgManager.uninstall("py2ls")
@@ -102,7 +112,7 @@ class PkgManager:
             subprocess.run(["pip", "uninstall", "-y", pkg], check=True)
 
         if make_log:
-            log_path = os.path.join(station, f"uninstall_{timestamp}.txt")
+            log_path = os.path.join(station, f"log_uninstall.txt")
             with open(log_path, "w") as f:
                 f.write(f"# Uninstallation log created at {timestamp}\n")
                 f.write(f"# Mode: {mode}, Keywords: {kw}\n\n")
@@ -237,7 +247,99 @@ class PkgManager:
                 else:
                     print("Invalid selection. Please try again.")
             except ValueError:
-                print("Please enter a valid number.")
+                print("Please enter a valid number.")  
+    @staticmethod
+    def listfunc(
+        where: Union[str, Any]= None,
+        query: Optional[str] = None,
+        return_output:bool=False,
+        show_all: bool = False,
+        include_dunder: bool = False,
+        only_defined: bool = True,
+        verbose: bool = False
+    ) -> Dict[str, Any]:
+        """
+        Recursively list functions defined in a package/module and its submodules.
+        If `where=None`, returns the installed pip packages instead.
+
+        Args:
+            where (str or module or None): Module/package to inspect, or None for full pip list.
+            query (str): Optional search string for fuzzy match.
+            show_all (bool): Show all callables including those starting with '_'.
+            include_dunder (bool): Include dunder (__) methods like __init__.
+            only_defined (bool): Only show functions actually defined in the module.
+            verbose (bool): Show detailed skip/load error messages.
+
+        Returns:
+            dict: Nested dictionary with module names and their function lists or pip list.
+        """
+        if where is None:
+            # Return pip list instead
+            print("📦 Installed pip packages:")
+            pip_packages = {dist.metadata['Name']: dist.version for dist in metadata.distributions()}
+            if query:
+                func_OI = strcmp(query, list(pip_packages.keys()))[0]
+                print(f"  - {func_OI}=={pip_packages[func_OI]}")
+                return {func_OI: pip_packages[func_OI]}
+            for name, version in sorted(pip_packages.items()):
+                print(f"  - {name}=={version}")
+            return pip_packages
+        if isinstance(where, str):
+            try:
+                mod = importlib.import_module(where)
+            except ModuleNotFoundError:
+                print(f"Module '{where}' not found.")
+                return {}
+        else:
+            mod = where
+
+        root_name = mod.__name__
+        results = {}
+
+        def list_functions_in_module(module, module_name) -> List[str]:
+            funcs = []
+            for name in dir(module):
+                attr = getattr(module, name)
+                if callable(attr):
+                    if not show_all:
+                        if name.startswith("__") and not include_dunder:
+                            continue
+                        if name.startswith("_") and not name.startswith("__"):
+                            continue
+                    if only_defined and getattr(attr, "__module__", "") != module_name:
+                        continue
+                    funcs.append(name)
+            if query:
+                from difflib import get_close_matches
+                funcs = get_close_matches(query, funcs, n=10, cutoff=0.3)
+            return sorted(set(funcs))
+
+        def walk_package(mod) -> Dict[str, Any]:
+            subresults = {}
+            modname = mod.__name__
+            funcs = list_functions_in_module(mod, modname)
+            if funcs:
+                print(f"\n🎒: {modname}")
+                for f in funcs:
+                    print(f"  - {f}")
+                subresults[modname] = funcs
+
+            if hasattr(mod, '__path__'):  # If it's a package
+                for finder, name, ispkg in pkgutil.walk_packages(mod.__path__, prefix=mod.__name__ + "."):
+                    try:
+                        submod = importlib.import_module(name)
+                        submod_result = walk_package(submod)
+                        subresults.update(submod_result)
+                    except pytest.skip.Exception as e:
+                        if verbose:
+                            print(f"正常跳过: Skipped test module {name}: {e}")
+                    except Exception as e:
+                        if verbose:
+                            print(f"因错跳过 {name}: {e}")
+            return subresults
+
+        results[root_name] = walk_package(mod)
+        return results if return_output else None
 
 def _yaoshi_fernet(mima="mimashigudingde",yan=b"mimashigudingde",verbose=True):
     import base64
@@ -3361,7 +3463,7 @@ def text2audio(
                 sys.exit()
             except SystemExit:
                 pass
-    elif method.lower() in ["google", "gtts"]:
+    elif method in ["google", "gtts"]:
         from gtts import gTTS
 
         try:
@@ -3392,7 +3494,7 @@ def text2audio(
     print("done")
 
 # from datetime import datetime
-from dateutil import parser
+
 def str2time(
     time_str: str, 
     fmt: str = "24", 
@@ -4433,15 +4535,52 @@ def paper_size(paper_type_str="a4"):
     if not paper_type:
         paper_type = "a4"  # default
     return df[paper_type].tolist()
+ 
+def docx2pdf(dir_docx, dir_pdf=None):
+    """
+    Converts .docx to .pdf. Works on Windows using docx2pdf and on Linux/macOS using LibreOffice.
+    
+    Parameters:
+    - dir_docx: path to .docx file or directory containing .docx files
+    - dir_pdf: optional output directory; if None, uses same directory as input
+    """
 
+    system = platform.system()
+    is_file = os.path.isfile(dir_docx)
+    is_dir = os.path.isdir(dir_docx)
 
-def docx2pdf(dir_docx, dir_pdf=None):
-    from docx2pdf import convert
+    if not is_file and not is_dir:
+        raise FileNotFoundError(f"Input path '{dir_docx}' does not exist.")
+
+    if system == "Windows":
+        try:
+            from docx2pdf import convert
+        except ImportError:
+            raise ImportError("docx2pdf is not installed. Run: pip install docx2pdf")
+
+        convert(dir_docx, dir_pdf) if dir_pdf else convert(dir_docx)
+
+    elif system in {"Linux", "Darwin"}:
+        # Check if libreoffice is available
+        if shutil.which("libreoffice") is None:
+            raise EnvironmentError("LibreOffice is not installed or not in PATH. Install it with: sudo apt install libreoffice")
+
+        # Determine the output directory
+        output_dir = dir_pdf or os.path.dirname(dir_docx) if is_file else dir_docx
 
-    if dir_pdf:
-        convert(dir_docx, dir_pdf)
+        if is_file:
+            subprocess.run([
+                "libreoffice", "--headless", "--convert-to", "pdf", "--outdir", output_dir, dir_docx
+            ], check=True)
+        elif is_dir:
+            for filename in os.listdir(dir_docx):
+                if filename.lower().endswith(".docx"):
+                    full_path = os.path.join(dir_docx, filename)
+                    subprocess.run([
+                        "libreoffice", "--headless", "--convert-to", "pdf", "--outdir", dir_pdf or dir_docx, full_path
+                    ], check=True)
     else:
-        convert(dir_docx)
+        raise OSError(f"Unsupported OS: {system}")
 
 
 def img2pdf(dir_img, kind=None, page=None, dir_save=None, page_size="a4", dpi=300):
@@ -18666,12 +18805,6 @@ def py2installer(
     docker_image (str): Docker image to use for packaging.
 
     """
-
-    import os
-    import sys
-    import shutil
-    import subprocess
-    import sys
     import glob
     from pathlib import Path
 
@@ -19139,131 +19272,390 @@ print("Result of padcat(a, b, c):\n", result2)
     return result
 
  
-# ========== memory cleaner ==========
-import gc
-import os
-import sys
-import psutil
-import platform
-import ctypes
-import subprocess
-import warnings 
+# ========== memory cleaner ========== 
+import gc 
+import psutil 
+import weakref
 import time
+import inspect 
+import tracemalloc
+from collections import defaultdict
 
 class MemoryOptimizer:
-    def __init__(self, verbose: bool = True, aggressive_mode: bool = True):
+    def __init__(self, 
+                 verbose: bool = True, 
+                 aggressive_mode: bool = True,
+                 track_leaks: bool = False,
+                 max_history: int = 100):
         self.verbose = verbose
         self.aggressive_mode = aggressive_mode
+        self.track_leaks = track_leaks
+        self.max_history = max_history
         self.system = platform.system()
         self.process = psutil.Process(os.getpid())
         self.start_time = time.time()
         self.memory_history = []
+        self.leak_tracker = None
 
+        if track_leaks:
+            self._setup_leak_tracking()
+    
+    def _setup_leak_tracking(self):
+        self.leak_tracker = {
+            'snapshots': [],
+            'diff_stats': [],
+            'object_types': defaultdict(int),
+            'suspected_leaks': []
+        }
+        tracemalloc.start(25)
+    
     def log(self, msg: str, level: str = "INFO"):
         if self.verbose:
             rss = self.process.memory_info().rss / (1024 ** 2)
             elapsed = time.time() - self.start_time
-            print(f"[{level}][{elapsed:.2f}s][{rss:.1f}MB] {msg}")
+            caller = inspect.currentframe().f_back.f_code.co_name
+            print(f"[{level}][{elapsed:.2f}s][{rss:.1f}MB][{caller}] {msg}")
+    
+    def collect_garbage(self, generations: List[int] = None) -> Dict[str, Any]:
+        self.log("Starting deep garbage collection...")
+        stats = {
+            'collected': defaultdict(int),
+            'garbage_cleared': 0,
+            'freed_mb': 0
+        }
 
-    def collect_garbage(self):
-        self.log("Performing deep garbage collection...")
-        stats = {}
         before_mem = self.process.memory_info().rss
-        for gen in reversed(range(3)):
+
+        if self.aggressive_mode:
+            gc.set_threshold(1, 1, 1)
+            gc.set_debug(gc.DEBUG_SAVEALL)
+
+        gens = generations if generations is not None else [2, 1, 0]
+        for gen in gens:
             collected = gc.collect(gen)
-            self.log(f"GC Gen {gen}: Collected {collected}")
+            stats['collected'][f'gen_{gen}'] = collected
+            self.log(f"GC Gen {gen}: Collected {collected} objects")
+
+        stats['garbage_cleared'] = len(gc.garbage)
         gc.garbage.clear()
+
+        self._clear_weakref_caches()
+
         after_mem = self.process.memory_info().rss
         stats['freed_mb'] = (before_mem - after_mem) / (1024 ** 2)
+
         return stats
 
-    def clear_frameworks(self):
+    def _clear_weakref_caches(self):
+        self.log("Clearing weak reference caches...")
+        try:
+            for obj in gc.get_objects():
+                if isinstance(obj, weakref.WeakValueDictionary):
+                    obj.clear()
+        except Exception as e:
+            self.log(f"Failed to clear weakref caches: {e}", "WARNING")
+    
+    def clear_frameworks(self) -> Dict[str, Any]:
         result = {}
+
+        # PyTorch
         try:
             import torch
             if torch.cuda.is_available():
-                self.log("Clearing PyTorch cache...")
+                self.log("Clearing PyTorch CUDA cache...")
                 torch.cuda.empty_cache()
                 torch.cuda.ipc_collect()
-                result['pytorch'] = 'cleared'
+                result['pytorch'] = {
+                    'cuda_cache_cleared': True,
+                    'allocated_mb': torch.cuda.memory_allocated() / (1024 ** 2),
+                    'cached_mb': torch.cuda.memory_reserved() / (1024 ** 2)
+                }
         except Exception as e:
             self.log(f"PyTorch skipped: {e}", "WARNING")
-
+            result['pytorch'] = {'error': str(e)}
+        
+        # TensorFlow
         try:
             import tensorflow as tf
             self.log("Clearing TensorFlow session...")
             tf.keras.backend.clear_session()
-            result['tensorflow'] = 'cleared'
+            result['tensorflow'] = {'session_cleared': True}
         except Exception as e:
             self.log(f"TensorFlow skipped: {e}", "WARNING")
-
+            result['tensorflow'] = {'error': str(e)}
+        
+        # OpenCV
         try:
             import cv2
             self.log("Closing OpenCV windows...")
             cv2.destroyAllWindows()
-            result['opencv'] = 'cleared'
-        except Exception:
-            pass
+            result['opencv'] = {'windows_closed': True}
+        except Exception as e:
+            self.log(f"OpenCV skipped: {e}", "WARNING")
+            result['opencv'] = {'error': str(e)}
 
+        # Matplotlib
         try:
             import matplotlib.pyplot as plt
             self.log("Closing matplotlib figures...")
             plt.close('all')
-            result['matplotlib'] = 'cleared'
-        except Exception:
-            pass
-
-        return result
+            result['matplotlib'] = {'figures_closed': True}
+        except Exception as e:
+            self.log(f"Matplotlib skipped: {e}", "WARNING")
+            result['matplotlib'] = {'error': str(e)}
 
-    def clear_system_caches(self):
-        result = {}
-        self.log("Attempting full system cache clearance...")
+        # IPython
         try:
-            if self.system == "Linux":
-                subprocess.run(["sync"], check=True)
-                subprocess.run(["sudo", "sh", "-c", "echo 3 > /proc/sys/vm/drop_caches"], check=True)
-                result['linux'] = 'caches dropped'
-            elif self.system == "Darwin":
-                subprocess.run(["sudo", "purge"], check=True)
-                result['macos'] = 'purge run'
-            elif self.system == "Windows":
-                ctypes.windll.psapi.EmptyWorkingSet(-1)
-                if self.aggressive_mode:
-                    ctypes.windll.kernel32.SetProcessWorkingSetSizeEx(
-                        -1, ctypes.c_size_t(-1), ctypes.c_size_t(-1), ctypes.c_uint(0x1)
-                    )
-                result['windows'] = 'working set emptied'
+            from IPython import get_ipython
+            ipython = get_ipython()
+            if ipython is not None:
+                self.log("Clearing IPython outputs...")
+                ipython.run_line_magic('reset', '-f')
+                result['ipython'] = {'outputs_cleared': True}
         except Exception as e:
-            self.log(f"System cache clearing failed: {e}", "ERROR")
+            self.log(f"IPython skipped: {e}", "WARNING")
+            result['ipython'] = {'error': str(e)}
+
         return result
+ 
 
-    def profile(self) -> Dict[str, Any]:
+    def profile(self, deep: bool = False) -> Dict[str, Any]:
         mem = self.process.memory_info()
         vm = psutil.virtual_memory()
+        swap = psutil.swap_memory()
+
         profile = {
-            'rss_mb': mem.rss / (1024 ** 2),
-            'vms_mb': mem.vms / (1024 ** 2),
-            'used_gb': vm.used / (1024 ** 3),
-            'available_gb': vm.available / (1024 ** 3),
-            'percent': vm.percent,
+            'timestamp': time.time(),
+            'process': {
+                'rss_mb': mem.rss / (1024 ** 2),
+                'vms_mb': mem.vms / (1024 ** 2),
+            },
+            'system': {
+                'used_gb': vm.used / (1024 ** 3),
+                'available_gb': vm.available / (1024 ** 3),
+                'percent': vm.percent,
+                'swap_used_gb': swap.used / (1024 ** 3),
+                'swap_free_gb': swap.free / (1024 ** 3),
+            },
+            'gc': {
+                'objects': len(gc.get_objects()),
+                'garbage': len(gc.garbage),
+                'thresholds': gc.get_threshold(),
+            }
         }
+
+        if deep:
+            profile['deep'] = self._deep_memory_analysis()
+
         self.memory_history.append(profile)
+        if len(self.memory_history) > self.max_history:
+            self.memory_history.pop(0)
+
         return profile
 
-    def optimize(self) -> Dict[str, Any]:
-        result = {}
-        result['before'] = self.profile()
-        result['gc'] = self.collect_garbage()
-        result['frameworks'] = self.clear_frameworks()
-        result['system'] = self.clear_system_caches()
-        result['after'] = self.profile()
-        saved = result['before']['rss_mb'] - result['after']['rss_mb']
-        result['saved_mb'] = saved
-        result['saved_percent'] = (saved / result['before']['rss_mb']) * 100 if result['before']['rss_mb'] else 0
-        self.log(f"Optimization complete: Saved {saved:.2f} MB ({result['saved_percent']:.1f}%)", "SUCCESS")
+    def _deep_memory_analysis(self) -> Dict[str, Any]:
+        self.log("Performing deep memory analysis...")
+        type_sizes = defaultdict(int)
+        for obj in gc.get_objects():
+            try:
+                obj_type = type(obj).__name__
+                type_sizes[obj_type] += sys.getsizeof(obj)
+            except Exception:
+                continue
+
+        top_types = sorted(type_sizes.items(), key=lambda x: x[1], reverse=True)[:10]
+        return {'top_object_types': top_types}
+ 
+    
+    def detect_leaks(self, min_growth_mb: float = 5.0) -> Optional[Dict[str, Any]]:
+        """
+        Detect potential memory leaks by comparing snapshots.
+        
+        Args:
+            min_growth_mb: Minimum growth in MB to consider a leak
+            
+        Returns:
+            Leak detection report or None if no leaks detected
+        """
+        if not self.track_leaks or len(self.memory_history) < 2:
+            return None
+        
+        current = self.memory_history[-1]
+        previous = self.memory_history[-2]
+        
+        growth_mb = current['process']['rss_mb'] - previous['process']['rss_mb']
+        if growth_mb < min_growth_mb:
+            return None
+        
+        leak_report = {
+            'growth_mb': growth_mb,
+            'time_elapsed': current['timestamp'] - previous['timestamp'],
+            'suspected_causes': [],
+        }
+        
+        # Try to identify potential causes
+        if 'deep' in current and 'deep' in previous:
+            current_counts = current['deep']['object_counts']
+            previous_counts = previous['deep']['object_counts']
+            
+            for obj_type, count in current_counts.items():
+                prev_count = previous_counts.get(obj_type, 0)
+                if count > prev_count * 1.5 and count - prev_count > 100:
+                    leak_report['suspected_causes'].append({
+                        'type': obj_type,
+                        'growth': count - prev_count,
+                        'percent_growth': ((count - prev_count) / prev_count * 100) if prev_count else float('inf')
+                    })
+        
+        if leak_report['suspected_causes']:
+            self.leak_tracker['suspected_leaks'].append(leak_report)
+            return leak_report
+        
+        return None
+    
+    def optimize(self, full: bool = True) -> Dict[str, Any]:
+        """
+        Perform comprehensive memory optimization.
+        
+        Args:
+            full: Whether to perform all optimization steps
+            
+        Returns:
+            Dictionary with optimization results
+        """
+        result = {
+            'timestamp': time.time(),
+            'before': self.profile(deep=self.track_leaks),
+            'steps': {}
+        }
+        
+        # Step 1: Garbage collection
+        result['steps']['gc'] = self.collect_garbage()
+        
+        # Step 2: Framework-specific memory clearing
+        result['steps']['frameworks'] = self.clear_frameworks()
+        
+        # # Step 3: System-level cache clearing
+        # if full:
+        #     result['steps']['system'] = self.clear_system_caches()
+        
+        # Step 4: Additional aggressive measures
+        if self.aggressive_mode and full:
+            result['steps']['aggressive'] = self._aggressive_optimizations()
+        
+        # Final profile and results
+        result['after'] = self.profile(deep=self.track_leaks)
+        
+        # Calculate savings
+        saved_mb = result['before']['process']['rss_mb'] - result['after']['process']['rss_mb']
+        result['saved_mb'] = saved_mb
+        result['saved_percent'] = (saved_mb / result['before']['process']['rss_mb']) * 100
+        
+        # Check for leaks if tracking enabled
+        if self.track_leaks:
+            leak_report = self.detect_leaks()
+            if leak_report:
+                result['leak_detected'] = leak_report
+        
+        self.log(
+            f"Optimization complete: Saved {saved_mb:.2f} MB "
+            f"({result['saved_percent']:.1f}% reduction)",
+            "SUCCESS"
+        )
+        
         return result
+     
+    def _aggressive_optimizations(self):
+        self.log("Aggressively clearing known caches...")
 
+        errors = {}
+        try:
+            gc.collect()
+            self.log("Basic garbage collection done.")
+        except Exception as e:
+            errors['gc_collect'] = str(e)
+
+        try:
+            import numpy as np
+            _ = np.empty(0)  # trigger allocation to finalize previous arrays
+        except Exception as e:
+            errors['numpy'] = str(e)
 
-def cleaner(verbose: bool = True, aggressive: bool = True) -> Dict[str, Any]:
-    optimizer = MemoryOptimizer(verbose=verbose, aggressive_mode=aggressive)
-    return optimizer.optimize()
+        try:
+            import pandas as pd
+            _ = pd.DataFrame()  # no effect but helps ensure cleanup
+        except Exception as e:
+            errors['pandas'] = str(e)
+
+        return {'status': 'done', 'errors': errors}
+
+    def memory_report(self, detailed: bool = False) -> str:
+        """Generate a comprehensive memory usage report."""
+        current = self.profile(deep=detailed)
+        report = [
+            "="*80,
+            f"Memory Report (PID: {os.getpid()})",
+            "="*80,
+            f"Process RSS: {current['process']['rss_mb']:.1f} MB",
+            f"Process VMS: {current['process']['vms_mb']:.1f} MB",
+            f"System Memory Used: {current['system']['used_gb']:.1f} GB ({current['system']['percent']}%)",
+            f"Available Memory: {current['system']['available_gb']:.1f} GB",
+            f"Swap Used: {current['system']['swap_used_gb']:.1f} GB",
+            f"GC Objects: {current['gc']['objects']:,}",
+            f"GC Garbage: {current['gc']['garbage']:,}",
+        ]
+        
+        if detailed and 'deep' in current:
+            report.append("\n[Object Type Breakdown (Top 10)]")
+            sorted_types = sorted(
+                current['deep']['object_counts'].items(),
+                key=lambda x: x[1],
+                reverse=True
+            )[:10]
+            
+            for obj_type, count in sorted_types:
+                size_mb = current['deep']['estimated_sizes'].get(obj_type, 0)
+                report.append(f"{obj_type}: {count:,} objects ({size_mb:.2f} MB)")
+        
+        if self.track_leaks and self.leak_tracker['suspected_leaks']:
+            report.append("\n[Potential Memory Leaks]")
+            for i, leak in enumerate(self.leak_tracker['suspected_leaks'], 1):
+                report.append(
+                    f"Leak {i}: +{leak['growth_mb']:.1f}MB in "
+                    f"{leak['time_elapsed']:.1f}s"
+                )
+                for cause in leak['suspected_causes']:
+                    report.append(
+                        f"  - {cause['type']}: +{cause['growth']:,} "
+                        f"({cause['percent_growth']:.1f}%)"
+                    )
+        
+        return "\n".join(report)
+
+
+def cleaner(
+    verbose: bool = True, 
+    aggressive: bool = True,
+    track_leaks: bool = False,
+    full_clean: bool = True,
+    return_output:bool=False
+) -> Dict[str, Any]:
+    """
+    Ultimate memory cleaning function with all optimizations.
+    
+    Args:
+        verbose: Print detailed progress information
+        aggressive: Use aggressive memory clearing techniques
+        track_leaks: Enable memory leak detection
+        full_clean: Perform all cleaning steps (including system-level)
+    
+    Returns:
+        Dictionary with optimization results
+    """
+    optimizer = MemoryOptimizer(
+        verbose=verbose,
+        aggressive_mode=aggressive,
+        track_leaks=track_leaks
+    )
+    output=optimizer.optimize(full=full_clean)
+    return output if return_output else None

{py2ls-0.2.6.2.dist-info → py2ls-0.2.6.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: py2ls
-Version: 0.2.6.2
+Version: 0.2.6.3
 Summary: py(thon)2(too)ls
 Author: Jianfeng
 Author-email: Jianfeng.Liu0413@gmail.com
@@ -18,24 +18,25 @@ Provides-Extra: full
 Provides-Extra: light
 Provides-Extra: ml
 Provides-Extra: neuroscience
+Provides-Extra: superlight
 Requires-Dist: GEOparse (>=2.0.4) ; extra == "full"
-Requires-Dist: Pillow (>=11.2.1) ; extra == "full" or extra == "light"
-Requires-Dist: PyPDF2 (>=3.0.1) ; extra == "full" or extra == "light"
-Requires-Dist: PyYAML (>=6.0.1) ; extra == "full" or extra == "light"
+Requires-Dist: Pillow (>=11.2.1) ; extra == "full" or extra == "superlight" or extra == "light"
+Requires-Dist: PyPDF2 (>=3.0.1) ; extra == "full" or extra == "superlight" or extra == "light"
+Requires-Dist: PyYAML (>=6.0.1) ; extra == "full" or extra == "superlight" or extra == "light"
 Requires-Dist: SQLAlchemy (>=2.0.37) ; extra == "full"
-Requires-Dist: adjustText (>=1.3.0) ; extra == "full" or extra == "light"
+Requires-Dist: adjustText (>=1.3.0) ; extra == "full" or extra == "superlight" or extra == "light"
 Requires-Dist: autogluon (>=1.2) ; extra == "full" or extra == "ml"
 Requires-Dist: beautifulsoup4 (>=4.12.3) ; extra == "full" or extra == "light"
 Requires-Dist: catboost (>=1.2.8) ; extra == "full" or extra == "ml"
 Requires-Dist: category_encoders (>=2.8.1) ; extra == "full"
-Requires-Dist: chardet (>=3.0.4) ; extra == "full" or extra == "light"
-Requires-Dist: cryptography (>=45.0.3) ; extra == "full" or extra == "light"
-Requires-Dist: cycler (>=0.12.1) ; extra == "full" or extra == "light"
-Requires-Dist: docx2pdf (>=0.1.8) ; extra == "full" or extra == "light"
+Requires-Dist: chardet (>=3.0.4) ; extra == "full" or extra == "superlight" or extra == "light"
+Requires-Dist: cryptography (>=45.0.3) ; extra == "full" or extra == "superlight" or extra == "light"
+Requires-Dist: cycler (>=0.12.1) ; extra == "full" or extra == "superlight" or extra == "light"
+Requires-Dist: docx2pdf (>=0.1.8) ; extra == "full" or extra == "superlight" or extra == "light"
 Requires-Dist: fake-useragent (>=1.5.1) ; extra == "full" or extra == "light"
 Requires-Dist: folium (>=0.19.6) ; extra == "full"
-Requires-Dist: fpdf (>=1.7.2) ; extra == "full" or extra == "light"
-Requires-Dist: fuzzywuzzy (>=0.18.0) ; extra == "full" or extra == "light"
+Requires-Dist: fpdf (>=1.7.2) ; extra == "full" or extra == "superlight" or extra == "light"
+Requires-Dist: fuzzywuzzy (>=0.18.0) ; extra == "full" or extra == "superlight" or extra == "light"
 Requires-Dist: geopy (>=2.4.1) ; extra == "full"
 Requires-Dist: gseapy (>=1.1.8) ; extra == "full"
 Requires-Dist: gtts (>=2.5.4) ; extra == "full"
@@ -44,26 +45,26 @@ Requires-Dist: img2pdf (>=0.5.1) ; extra == "full"
 Requires-Dist: ipython (>=8.26.0) ; extra == "full" or extra == "light"
 Requires-Dist: langdetect (>=1.0.9) ; extra == "full"
 Requires-Dist: lightgbm (>=4.6.0) ; extra == "full" or extra == "ml"
-Requires-Dist: lxml (>=5.3.0) ; extra == "full" or extra == "light"
-Requires-Dist: matplotlib (>=3.9.1) ; extra == "full" or extra == "light"
+Requires-Dist: lxml (>=5.3.0) ; extra == "full" or extra == "superlight" or extra == "light"
+Requires-Dist: matplotlib (>=3.9.1) ; extra == "full" or extra == "superlight" or extra == "light"
 Requires-Dist: matplotlib-venn (>=1.1.2) ; extra == "full"
 Requires-Dist: mne (>=1.6.1) ; extra == "neuroscience"
-Requires-Dist: msoffcrypto-tool (>=5.4.2) ; extra == "full" or extra == "light"
+Requires-Dist: msoffcrypto-tool (>=5.4.2) ; extra == "full" or extra == "superlight" or extra == "light"
 Requires-Dist: neo (>=0.13.1) ; extra == "neuroscience"
-Requires-Dist: networkx (>=3.3) ; extra == "full" or extra == "light"
+Requires-Dist: networkx (>=3.3) ; extra == "full" or extra == "superlight" or extra == "light"
 Requires-Dist: nltk (>=3.8.1) ; extra == "full" or extra == "light"
-Requires-Dist: numerizer (>=0.2.3) ; extra == "full" or extra == "light"
-Requires-Dist: numpy (>=1.26.4,<2.0.0) ; extra == "full" or extra == "light"
+Requires-Dist: numerizer (>=0.2.3) ; extra == "full" or extra == "superlight" or extra == "light"
+Requires-Dist: numpy (>=1.26.4,<2.0.0) ; extra == "full" or extra == "superlight" or extra == "light"
 Requires-Dist: opencv-python-headless (>=4.10.0.84) ; extra == "full"
 Requires-Dist: openlocationcode (>=1.0.1) ; extra == "full"
-Requires-Dist: openpyxl (>=3.1.5) ; extra == "full" or extra == "light"
-Requires-Dist: pandas (>=2.2.2) ; extra == "full" or extra == "light"
+Requires-Dist: openpyxl (>=3.1.5) ; extra == "full" or extra == "superlight" or extra == "light"
+Requires-Dist: pandas (>=2.2.2) ; extra == "full" or extra == "superlight" or extra == "light"
 Requires-Dist: pdf2image (>=1.17.0) ; extra == "full"
 Requires-Dist: phonenumbers (>=8.13.51) ; extra == "full"
-Requires-Dist: pingouin (>=0.5.4) ; extra == "full"
+Requires-Dist: pingouin (>=0.5.4) ; extra == "full" or extra == "light"
 Requires-Dist: pixels2svg (>=0.2.2) ; extra == "full"
-Requires-Dist: psutil (>=5.9.8) ; extra == "full" or extra == "light"
-Requires-Dist: py-cpuinfo (>=9.0.0) ; extra == "light"
+Requires-Dist: psutil (>=5.9.8) ; extra == "full" or extra == "superlight" or extra == "light"
+Requires-Dist: py-cpuinfo (>=9.0.0) ; extra == "superlight" or extra == "light"
 Requires-Dist: py7zr (>=0.22.0) ; extra == "full"
 Requires-Dist: pyautogui (>=0.9.54) ; extra == "full"
 Requires-Dist: pycryptodome (>=3.23.0) ; extra == "full"
@@ -71,20 +72,20 @@ Requires-Dist: pydeck (>=0.9.1) ; extra == "full"
 Requires-Dist: pyperclip (>=1.9.0) ; extra == "full"
 Requires-Dist: pypinyin (>=0.54.0) ; extra == "full"
 Requires-Dist: python-box (>=7.2.0) ; extra == "full" or extra == "light"
-Requires-Dist: python-dateutil (>=2.9.0.post0) ; extra == "full" or extra == "light"
-Requires-Dist: python-docx (>=1.1.2) ; extra == "full" or extra == "light"
-Requires-Dist: pytz (>=2024.1) ; extra == "full" or extra == "light"
+Requires-Dist: python-dateutil (>=2.9.0.post0) ; extra == "full" or extra == "superlight" or extra == "light"
+Requires-Dist: python-docx (>=1.1.2) ; extra == "full" or extra == "superlight" or extra == "light"
+Requires-Dist: pytz (>=2024.1) ; extra == "full" or extra == "superlight" or extra == "light"
 Requires-Dist: pyvis (>=0.3.2) ; extra == "full"
 Requires-Dist: rarfile (>=4.2) ; extra == "full"
 Requires-Dist: realesrgan (>=0.3.0) ; extra == "full"
-Requires-Dist: regex (>=2024.5.15) ; extra == "full" or extra == "light"
+Requires-Dist: regex (>=2024.5.15) ; extra == "full" or extra == "superlight" or extra == "light"
 Requires-Dist: rembg (>=2.0.57) ; extra == "full"
 Requires-Dist: requests (>=2.32.3) ; extra == "full" or extra == "light"
 Requires-Dist: schedule (>=1.2.2) ; extra == "full"
 Requires-Dist: scikit-image (>=0.23.2) ; extra == "full"
 Requires-Dist: scikit-learn (>=1.5.1) ; extra == "full" or extra == "ml"
-Requires-Dist: scipy (>=1.14.0) ; extra == "full" or extra == "light"
-Requires-Dist: seaborn (>=0.13.2) ; extra == "full"
+Requires-Dist: scipy (>=1.14.0) ; extra == "full" or extra == "superlight" or extra == "light"
+Requires-Dist: seaborn (>=0.13.2) ; extra == "full" or extra == "superlight" or extra == "light"
 Requires-Dist: selenium (>=4.23.1) ; extra == "full" or extra == "light"
 Requires-Dist: skimpy (>=0.0.15) ; extra == "full"
 Requires-Dist: skorch (>=1.0.0) ; extra == "full" or extra == "ml"
@@ -94,7 +95,7 @@ Requires-Dist: streamlit-folium (>=0.25.0) ; extra == "full"
 Requires-Dist: striprtf (>=0.0.29) ; extra == "full"
 Requires-Dist: symspellpy (>=6.9.0) ; extra == "full"
 Requires-Dist: tensorflow (>=2.19.0) ; extra == "full" or extra == "ml"
-Requires-Dist: textblob (>=0.18.0.post0) ; extra == "full" or extra == "light"
+Requires-Dist: textblob (>=0.18.0.post0) ; extra == "full" or extra == "superlight" or extra == "light"
 Requires-Dist: torch (>=2.4.0) ; extra == "full" or extra == "ml"
 Requires-Dist: tqdm (>=4.66.4) ; extra == "full" or extra == "light"
 Requires-Dist: umap (>=0.1.1) ; extra == "full"

{py2ls-0.2.6.2.dist-info → py2ls-0.2.6.3.dist-info}/RECORD

@@ -243,7 +243,7 @@ py2ls/fetch_update.py,sha256=9LXj661GpCEFII2wx_99aINYctDiHni6DOruDs_fdt8,4752
 py2ls/freqanalysis.py,sha256=F4218VSPbgL5tnngh6xNCYuNnfR-F_QjECUUxrPYZss,32594
 py2ls/ich2ls.py,sha256=zXWdQzebBZjFIfpjgJuqZ6_7AnGehFTPX-BoNnAQwyc,81940
 py2ls/im2.py,sha256=inSdpU_IIvHG7FoXcdIvpGprPASySwJCR05Lpaa5fdU,3026
-py2ls/ips.py,sha256=EwsE1a0ti16G58YM9-S6Z6mJ28Sh4_UDbquzvEl-hwg,741622
+py2ls/ips.py,sha256=T6NbmCHn4LQjMHZfdYUgz0ExXUITpgf3M-1oVTqGqHg,756341
 py2ls/ml2ls.py,sha256=I-JFPdikgEtfQjhv5gBz-QSeorpTJI_Pda_JwkTioBY,209732
 py2ls/mol.py,sha256=AZnHzarIk_MjueKdChqn1V6e4tUle3X1NnHSFA6n3Nw,10645
 py2ls/netfinder.py,sha256=GZinvZrKRV7h8GPPUBczFEcUKoHNLinh7PafnqMqsYg,81131
@@ -255,6 +255,6 @@ py2ls/sleep_events_detectors.py,sha256=bQA3HJqv5qnYKJJEIhCyhlDtkXQfIzqksnD0YRXso
 py2ls/stats.py,sha256=xBXUHgV92iqNKtNaj7p5YouNJXKPrJcwkYJhc6lw8NI,34107
 py2ls/translator.py,sha256=77Tp_GjmiiwFbEIJD_q3VYpQ43XL9ZeJo6Mhl44mvh8,34284
 py2ls/wb_detector.py,sha256=7y6TmBUj9exCZeIgBAJ_9hwuhkDh1x_-yg4dvNY1_GQ,6284
-py2ls-0.2.6.2.dist-info/METADATA,sha256=5dnSVzTOBpmJlixUkJDlGf9Wu2b_Tta1spNIcWzILTc,17790
-py2ls-0.2.6.2.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-py2ls-0.2.6.2.dist-info/RECORD,,
+py2ls-0.2.6.3.dist-info/METADATA,sha256=F0ZC706JhRsKyvns1iLr9h_Kj9eEcnDYO9wwJ7dlcmU,18532
+py2ls-0.2.6.3.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+py2ls-0.2.6.3.dist-info/RECORD,,