webexec 1.0.0__py3-none-any.whl

webexec/__init__.py

@@ -0,0 +1,28 @@
+"""
+webexec - Fetch and execute Python scripts from any raw URL.
+
+Created by ZeroTeam.
+"""
+
+from .executor import run, load, run_all, watch
+from .utils import preview, install_imports
+from .fetcher import fetch_content
+from .cache import clear_cache
+
+# Export all public functions
+__all__ = [
+    'run',
+    'load', 
+    'fetch',
+    'clear_cache',
+    'watch',
+    'run_all',
+    'preview',
+    'install_imports'
+]
+
+# Alias fetch_content to fetch for the public API
+fetch = fetch_content
+
+__version__ = "1.0.0"
+__author__ = "ZeroTeam"

webexec/cache.py

@@ -0,0 +1,42 @@
+"""
+In-memory cache for webexec package.
+"""
+
+import time
+from typing import Dict, Optional
+
+class Cache:
+    """Simple in-memory cache with timestamp support."""
+    
+    def __init__(self):
+        self._cache: Dict[str, tuple] = {}
+    
+    def get(self, key: str) -> Optional[str]:
+        """Get cached content if available."""
+        if key in self._cache:
+            content, timestamp = self._cache[key]
+            return content
+        return None
+    
+    def set(self, key: str, value: str) -> None:
+        """Cache content with current timestamp."""
+        self._cache[key] = (value, time.time())
+    
+    def clear(self) -> None:
+        """Clear all cached content."""
+        self._cache.clear()
+    
+    def size(self) -> int:
+        """Return number of cached items."""
+        return len(self._cache)
+
+# Global cache instance
+_cache = Cache()
+
+def get_cache() -> Cache:
+    """Get the global cache instance."""
+    return _cache
+
+def clear_cache() -> None:
+    """Clear the global cache."""
+    _cache.clear()

webexec/executor.py

@@ -0,0 +1,94 @@
+"""
+Execution functionality for webexec package.
+"""
+
+import time
+import threading
+import types
+import importlib.util
+from typing import List, Optional, Dict, Any
+from .fetcher import fetch_content
+
+def run(url: str, *, timeout: int = 10, cache: bool = False, globals_: Optional[Dict[str, Any]] = None) -> None:
+    """
+    Fetch and execute a Python script from a URL.
+    
+    Args:
+        url: The URL to fetch the script from
+        timeout: Request timeout in seconds
+        cache: Whether to use cached content if available
+        globals_: Global variables to use during execution
+    """
+    content = fetch_content(url, timeout=timeout, cache=cache)
+    
+    if globals_ is None:
+        globals_ = {}
+    
+    exec(content, globals_)
+
+def load(url: str, module_name: Optional[str] = None, *, timeout: int = 10, cache: bool = False) -> types.ModuleType:
+    """
+    Fetch a script from a URL and return it as an importable module.
+    
+    Args:
+        url: The URL to fetch the script from
+        module_name: Name for the created module (auto-generated if None)
+        timeout: Request timeout in seconds
+        cache: Whether to use cached content if available
+        
+    Returns:
+        A module object containing the fetched script
+    """
+    content = fetch_content(url, timeout=timeout, cache=cache)
+    
+    if module_name is None:
+        module_name = f"webexec_module_{hash(url) % 1000000}"
+    
+    spec = importlib.util.spec_from_loader(module_name, loader=None)
+    module = importlib.util.module_from_spec(spec)
+    
+    exec(content, module.__dict__)
+    
+    return module
+
+def run_all(urls: List[str], *, timeout: int = 10, cache: bool = False, globals_: Optional[Dict[str, Any]] = None) -> None:
+    """
+    Fetch and run multiple scripts in order.
+    
+    Args:
+        urls: List of URLs to fetch and execute
+        timeout: Request timeout in seconds
+        cache: Whether to use cached content if available
+        globals_: Global variables to use during execution
+    """
+    if globals_ is None:
+        globals_ = {}
+    
+    for url in urls:
+        run(url, timeout=timeout, cache=cache, globals_=globals_)
+
+def watch(url: str, interval: int = 60, *, timeout: int = 10, cache: bool = False, globals_: Optional[Dict[str, Any]] = None) -> threading.Thread:
+    """
+    Re-fetch and re-run a script every X seconds in a background thread.
+    
+    Args:
+        url: The URL to watch
+        interval: Interval in seconds between re-runs
+        timeout: Request timeout in seconds
+        cache: Whether to use cached content if available
+        globals_: Global variables to use during execution
+        
+    Returns:
+        The background thread object
+    """
+    def watch_loop():
+        while True:
+            try:
+                run(url, timeout=timeout, cache=False, globals_=globals_)  # Don't use cache for watching
+            except Exception as e:
+                print(f"Error watching {url}: {e}")
+            time.sleep(interval)
+    
+    thread = threading.Thread(target=watch_loop, daemon=True)
+    thread.start()
+    return thread

webexec/fetcher.py

@@ -0,0 +1,52 @@
+"""
+HTTP fetching functionality for webexec package.
+"""
+
+import urllib.request
+import urllib.error
+from typing import Optional
+from .cache import get_cache
+
+def fetch_content(url: str, timeout: int = 10, cache: bool = False) -> str:
+    """
+    Fetch content from a URL.
+    
+    Args:
+        url: The URL to fetch from
+        timeout: Request timeout in seconds
+        cache: Whether to use cached content if available
+        
+    Returns:
+        The fetched content as string
+        
+    Raises:
+        RuntimeError: If the request fails
+    """
+    if cache:
+        cached_content = get_cache().get(url)
+        if cached_content is not None:
+            return cached_content
+    
+    try:
+        req = urllib.request.Request(url)
+        req.add_header('User-Agent', 'webexec/1.0')
+        
+        with urllib.request.urlopen(req, timeout=timeout) as response:
+            if response.status != 200:
+                raise RuntimeError(f"HTTP {response.status}: Failed to fetch {url}")
+            
+            content = response.read().decode('utf-8')
+            
+            if cache:
+                get_cache().set(url, content)
+            
+            return content
+            
+    except urllib.error.HTTPError as e:
+        raise RuntimeError(f"HTTP {e.code}: Failed to fetch {url}")
+    except urllib.error.URLError as e:
+        raise RuntimeError(f"Network error: Failed to fetch {url} - {e.reason}")
+    except UnicodeDecodeError:
+        raise RuntimeError(f"Invalid content encoding: {url} does not contain valid UTF-8 text")
+    except Exception as e:
+        raise RuntimeError(f"Unexpected error fetching {url}: {e}")

webexec/utils.py

@@ -0,0 +1,132 @@
+"""
+Utility functions for webexec package.
+"""
+
+import ast
+import os
+import subprocess
+import sys
+from typing import Optional, List, Set
+from .fetcher import fetch_content
+
+def preview(url: str, *, timeout: int = 10, cache: bool = False) -> None:
+    """
+    Print the source code from a URL without executing it.
+    
+    Args:
+        url: The URL to preview
+        timeout: Request timeout in seconds
+        cache: Whether to use cached content if available
+    """
+    content = fetch_content(url, timeout=timeout, cache=cache)
+    print(content)
+
+def install_imports(url: str, *, timeout: int = 10, cache: bool = False, upgrade: bool = False, user: bool = False) -> List[str]:
+    """
+    Detect and install missing imports from a remote script.
+    
+    Args:
+        url: The URL to analyze and install imports for
+        timeout: Request timeout in seconds
+        cache: Whether to use cached content if available
+        upgrade: Whether to upgrade existing packages
+        user: Whether to install in user site-packages
+        
+    Returns:
+        List of packages that were attempted to install
+        
+    Raises:
+        RuntimeError: If URL fetch fails or pip installation encounters errors
+    """
+    content = fetch_content(url, timeout=timeout, cache=cache)
+    
+    # Parse the AST to find all import statements
+    try:
+        tree = ast.parse(content)
+    except SyntaxError as e:
+        raise RuntimeError(f"Invalid Python syntax in {url}: {e}")
+    
+    # Extract imported module names
+    imported_modules = set()
+    
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                # Get the top-level package name
+                module_name = alias.name.split('.')[0]
+                imported_modules.add(module_name)
+        elif isinstance(node, ast.ImportFrom):
+            if node.module:
+                # Get the top-level package name
+                module_name = node.module.split('.')[0]
+                imported_modules.add(module_name)
+    
+    # Filter out standard library modules
+    stdlib_modules = {
+        'argparse', 'array', 'asyncio', 'base64', 'binascii', 'bisect', 'builtins',
+        'calendar', 'cgi', 'cgitb', 'codecs', 'collections', 'colorsys', 'compileall',
+        'concurrent', 'configparser', 'contextlib', 'copy', 'copyreg', 'csv',
+        'ctypes', 'datetime', 'decimal', 'difflib', 'dis', 'doctest', 'email',
+        'enum', 'errno', 'faulthandler', 'fcntl', 'filecmp', 'fileinput', 'fnmatch',
+        'fractions', 'ftplib', 'functools', 'gc', 'getopt', 'getpass', 'gettext',
+        'glob', 'grp', 'gzip', 'hashlib', 'heapq', 'hmac', 'html', 'http',
+        'imaplib', 'imghdr', 'imp', 'importlib', 'inspect', 'io', 'ipaddress',
+        'itertools', 'json', 'keyword', 'linecache', 'locale', 'logging',
+        'lzma', 'mailbox', 'mailcap', 'marshal', 'math', 'mimetypes', 'mmap',
+        'modulefinder', 'multiprocessing', 'netrc', 'nntplib', 'numbers',
+        'operator', 'os', 'ossaudiodev', 'pathlib', 'pdb', 'pickle', 'pickletools',
+        'pipes', 'pkgutil', 'platform', 'plistlib', 'poplib', 'posix', 'pprint',
+        'profile', 'pstats', 'pty', 'pwd', 'py_compile', 'pyclbr', 'pydoc',
+        'queue', 'quopri', 'random', 're', 'readline', 'reprlib', 'resource',
+        'rlcompleter', 'runpy', 'sched', 'secrets', 'select', 'selectors', 'shelve',
+        'shlex', 'shutil', 'signal', 'site', 'smtpd', 'smtplib', 'sndhdr', 'socket',
+        'socketserver', 'sqlite3', 'ssl', 'stat', 'statistics', 'string',
+        'stringprep', 'struct', 'subprocess', 'sunau', 'symbol', 'symtable',
+        'sys', 'sysconfig', 'syslog', 'tabnanny', 'tarfile', 'telnetlib', 'tempfile',
+        'termios', 'textwrap', 'threading', 'time', 'timeit', 'tkinter', 'token',
+        'tokenize', 'trace', 'traceback', 'tracemalloc', 'tty', 'turtle', 'types',
+        'typing', 'unicodedata', 'unittest', 'urllib', 'uu', 'uuid', 'venv',
+        'warnings', 'wave', 'weakref', 'webbrowser', 'winreg', 'winsound',
+        'wsgiref', 'xdrlib', 'xml', 'xmlrpc', 'zipapp', 'zipfile', 'zipimport',
+        'zlib'
+    }
+    
+    # Filter out standard library and local modules
+    third_party_modules = []
+    for module in imported_modules:
+        if module not in stdlib_modules and not module.startswith('_'):
+            # Check if module is already installed
+            try:
+                __import__(module)
+                if upgrade:
+                    third_party_modules.append(module)
+            except ImportError:
+                third_party_modules.append(module)
+    
+    # Install missing packages
+    installed_packages = []
+    
+    if third_party_modules:
+        pip_cmd = [sys.executable, '-m', 'pip', 'install']
+        
+        if upgrade:
+            pip_cmd.append('--upgrade')
+        if user:
+            pip_cmd.append('--user')
+            
+        for package in third_party_modules:
+            try:
+                install_cmd = pip_cmd + [package]
+                result = subprocess.run(
+                    install_cmd,
+                    capture_output=True,
+                    text=True,
+                    check=True
+                )
+                installed_packages.append(package)
+                print(f"✓ Installed {package}")
+            except subprocess.CalledProcessError as e:
+                print(f"✗ Failed to install {package}: {e.stderr}")
+                raise RuntimeError(f"Failed to install {package}: {e.stderr}")
+    
+    return installed_packages

webexec-1.0.0.dist-info/METADATA

@@ -0,0 +1,220 @@
+Metadata-Version: 2.4
+Name: webexec
+Version: 1.0.0
+Summary: Fetch and execute Python scripts from any raw URL
+Author-email: ZeroTeam <zeroteam@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/zeroteam/webexec
+Project-URL: Repository, https://github.com/zeroteam/webexec
+Project-URL: Issues, https://github.com/zeroteam/webexec/issues
+Keywords: web,exec,remote,script,fetch,url
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Internet :: WWW/HTTP
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# webexec
+
+Fetch and execute Python scripts from any raw URL.
+
+Created by ZeroTeam.
+
+## Installation
+
+```bash
+pip install webexec
+```
+
+## Core Functions
+
+### `webexec.run(url, *, timeout=10, cache=False, globals_=None)`
+
+Fetch and execute a Python script from a URL.
+
+```python
+import webexec
+
+# Execute a script from Pastebin
+webexec.run("https://pastebin.com/raw/abc123")
+
+# Execute with custom globals
+my_globals = {"name": "Alice"}
+webexec.run("https://example.com/script.py", globals_=my_globals)
+
+# Use caching
+webexec.run("https://example.com/script.py", cache=True)
+```
+
+### `webexec.load(url, module_name=None, *, timeout=10, cache=False)`
+
+Fetch a script and return it as an importable module.
+
+```python
+import webexec
+
+# Load as module
+mod = webexec.load("https://raw.githubusercontent.com/user/repo/main/script.py")
+print(mod.hello_world())
+
+# Load with custom module name
+utils = webexec.load("https://raw.githubusercontent.com/user/repo/main/utils.py", module_name="myutils")
+utils.helper_function()
+```
+
+### `webexec.fetch(url, *, timeout=10, cache=False)`
+
+Return source code as string without executing.
+
+```python
+import webexec
+
+# Get source code
+source = webexec.fetch("https://raw.githubusercontent.com/user/repo/main/script.py")
+print(source)
+```
+
+### `webexec.clear_cache()`
+
+Clear the in-memory cache.
+
+```python
+import webexec
+
+# Clear cached content
+webexec.clear_cache()
+```
+
+## Extra Functions
+
+### `webexec.watch(url, interval=60)`
+
+Re-fetch and re-run a script every X seconds automatically.
+
+```python
+import webexec
+import time
+
+# Watch a script every 30 seconds
+thread = webexec.watch("https://raw.githubusercontent.com/user/repo/main/monitor.py", interval=30)
+
+# Keep the main thread alive
+try:
+    while True:
+        time.sleep(1)
+except KeyboardInterrupt:
+    print("Stopped watching")
+```
+
+### `webexec.run_all([url1, url2, url3])`
+
+Fetch and run multiple scripts in order.
+
+```python
+import webexec
+
+# Run multiple scripts
+urls = [
+    "https://raw.githubusercontent.com/user/repo/main/setup.py",
+    "https://raw.githubusercontent.com/user/repo/main/main.py",
+    "https://raw.githubusercontent.com/user/repo/main/cleanup.py"
+]
+webexec.run_all(urls)
+```
+
+### `webexec.preview(url)`
+
+Print the source code without executing it.
+
+```python
+import webexec
+
+# Preview a script
+webexec.preview("https://raw.githubusercontent.com/user/repo/main/script.py")
+```
+
+### `webexec.install_imports(url, *, timeout=10, cache=False, upgrade=False, user=False)`
+
+Detect and install missing imports from a remote script.
+
+```python
+import webexec
+
+# Install missing dependencies
+installed = webexec.install_imports("https://raw.githubusercontent.com/user/repo/main/script.py")
+print(f"Installed packages: {installed}")
+
+# Install with upgrade and user flags
+webexec.install_imports("https://raw.githubusercontent.com/user/repo/main/script.py", 
+                       upgrade=True, user=True)
+```
+
+## URL Examples
+
+The package works with any raw URL that returns Python code:
+
+### GitHub Raw URLs
+```python
+webexec.run("https://raw.githubusercontent.com/username/repository/main/script.py")
+```
+
+### Pastebin Raw URLs
+```python
+webexec.run("https://pastebin.com/raw/abc123def")
+```
+
+### Any Raw URL
+```python
+webexec.run("https://example.com/files/myscript.py")
+```
+
+## Error Handling
+
+The package raises clear `RuntimeError` exceptions when:
+
+- URL is not reachable
+- HTTP status code is not 200
+- Content is not valid UTF-8 text
+- Network errors occur
+
+```python
+import webexec
+
+try:
+    webexec.run("https://example.com/nonexistent.py")
+except RuntimeError as e:
+    print(f"Error: {e}")
+```
+
+## Caching
+
+Enable caching to avoid re-fetching the same URL:
+
+```python
+import webexec
+
+# First call fetches from URL
+webexec.run("https://example.com/script.py", cache=True)
+
+# Subsequent calls use cached content
+webexec.run("https://example.com/script.py", cache=True)
+
+# Clear cache when needed
+webexec.clear_cache()
+```
+
+## License
+
+MIT License - see LICENSE file for details.

webexec-1.0.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+webexec/__init__.py,sha256=LhILUFD_Ib5VAQqa1t9jrg5kfwQNr7iSZ9wGK9KVD8k,536
+webexec/cache.py,sha256=ImI5I7-mlJPLAnw55kfbiUGAjJC1--GIRWG9QfwrOQE,1035
+webexec/executor.py,sha256=VERMIQA3agATkA1fJc48xddBahAZardRKfl-gEPK7H8,3105
+webexec/fetcher.py,sha256=orQrLdehXstNEup8VkBH-UgB919TAnkT3vlz7IN-hbs,1653
+webexec/utils.py,sha256=bQorcQAQ-5b41dy1nAsIXB0LKA02BrwBAva_1bAwaVA,5537
+webexec-1.0.0.dist-info/licenses/LICENSE,sha256=EQFzylAztx6xRhAM1HnQnQaYIWrtwYCnxI8E16HuwmI,1065
+webexec-1.0.0.dist-info/METADATA,sha256=GeqHRy88Liu7Cf2wccY6cEb0Vf8sDE5pBbCGVZ0Ki8I,5390
+webexec-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+webexec-1.0.0.dist-info/top_level.txt,sha256=0Kc1EAv6R1AY_pDcPdwTHXUjAUO1fmyS2I-glb2G0QU,8
+webexec-1.0.0.dist-info/RECORD,,

webexec-1.0.0.dist-info/WHEEL

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

webexec-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 ZeroTeam
+
+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.

webexec-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+webexec