hython 1.0.1__py3-none-any.whl

autopublish/publisher.py

@@ -0,0 +1,64 @@
+import os
+import subprocess
+import sys
+import glob
+
+
+def deploy():
+    """
+    Automatically builds setup.py and deploys the package to PyPI using token authentication.
+    """
+    print("\n🚀 [PyPI Auto-Publisher] Starting global deployment pipeline...")
+
+    # 1. Check for setup.py
+    if not os.path.exists("setup.py"):
+        print("❌ ERROR: 'setup.py' not found in the current directory.")
+        print("💡 Action: Please navigate to the root directory of your project.")
+        return
+
+    # 2. Retrieve PyPI Token from Environment Variables
+    pypi_token = os.environ.get("PYPI_TOKEN")
+    if not pypi_token:
+        print("❌ ERROR: Environment variable 'PYPI_TOKEN' is missing.")
+        print("💡 Action: Set your token in the terminal first:")
+        print("   Windows (PowerShell): $env:PYPI_TOKEN='pypi-your-token-here'")
+        return
+
+    try:
+        # 3. Clean up previous build artifacts
+        print("\n🧹 [1/3] Cleaning up old build artifacts (dist/build)...")
+        if os.path.exists("dist"):
+            subprocess.run("rmdir /s /q dist" if os.name == "nt" else "rm -rf dist", shell=True)
+        if os.path.exists("build"):
+            subprocess.run("rmdir /s /q build" if os.name == "nt" else "rm -rf build", shell=True)
+
+        # 4. Build source distribution and wheel
+        print("\n📦 [2/3] Building source distribution and wheel archives...")
+        subprocess.run([sys.executable, "setup.py", "sdist", "bdist_wheel"], check=True)
+
+        # 5. Find actual built files (Fixing Windows dist/* wildcard 400 bug)
+        built_files = glob.glob(os.path.join("dist", "*"))
+        if not built_files:
+            print("❌ ERROR: No built files found in 'dist' folder.")
+            return
+
+        print("\n🔥 [3/3] Uploading packages to PyPI warehouse via Twine...")
+
+        # Inject API token into environment for secure non-interactive authentication
+        env_copy = os.environ.copy()
+        env_copy["TWINE_USERNAME"] = "__token__"
+        env_copy["TWINE_PASSWORD"] = pypi_token
+
+        # Execute twine upload with explicit file list instead of dist/*
+        cmd = ["twine", "upload"] + built_files
+        subprocess.run(cmd, check=True, env=env_copy, shell=True)
+
+        print("\n🎉 [SUCCESS] Deployment completed successfully!")
+        print("🌐 Your library has been published to the global Python ecosystem.")
+
+    except subprocess.CalledProcessError as e:
+        print(f"\n❌ ERROR: Command execution failed during build/upload process.")
+        print(f"Details: {e}")
+    except Exception as e:
+        print(f"\n❌ ERROR: Unexpected system error occurred.")
+        print(f"Details: {e}")

easy-path/easy-path1.py

@@ -0,0 +1,68 @@
+import os
+import shutil
+import sys
+
+class Path(str):
+    """
+    Super-intuitive Path manipulation library for humans.
+    Inherits from 'str' so it can be used directly anywhere a string is required.
+    """
+
+    @classmethod
+    def here(cls):
+        """Returns the absolute directory path of the currently executing script."""
+        # Get the caller's file path frame dynamically
+        try:
+            import inspect
+            frame = inspect.stack()[1]
+            module = inspect.getmodule(frame[0])
+            if module and hasattr(module, '__file__'):
+                return cls(os.path.dirname(os.path.abspath(module.__file__)))
+        except Exception:
+            pass
+        return cls(os.getcwd())
+
+    def __truediv__(self, next_path):
+        """Enables intuitive slash '/' routing syntax (e.g., Path.here() / 'folder' / 'file.txt')"""
+        return Path(os.path.join(self, str(next_path)))
+
+    @property
+    def exists(self):
+        """Returns True if the path exists on the system."""
+        return os.path.exists(self)
+
+    @property
+    def is_file(self):
+        """Returns True if the path points to a file."""
+        return os.path.isfile(self)
+
+    @property
+    def is_dir(self):
+        """Returns True if the path points to a directory."""
+        return os.path.isdir(self)
+
+    def change_ext(self, new_ext):
+        """Changes or adds a file extension easily."""
+        base, _ = os.path.splitext(self)
+        if not new_ext.startswith('.'):
+            new_ext = '.' + new_ext
+        return Path(base + new_ext)
+
+    def make_dir(self):
+        """Creates the directory if it does not exist. (Like mkdir -p)"""
+        os.makedirs(self, exist_ok=True)
+        return self
+
+    def read(self, encoding="utf-8"):
+        """Reads file content in a single line."""
+        with open(self, "r", encoding=encoding) as f:
+            return f.read()
+
+    def write(self, content, encoding="utf-8"):
+        """Writes content to the file in a single line. Automatically creates parent directories if missing."""
+        parent = os.path.dirname(self)
+        if parent:
+            os.makedirs(parent, exist_ok=True)
+        with open(self, "w", encoding=encoding) as f:
+            f.write(str(content))
+        return self

fasthardware/__init__.py

@@ -0,0 +1,2 @@
+# 옆에 있는 fasthardware.py 모듈을 패키지 루트로 끌어올립니다.
+from . import fasthardware

fasthardware/fasthardware.py

@@ -0,0 +1,78 @@
+import os
+import sys
+import psutil
+import gc
+
+_current_process = psutil.Process(os.getpid())
+
+
+def speedup(mode="DEFAULT"):
+    print(f"\n [FASTHARDWARE V2] Tuning mode: {mode}...")
+
+    _elevate_priority(_current_process)
+    _optimize_runtime()
+    _bind_c_libraries()
+
+    if mode == "ULTIMATE":
+        _supercharge_children()
+
+    print(" [FASTHARDWARE V2] System hardware optimization complete.\n")
+
+
+def _elevate_priority(process):
+    try:
+        if sys.platform == "win32":
+            process.nice(psutil.HIGH_PRIORITY_CLASS)
+        else:
+            process.nice(-20)
+    except Exception:
+        pass
+
+
+def _optimize_runtime():
+    try:
+        gc.disable()
+        gc.set_threshold(700, 10, 10)
+    except Exception:
+        pass
+
+
+def _bind_c_libraries():
+    try:
+        total_cores = str(os.cpu_count() or 4)
+        for flag in ["OMP_NUM_THREADS", "MKL_NUM_THREADS", "OPENBLAS_NUM_THREADS", "NUMEXPR_NUM_THREADS"]:
+            os.environ[flag] = total_cores
+    except Exception:
+        pass
+
+
+def _supercharge_children():
+    try:
+        children = _current_process.children(recursive=True)
+        if not children:
+            print("   -> [MP] No child processes detected yet. Buffers ready.")
+            return
+
+        print(f"   -> [MP] Detecting {len(children)} child processes. Intercepting...")
+
+        all_cores = list(range(os.cpu_count() or 4))
+        if not all_cores:
+            return
+
+        for i, child in enumerate(children):
+            try:
+                if child.is_running():
+                    _elevate_priority(child)
+                    assigned_core = [all_cores[i % len(all_cores)]]
+                    child.cpu_affinity(assigned_core)
+                    print(f"      └─ Child [{child.pid}] Supercharged & Bound to Core {assigned_core}")
+            except Exception:
+                pass
+    except Exception:
+        pass
+
+
+def manual_sweep():
+    gc.enable()
+    gc.collect(0)
+    gc.disable()

hython/__init__.py

@@ -0,0 +1,2 @@
+# hython.py 파일(현재 폴더 .)에서 함수들을 가져와서 외부로 연결해줍니다.
+from .hython import init, boost

hython/hython.py

@@ -0,0 +1,22 @@
+from fasthardware import fasthardware
+import numpy as np
+import aiohttp
+import requests
+from functools import wraps
+
+def init(mode="DEFAULT"):
+    print("\n🚀 [HYTHON] Initializing Hyper-Performance Environment...")
+    fasthardware.speedup(mode=mode)
+
+def boost(mode="DEFAULT"):
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            fasthardware.speedup(mode=mode)
+            try:
+                result = func(*args, **kwargs)
+                return result
+            finally:
+                fasthardware.manual_sweep()
+        return wrapper
+    return decorator

hython-1.0.1.dist-info/METADATA

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: hython
+Version: 1.0.1
+Summary: The ultimate high-performance utility framework for Python, powered by fasthardware.
+Author: Choi Woongyo
+Author-email: chldnsry1214@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: fasthardware>=2.0.3
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: requests>=2.31.0
+Requires-Dist: aiohttp>=3.9.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+Markdown
+<p align="center">
+  <img src="logo.png" alt="hython Official Logo" width="400">
+</p>
+
+# 🚀 hython 
+
+[![PyPI version](https://img.shields.io/pypi/v/hython.svg)](https://pypi.org/project/hython/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+**The ultimate high-performance utility framework for Python. Supercharge your functions with just a single decorator.**
+
+`hython` is a next-generation mega-utility pack designed to eliminate Python's performance bottlenecks. Powered by the legendary `fasthardware` engine, `hython` allows you to inject hardcore OS-level optimization, strict multicore affinity binding, and ultra-fast computing/networking libraries directly into your critical functions using a simple, native decorator.
+
+---
+
+## ⚡ Key Features
+
+* **Built-in `fasthardware` V2 Engine:** Automatically inherits OS priority escalation and multi-process core-binding (`ULTIMATE` mode).
+* **`@hython.boost` Decorator:** Instantly accelerates specific functions on-demand. Boosts hardware efficiency upon entry and clears memory caches immediately upon exit.
+* **All-in-One High-Speed Battery Pack:** Automatically bundles industry-standard core libraries for high-performance computing and asynchronous networking (`NumPy`, `Requests`, `AioHTTP`).
+* **Zero Configuration boilerplate:** No tedious setups or multi-package imports. Just decorate and launch.
+
+---
+
+## 📦 Installation
+
+Install the complete performance ecosystem with a single command:
+
+```bash
+pip install hython
+```
+(This will automatically install fasthardware, numpy, requests, and aiohttp in the background.)
+
+🛠️ Quick Start
+1. Function-Level On-Demand Acceleration (Recommended)
+Simply place the @hython.boost() decorator above any heavy CPU-bound or multi-process function.
+
+```Python
+import hython
+```
+
+# Supercharge this specific function and its child processes recursively
+```Python
+@hython.boost(mode="ULTIMATE")
+def heavy_data_pipeline():
+    # 1. OS priority is elevated to maximum instantly
+    # 2. Child processes are strictly bound to isolated CPU cores
+    print("Processing massive numbers or real-time streaming...")
+```
+    
+    # [hython] Automatically provides pre-imported high-speed utilities
+    # e.g., hython.np, hython.requests, hython.aiohttp are ready to use
+    
+    # 3. Upon function completion, memory generation-0 cache is swept safely!
+2. Global Environment Initialization
+If you want to apply the hardware booster globally to your entire script from start to finish:
+
+```Python
+import hython
+```
+
+# Initialize hyper-performance environment for the entire process lifetime
+```Python
+hython.init(mode="ULTIMATE")
+```
+
+# Your standard scripts go here...
+🏗️ Integrated Ecosystem
+By installing hython, you instantly get optimized wrappers for:
+
+System Boosting: fasthardware (OS Scheduling Hijacking & Core Affinity)
+
+Fast Vectorization: numpy (C-optimized array operations)
+
+Hyper Network I/O: requests & aiohttp (Blazing fast synchronous & asynchronous I/O)
+
+📜 License
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+Developed with ⚡ by Choi Woongyo.

hython-1.0.1.dist-info/RECORD

@@ -0,0 +1,14 @@
+autopublish/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+autopublish/publisher.py,sha256=LoZbOr5_iQ9y8oT9mQWQn-chbvotVWbajnGFaDaBGZg,2738
+easy-path/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+easy-path/easy-path1.py,sha256=jLW_Pm1GDKmqvEaBoRc_Y6c6fwCQC4mV9n8UQLlSGgY,2333
+fasthardware/__init__.py,sha256=Tffov2cixPb84mx9dW8Le3ylvWIOp1ZOMdTNcaDDN3Y,109
+fasthardware/fasthardware.py,sha256=GlTwb846doiRNK0G4PlSXwKD_UuibMJY7RiGNrX1pTQ,2039
+hython/__init__.py,sha256=-kDqGLBcrjQbA2CaJdFmYE0qEyxYMb58cKPy8izHiGY,130
+hython/hython.py,sha256=ms9HtOC1h1EYSsnjTHzMP0SeaEcZWDdCHLqMjCa9rrc,633
+package_guardian/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+package_guardian/guardian1.py,sha256=a2fb6AWFUNm2KCIKrXCCWCQmQ0P_fe8NO8W9lsIDthY,2576
+hython-1.0.1.dist-info/METADATA,sha256=LODRJF4Gm1ManM8GfV2JalscGpc2e6o4PQpAcbkslWk,4058
+hython-1.0.1.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
+hython-1.0.1.dist-info/top_level.txt,sha256=ljiZyZ7jrFA_574QCJSwL4pSaQ_b1qu1RYwx4szN840,59
+hython-1.0.1.dist-info/RECORD,,

hython-1.0.1.dist-info/WHEEL

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

hython-1.0.1.dist-info/top_level.txt

@@ -0,0 +1,5 @@
+autopublish
+easy-path
+fasthardware
+hython
+package_guardian

package_guardian/guardian1.py

@@ -0,0 +1,69 @@
+import importlib.util
+import os
+import subprocess
+import sys
+import urllib.request
+import json
+
+
+def get_package_size(package_name):
+    """
+    Fetches the approximate download size of the package from the PyPI JSON API.
+    Returns size in MB as a string, or 'Unknown' if failed.
+    """
+    try:
+        # Querying PyPI official JSON API
+        url = f"https://pypi.org/pypi/{package_name}/json"
+        with urllib.request.urlopen(url, timeout=3) as response:
+            data = json.loads(response.read().decode())
+
+            # Look at the latest release files to calculate size
+            latest_version = data["info"]["version"]
+            releases = data["releases"].get(latest_version, [])
+
+            if not releases:
+                return "Unknown"
+
+            # Sum up sizes of available wheels/tarballs
+            total_bytes = sum(file_info["size"] for file_info in releases if "size" in file_info)
+            size_mb = total_bytes / (1024 * 1024)
+            return f"{size_mb:.2f} MB"
+    except Exception:
+        return "Unknown"
+
+
+def auto_require(package_name, pip_name=None):
+    """
+    Checks if a package is installed. If not, prompts the user with size info and installs it.
+    """
+    if pip_name is None:
+        pip_name = package_name
+
+    # Check if package is already installed
+    spec = importlib.util.find_spec(package_name)
+    if spec is not None:
+        return  # Already installed, pass smoothly
+
+    print(f"\n🔍 [Package Guardian] Missing required package: '{pip_name}'")
+    print("⏳ Fetching package metadata from PyPI...")
+
+    # Get download size
+    size = get_package_size(pip_name)
+    print(f"📦 Package: {pip_name} | Estimated Download Size: {size}")
+
+    # Prompt user for installation
+    response = input(f"❓ Would you like to install '{pip_name}' now? (y/n): ").strip().lower()
+
+    if response in ['y', 'yes']:
+        print(f"⚡ Installing '{pip_name}' via pip... Please wait.")
+        try:
+            # Execute pip install programmatically
+            subprocess.check_call([sys.executable, "-m", "pip", "install", pip_name])
+            print(f"🎉 [SUCCESS] '{pip_name}' has been successfully installed!\n")
+        except subprocess.CalledProcessError as e:
+            print(f"❌ [ERROR] Failed to install '{pip_name}'.")
+            print(f"Details: {e}")
+            sys.exit(1)
+    else:
+        print(f"🛑 [CANCELLED] Installation aborted by user. Execution cannot continue without '{pip_name}'.")
+        sys.exit(1)