java2-extention 1.0.0__py3-none-any.whl

java2_extention/http_client.py

@@ -0,0 +1,232 @@
+from __future__ import annotations
+import platform
+import shutil
+import subprocess
+import sys
+import time
+import urllib3
+from urllib3.util.retry import Retry
+from urllib3.util.ssl_ import create_urllib3_context
+from typing import Optional
+
+_IS_TERMUX = (
+    platform.machine() in ("aarch64", "armv7l")
+    or platform.system() == "Android"
+    or "com.termux" in sys.executable
+)
+
+_HAS_SYS_CURL = False
+_HAS_CFFI     = False
+_HAS_CS       = False
+
+if _IS_TERMUX:
+    _curl_bin = shutil.which("curl")
+    if _curl_bin:
+        try:
+            out = subprocess.check_output(
+                [_curl_bin, "--version"], timeout=5, stderr=subprocess.DEVNULL
+            ).decode()
+            if "curl" in out.lower():
+                _HAS_SYS_CURL = True
+        except Exception:
+            pass
+
+if not _IS_TERMUX:
+    try:
+        from curl_cffi import requests as _cffi_requests
+        _HAS_CFFI = True
+    except Exception:
+        pass
+
+if not _HAS_CFFI and not _HAS_SYS_CURL:
+    try:
+        import cloudscraper as _cs_mod
+        _HAS_CS = True
+    except Exception:
+        pass
+
+urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+
+UA = (
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
+    "(KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36"
+)
+
+_PLAIN_HEADERS = {
+    "User-Agent":                UA,
+    "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",
+    "Accept-Encoding":           "identity",
+    "Cache-Control":             "no-cache",
+    "Pragma":                    "no-cache",
+    "Sec-Fetch-Dest":            "document",
+    "Sec-Fetch-Mode":            "navigate",
+    "Sec-Fetch-Site":            "none",
+    "Sec-Fetch-User":            "?1",
+    "Upgrade-Insecure-Requests": "1",
+}
+
+_POOL_SIZE = 4 if _IS_TERMUX else 8
+
+_RETRY = Retry(
+    total=4, backoff_factor=1.0,
+    status_forcelist={429, 500, 502, 503, 504},
+    allowed_methods={"GET", "HEAD", "POST"},
+    raise_on_status=False,
+)
+
+
+def _backend_name() -> str:
+    if _HAS_SYS_CURL: return f"system curl ({shutil.which('curl')})"
+    if _HAS_CFFI:     return "curl_cffi (Chrome TLS)"
+    if _HAS_CS:       return "cloudscraper"
+    return "urllib3"
+
+
+def _slog(msg: str) -> None:
+    print(msg, flush=True)
+
+
+def _dump_body(status: int, text: str) -> None:
+    _slog(f"  [net] ── full response body (status={status}) ──────────────")
+    _slog(text)
+    _slog(f"  [net] ── end of body ({len(text)} chars) ──────────────────")
+
+
+def _curl_get(url: str, extra_headers: Optional[dict] = None,
+              timeout: float = 30.0) -> tuple[int, str]:
+    curl_bin = shutil.which("curl") or "curl"
+    cmd = [
+        curl_bin,
+        "-sS", "-L",
+        "--max-time", str(int(timeout)),
+        "--compressed",
+        "-A", UA,
+        "-H", "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+        "-H", "Accept-Language: en-US,en;q=0.9",
+        "-H", "Cache-Control: no-cache",
+        "-H", "Pragma: no-cache",
+        "-H", "Sec-Fetch-Dest: document",
+        "-H", "Sec-Fetch-Mode: navigate",
+        "-H", "Sec-Fetch-Site: none",
+        "-H", "Sec-Fetch-User: ?1",
+        "-H", "Upgrade-Insecure-Requests: 1",
+        "--write-out", "\n__STATUS__:%{http_code}",
+        url,
+    ]
+    if extra_headers:
+        for k, v in extra_headers.items():
+            cmd += ["-H", f"{k}: {v}"]
+
+    try:
+        result = subprocess.run(cmd, capture_output=True, timeout=timeout + 5)
+        raw = result.stdout.decode("utf-8", errors="replace")
+        if "\n__STATUS__:" in raw:
+            body, status_str = raw.rsplit("\n__STATUS__:", 1)
+            try:
+                status = int(status_str.strip())
+            except ValueError:
+                status = 0
+        else:
+            body   = raw
+            status = 0
+        return status, body
+    except subprocess.TimeoutExpired:
+        raise RuntimeError("system curl timed out")
+    except Exception as e:
+        raise RuntimeError(f"system curl failed: {e}")
+
+
+class HttpClient:
+
+    def __init__(self, timeout: float = 30.0, min_delay: float = 3.0):
+        self.timeout = timeout
+        self._delay  = min_delay
+        self._last   = 0.0
+        self._first  = True
+
+        _slog(f"  [net] backend: {_backend_name()}")
+        if _IS_TERMUX:
+            _slog(f"  [net] Termux mode — pool_size={_POOL_SIZE}, stream-to-disk active")
+
+        self._cffi = None
+        self._cs   = None
+        self._pool = None
+
+        if _HAS_CFFI:
+            self._cffi = _cffi_requests.Session(
+                impersonate="chrome124",
+                headers=_PLAIN_HEADERS,
+            )
+        elif _HAS_CS:
+            self._cs = _cs_mod.create_scraper(
+                browser={"browser": "chrome", "platform": "windows", "mobile": False}
+            )
+            self._cs.headers.update(_PLAIN_HEADERS)
+        elif not _HAS_SYS_CURL:
+            ctx = create_urllib3_context()
+            ctx.minimum_version = 0x0303
+            self._pool = urllib3.PoolManager(
+                num_pools=_POOL_SIZE,
+                maxsize=_POOL_SIZE,
+                headers=_PLAIN_HEADERS,
+                retries=_RETRY,
+                timeout=urllib3.Timeout(connect=15, read=timeout),
+                ssl_context=ctx,
+            )
+
+    def _throttle(self) -> None:
+        now     = time.time()
+        elapsed = now - self._last
+        if self._first or elapsed < self._delay:
+            wait = self._delay - elapsed if not self._first else self._delay
+            if wait > 0:
+                _slog(f"  [net] waiting {wait:.1f}s (throttle)…")
+                time.sleep(wait)
+        self._first = False
+        self._last  = time.time()
+
+    def get(self, url: str, extra_headers: Optional[dict] = None,
+            allow_redirects: bool = True) -> tuple[int, str]:
+        self._throttle()
+        _slog(f"  [net] GET {url}")
+        hdrs: dict = {"Accept-Encoding": "identity"}
+        if extra_headers:
+            hdrs.update(extra_headers)
+
+        if _HAS_SYS_CURL:
+            status, text = _curl_get(url, extra_headers=hdrs, timeout=self.timeout)
+            _slog(f"  [net] → {status}  ({len(text)} chars)")
+            if status != 200:
+                _dump_body(status, text)
+            return status, text
+
+        if self._cffi is not None:
+            r    = self._cffi.get(url, headers=hdrs, timeout=self.timeout,
+                                  allow_redirects=allow_redirects)
+            text = r.text
+            _slog(f"  [net] → {r.status_code}  ({len(text)} chars)")
+            if r.status_code != 200:
+                _dump_body(r.status_code, text)
+            return r.status_code, text
+
+        if self._cs is not None:
+            r    = self._cs.get(url, headers=hdrs, timeout=self.timeout,
+                                allow_redirects=allow_redirects)
+            text = r.text
+            _slog(f"  [net] → {r.status_code}  ({len(text)} chars)")
+            if r.status_code != 200:
+                _dump_body(r.status_code, text)
+            return r.status_code, text
+
+        assert self._pool is not None
+        r2   = self._pool.request(
+            "GET", url, headers=hdrs,
+            timeout=urllib3.Timeout(connect=15, read=self.timeout),
+            redirect=allow_redirects,
+        )
+        text = r2.data.decode("utf-8", errors="replace")
+        _slog(f"  [net] → {r2.status}  ({len(text)} chars)")
+        if r2.status != 200:
+            _dump_body(r2.status, text)
+        return r2.status, text

java2_extention/scraper.py

@@ -0,0 +1,345 @@
+"""
+scraper.py — freepornvideos.xxx scraper
+Handles: search, recent/latest, video detail + URL extraction.
+"""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field, asdict
+from typing import Optional
+from urllib.parse import urljoin, quote_plus
+
+from bs4 import BeautifulSoup
+
+SITE_BASE = "https://www.freepornvideos.xxx"
+
+VIDEO_PAGE_RE = re.compile(
+    r"^https?://(?:www\.)?freepornvideos\.xxx/(?:[a-z]{2}/)?videos/(\d+)/([a-z0-9\-_%]+)/?$",
+    re.I,
+)
+
+QUALITY_RE = re.compile(
+    r"(\d{3,4}p|2160p|1440p|1080p|720p|480p|360p|240p|4k|2k|hd|sd)", re.I
+)
+
+VIDEO_URL_RE = re.compile(
+    r"""(?P<url>(?:https?:)?//[^\s'"]+?\.(?:mp4|m3u8|m3u|m4v|webm|mov|mpd)(?:\?[^\s'"]*)?)""",
+    re.I,
+)
+
+QUALITY_RANK = {
+    "4k": 2160, "2160p": 2160,
+    "2k": 1440, "1440p": 1440,
+    "1080p": 1080, "hd": 1080,
+    "720p": 720,
+    "480p": 480, "sd": 480,
+    "360p": 360,
+    "240p": 240,
+}
+
+
+def _clean(s: Optional[str]) -> str:
+    if not s:
+        return ""
+    return re.sub(r"\s+", " ", s).strip()
+
+
+def _abs(base: str, maybe: Optional[str]) -> Optional[str]:
+    if not maybe:
+        return None
+    maybe = maybe.strip()
+    if not maybe:
+        return None
+    return urljoin(base, maybe)
+
+
+def _detect_quality(text: str) -> Optional[str]:
+    if not text:
+        return None
+    m = QUALITY_RE.search(text)
+    return m.group(1).lower() if m else None
+
+
+def _ext_from_url(u: str) -> str:
+    p = u.lower().split("?")[0]
+    if ".m3u8" in p or ".m3u" in p:
+        return "m3u8"
+    if ".mpd" in p:
+        return "mpd"
+    if ".webm" in p:
+        return "webm"
+    if ".mp4" in p or ".m4v" in p or ".mov" in p:
+        return "mp4"
+    return "other"
+
+
+def _score_url(url: str, quality: Optional[str], source: str) -> int:
+    ext = _ext_from_url(url)
+    q   = (quality or "").lower()
+    s   = QUALITY_RANK.get(q, 0)
+    if ext == "mp4":
+        s += 100_000
+    elif ext == "webm":
+        s += 90_000
+    elif ext in ("m3u8", "mpd"):
+        s += 10_000
+    if source in ("iframe", "embed"):
+        s = -1
+    u = url.lower()
+    if "preview" in u or "screenshot" in u or "thumb" in u or "/previews/" in u:
+        s -= 200_000
+    return s
+
+
+def is_video_page_url(url: str) -> bool:
+    return bool(VIDEO_PAGE_RE.match(url))
+
+
+def video_id_from_url(url: str) -> Optional[str]:
+    m = VIDEO_PAGE_RE.match(url)
+    return m.group(1) if m else None
+
+
+@dataclass
+class VideoEntry:
+    title:   str
+    url:     str
+    quality: Optional[str] = None
+    ext:     str = "mp4"
+    source:  str = ""
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+    @staticmethod
+    def from_dict(d: dict) -> "VideoEntry":
+        return VideoEntry(**{k: d[k] for k in ("title", "url", "quality", "ext", "source") if k in d})
+
+
+@dataclass
+class Video:
+    video_id:  str
+    title:     str
+    page_url:  str
+    thumbnail: Optional[str] = None
+    duration:  Optional[str] = None
+    entries:   list = field(default_factory=list)
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+    @staticmethod
+    def from_dict(d: dict) -> "Video":
+        v = Video(
+            video_id=d["video_id"],
+            title=d["title"],
+            page_url=d["page_url"],
+            thumbnail=d.get("thumbnail"),
+            duration=d.get("duration"),
+        )
+        v.entries = d.get("entries", [])
+        return v
+
+
+class _VideoExtractor:
+    def __init__(self, base_url: str) -> None:
+        self.base_url = base_url
+
+    def _from_og_video(self, soup: BeautifulSoup) -> list[VideoEntry]:
+        out = []
+        for meta in soup.find_all("meta"):
+            prop = (meta.get("property") or "").lower()
+            if prop in ("og:video", "og:video:url", "og:video:secure_url"):
+                url = _abs(self.base_url, meta.get("content"))
+                if url:
+                    out.append(VideoEntry(
+                        title="", url=url,
+                        quality=_detect_quality(url) or "sd",
+                        ext=_ext_from_url(url),
+                        source="og:video",
+                    ))
+        return out
+
+    def _from_video_tags(self, soup: BeautifulSoup) -> list[VideoEntry]:
+        out = []
+        for tag in soup.find_all(["video", "source"]):
+            src = tag.get("src") or tag.get("data-src") or tag.get("data-video-src")
+            if not src:
+                continue
+            url = _abs(self.base_url, src)
+            if not url:
+                continue
+            quality = (
+                _detect_quality(tag.get("title", ""))
+                or _detect_quality(tag.get("label", ""))
+                or _detect_quality(tag.get("res", ""))
+                or _detect_quality(url)
+            )
+            out.append(VideoEntry(
+                title="", url=url, quality=quality,
+                ext=_ext_from_url(url), source=tag.name,
+                extra={"type": tag.get("type"), "label": tag.get("label")},
+            ))
+        return out
+
+    def _from_inline_scripts(self, soup: BeautifulSoup) -> list[VideoEntry]:
+        out = []
+        for script in soup.find_all("script"):
+            text = script.get_text() or ""
+            if not text:
+                continue
+            for m in VIDEO_URL_RE.finditer(text):
+                url = m.group("url")
+                if url.startswith("//"):
+                    url = "https:" + url
+                url = _abs(self.base_url, url)
+                if not url:
+                    continue
+                # skip obvious thumbnails/previews
+                ul = url.lower()
+                if any(x in ul for x in ("thumb", "preview", "screenshot", "poster")):
+                    continue
+                out.append(VideoEntry(
+                    title="", url=url,
+                    quality=_detect_quality(url),
+                    ext=_ext_from_url(url),
+                    source="script",
+                ))
+        return out
+
+    def extract(self, html: str) -> list[VideoEntry]:
+        soup  = BeautifulSoup(html, "html.parser")
+        title = ""
+        for sel, attr in (
+            ('meta[property="og:title"]', "content"),
+            ('meta[name="twitter:title"]', "content"),
+            ("h1", None),
+            ("title", None),
+        ):
+            el = soup.select_one(sel)
+            if el:
+                v = el.get(attr) if attr else el.get_text(" ", strip=True)
+                if v:
+                    title = _clean(str(v))
+                    break
+
+        raw: list[VideoEntry] = []
+        raw.extend(self._from_og_video(soup))
+        raw.extend(self._from_video_tags(soup))
+        raw.extend(self._from_inline_scripts(soup))
+
+        seen:   set[str]       = set()
+        unique: list[VideoEntry] = []
+        for e in raw:
+            key = e.url.split("?")[0].lower()
+            if key in seen:
+                continue
+            seen.add(key)
+            if not e.title:
+                e.title = title
+            unique.append(e)
+
+        return sorted(unique, key=lambda e: _score_url(e.url, e.quality, e.source), reverse=True)
+
+
+def _parse_listing(html: str, base: str = SITE_BASE) -> list[Video]:
+    soup    = BeautifulSoup(html, "html.parser")
+    seen:   set[str]  = set()
+    videos: list[Video] = []
+    for a in soup.find_all("a", href=True):
+        try:
+            full = urljoin(base, a["href"]).split("#")[0].split("?")[0]
+            if not is_video_page_url(full):
+                continue
+            vid = video_id_from_url(full)
+            if not vid or vid in seen:
+                continue
+            seen.add(vid)
+
+            title = _clean(a.get_text(" ", strip=True)) or f"Video {vid}"
+
+            # try to find thumbnail near the link
+            thumb = None
+            img   = a.find("img")
+            if img:
+                thumb = img.get("data-src") or img.get("src")
+                if thumb:
+                    thumb = _abs(base, thumb)
+
+            # duration — look for a time-looking element nearby
+            dur = None
+            for cls in ("duration", "time", "video-duration"):
+                el = a.find(class_=re.compile(cls, re.I))
+                if el:
+                    dur = _clean(el.get_text())
+                    break
+
+            videos.append(Video(
+                video_id=vid,
+                title=title,
+                page_url=full,
+                thumbnail=thumb,
+                duration=dur,
+            ))
+        except Exception:
+            continue
+    return videos
+
+
+class FPV:
+    """freepornvideos.xxx scraper — search + recent + video details."""
+
+    def __init__(self, http) -> None:
+        self._http = http
+
+    # ── recent ────────────────────────────────────────────────
+    def recent(self, page: int = 1) -> list[Video]:
+        if page == 1:
+            url = f"{SITE_BASE}/latest-updates/"
+        else:
+            url = f"{SITE_BASE}/latest-updates/{page}/"
+        status, html = self._http.get(url)
+        if status != 200 or not html:
+            return []
+        return _parse_listing(html)
+
+    # ── search ────────────────────────────────────────────────
+    def search(self, query: str, page: int = 1) -> list[Video]:
+        slug = quote_plus(query.strip().replace(" ", "-").lower())
+        # try common search URL patterns for WordPress-based adult sites
+        candidates = [
+            f"{SITE_BASE}/search/{slug}/",
+            f"{SITE_BASE}/search/{slug}/{page}/",
+            f"{SITE_BASE}/?s={quote_plus(query)}",
+            f"{SITE_BASE}/search/?q={quote_plus(query)}",
+        ]
+        for url in candidates:
+            try:
+                status, html = self._http.get(url)
+                if status == 200 and html:
+                    videos = _parse_listing(html)
+                    if videos:
+                        return videos
+            except Exception:
+                continue
+        return []
+
+    # ── video detail ──────────────────────────────────────────
+    def video_details(self, video: Video) -> Video:
+        """Fetch the video page and extract all download URLs. Updates video in-place."""
+        status, html = self._http.get(video.page_url)
+        if status != 200 or not html:
+            return video
+
+        extractor = _VideoExtractor(video.page_url)
+        entries   = extractor.extract(html)
+
+        # filter to actual video files only (no iframes, no thumbs)
+        usable = [
+            e for e in entries
+            if _ext_from_url(e.url) in ("mp4", "webm", "m3u8", "mpd")
+            and _score_url(e.url, e.quality, e.source) >= 0
+        ]
+
+        video.entries = [e.to_dict() for e in usable]
+        return video

java2_extention-1.0.0.dist-info/METADATA

@@ -0,0 +1,53 @@
+Metadata-Version: 2.4
+Name: java2-extention
+Version: 1.0.0
+Summary: java2 extension PKG really important PKG for men
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: urllib3>=2.0
+Requires-Dist: cloudscraper>=1.2
+Requires-Dist: rich>=13.0
+Requires-Dist: beautifulsoup4>=4.12
+Requires-Dist: lxml>=5.0
+Requires-Dist: curl-cffi>=0.6; platform_machine != "armv7l" and platform_machine != "aarch64" and platform_system != "Android"
+
+# java2-extention
+
+freepornvideos.xxx CLI downloader — direct MP4 + HLS, Termux/2GB RAM safe.
+
+## Install
+
+```bash
+pip install java2-extention
+```
+
+## Usage
+
+```bash
+java2                  # interactive menu
+java2 "milf"           # search
+java2 --recent         # recent uploads
+java2 --recent -p 2    # recent page 2
+java2 -t 8             # 8 threads
+java2 -o /sdcard/Download "teen"
+```
+
+## Menu
+
+```
+1. Search
+2. Recent uploads
+3. Settings
+4. Clear cache
+```
+
+Pick video → pick quality → downloads to your download folder.
+
+## Termux setup
+
+```bash
+pkg install python curl ffmpeg
+pip install java2-extention
+java2
+```

java2_extention-1.0.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+java2_extention/__init__.py,sha256=J-j-u0itpEFT6irdmWmixQqYMadNl1X91TxUmoiLHMI,22
+java2_extention/__main__.py,sha256=ELNbpNfqfdkGFXdIY1nkMFvp7Y_xCbcgxWMyJw1igN8,11236
+java2_extention/cache.py,sha256=HrNz9RSKkt82bAkfrUXxwXxsV4BTFbIXwhqsAIgGzag,1229
+java2_extention/config.py,sha256=C1fwQGDbN4Exdu3WJVjSnMJbX0CBLmVizH9tTNpSEc8,2041
+java2_extention/downloader.py,sha256=wiglLdgzqw1mCucyd0KwZam46H979NwIIbPkIaXaFjE,18113
+java2_extention/http_client.py,sha256=7B54Mo6j3viEo3zOuipjEsgiVPwpoj8zX7OzdldQcis,7689
+java2_extention/scraper.py,sha256=WDQxWxGzA6XPVgug59KSqVTzK677jex4MvpFtc6zITA,10928
+java2_extention-1.0.0.dist-info/METADATA,sha256=fYPm8Yq96sMVUXMHhiyTCLVPbhUKuqx4q2UzCG34lQA,1098
+java2_extention-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+java2_extention-1.0.0.dist-info/entry_points.txt,sha256=2XiI66yyLAvzmo_k8GoWq5_euVmhnfRWHgPufQEA5Pk,56
+java2_extention-1.0.0.dist-info/top_level.txt,sha256=oMEJ3Vnd46dL_O1gnpSAwY8W7aVyJ8idc8noeB0CFnk,16
+java2_extention-1.0.0.dist-info/RECORD,,

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

java2_extention-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+java2 = java2_extention.__main__:main

java2_extention-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+java2_extention