NullGaze 1.0.0__py3-none-any.whl

nullgaze/__init__.py

@@ -0,0 +1,36 @@
+from .downloader import ImageDownloader
+from .exceptions import NullGazeError, DownloadFailedError, InvalidURLError
+
+__version__ = "1.0.0"
+__all__ = [
+    "ImageDownloader",
+    "download_image",
+    "NullGazeError",
+    "DownloadFailedError",
+    "InvalidURLError",
+]
+
+def download_image(
+    url: str, 
+    output_path: str, 
+    verbose: bool = False, 
+    headers: dict = None
+) -> str:
+    """
+    Convenience wrapper to download an image using the NullGaze engine.
+    
+    Args:
+        url (str): The direct URL or link of the image to retrieve.
+        output_path (str): The local path where the image should be saved.
+        verbose (bool): If True, prints verbose debugging output.
+        headers (dict, optional): Custom headers to merge into the request.
+        
+    Returns:
+        str: The path to the downloaded image.
+        
+    Raises:
+        DownloadFailedError: If all bypass strategies fail.
+        InvalidURLError: If the provided URL is malformed.
+    """
+    downloader = ImageDownloader(verbose=verbose)
+    return downloader.download(url, output_path, headers=headers)

nullgaze/downloader.py

@@ -0,0 +1,392 @@
+import os
+import ssl
+import select
+import socket
+import base64
+import logging
+import threading
+import time
+import urllib.parse
+import urllib.request
+from typing import Optional, Dict
+
+from .utils import get_default_headers
+from .exceptions import DownloadFailedError, InvalidURLError
+
+# Configure logging
+logger = logging.getLogger("NullGaze")
+
+# Try to import requests for standard download
+try:
+    import requests
+    HAS_REQUESTS = True
+except ImportError:
+    HAS_REQUESTS = False
+
+# Try to import curl_cffi for advanced TLS impersonation
+try:
+    from curl_cffi import requests as curl_requests
+    HAS_CURL_CFFI = True
+except ImportError:
+    HAS_CURL_CFFI = False
+    logger.warning("curl_cffi is not installed. TLS impersonation strategy will be limited.")
+
+# Try to import DrissionPage for advanced Chromium stealth bypassing
+try:
+    from DrissionPage import ChromiumPage, ChromiumOptions
+    HAS_DRISSION = True
+except ImportError:
+    HAS_DRISSION = False
+    logger.warning("DrissionPage is not installed. Browser rendering strategy will be skipped.")
+
+
+class LocalSplitProxyServer:
+    """A lightweight HTTP CONNECT proxy server that splits the TLS ClientHello to bypass DPI SNI blocks."""
+
+    def __init__(self):
+        self.server_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self.server_sock.bind(("127.0.0.1", 0))  # Bind to a random free port
+        self.port = self.server_sock.getsockname()[1]
+        self.running = False
+        self.thread = None
+
+    def start(self):
+        self.running = True
+        self.server_sock.listen(5)
+        self.thread = threading.Thread(target=self._listen_loop)
+        self.thread.daemon = True
+        self.thread.start()
+        logger.info(f"Local split proxy started on port {self.port}")
+
+    def stop(self):
+        self.running = False
+        try:
+            self.server_sock.close()
+        except Exception:
+            pass
+
+    def _listen_loop(self):
+        while self.running:
+            try:
+                conn, addr = self.server_sock.accept()
+                t = threading.Thread(target=self._handle_client, args=(conn,))
+                t.daemon = True
+                t.start()
+            except Exception:
+                break
+
+    def _handle_client(self, local_conn):
+        # 1. Read HTTP proxy CONNECT request
+        req_data = b""
+        try:
+            while b"\r\n\r\n" not in req_data:
+                chunk = local_conn.recv(4096)
+                if not chunk:
+                    break
+                req_data += chunk
+        except Exception as e:
+            logger.info(f"Failed to read CONNECT header: {e}")
+            local_conn.close()
+            return
+
+        if not req_data.startswith(b"CONNECT"):
+            local_conn.close()
+            return
+
+        # Parse target host and port
+        try:
+            first_line = req_data.split(b"\r\n")[0].decode('utf-8')
+            _, target, _ = first_line.split(" ")
+            host, port = target.split(":")
+            port = int(port)
+        except Exception as e:
+            logger.info(f"Failed to parse CONNECT targets: {e}")
+            local_conn.close()
+            return
+
+        # 2. Establish connection to remote server
+        try:
+            remote_sock = socket.create_connection((host, port), timeout=6)
+        except Exception as e:
+            logger.info(f"Proxy failed to connect to remote {host}:{port}: {e}")
+            local_conn.close()
+            return
+
+        # 3. Confirm connection established to local client
+        try:
+            local_conn.sendall(b"HTTP/1.1 200 Connection Established\r\n\r\n")
+        except Exception as e:
+            logger.info(f"Proxy failed to write established confirmation: {e}")
+            local_conn.close()
+            remote_sock.close()
+            return
+
+        # 4. Bidirectional socket forwarding with TLS ClientHello splitting
+        self._forward_sockets(local_conn, remote_sock)
+
+    def _forward_sockets(self, local_conn, remote_sock):
+        # Keep sockets in blocking mode for reliable writes/sendall
+        first_client_packet = True
+        socks = [local_conn, remote_sock]
+        closed = False
+        
+        while self.running and not closed:
+            try:
+                # Use select to wait until data is readable on either socket (with a 1.0 second timeout)
+                r, _, x = select.select(socks, [], socks, 1.0)
+                if x:
+                    break
+                for s in r:
+                    if s is local_conn:
+                        data = local_conn.recv(16384)
+                        if not data:
+                            closed = True
+                            break
+                        
+                        # Check if first packet is TLS ClientHello (starts with 0x16 0x03)
+                        if first_client_packet and data.startswith(b"\x16\x03"):
+                            first_client_packet = False
+                            logger.info(f"DPI Bypass: Splitting ClientHello ({len(data)} bytes)...")
+                            # Split into two parts (first 100 bytes and the rest)
+                            split_idx = min(100, len(data) - 1)
+                            part1 = data[:split_idx]
+                            part2 = data[split_idx:]
+                            
+                            remote_sock.sendall(part1)
+                            time.sleep(0.01)  # Delay of 10ms to force separate TCP segments
+                            remote_sock.sendall(part2)
+                        else:
+                            remote_sock.sendall(data)
+                            
+                    elif s is remote_sock:
+                        data = remote_sock.recv(16384)
+                        if not data:
+                            closed = True
+                            break
+                        local_conn.sendall(data)
+            except Exception as e:
+                logger.info(f"Socket forwarding error: {e}")
+                closed = True
+                break
+
+        try:
+            local_conn.close()
+        except Exception:
+            pass
+        try:
+            remote_sock.close()
+        except Exception:
+            pass
+
+
+class ImageDownloader:
+    """A highly resilient image downloading engine with multi-tier fallback strategies."""
+
+    def __init__(self, verbose: bool = False):
+        self.verbose = verbose
+        if verbose:
+            logging.basicConfig(level=logging.INFO)
+            logger.setLevel(logging.INFO)
+        else:
+            logger.setLevel(logging.WARNING)
+
+    def download(self, url: str, output_path: str, headers: Optional[Dict[str, str]] = None) -> str:
+        """
+        Downloads an image from the specified URL and saves it to output_path.
+        Tries multiple bypass strategies sequentially until one succeeds.
+        """
+        if not url.startswith("http://") and not url.startswith("https://"):
+            raise InvalidURLError("The URL must start with http:// or https://")
+
+        # Resolve output directory
+        out_dir = os.path.dirname(os.path.abspath(output_path))
+        if out_dir:
+            os.makedirs(out_dir, exist_ok=True)
+
+        # Merge or generate headers
+        req_headers = get_default_headers(url)
+        if headers:
+            req_headers.update(headers)
+
+        strategies = [
+            ("Direct HTTP Request", lambda: self._download_direct(url, output_path, req_headers)),
+            ("DPI-Bypass TLS Impersonation (Split Proxy)", lambda: self._download_dpi_bypass(url, output_path, req_headers)),
+            ("Stealth Browser Rendering (Chromium)", lambda: self._download_browser(url, output_path)),
+            ("Weserv Image Proxy Fallback", lambda: self._download_via_proxy(url, output_path)),
+        ]
+
+        errors = []
+        for name, strategy_fn in strategies:
+            logger.info(f"Trying strategy: {name}")
+            try:
+                if strategy_fn():
+                    logger.info(f"Successfully downloaded image using strategy: {name}")
+                    return output_path
+            except Exception as e:
+                err_msg = f"Strategy '{name}' failed: {e}"
+                logger.info(err_msg)
+                errors.append(err_msg)
+
+        # If all strategies failed, raise an exception
+        detailed_error = "\n".join(errors)
+        raise DownloadFailedError(
+            f"Failed to download image from {url} after trying all strategies.\nDetails:\n{detailed_error}"
+        )
+
+    def _download_direct(self, url: str, output_path: str, headers: dict) -> bool:
+        """Strategy 1: Direct HTTP GET using requests (or urllib if requests is missing)."""
+        if HAS_REQUESTS:
+            response = requests.get(url, headers=headers, timeout=1.5, stream=True)
+            response.raise_for_status()
+            with open(output_path, "wb") as f:
+                for chunk in response.iter_content(chunk_size=8192):
+                    if chunk:
+                        f.write(chunk)
+            return True
+        else:
+            req = urllib.request.Request(url, headers=headers)
+            with urllib.request.urlopen(req, timeout=1.5) as response:
+                with open(output_path, "wb") as f:
+                    f.write(response.read())
+            return True
+
+    def _download_dpi_bypass(self, url: str, output_path: str, headers: dict) -> bool:
+        """
+        Strategy 2: Insane Speed DPI-Bypass TLS Impersonation.
+        Launches a local split proxy in a background thread, routes curl_cffi through it,
+        which bypasses SNI blocks in fractions of a second, downloading the original file.
+        """
+        if not HAS_CURL_CFFI:
+            raise NotImplementedError("curl_cffi is not installed.")
+
+        # Start the local split proxy
+        proxy = LocalSplitProxyServer()
+        proxy.start()
+        
+        time.sleep(0.05)  # Let proxy bind and start listening
+        
+        proxies = {
+            "http": f"http://127.0.0.1:{proxy.port}",
+            "https": f"http://127.0.0.1:{proxy.port}"
+        }
+
+        try:
+            logger.info("Routing curl_cffi Chrome impersonation through local split proxy...")
+            response = curl_requests.get(
+                url,
+                headers=headers,
+                impersonate="chrome",
+                proxies=proxies,
+                timeout=12
+            )
+            
+            if response.status_code >= 400:
+                raise Exception(f"HTTP status code {response.status_code}")
+
+            with open(output_path, "wb") as f:
+                f.write(response.content)
+            return True
+        finally:
+            proxy.stop()
+
+    def _download_browser(self, url: str, output_path: str) -> bool:
+        """
+        Strategy 3: Stealth Browser Rendering using DrissionPage (Chromium).
+        Bypasses extreme active JS challenges (Turnstile) by rendering the page.
+        Extracts image data directly from memory/canvas or element screenshotting.
+        """
+        if not HAS_DRISSION:
+            raise NotImplementedError("DrissionPage is not installed.")
+
+        logger.info("Initializing headless Chromium browser...")
+        co = ChromiumOptions()
+        co.headless(True)
+        co.set_argument('--no-sandbox')
+        co.set_argument('--disable-gpu')
+        
+        page = ChromiumPage(co)
+        try:
+            logger.info(f"Navigating to URL: {url}")
+            page.get(url)
+            
+            # Wait for browser to render and decode the image
+            page.wait(3)
+
+            # --- Attempt 1: Canvas Base64 Pixel Extraction ---
+            js_canvas_extract = """
+            const img = document.querySelector('img');
+            if (!img || img.naturalWidth === 0) {
+                return null;
+            }
+            const canvas = document.createElement('canvas');
+            canvas.width = img.naturalWidth;
+            canvas.height = img.naturalHeight;
+            const ctx = canvas.getContext('2d');
+            try {
+                ctx.drawImage(img, 0, 0);
+                return canvas.toDataURL('image/jpeg', 0.95);
+            } catch (err) {
+                return null;
+            }
+            """
+            
+            logger.info("Attempting Canvas pixel extraction...")
+            data_url = page.run_js(js_canvas_extract)
+            
+            if data_url and data_url.startswith("data:image/jpeg;base64,"):
+                header, base64_data = data_url.split(",", 1)
+                image_data = base64.b64decode(base64_data)
+                with open(output_path, "wb") as f:
+                    f.write(image_data)
+                logger.info("Canvas extraction successful!")
+                return True
+
+            # --- Attempt 2: Direct Element Screenshot ---
+            logger.info("Canvas extraction failed. Attempting element screenshot...")
+            img_element = page.ele('tag:img')
+            if img_element:
+                img_element.get_screenshot(path=output_path)
+                if os.path.exists(output_path) and os.path.getsize(output_path) > 0:
+                    logger.info("Element screenshot successful!")
+                    return True
+
+            # --- Attempt 3: Browser Session Download API ---
+            logger.info("Screenshot failed. Attempting browser download API...")
+            if img_element:
+                src = img_element.attr('src')
+                if src:
+                    out_dir = os.path.dirname(os.path.abspath(output_path))
+                    filename = os.path.basename(output_path)
+                    res = page.download(src, out_dir, rename=filename)
+                    if res and os.path.exists(output_path) and os.path.getsize(output_path) > 0:
+                        logger.info("Browser session download API successful!")
+                        return True
+
+            raise Exception("Failed to extract image via Canvas, Screenshot, or Download API.")
+        finally:
+            page.quit()
+
+    def _download_via_proxy(self, url: str, output_path: str) -> bool:
+        """Strategy 4: Download via high-availability free caching proxy (Weserv)."""
+        encoded_url = urllib.parse.quote(url)
+        proxy_url = f"https://images.weserv.nl/?url={encoded_url}"
+        
+        headers = {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
+            "Accept": "image/*,*/*"
+        }
+
+        if HAS_REQUESTS:
+            response = requests.get(proxy_url, headers=headers, timeout=10, stream=True)
+            response.raise_for_status()
+            with open(output_path, "wb") as f:
+                for chunk in response.iter_content(chunk_size=8192):
+                    if chunk:
+                        f.write(chunk)
+            return True
+        else:
+            req = urllib.request.Request(proxy_url, headers=headers)
+            with urllib.request.urlopen(req, timeout=10) as response:
+                with open(output_path, "wb") as f:
+                    f.write(response.read())
+            return True

nullgaze/exceptions.py

@@ -0,0 +1,11 @@
+class NullGazeError(Exception):
+    """Base exception for all NullGaze library errors."""
+    pass
+
+class DownloadFailedError(NullGazeError):
+    """Raised when all download strategies fail to retrieve the image."""
+    pass
+
+class InvalidURLError(NullGazeError):
+    """Raised when the provided image URL is invalid or malformed."""
+    pass

nullgaze/utils.py

@@ -0,0 +1,52 @@
+import random
+from urllib.parse import urlparse
+
+USER_AGENTS = [
+    # Chrome on Windows
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36",
+    # Chrome on macOS
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+    # Firefox on Windows
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/121.0",
+    # Safari on macOS
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 14_2_1) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2 Safari/605.1.15",
+    # Edge on Windows
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36 Edg/120.0.0.0"
+]
+
+def get_random_user_agent() -> str:
+    """Returns a random modern User-Agent string."""
+    return random.choice(USER_AGENTS)
+
+def get_base_domain(url: str) -> str:
+    """Extracts the base domain (scheme + netloc) from a URL."""
+    parsed = urlparse(url)
+    if not parsed.netloc:
+        return ""
+    # E.g. cdn4.webtoonscan.com -> webtoonscan.com or keep as scheme + netloc
+    return f"{parsed.scheme}://{parsed.netloc}"
+
+def get_default_headers(url: str) -> dict:
+    """Generates standard browser-like headers for a given URL, matching the Referer."""
+    base_domain = get_base_domain(url)
+    parsed = urlparse(url)
+    
+    # We can try to guess the referer domain: e.g. webtoonscan.com instead of cdn4.webtoonscan.com
+    # if it starts with cdn/static/assets etc.
+    referer = base_domain
+    netloc_parts = parsed.netloc.split('.')
+    if len(netloc_parts) > 2:
+        # If it's a subdomain like cdn4.webtoonscan.com, we can also use the parent webtoonscan.com as a fallback candidate
+        parent_domain = '.'.join(netloc_parts[-2:])
+        # For Referer, we can use the main site domain, which is often what CDNs expect for hotlink bypass
+        referer = f"{parsed.scheme}://{parent_domain}/"
+
+    return {
+        "User-Agent": get_random_user_agent(),
+        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
+        "Accept-Language": "en-US,en;q=0.9,ar;q=0.8",
+        "Referer": referer,
+        "Connection": "keep-alive",
+        "Upgrade-Insecure-Requests": "1"
+    }

nullgaze-1.0.0.dist-info/METADATA

@@ -0,0 +1,215 @@
+Metadata-Version: 2.4
+Name: NullGaze
+Version: 1.0.0
+Summary: A highly resilient image downloading library that bypasses DPI/SNI blocks, Cloudflare, TLS fingerprinting, and hotlinking protections.
+Home-page: https://github.com/batal/NullGaze
+Author: Batal
+Author-email: batal@example.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Multimedia :: Graphics
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.25.0
+Requires-Dist: curl_cffi>=0.5.0
+Provides-Extra: browser
+Requires-Dist: DrissionPage>=4.0.0; extra == "browser"
+Provides-Extra: full
+Requires-Dist: curl_cffi>=0.5.0; extra == "full"
+Requires-Dist: DrissionPage>=4.0.0; extra == "full"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# NullGaze 👁️‍🗨️
+
+**مكتبة بايثون ثورية لتحميل الصور من أي رابط مهما كانت الحمايات.**
+
+تتخطى حجب مزودي الإنترنت (ISP SNI Blocks)، وحمايات Cloudflare، ومنع الربط المباشر (Hotlinking)، وبصمات TLS — بسرعة مجنونة تصل إلى أجزاء من الثانية.
+
+---
+
+## ⚡ التثبيت السريع
+
+```bash
+pip install NullGaze
+```
+
+أو للتثبيت الكامل مع دعم المتصفح الخفي:
+```bash
+pip install NullGaze[full]
+```
+
+أو التثبيت المحلي من المصدر:
+```bash
+cd NullGaze
+pip install -e .
+```
+
+---
+
+## 🚀 طريقة الاستخدام
+
+```python
+from nullgaze import download_image
+
+# سطر واحد فقط لتحميل أي صورة محمية
+download_image(
+    url="https://cdn4.webtoonscan.com/erotic-manga-cafe-girls-raw-15264/chapter-20/17.jpg",
+    output_path="my_image.jpg",
+    verbose=True
+)
+print("تم التحميل بنجاح!")
+```
+
+### استخدام متقدم مع كلاس ImageDownloader
+
+```python
+from nullgaze import ImageDownloader
+
+downloader = ImageDownloader(verbose=True)
+
+# تحميل صورة واحدة
+downloader.download(
+    url="https://example.com/protected/image.jpg",
+    output_path="output/image.jpg"
+)
+
+# تحميل عدة صور
+urls = [
+    "https://cdn.example.com/img1.jpg",
+    "https://cdn.example.com/img2.jpg",
+    "https://cdn.example.com/img3.jpg",
+]
+
+for i, url in enumerate(urls):
+    try:
+        downloader.download(url, f"output/image_{i+1}.jpg")
+        print(f"✅ Image {i+1} downloaded!")
+    except Exception as e:
+        print(f"❌ Image {i+1} failed: {e}")
+```
+
+### إضافة ترويسات مخصصة
+
+```python
+from nullgaze import download_image
+
+custom_headers = {
+    "Referer": "https://mywebsite.com/",
+    "Cookie": "session_id=abc123"
+}
+
+download_image(
+    url="https://protected-cdn.example.com/image.png",
+    output_path="result.png",
+    headers=custom_headers
+)
+```
+
+---
+
+## 🧠 كيف تعمل المكتبة (نظام التخطي المتعدد المستويات)
+
+| المستوى | الاسم | السرعة | الوصف |
+|---------|-------|--------|-------|
+| 1 | Direct HTTP Request | ⚡⚡⚡ | طلب مباشر بترويسات متصفح ذكية |
+| 2 | **DPI-Bypass TLS Impersonation** | ⚡⚡⚡ | **الطريقة الثورية**: تقسيم حزمة ClientHello + انتحال بصمة Chrome |
+| 3 | Stealth Browser Rendering | ⚡ | متصفح Chromium خفي مع استخراج بكسلات Canvas |
+| 4 | Weserv Image Proxy | ⚡⚡ | توجيه عبر بروكسي تخزين مؤقت |
+
+> **ملاحظة**: المستوى الثاني هو الابتكار الثوري الأساسي. يقوم بتشغيل بروكسي محلي خفيف على جهازك يقسم حزمة مصافحة TLS إلى جزأين، مما يخدع جدار حماية مزود الإنترنت ويمنعه من قراءة اسم النطاق المحجوب (SNI). اقرأ [التوثيق التقني الكامل](nullgaze/DPI_BYPASS_DOC.md) لفهم الآلية.
+
+---
+
+## 📦 دليل نشر المكتبة على PyPI (للمبتدئين خطوة بخطوة)
+
+### الخطوة 1: إنشاء حساب على PyPI
+1. افتح الموقع: https://pypi.org/account/register/
+2. سجّل بإيميلك وأنشئ كلمة مرور.
+3. فعّل الحساب من الإيميل.
+4. ادخل على **Account Settings** → **API tokens** → **Add API token**.
+5. اختر الاسم مثلاً `nullgaze-token` والنطاق `Entire account`.
+6. **انسخ الرمز** الذي يبدأ بـ `pypi-` واحفظه في مكان آمن. هذا هو كلمة مرورك للرفع.
+
+### الخطوة 2: تثبيت أدوات البناء والرفع
+```bash
+pip install --upgrade build twine
+```
+
+### الخطوة 3: بناء الحزمة
+تأكد أنك داخل مجلد `NullGaze` (الذي فيه `setup.py`):
+```bash
+cd C:\Users\batal\Desktop\cwewd21\NullGaze
+python -m build
+```
+سيظهر مجلد جديد اسمه `dist/` فيه ملفات `.whl` و `.tar.gz`.
+
+### الخطوة 4: رفع المكتبة إلى PyPI
+```bash
+python -m twine upload dist/*
+```
+- **Username**: اكتب `__token__`
+- **Password**: الصق الرمز (API Token) الذي يبدأ بـ `pypi-`
+
+🎉 **مبروك!** مكتبتك الآن متاحة للعالم كله:
+```bash
+pip install NullGaze
+```
+
+---
+
+## 🔄 كيف تحدّث المكتبة (بعد إضافة ميزات جديدة)
+
+### الخطوة 1: غيّر رقم الإصدار
+افتح ملف `setup.py` وغيّر الرقم:
+```python
+version="1.0.1"  # كان 1.0.0، الآن 1.0.1
+```
+وافتح ملف `nullgaze/__init__.py` وغيّر:
+```python
+__version__ = "1.0.1"
+```
+
+### الخطوة 2: احذف الملفات القديمة
+```bash
+rmdir /s /q dist build NullGaze.egg-info
+```
+
+### الخطوة 3: أعد البناء والرفع
+```bash
+python -m build
+python -m twine upload dist/*
+```
+
+---
+
+## 📥 كيف يثبّت المستخدمون مكتبتك
+
+```bash
+# التثبيت الأساسي (يكفي لمعظم الحالات)
+pip install NullGaze
+
+# التثبيت الكامل مع دعم المتصفح الخفي
+pip install NullGaze[full]
+
+# التحديث لآخر إصدار
+pip install --upgrade NullGaze
+```
+
+---
+
+## 📄 الترخيص
+
+MIT License — مكتبة مفتوحة المصدر، استخدمها كما تشاء.

nullgaze-1.0.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+nullgaze/__init__.py,sha256=wBf93gO3N0D2dA_EWLJJ4pKkTUs8XVidi595IezdY_w,1104
+nullgaze/downloader.py,sha256=LtpxAmP4RZVSnlmQSjQPW3xqwJ3kIybANasueRcI5ZU,15107
+nullgaze/exceptions.py,sha256=3DIJYVW3PUPW3rvvXpXWrQe-EscNSBz2GRyJKq8ft9E,343
+nullgaze/utils.py,sha256=T70xaIACFbii8brvrCak62dFqTim1YTrA9McKC9Y0vg,2451
+nullgaze-1.0.0.dist-info/licenses/LICENSE,sha256=XQgFexabq7mDn_MJ7wpv8IzxjNUP3Tlu-CFTQRj3Kx8,1062
+nullgaze-1.0.0.dist-info/METADATA,sha256=BskDrZktQnBBKFr_u94WRx3tPuE_4ZtkGb7bmZeOA_8,6812
+nullgaze-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+nullgaze-1.0.0.dist-info/top_level.txt,sha256=T7AOkdcbKHoS_Gct_jOYP5yjhYuvYHt6wj6bfeshEuo,9
+nullgaze-1.0.0.dist-info/RECORD,,

nullgaze-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
+

nullgaze-1.0.0.dist-info/licenses/LICENSE

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

nullgaze-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+nullgaze