mfget 0.1.1__py3-none-any.whl

mediafire_dl/__init__.py

@@ -0,0 +1,3 @@
+"""Mediafire-DL package."""
+
+__version__ = "0.1.0"

mediafire_dl/__main__.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+import sys
+
+from .cli import main
+
+
+if __name__ == "__main__":
+    sys.exit(main())

mediafire_dl/cli.py

@@ -0,0 +1,112 @@
+from __future__ import annotations
+
+import argparse
+import logging
+import sys
+from pathlib import Path
+
+from rich.console import Console
+
+from .downloader import Downloader
+from .errors import MediafireDLError
+from .http import HttpClient
+from .mediafire import MediafireClient
+from .output import RichUI
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = parse_args(argv)
+    configure_logging(args.verbose)
+
+    ui = RichUI(Console())
+    link = args.link or ui.ask_link()
+    if not link.strip():
+        ui.error("Please paste a MediaFire file or folder link.")
+        return 1
+    destination = Path(args.output or ui.ask_save_dir(str(default_downloads_dir()))).expanduser()
+
+    try:
+        cookie_file = Path(args.cookies).expanduser() if args.cookies else None
+        http = HttpClient(cookie_file=cookie_file)
+        client = MediafireClient(http)
+        downloader = Downloader(http)
+
+        ui.status("Finding files...")
+        plan = client.build_plan(link)
+        if not plan.files:
+            ui.warning("No downloadable files were found.")
+            return 1
+
+        ui.show_plan(plan)
+        ui.status("Preparing downloads...")
+
+        if args.dry_run:
+            ui.warning("Dry run: nothing was downloaded.")
+            return 0
+
+        ui.status("Downloading...")
+        saved_to = downloader.download_plan(plan, destination, ui)
+        ui.finished(str(saved_to))
+        return 0
+    except KeyboardInterrupt:
+        ui.error("Download cancelled.")
+        return 130
+    except MediafireDLError as exc:
+        if args.verbose:
+            logging.getLogger(__name__).exception("Mediafire-DL failed")
+        ui.error(str(exc))
+        return 1
+    except Exception as exc:
+        if args.verbose:
+            logging.getLogger(__name__).exception("Unexpected failure")
+            ui.error(str(exc))
+        else:
+            ui.error("Something went wrong. Run again with --verbose for details.")
+        return 1
+
+
+def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        prog="mediafire-dl",
+        description="Download MediaFire files and folders with a clean progress UI.",
+    )
+    parser.add_argument("link", nargs="?", help="MediaFire file or folder link")
+    parser.add_argument(
+        "-o",
+        "--output",
+        help="Folder to save downloads into. Defaults to your Downloads folder.",
+    )
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="List files without downloading them.",
+    )
+    parser.add_argument(
+        "--cookies",
+        help=(
+            "Path to a Netscape/Mozilla cookies.txt file to use for links your browser can access. "
+            "Cookies are read locally and are not saved by Mediafire-DL."
+        ),
+    )
+    parser.add_argument(
+        "--verbose",
+        action="store_true",
+        help="Show technical logs and tracebacks for troubleshooting.",
+    )
+    return parser.parse_args(argv)
+
+
+def configure_logging(verbose: bool) -> None:
+    logging.basicConfig(
+        level=logging.DEBUG if verbose else logging.CRITICAL,
+        format="%(levelname)s: %(name)s: %(message)s",
+    )
+
+
+def default_downloads_dir() -> Path:
+    downloads = Path.home() / "Downloads"
+    return downloads if downloads.exists() else Path.home()
+
+
+if __name__ == "__main__":
+    sys.exit(main())

mediafire_dl/downloader.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+
+from .errors import DownloadLinkError, MediafireDLError
+from .http import HttpClient
+from .mediafire import safe_name
+from .models import DownloadPlan, MediafireItem
+from .output import UserInterface
+
+LOGGER = logging.getLogger(__name__)
+
+
+class Downloader:
+    def __init__(self, http: HttpClient | None = None, chunk_size: int = 1024 * 128) -> None:
+        self.http = http or HttpClient()
+        self.chunk_size = chunk_size
+
+    def download_plan(self, plan: DownloadPlan, destination: Path, ui: UserInterface) -> Path:
+        root = destination / safe_name(plan.display_name) if plan.is_folder else destination
+        root.mkdir(parents=True, exist_ok=True)
+
+        total = len(plan.files)
+        for index, item in enumerate(plan.files, start=1):
+            self._download_item(item, root, ui, index, total)
+        return root
+
+    def _download_item(
+        self,
+        item: MediafireItem,
+        root: Path,
+        ui: UserInterface,
+        index: int,
+        total: int,
+    ) -> None:
+        target = root / Path(*item.relative_folder.parts) / safe_name(item.name)
+        target.parent.mkdir(parents=True, exist_ok=True)
+        partial = target.with_name(f"{target.name}.part")
+
+        try:
+            direct_url = self.http.find_public_download_url(item.page_url)
+        except MediafireDLError:
+            raise
+        except Exception as exc:
+            LOGGER.debug("Unexpected error while finding download URL", exc_info=exc)
+            raise DownloadLinkError(f"Could not prepare {item.name} for download.") from exc
+
+        with self.http.open_download(direct_url) as response:
+            length = response.headers.get("Content-Length")
+            total_size = int(length) if length and length.isdigit() else item.size
+            progress = ui.start_file(index, total, item, total_size)
+            with partial.open("wb") as file:
+                while True:
+                    chunk = response.read(self.chunk_size)
+                    if not chunk:
+                        break
+                    file.write(chunk)
+                    progress.update(len(chunk))
+            progress.finish()
+        partial.replace(target)

mediafire_dl/errors.py

@@ -0,0 +1,18 @@
+class MediafireDLError(Exception):
+    """Base exception for user-facing downloader errors."""
+
+
+class UnsupportedLinkError(MediafireDLError):
+    """Raised when a link is not a supported MediaFire file or folder URL."""
+
+
+class MediafireAPIError(MediafireDLError):
+    """Raised when MediaFire's public API returns an error."""
+
+
+class DownloadLinkError(MediafireDLError):
+    """Raised when a public download URL cannot be extracted."""
+
+
+class CookieFileError(MediafireDLError):
+    """Raised when a user-provided cookie file cannot be loaded."""

mediafire_dl/http.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+import json
+import logging
+from http.cookiejar import LoadError, MozillaCookieJar
+from html import unescape
+from html.parser import HTMLParser
+from pathlib import Path
+from typing import Any
+from urllib.error import HTTPError, URLError
+from urllib.parse import quote, urlencode
+from urllib.request import HTTPCookieProcessor, Request, build_opener
+
+from .errors import CookieFileError, DownloadLinkError, MediafireAPIError
+
+LOGGER = logging.getLogger(__name__)
+
+USER_AGENT = "Mediafire-DL/0.1 (+https://github.com/)"
+API_BASE = "https://www.mediafire.com/api/1.5"
+
+
+class DownloadButtonParser(HTMLParser):
+    def __init__(self) -> None:
+        super().__init__()
+        self.download_url: str | None = None
+        self.title: str | None = None
+        self._in_title = False
+
+    def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
+        attr_map = dict(attrs)
+        if tag == "a" and attr_map.get("id") == "downloadButton":
+            href = attr_map.get("href")
+            if href:
+                self.download_url = unescape(href)
+        if tag == "title":
+            self._in_title = True
+
+    def handle_endtag(self, tag: str) -> None:
+        if tag == "title":
+            self._in_title = False
+
+    def handle_data(self, data: str) -> None:
+        if self._in_title and data.strip():
+            self.title = data.strip()
+
+
+class HttpClient:
+    def __init__(self, timeout: int = 30, cookie_file: Path | None = None) -> None:
+        self.timeout = timeout
+        self.opener = build_opener()
+        if cookie_file:
+            self._load_cookies(cookie_file)
+
+    def _load_cookies(self, cookie_file: Path) -> None:
+        path = cookie_file.expanduser()
+        if not path.exists():
+            raise CookieFileError(f"Cookie file was not found: {path}")
+        if not path.is_file():
+            raise CookieFileError(f"Cookie path is not a file: {path}")
+
+        jar = MozillaCookieJar(str(path))
+        try:
+            jar.load(ignore_discard=True, ignore_expires=True)
+        except (LoadError, OSError) as exc:
+            LOGGER.debug("Could not load cookie file %s", path, exc_info=exc)
+            raise CookieFileError(
+                "Could not read the cookie file. Use a Netscape/Mozilla cookies.txt export."
+            ) from exc
+        self.opener = build_opener(HTTPCookieProcessor(jar))
+
+    def api_get(self, endpoint: str, params: dict[str, str]) -> dict[str, Any]:
+        params = {**params, "response_format": "json"}
+        url = f"{API_BASE}/{endpoint}?{urlencode(params)}"
+        data = self.fetch_bytes(url)
+        try:
+            payload = json.loads(data.decode("utf-8"))
+        except json.JSONDecodeError as exc:
+            LOGGER.debug("Invalid JSON returned by MediaFire API", exc_info=exc)
+            raise MediafireAPIError("MediaFire returned an unreadable response.") from exc
+
+        response = payload.get("response", {})
+        result = response.get("result")
+        if result and result != "Success":
+            message = response.get("message") or "MediaFire reported an error."
+            raise MediafireAPIError(message)
+        return response
+
+    def fetch_text(self, url: str) -> str:
+        return self.fetch_bytes(url).decode("utf-8", errors="replace")
+
+    def fetch_bytes(self, url: str) -> bytes:
+        request = Request(url, headers={"User-Agent": USER_AGENT})
+        try:
+            with self.opener.open(request, timeout=self.timeout) as response:
+                return response.read()
+        except HTTPError as exc:
+            LOGGER.debug("HTTP error while fetching %s", url, exc_info=exc)
+            raise MediafireAPIError("MediaFire could not be reached right now.") from exc
+        except URLError as exc:
+            LOGGER.debug("Network error while fetching %s", url, exc_info=exc)
+            raise MediafireAPIError("Network connection failed while contacting MediaFire.") from exc
+
+    def open_download(self, url: str):
+        request = Request(url, headers={"User-Agent": USER_AGENT})
+        return self.opener.open(request, timeout=self.timeout)
+
+    def find_public_download_url(self, page_url: str) -> str:
+        html = self.fetch_text(page_url)
+        parser = DownloadButtonParser()
+        parser.feed(html)
+        if parser.download_url:
+            return parser.download_url
+        LOGGER.debug("downloadButton link was not found on %s", page_url)
+        raise DownloadLinkError("Could not find the public download button for a file.")
+
+
+def encoded_path_segment(value: str) -> str:
+    return quote(value.replace(" ", "_"), safe="")

mediafire_dl/mediafire.py

@@ -0,0 +1,159 @@
+from __future__ import annotations
+
+import logging
+import re
+from pathlib import PurePosixPath
+from urllib.parse import unquote, urlparse
+
+from .errors import MediafireAPIError, UnsupportedLinkError
+from .http import HttpClient, encoded_path_segment
+from .models import DownloadPlan, MediafireItem
+
+LOGGER = logging.getLogger(__name__)
+
+FOLDER_RE = re.compile(r"/folder/([^/?#]+)")
+FILE_RE = re.compile(r"/file/([^/?#]+)")
+
+
+class MediafireClient:
+    def __init__(self, http: HttpClient | None = None) -> None:
+        self.http = http or HttpClient()
+
+    def build_plan(self, link: str) -> DownloadPlan:
+        kind, key = parse_mediafire_link(link)
+        if kind == "folder":
+            return self._build_folder_plan(key)
+        return self._build_file_plan(key, link)
+
+    def _build_folder_plan(self, folder_key: str) -> DownloadPlan:
+        folder_name = self._folder_name(folder_key) or "MediaFire Folder"
+        files = tuple(self._walk_folder(folder_key, PurePosixPath()))
+        return DownloadPlan(display_name=folder_name, files=files, is_folder=True)
+
+    def _build_file_plan(self, quick_key: str, original_link: str) -> DownloadPlan:
+        info = self._file_info(quick_key)
+        filename = info.get("filename") or filename_from_url(original_link) or "MediaFire File"
+        page_url = info.get("links", {}).get("normal_download") or original_link
+        size = parse_int(info.get("size"))
+        item = MediafireItem(name=filename, page_url=page_url, size=size)
+        return DownloadPlan(display_name=filename, files=(item,), is_folder=False)
+
+    def _walk_folder(
+        self,
+        folder_key: str,
+        relative_folder: PurePosixPath,
+    ) -> list[MediafireItem]:
+        items: list[MediafireItem] = []
+
+        chunk = 1
+        while True:
+            response = self.http.api_get(
+                "folder/get_content.php",
+                {
+                    "folder_key": folder_key,
+                    "content_type": "files",
+                    "chunk_number": str(chunk),
+                    "chunk_size": "100",
+                },
+            )
+            content = response.get("folder_content", {})
+            for entry in content.get("files", []):
+                links = entry.get("links", {})
+                page_url = links.get("normal_download")
+                filename = entry.get("filename")
+                if not page_url or not filename:
+                    LOGGER.debug("Skipping incomplete MediaFire file entry: %r", entry)
+                    continue
+                items.append(
+                    MediafireItem(
+                        name=filename,
+                        page_url=page_url,
+                        size=parse_int(entry.get("size")),
+                        relative_folder=relative_folder,
+                    )
+                )
+            if content.get("more_chunks") != "yes":
+                break
+            chunk += 1
+
+        chunk = 1
+        while True:
+            response = self.http.api_get(
+                "folder/get_content.php",
+                {
+                    "folder_key": folder_key,
+                    "content_type": "folders",
+                    "chunk_number": str(chunk),
+                    "chunk_size": "100",
+                },
+            )
+            content = response.get("folder_content", {})
+            for entry in content.get("folders", []):
+                child_key = entry.get("folderkey")
+                child_name = entry.get("name") or entry.get("foldername") or "Untitled Folder"
+                if not child_key:
+                    LOGGER.debug("Skipping incomplete MediaFire folder entry: %r", entry)
+                    continue
+                items.extend(self._walk_folder(child_key, relative_folder / safe_name(child_name)))
+            if content.get("more_chunks") != "yes":
+                break
+            chunk += 1
+
+        return items
+
+    def _folder_name(self, folder_key: str) -> str | None:
+        try:
+            response = self.http.api_get("folder/get_info.php", {"folder_key": folder_key})
+        except MediafireAPIError:
+            LOGGER.debug("Could not fetch folder name for %s", folder_key, exc_info=True)
+            return None
+        info = response.get("folder_info", {})
+        return info.get("name") or info.get("foldername")
+
+    def _file_info(self, quick_key: str) -> dict:
+        response = self.http.api_get("file/get_info.php", {"quick_key": quick_key})
+        return response.get("file_info", {})
+
+
+def parse_mediafire_link(link: str) -> tuple[str, str]:
+    parsed = urlparse(link.strip())
+    if not parsed.netloc or "mediafire.com" not in parsed.netloc.lower():
+        raise UnsupportedLinkError("Please provide a MediaFire file or folder link.")
+
+    path = unquote(parsed.path)
+    folder_match = FOLDER_RE.search(path)
+    if folder_match:
+        return "folder", folder_match.group(1)
+
+    file_match = FILE_RE.search(path)
+    if file_match:
+        return "file", file_match.group(1)
+
+    raise UnsupportedLinkError("Please provide a MediaFire file or folder link.")
+
+
+def filename_from_url(link: str) -> str | None:
+    parsed = urlparse(link)
+    pieces = [piece for piece in unquote(parsed.path).split("/") if piece]
+    if len(pieces) >= 3 and pieces[0] == "file":
+        return pieces[2].replace("_", " ")
+    return None
+
+
+def safe_name(name: str) -> str:
+    return name.replace("/", "-").replace("\\", "-").strip() or "Untitled"
+
+
+def page_url_for_item(item: MediafireItem) -> str:
+    return item.page_url
+
+
+def api_file_page(quick_key: str, filename: str) -> str:
+    return f"https://www.mediafire.com/file/{quick_key}/{encoded_path_segment(filename)}/file"
+
+
+def parse_int(value: object) -> int | None:
+    try:
+        return int(str(value))
+    except (TypeError, ValueError):
+        return None

mediafire_dl/models.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import PurePosixPath
+
+
+@dataclass(frozen=True)
+class MediafireItem:
+    name: str
+    page_url: str
+    size: int | None = None
+    relative_folder: PurePosixPath = PurePosixPath()
+
+    @property
+    def relative_path(self) -> PurePosixPath:
+        return self.relative_folder / self.name
+
+
+@dataclass(frozen=True)
+class MediafireFolder:
+    name: str
+    key: str
+    files: tuple[MediafireItem, ...]
+
+
+@dataclass(frozen=True)
+class DownloadPlan:
+    display_name: str
+    files: tuple[MediafireItem, ...]
+    is_folder: bool

mediafire_dl/output.py

@@ -0,0 +1,172 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from pathlib import PurePosixPath
+from typing import Iterable
+
+from rich import box
+from rich.console import Console
+from rich.panel import Panel
+from rich.progress import (
+    BarColumn,
+    DownloadColumn,
+    Progress,
+    SpinnerColumn,
+    TaskID,
+    TextColumn,
+    TimeRemainingColumn,
+    TransferSpeedColumn,
+)
+from rich.prompt import Prompt
+from rich.table import Table
+from rich.text import Text
+from rich.tree import Tree
+
+from .models import DownloadPlan, MediafireItem
+
+MINT = "#7fffd4"
+MINT_DIM = "#5fd6b5"
+
+
+class ProgressHandle(ABC):
+    @abstractmethod
+    def update(self, advance: int) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def finish(self) -> None:
+        raise NotImplementedError
+
+
+class UserInterface(ABC):
+    @abstractmethod
+    def ask_link(self) -> str:
+        raise NotImplementedError
+
+    @abstractmethod
+    def ask_save_dir(self, default: str) -> str:
+        raise NotImplementedError
+
+    @abstractmethod
+    def status(self, message: str) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def show_plan(self, plan: DownloadPlan) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def start_file(self, index: int, total: int, item: MediafireItem, size: int | None) -> ProgressHandle:
+        raise NotImplementedError
+
+    @abstractmethod
+    def finished(self, path: str) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def warning(self, message: str) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def error(self, message: str) -> None:
+        raise NotImplementedError
+
+
+class RichProgressHandle(ProgressHandle):
+    def __init__(self, progress: Progress, task_id: TaskID) -> None:
+        self.progress = progress
+        self.task_id = task_id
+
+    def update(self, advance: int) -> None:
+        self.progress.update(self.task_id, advance=advance)
+
+    def finish(self) -> None:
+        task = next(task for task in self.progress.tasks if task.id == self.task_id)
+        if task.total is not None:
+            self.progress.update(self.task_id, completed=task.total)
+        self.progress.stop_task(self.task_id)
+
+
+class RichUI(UserInterface):
+    def __init__(self, console: Console | None = None) -> None:
+        self.console = console or Console()
+        self.progress = Progress(
+            SpinnerColumn(style=MINT),
+            TextColumn("[bold #7fffd4]{task.description}"),
+            BarColumn(bar_width=None, complete_style=MINT, finished_style=MINT, pulse_style=MINT_DIM),
+            DownloadColumn(),
+            TransferSpeedColumn(),
+            TimeRemainingColumn(),
+            console=self.console,
+            transient=False,
+        )
+        self._progress_started = False
+
+    def ask_link(self) -> str:
+        try:
+            return Prompt.ask("[#7fffd4]Paste a MediaFire file or folder link[/#7fffd4]").strip()
+        except EOFError:
+            return ""
+
+    def ask_save_dir(self, default: str) -> str:
+        try:
+            answer = Prompt.ask(
+                "[#7fffd4]Where should files be saved?[/#7fffd4]",
+                default=default,
+            ).strip()
+        except EOFError:
+            return default
+        return answer or default
+
+    def status(self, message: str) -> None:
+        self.console.print(Text(message, style=MINT))
+
+    def show_plan(self, plan: DownloadPlan) -> None:
+        kind = "folder" if plan.is_folder else "file"
+        self.console.print(f"[#7fffd4]Found {kind}:[/#7fffd4] [bold]{plan.display_name}[/bold]")
+        count = len(plan.files)
+        label = "file" if count == 1 else "files"
+        self.console.print(f"[#7fffd4]Found {count} {label}:[/#7fffd4]")
+        self.console.print(build_file_tree(plan.files))
+
+    def start_file(self, index: int, total: int, item: MediafireItem, size: int | None) -> ProgressHandle:
+        if not self._progress_started:
+            self.progress.start()
+            self._progress_started = True
+        description = f"Downloading {index} of {total}: {item.name}"
+        task_id = self.progress.add_task(description, total=size)
+        return RichProgressHandle(self.progress, task_id)
+
+    def finished(self, path: str) -> None:
+        if self._progress_started:
+            self.progress.stop()
+            self._progress_started = False
+        table = Table.grid(padding=(0, 1))
+        table.add_column(style=MINT)
+        table.add_column()
+        table.add_row("Finished.", path)
+        self.console.print(Panel(table, border_style=MINT, box=box.ROUNDED))
+
+    def warning(self, message: str) -> None:
+        self.console.print(f"[yellow]{message}[/yellow]")
+
+    def error(self, message: str) -> None:
+        if self._progress_started:
+            self.progress.stop()
+            self._progress_started = False
+        self.console.print(f"[bold red]Error:[/bold red] {message}")
+
+
+def build_file_tree(files: Iterable[MediafireItem]) -> Tree:
+    root = Tree("[bold]Files[/bold]", guide_style=MINT_DIM)
+    folder_nodes: dict[PurePosixPath, Tree] = {PurePosixPath(): root}
+    for item in sorted(files, key=lambda file: str(file.relative_path).lower()):
+        current_path = PurePosixPath()
+        current_node = root
+        for part in item.relative_folder.parts:
+            current_path = current_path / part
+            if current_path not in folder_nodes:
+                folder_nodes[current_path] = current_node.add(f"[#7fffd4]{part}/[/#7fffd4]")
+            current_node = folder_nodes[current_path]
+        current_node.add(item.name)
+    return root

mfget-0.1.1.dist-info/METADATA

@@ -0,0 +1,235 @@
+Metadata-Version: 2.4
+Name: mfget
+Version: 0.1.1
+Summary: A clean MediaFire file and folder downloader with a Rich-powered CLI.
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/worstgirlinamerica/mediafire-dl
+Project-URL: Repository, https://github.com/worstgirlinamerica/mediafire-dl
+Project-URL: Issues, https://github.com/worstgirlinamerica/mediafire-dl/issues
+Keywords: mediafire,downloader,cli,rich
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: rich>=13.7.0
+Dynamic: license-file
+
+# Mediafire-DL
+
+Mediafire-DL is a small command-line downloader for MediaFire links.
+
+It handles single files and folders, keeps nested folder structure intact, and shows a clean progress display while it downloads. Public links work without any login details. Links that require an account can be tried with an optional local cookies file.
+
+## What It Does
+
+- Downloads public MediaFire file links
+- Downloads public MediaFire folder links
+- Walks nested folders automatically
+- Saves folders using the same folder layout MediaFire reports
+- Shows a file preview before downloading
+- Supports a dry-run mode so you can check what would be saved first
+- Defaults to your system `Downloads` folder
+- Can read a local `cookies.txt` file for links your own browser account can access
+
+## Install
+
+You need Python 3.9 or newer.
+
+### From GitHub
+
+This works without cloning the repo first:
+
+```bash
+python3 -m pip install --user git+https://github.com/worstgirlinamerica/mediafire-dl.git
+```
+
+Then run:
+
+```bash
+mediafire-dl
+```
+
+On Windows, use `py` instead of `python3`:
+
+```powershell
+py -m pip install --user git+https://github.com/worstgirlinamerica/mediafire-dl.git
+```
+
+### From PyPI
+
+Once Mediafire-DL is published to PyPI as `mfget`, it can be installed like this:
+
+```bash
+python3 -m pip install --user mfget
+```
+
+On Windows:
+
+```powershell
+py -m pip install --user mfget
+```
+
+### macOS
+
+If you installed with Python 3:
+
+```bash
+mediafire-dl
+```
+
+If your terminal says `mediafire-dl` was not found, use the module form:
+
+```bash
+python3 -m mediafire_dl
+```
+
+If the command is installed but your shell cannot find it, add Python's user script folder to your PATH. The version number may be different on your machine:
+
+```bash
+echo 'export PATH="$HOME/Library/Python/3.12/bin:$PATH"' >> ~/.zshrc
+source ~/.zshrc
+```
+
+### Windows
+
+Run:
+
+```powershell
+mediafire-dl
+```
+
+If PowerShell says `mediafire-dl` was not found, use:
+
+```powershell
+py -m mediafire_dl
+```
+
+If you want the `mediafire-dl` command to work directly, add Python's user Scripts folder to PATH. It usually looks like this, with the Python version adjusted for your install:
+
+```text
+%APPDATA%\Python\Python312\Scripts
+```
+
+### Linux
+
+Run:
+
+```bash
+mediafire-dl
+```
+
+If your shell says `mediafire-dl` was not found, use:
+
+```bash
+python3 -m mediafire_dl
+```
+
+Or add Python's user script folder to your PATH:
+
+```bash
+echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc
+source ~/.bashrc
+```
+
+### Local Development
+
+If you cloned the repo and want to install from the project folder:
+
+```bash
+python3 -m pip install --user .
+```
+
+## Usage
+
+Run the command and paste a MediaFire link when it asks:
+
+```bash
+mediafire-dl
+```
+
+Or pass the link directly:
+
+```bash
+mediafire-dl "https://www.mediafire.com/file/example/file.zip/file"
+```
+
+Choose a save folder:
+
+```bash
+mediafire-dl "https://www.mediafire.com/folder/example/My+Folder" --output ~/Downloads/MediaFire
+```
+
+Preview a folder without downloading anything:
+
+```bash
+mediafire-dl --dry-run "https://www.mediafire.com/folder/example/My+Folder"
+```
+
+Show more technical error details:
+
+```bash
+mediafire-dl --verbose "https://www.mediafire.com/file/example/file.zip/file"
+```
+
+Use a local cookies file for a link that your browser account can already access:
+
+```bash
+mediafire-dl --cookies ~/Downloads/cookies.txt "https://www.mediafire.com/file/example/file.zip/file"
+```
+
+The cookies file must be in Netscape/Mozilla `cookies.txt` format. Mediafire-DL only reads the file from your computer for that run.
+
+## Supported Links
+
+Supported:
+
+- Public MediaFire file links
+- Public MediaFire folder links
+- Public folders with nested subfolders
+- MediaFire file or folder links that work with a user-provided `cookies.txt` file
+
+Not supported:
+
+- Asking for or storing MediaFire usernames and passwords
+- Automatically reading cookies from your browser
+- Password-protected downloads that require an extra password prompt
+- Captcha-gated or blocked downloads
+
+## Privacy And Safety
+
+Mediafire-DL does not ask for MediaFire login details and does not read browser cookies automatically. If you use `--cookies`, the cookie file stays on your machine and is only read by the current command.
+
+This repo already ignores common private and generated files in `.gitignore`, including `.env`, cookies, logs, caches, virtual environments, `.DS_Store`, partial downloads, and local media/download folders.
+
+## Development
+
+For an editable install while working on the code:
+
+```bash
+python3 -m pip install --user -e .
+```
+
+Run the CLI from source:
+
+```bash
+python3 -m mediafire_dl
+```
+
+The package entry point is:
+
+```bash
+mediafire-dl
+```
+
+## License
+
+MIT License. See [LICENSE](LICENSE).

mfget-0.1.1.dist-info/RECORD

@@ -0,0 +1,15 @@
+mediafire_dl/__init__.py,sha256=3nx79VFXPQQQ-og2g4JU6mSIn7SGb9N0Gj9q_RjTOcI,51
+mediafire_dl/__main__.py,sha256=pb2bv7Lw6q-BWUue8v6YGW8OXQEZ9V_cSmC9G70FtjE,120
+mediafire_dl/cli.py,sha256=gBIt0-gb0OInATwQmtjSofwjGUMTqdweBD1QxcDj2SI,3388
+mediafire_dl/downloader.py,sha256=4YMnvQ0qhfdjT7UWe3Hrc3uidRSQQCF3hIYIKJtjsGQ,2255
+mediafire_dl/errors.py,sha256=wXTd0p38m5_yi3nceSkKT5VTSvc5G6RhLCH70k5ZUeg,550
+mediafire_dl/http.py,sha256=xscB1biVVYSp2CrrMiIZQ7aj3-6jiT4dOosIrGg4vIo,4645
+mediafire_dl/mediafire.py,sha256=IjWUMYsLJ_wcOqCndFMEXK1rO_639furDxEq5eVlGew,5838
+mediafire_dl/models.py,sha256=4UWDpxVCCW50RF0HEK26Y0P2qDTq4FblyhEhss_t63s,611
+mediafire_dl/output.py,sha256=tltsoTdg8M0LhB0frsKohqS1deXqoeIhkWsw0cctZrI,5641
+mfget-0.1.1.dist-info/licenses/LICENSE,sha256=aKwPDohMJF34kmg5u90KPsjDHylRM7jzJCNsUcqjF-M,1082
+mfget-0.1.1.dist-info/METADATA,sha256=S-tnWYJt_udjmVxVzpvmz7Ud87Nge4DcKJMZ9Ca-xQo,5713
+mfget-0.1.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+mfget-0.1.1.dist-info/entry_points.txt,sha256=9QYSF6dCxPxBd2eNF23UvsY_oYCHpvsEy_0dgTWZzeQ,55
+mfget-0.1.1.dist-info/top_level.txt,sha256=F8JY_qmbnVM54_aaJL1sKHmjq8RAWq6_dqL3gOo5P-I,13
+mfget-0.1.1.dist-info/RECORD,,

mfget-0.1.1.dist-info/WHEEL

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

mfget-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mediafire-dl = mediafire_dl.cli:main

mfget-0.1.1.dist-info/licenses/LICENSE

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

mfget-0.1.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+mediafire_dl