fasthardware 2.0.3__tar.gz → 2.2.2__tar.gz

fasthardware-2.2.2/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.4
+Name: fasthardware
+Version: 2.2.2
+Summary: Hyper-Performance Environment Setup for AI & Hardware Accelerating
+Author: ungyo
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: Microsoft :: Windows
+Requires-Python: >=3.8
+Requires-Dist: numpy>=1.20.0
+Requires-Dist: aiohttp>=3.8.0
+Requires-Dist: requests>=2.25.0
+Requires-Dist: openvino>=2023.0.0
+Requires-Dist: opencv-python>=4.5.0
+Dynamic: author
+Dynamic: classifier
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

fasthardware-2.2.2/README.md

@@ -0,0 +1,52 @@
+Markdown
+# 🚀 ungyoseries
+
+`hython` is a hyper-performance optimization framework designed to break through Python's runtime limitations and extract 100% of the underlying hardware potential. 
+
+By seamlessly integrating with `fasthardware V2`, the low-level system tuning engine, `hython` allows you to manage OS scheduler preemption, OpenVINO iGPU cache synchronization, and OpenCV SIMD acceleration with just a single line of code.
+
+---
+
+## 🛠️ Core Features
+
+1. **`fasthardware` Backbone**: Native integration with the core hardware acceleration module as a strict dependency, guaranteeing an optimized execution layer.
+2. **OS Process Preemption**: Dynamically elevates the process priority to the highest tier (`HIGH_PRIORITY_CLASS` on Windows / `NICE -20` on Linux) and binds child processes to dedicated CPU cores (`ULTIMATE` mode) to eliminate context-switching overhead.
+3. **OpenVINO Singleton Acceleration**: Synchronizes the core instance to leverage the Intel iGPU `LATENCY` optimization hint and handles model caching to eliminate initial compilation delays.
+4. **Intelligent GC Scheduling**: Suppresses the background Python Garbage Collector during execution to wipe out frame drops (stuttering), while executing low-level virtual memory working set flushes via `manual_sweep()` right at the function exit.
+5. **Built-in Aliasing**: Exposes direct access to high-speed computation modules like `hython.np` and the engine `hython.fasthardware` out of the box.
+
+---
+
+## 📦 Local Developer Installation
+
+Open your terminal in the project's root directory and run the following commands to perform a clean build and forced update:
+
+```bash
+# 1. Clean previous build caches and metadata
+rmdir /s /q build dist hython.egg-info
+
+# 2. Re-install in editable mode based on the verified setup.py
+python setup.py sdist bdist_wheel
+pip install --upgrade -e .
+💻 Usage
+Global Initialization and Pipeline Wrapping
+Call init exactly once when the main script boots to configure the system environment, and wrap your real-time processing loop with the @hython.boost() decorator to prevent memory leaks and frame jitter.
+
+Python
+from ungyoseries import hython
+
+# 1. Initialize global hardware tuning (ULTIMATE mode recruits all child processes)
+hython.init(mode="ULTIMATE")
+
+# 2. Decorate the pipeline for frame-drop protection and automatic memory overhaul
+@hython.boost()
+def my_heavy_pipeline():
+    # Directly access high-speed libraries embedded in hython
+    large_matrix = hython.np.ones(50000000)
+    print("🚀 Hyper-performance real-time inference pipeline is active.")
+    
+    # Explicitly invoke a low-level working set flush inside the loop if necessary
+    hython.fasthardware.manual_sweep()
+
+if __name__ == "__main__":
+    my_heavy_pipeline()

{fasthardware-2.0.3 → fasthardware-2.2.2}/autopublish/publisher.py

@@ -21,6 +21,7 @@ def deploy():
     if not pypi_token:
         print("❌ ERROR: Environment variable 'PYPI_TOKEN' is missing.")
         print("💡 Action: Set your token in the terminal first:")
+        pypi_token = input()
         print("   Windows (PowerShell): $env:PYPI_TOKEN='pypi-your-token-here'")
         return
 

fasthardware-2.2.2/cy_yologic/__init__.py

@@ -0,0 +1,2 @@
+# __init__.py
+from .cy_yologic import get_spine_angle_fast, check_immobile_fast

fasthardware-2.2.2/fasthardware/__init__.py

@@ -0,0 +1,14 @@
+# 옆에 있는 fasthardware.py 모듈을 패키지 루트로 끌어올립니다.
+# ungyoseries/fasthardware/__init__.py
+from .fasthardware import speedup, get_core, manual_sweep, FastVideoStream
+
+# 💡 웅요님이 설계하신 대로!
+# 시스템 튜닝 함수들은 fasthardware 모듈의 직계 자식으로 바로 노출합니다.
+# ex) fasthardware.speedup(), fasthardware.FastVideoStream()
+
+__all__ = [
+    'speedup',
+    'get_core',
+    'manual_sweep',
+    'FastVideoStream',
+]

fasthardware-2.2.2/fasthardware/fasthardware.py

@@ -0,0 +1,211 @@
+import os
+import sys
+import psutil
+import gc
+import ctypes
+import platform
+import cv2
+import threading
+import numpy as np
+
+_current_process = psutil.Process(os.getpid())
+_ov_core = None  # 싱글톤 OpenVINO core
+
+
+# ─────────────────────────────────────────
+# 🚀 웅요님의 최고 성능 완제품 비디오 스트림 엔진
+# ─────────────────────────────────────────
+class FastVideoStream:
+    def __init__(self, src=0):
+        # 윈도우 환경 최적화(CAP_DSHOW) 및 해상도, 버퍼 최소화 고정 세팅
+        self.cap = cv2.VideoCapture(src, cv2.CAP_DSHOW)
+        self.cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
+        self.cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)
+        self.cap.set(cv2.CAP_PROP_BUFFERSIZE, 1)
+
+        self.ret, self.frame = self.cap.read()
+        self.latest_frame = self.frame.copy() if self.ret else np.zeros((480, 640, 3), dtype=np.uint8)
+        self.started = False
+
+    def start(self):
+        """백그라운드 쓰레드로 스트림 상시 가동"""
+        if self.started:
+            return self
+        self.started = True
+        threading.Thread(target=self.update, daemon=True).start()
+        return self
+
+    def update(self):
+        """GIL 보호 영역에서 최신 프레임 무한 갱신 (OpenCV 렉 원천 차단)"""
+        while self.started:
+            ret, frame = self.cap.read()
+            if ret:
+                self.latest_frame = frame
+
+    def read(self):
+        """지연 시간이 '0'에 수렴하는 가장 최신의 프레임 반환"""
+        return self.latest_frame
+
+    def stop(self):
+        """스트림 종료 및 하드웨어 가속 리소스 해제"""
+        self.started = False
+        if self.cap.isOpened():
+            self.cap.release()
+
+
+# ─────────────────────────────────────────
+# ⚡ 하드웨어 가속 런타임 튜닝 핵심 함수들
+# ─────────────────────────────────────────
+def speedup(mode="DEFAULT"):
+    print(f"\n [FASTHARDWARE V2] Tuning mode: {mode}...")
+
+    _elevate_priority(_current_process)
+    _optimize_runtime()
+    _bind_c_libraries()
+    _accelerate_inference()
+
+    if mode == "ULTIMATE":
+        _supercharge_children()
+
+    print(" [FASTHARDWARE V2] System hardware optimization complete.\n")
+
+
+def get_core():
+    """
+    fasthardware가 최적화 설정을 완료한 OpenVINO Core 싱글톤을 반환합니다.
+    speedup() 호출 후 사용하세요.
+    """
+    global _ov_core
+    if _ov_core is None:
+        raise RuntimeError("speedup()을 먼저 호출하세요.")
+    return _ov_core
+
+
+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 _accelerate_inference():
+    global _ov_core
+
+    # 1. NVIDIA CUDA (PyTorch)
+    try:
+        import torch
+        if torch.cuda.is_available():
+            torch.backends.cudnn.benchmark = True
+            torch.backends.cudnn.enabled = True
+            torch.backends.cuda.matmul.allow_tf32 = True
+            torch.backends.cudnn.allow_tf32 = True
+            device_name = torch.cuda.get_device_name(0)
+            print(f"   -> [CUDA] {device_name} detected. cuDNN benchmark + TF32 engaged.")
+        else:
+            torch.set_num_threads(os.cpu_count() or 4)
+            torch.set_num_interop_threads(os.cpu_count() or 4)
+            print(f"   -> [PyTorch] CPU mode. Threads maximized to {os.cpu_count()}.")
+    except ImportError:
+        pass
+
+    # 2. Intel OpenVINO — 싱글톤 core 생성 및 최적화
+    try:
+        import openvino as ov
+
+        core = ov.Core()
+
+        # 모델 캐시 — 두 번째 실행부터 컴파일 시간 제거
+        cache_dir = os.path.join(os.path.expanduser("~"), ".fasthardware_ov_cache")
+        os.makedirs(cache_dir, exist_ok=True)
+        core.set_property({"CACHE_DIR": cache_dir})
+
+        if "GPU" in core.available_devices:
+            core.set_property("GPU", {"PERFORMANCE_HINT": "LATENCY"})
+            print(f"   -> [OpenVINO] Intel iGPU detected. LATENCY hint + model cache engaged.")
+        else:
+            core.set_property("CPU", {"PERFORMANCE_HINT": "THROUGHPUT"})
+            print(f"   -> [OpenVINO] CPU mode. THROUGHPUT hint engaged.")
+
+        os.environ["OV_FRONTEND_CACHE_ENABLE"] = "1"
+
+        # 싱글톤으로 저장 → get_core()로 꺼내 쓸 수 있음
+        _ov_core = core
+
+    except ImportError:
+        pass
+
+    # 3. OpenCV
+    try:
+        cv2.setUseOptimized(True)
+        cv2.setNumThreads(os.cpu_count() or 4)
+        if cv2.ocl.haveOpenCL():
+            cv2.ocl.setUseOpenCL(True)
+            print(f"   -> [OpenCV] SIMD + OpenCL acceleration engaged.")
+        else:
+            print(f"   -> [OpenCV] SIMD acceleration engaged.")
+    except ImportError:
+        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()
+    gc.disable()
+
+    try:
+        if platform.system() == "Windows":
+            handle = ctypes.windll.kernel32.OpenProcess(0x1F0FFF, False, os.getpid())
+            if handle:
+                ctypes.windll.kernel32.SetProcessWorkingSetSize(handle, -1, -1)
+                ctypes.windll.kernel32.CloseHandle(handle)
+        elif platform.system() == "Linux":
+            libc = ctypes.CDLL("libc.so.6")
+            libc.malloc_trim(0)
+    except Exception:
+        pass

fasthardware-2.2.2/fasthardware.egg-info/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.4
+Name: fasthardware
+Version: 2.2.2
+Summary: Hyper-Performance Environment Setup for AI & Hardware Accelerating
+Author: ungyo
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: Microsoft :: Windows
+Requires-Python: >=3.8
+Requires-Dist: numpy>=1.20.0
+Requires-Dist: aiohttp>=3.8.0
+Requires-Dist: requests>=2.25.0
+Requires-Dist: openvino>=2023.0.0
+Requires-Dist: opencv-python>=4.5.0
+Dynamic: author
+Dynamic: classifier
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

{fasthardware-2.0.3 → fasthardware-2.2.2}/fasthardware.egg-info/SOURCES.txt

@@ -2,8 +2,7 @@ README.md
 setup.py
 autopublish/__init__.py
 autopublish/publisher.py
-easy-path/__init__.py
-easy-path/easy-path1.py
+cy_yologic/__init__.py
 fasthardware/__init__.py
 fasthardware/fasthardware.py
 fasthardware.egg-info/PKG-INFO
@@ -12,4 +11,6 @@ fasthardware.egg-info/dependency_links.txt
 fasthardware.egg-info/requires.txt
 fasthardware.egg-info/top_level.txt
 package_guardian/__init__.py
-package_guardian/guardian1.py
+package_guardian/guardian1.py
+ungyoseries/__init__.py
+ungyoseries/hython.py

fasthardware-2.2.2/fasthardware.egg-info/requires.txt

@@ -0,0 +1,5 @@
+numpy>=1.20.0
+aiohttp>=3.8.0
+requests>=2.25.0
+openvino>=2023.0.0
+opencv-python>=4.5.0

{fasthardware-2.0.3 → fasthardware-2.2.2}/fasthardware.egg-info/top_level.txt

@@ -1,4 +1,5 @@
 autopublish
-easy-path
+cy_yologic
 fasthardware
 package_guardian
+ungyoseries

fasthardware-2.2.2/setup.py

@@ -0,0 +1,25 @@
+# setup.py
+from setuptools import setup, find_packages
+
+setup(
+    name="fasthardware",
+    version="2.2.2",
+    description="Hyper-Performance Environment Setup for AI & Hardware Accelerating",
+    author="ungyo",
+    # 💡 ungyoseries 폴더와 그 하위 패키지(fasthardware)를 통째로 자동 탐색하여 묶습니다.
+    packages=find_packages(),
+    include_package_data=True,
+    python_requires=">=3.8",
+    # 💡 보스의 프레임워크가 요구하는 핵심 의존성 라이브러리 자동 매핑
+    install_requires=[
+        "numpy>=1.20.0",
+        "aiohttp>=3.8.0",
+        "requests>=2.25.0",
+        "openvino>=2023.0.0",
+        "opencv-python>=4.5.0",
+    ],
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "Operating System :: Microsoft :: Windows",
+    ],
+)

fasthardware-2.2.2/ungyoseries/__init__.py

@@ -0,0 +1,9 @@
+from .hython import fasthardware, init, boost, np, aiohttp, requests
+__all__=[
+    'fasthardware',
+    'init',
+    'boost',
+    'np',
+    'aiohttp',
+    'requests'
+]

fasthardware-2.2.2/ungyoseries/hython.py

@@ -0,0 +1,41 @@
+from fasthardware import fasthardware
+import numpy as np
+import aiohttp
+import requests
+from functools import wraps
+
+__all__ = ['fasthardware','np', 'aiohttp', 'requests', 'init', 'boost']
+
+_initialized = False
+
+
+def init(mode="DEFAULT"):
+    """
+    프로그램 시작 시 딱 한 번 호출.
+    전체 하드웨어 가속 환경을 초기화합니다.
+    mode: "DEFAULT" 또는 "ULTIMATE"
+    """
+    global _initialized
+    print("\n🚀 [HYTHON] Initializing Hyper-Performance Environment...")
+    fasthardware.speedup(mode=mode)
+    _initialized = True
+
+
+def boost():
+    """
+    함수에 붙이는 데코레이터.
+    함수 실행 후 메모리를 자동으로 정리합니다.
+    init()은 별도로 한 번만 호출하세요.
+    """
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            if not _initialized:
+                print("[HYTHON] Warning: call init() first.")
+            try:
+                result = func(*args, **kwargs)
+                return result
+            finally:
+                fasthardware.manual_sweep()
+        return wrapper
+    return decorator

fasthardware-2.0.3/PKG-INFO

@@ -1,104 +0,0 @@
-Metadata-Version: 2.4
-Name: fasthardware
-Version: 2.0.3
-Summary: Maximize the absolute computing power of your Python process with a single line of code.
-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
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Topic :: System :: Hardware
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-Requires-Dist: psutil>=5.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="fasthardware Official Logo" width="400">
-</p>
-# ⚡ fasthardware
-
-[![PyPI version](https://img.shields.io/pypi/v/fasthardware.svg)](https://pypi.org/project/fasthardware/)
-[![Downloads](https://pepy.tech/badge/fasthardware)](https://pepy.tech/project/fasthardware)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-
-**Maximize the absolute computing power of your Python process and all its child processes with just a single line of code.**
-
-`fasthardware` is a lightweight, zero-configuration hardware acceleration injector designed for high-performance, real-time Python applications (e.g., YOLO object detection, MediaPipe pose estimation, OpenCV video pipelines, and heavy distributed inference loops).
-
-By hijacking the OS scheduler, managing runtime memory thresholds, and forcing strict CPU core binding across multi-processes, `fasthardware` eliminates micro-stuttering and stabilizes frames under heavy loads.
-
----
-
-## 🚀 Key Features
-
-* **OS Priority Escalation:** Automatically forces the host OS (Windows/Linux) to allocate maximum CPU scheduling priority to your Python process.
-* **🔥 ULTIMATE Multi-Process Interception:** Automatically tracks all spawned child processes, forces them into high-priority classes, and binds them to dedicated CPU cores (`CPU Affinity`) to eliminate distributed bottlenecks.
-* **Micro-Stuttering Elimination:** Optimizes Python's Garbage Collection (GC) thresholds to prevent "Stop-the-World" latency spikes during heavy loops.
-* **C-Level Multicore Mobilization:** Injects global environment flags (`OMP`, `MKL`, `OPENBLAS`, `NUMEXPR`) to force underlying C/C++ backed libraries (NumPy, OpenCV) to utilize every single logical core available.
-* **Zero-Config Integration:** No code rewrites. Just import it at the very top of your script.
-
----
-
-## 📦 Installation
-
-Install the package directly from PyPI:
-
-```bash
-pip install fasthardware
-```
-🛠️ Quick Start
-1. Default Mode (Single Process Boost)
-Perfect for standard loops like standalone YOLO inference or single-camera stream pipelines.
-
-```Python
-from fasthardware import fasthardware
-```
-
-# Unlock maximum priority for the current process
-```Python
-fasthardware.speedup()
-```
-
-# Your heavy real-time loop goes here...
-2. ULTIMATE Mode (Multi-Process & Distributed Boost)
-Designed for massive pipelines that spawn child processes (e.g., multi-GPU frameworks, distributed learning, parallel workers). It intercepts all child processes and binds them to specific cores.
-
-```Python
-from fasthardware import fasthardware
-```
-
-# Supercharge both main and all child processes recursively
-```Python
-fasthardware.speedup(mode="ULTIMATE")
-```
-
-# Your heavy multiprocessing/distributed pipeline here...
-🧹 Manual Memory Sweeping (Optional)
-For ultra-heavy asynchronous pipelines (e.g., blending AI inference with async API requests or audio generation), manually sweep the 0-generation memory cache without breaking your frame rate:
-
-```Python
-# Call this at the end of your loop iteration if necessary
-fasthardware.manual_sweep()
-```
-📊 Performance Impact
-Actual benchmarking on heavy real-time pipelines (YOLOv8 Inference + Parallel Workers):
-
-Standard Python Implementation: ~30 FPS (with frequent micro-stutters and core thrashing)
-
-With fasthardware (ULTIMATE Mode): 53+ FPS (Stable, zero core competition, 40%+ performance jump)
-
-📜 License
-This project is licensed under the MIT License - see the LICENSE file for details.
-
-Developed with ⚡ by Choi Woongyo.

fasthardware-2.0.3/README.md

@@ -1,80 +0,0 @@
-Markdown
-<p align="center">
-  <img src="logo.png" alt="fasthardware Official Logo" width="400">
-</p>
-# ⚡ fasthardware
-
-[![PyPI version](https://img.shields.io/pypi/v/fasthardware.svg)](https://pypi.org/project/fasthardware/)
-[![Downloads](https://pepy.tech/badge/fasthardware)](https://pepy.tech/project/fasthardware)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-
-**Maximize the absolute computing power of your Python process and all its child processes with just a single line of code.**
-
-`fasthardware` is a lightweight, zero-configuration hardware acceleration injector designed for high-performance, real-time Python applications (e.g., YOLO object detection, MediaPipe pose estimation, OpenCV video pipelines, and heavy distributed inference loops).
-
-By hijacking the OS scheduler, managing runtime memory thresholds, and forcing strict CPU core binding across multi-processes, `fasthardware` eliminates micro-stuttering and stabilizes frames under heavy loads.
-
----
-
-## 🚀 Key Features
-
-* **OS Priority Escalation:** Automatically forces the host OS (Windows/Linux) to allocate maximum CPU scheduling priority to your Python process.
-* **🔥 ULTIMATE Multi-Process Interception:** Automatically tracks all spawned child processes, forces them into high-priority classes, and binds them to dedicated CPU cores (`CPU Affinity`) to eliminate distributed bottlenecks.
-* **Micro-Stuttering Elimination:** Optimizes Python's Garbage Collection (GC) thresholds to prevent "Stop-the-World" latency spikes during heavy loops.
-* **C-Level Multicore Mobilization:** Injects global environment flags (`OMP`, `MKL`, `OPENBLAS`, `NUMEXPR`) to force underlying C/C++ backed libraries (NumPy, OpenCV) to utilize every single logical core available.
-* **Zero-Config Integration:** No code rewrites. Just import it at the very top of your script.
-
----
-
-## 📦 Installation
-
-Install the package directly from PyPI:
-
-```bash
-pip install fasthardware
-```
-🛠️ Quick Start
-1. Default Mode (Single Process Boost)
-Perfect for standard loops like standalone YOLO inference or single-camera stream pipelines.
-
-```Python
-from fasthardware import fasthardware
-```
-
-# Unlock maximum priority for the current process
-```Python
-fasthardware.speedup()
-```
-
-# Your heavy real-time loop goes here...
-2. ULTIMATE Mode (Multi-Process & Distributed Boost)
-Designed for massive pipelines that spawn child processes (e.g., multi-GPU frameworks, distributed learning, parallel workers). It intercepts all child processes and binds them to specific cores.
-
-```Python
-from fasthardware import fasthardware
-```
-
-# Supercharge both main and all child processes recursively
-```Python
-fasthardware.speedup(mode="ULTIMATE")
-```
-
-# Your heavy multiprocessing/distributed pipeline here...
-🧹 Manual Memory Sweeping (Optional)
-For ultra-heavy asynchronous pipelines (e.g., blending AI inference with async API requests or audio generation), manually sweep the 0-generation memory cache without breaking your frame rate:
-
-```Python
-# Call this at the end of your loop iteration if necessary
-fasthardware.manual_sweep()
-```
-📊 Performance Impact
-Actual benchmarking on heavy real-time pipelines (YOLOv8 Inference + Parallel Workers):
-
-Standard Python Implementation: ~30 FPS (with frequent micro-stutters and core thrashing)
-
-With fasthardware (ULTIMATE Mode): 53+ FPS (Stable, zero core competition, 40%+ performance jump)
-
-📜 License
-This project is licensed under the MIT License - see the LICENSE file for details.
-
-Developed with ⚡ by Choi Woongyo.

fasthardware-2.0.3/easy-path/easy-path1.py

@@ -1,68 +0,0 @@
-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-2.0.3/fasthardware/__init__.py

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

fasthardware-2.0.3/fasthardware/fasthardware.py

@@ -1,78 +0,0 @@
-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()

fasthardware-2.0.3/fasthardware.egg-info/PKG-INFO

@@ -1,104 +0,0 @@
-Metadata-Version: 2.4
-Name: fasthardware
-Version: 2.0.3
-Summary: Maximize the absolute computing power of your Python process with a single line of code.
-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
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Topic :: System :: Hardware
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-Requires-Dist: psutil>=5.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="fasthardware Official Logo" width="400">
-</p>
-# ⚡ fasthardware
-
-[![PyPI version](https://img.shields.io/pypi/v/fasthardware.svg)](https://pypi.org/project/fasthardware/)
-[![Downloads](https://pepy.tech/badge/fasthardware)](https://pepy.tech/project/fasthardware)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-
-**Maximize the absolute computing power of your Python process and all its child processes with just a single line of code.**
-
-`fasthardware` is a lightweight, zero-configuration hardware acceleration injector designed for high-performance, real-time Python applications (e.g., YOLO object detection, MediaPipe pose estimation, OpenCV video pipelines, and heavy distributed inference loops).
-
-By hijacking the OS scheduler, managing runtime memory thresholds, and forcing strict CPU core binding across multi-processes, `fasthardware` eliminates micro-stuttering and stabilizes frames under heavy loads.
-
----
-
-## 🚀 Key Features
-
-* **OS Priority Escalation:** Automatically forces the host OS (Windows/Linux) to allocate maximum CPU scheduling priority to your Python process.
-* **🔥 ULTIMATE Multi-Process Interception:** Automatically tracks all spawned child processes, forces them into high-priority classes, and binds them to dedicated CPU cores (`CPU Affinity`) to eliminate distributed bottlenecks.
-* **Micro-Stuttering Elimination:** Optimizes Python's Garbage Collection (GC) thresholds to prevent "Stop-the-World" latency spikes during heavy loops.
-* **C-Level Multicore Mobilization:** Injects global environment flags (`OMP`, `MKL`, `OPENBLAS`, `NUMEXPR`) to force underlying C/C++ backed libraries (NumPy, OpenCV) to utilize every single logical core available.
-* **Zero-Config Integration:** No code rewrites. Just import it at the very top of your script.
-
----
-
-## 📦 Installation
-
-Install the package directly from PyPI:
-
-```bash
-pip install fasthardware
-```
-🛠️ Quick Start
-1. Default Mode (Single Process Boost)
-Perfect for standard loops like standalone YOLO inference or single-camera stream pipelines.
-
-```Python
-from fasthardware import fasthardware
-```
-
-# Unlock maximum priority for the current process
-```Python
-fasthardware.speedup()
-```
-
-# Your heavy real-time loop goes here...
-2. ULTIMATE Mode (Multi-Process & Distributed Boost)
-Designed for massive pipelines that spawn child processes (e.g., multi-GPU frameworks, distributed learning, parallel workers). It intercepts all child processes and binds them to specific cores.
-
-```Python
-from fasthardware import fasthardware
-```
-
-# Supercharge both main and all child processes recursively
-```Python
-fasthardware.speedup(mode="ULTIMATE")
-```
-
-# Your heavy multiprocessing/distributed pipeline here...
-🧹 Manual Memory Sweeping (Optional)
-For ultra-heavy asynchronous pipelines (e.g., blending AI inference with async API requests or audio generation), manually sweep the 0-generation memory cache without breaking your frame rate:
-
-```Python
-# Call this at the end of your loop iteration if necessary
-fasthardware.manual_sweep()
-```
-📊 Performance Impact
-Actual benchmarking on heavy real-time pipelines (YOLOv8 Inference + Parallel Workers):
-
-Standard Python Implementation: ~30 FPS (with frequent micro-stutters and core thrashing)
-
-With fasthardware (ULTIMATE Mode): 53+ FPS (Stable, zero core competition, 40%+ performance jump)
-
-📜 License
-This project is licensed under the MIT License - see the LICENSE file for details.
-
-Developed with ⚡ by Choi Woongyo.

fasthardware-2.0.3/fasthardware.egg-info/requires.txt

@@ -1 +0,0 @@
-psutil>=5.9.0

fasthardware-2.0.3/setup.py

@@ -1,38 +0,0 @@
-import os
-from setuptools import setup, find_packages
-
-# README.md 파싱 및 인코딩 방어막 구축
-long_description = ""
-if os.path.exists("README.md"):
-    with open("README.md", "r", encoding="utf-8") as fh:
-        long_description = fh.read()
-
-setup(
-    name="fasthardware",
-    version="2.0.3",  # 🌟 새 README 반영 기념 빌드업 버전!
-    author="Choi Woongyo",
-    author_email="chldnsry1214@gmail.com",  # 보스의 이메일로 변경 가능합니다.
-    description="Maximize the absolute computing power of your Python process with a single line of code.",
-    long_description=long_description,
-    long_description_content_type="text/markdown",
-
-    # 패키지 폴더 내부 구조 자동 추적
-    packages=find_packages(),
-    include_package_data=True,
-
-    # 하드웨어 제어 핵심 엔진 의존성 피드
-    install_requires=[
-        "psutil>=5.9.0",
-    ],
-
-    # PyPI 글로벌 카테고리 태그 세팅
-    classifiers=[
-        "Programming Language :: Python :: 3",
-        "License :: OSI Approved :: MIT License",
-        "Operating System :: Microsoft :: Windows",
-        "Operating System :: POSIX :: Linux",
-        "Topic :: Software Development :: Libraries :: Python Modules",
-        "Topic :: System :: Hardware",
-    ],
-    python_requires=">=3.8",
-)