ani-cli-ar 1.8.4__py3-none-any.whl

ani_cli_arabic/player.py

@@ -0,0 +1,281 @@
+import os
+import sys
+import time
+import shutil
+import subprocess
+import tempfile
+from typing import Optional
+from .utils import is_bundled
+
+class PlayerManager:
+    def __init__(self, rpc_manager=None, console=None):
+        self.temp_mpv_path = None
+        self.rpc_manager = rpc_manager
+        self.console = console
+
+    def get_mpv_path(self) -> Optional[str]:
+        if is_bundled():
+            exe_name = 'mpv.exe' if os.name == 'nt' else 'mpv'
+            bundled_mpv = os.path.join(sys._MEIPASS, 'mpv', exe_name)
+            if os.path.exists(bundled_mpv):
+                if not self.temp_mpv_path or not os.path.exists(self.temp_mpv_path):
+                    temp_dir = tempfile.mkdtemp(prefix='anime_browser_mpv_')
+                    self.temp_mpv_path = os.path.join(temp_dir, exe_name)
+                    shutil.copy2(bundled_mpv, self.temp_mpv_path)
+                    
+                    # Ensure executable permissions on Linux/macOS
+                    if os.name != 'nt':
+                        st = os.stat(self.temp_mpv_path)
+                        os.chmod(self.temp_mpv_path, st.st_mode | 0o111)
+                        
+                return self.temp_mpv_path
+        else:
+            base_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+            exe_name = 'mpv.exe' if os.name == 'nt' else 'mpv'
+            
+            dev_mpv = os.path.join(base_dir, 'mpv', exe_name)
+            if os.path.exists(dev_mpv):
+                return dev_mpv
+            
+            local_mpv = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'mpv', exe_name)
+            if os.path.exists(local_mpv):
+                return local_mpv
+
+            # Check system PATH
+            if shutil.which('mpv'):
+                return 'mpv'
+            
+            return 'mpv'
+        
+        return 'mpv'
+
+    def cleanup_temp_mpv(self):
+        if self.temp_mpv_path and os.path.exists(self.temp_mpv_path):
+            try:
+                temp_dir = os.path.dirname(self.temp_mpv_path)
+                shutil.rmtree(temp_dir, ignore_errors=True)
+            except (OSError, PermissionError):
+                pass
+
+    def get_available_players(self) -> dict:
+        players = {}
+        
+        # Check VLC
+        vlc_path = shutil.which('vlc')
+        if not vlc_path:
+            if os.name == 'nt':
+                paths = [
+                    r"C:\Program Files\VideoLAN\VLC\vlc.exe",
+                    r"C:\Program Files (x86)\VideoLAN\VLC\vlc.exe"
+                ]
+                for p in paths:
+                    if os.path.exists(p):
+                        vlc_path = p
+                        break
+            elif sys.platform == 'darwin':
+                paths = [
+                    "/Applications/VLC.app/Contents/MacOS/VLC",
+                    os.path.expanduser("~/Applications/VLC.app/Contents/MacOS/VLC")
+                ]
+                for p in paths:
+                    if os.path.exists(p):
+                        vlc_path = p
+                        break
+        if vlc_path:
+            players['VLC'] = vlc_path
+
+        # Check MPV
+        mpv_path = self.get_mpv_path()
+        if mpv_path == 'mpv':
+            if shutil.which('mpv'):
+                 players['MPV'] = 'mpv'
+        elif os.path.exists(mpv_path):
+            players['MPV'] = mpv_path
+
+        # Check MPC-HC
+        mpc_path = shutil.which('mpc-hc64') or shutil.which('mpc-hc')
+        if not mpc_path and os.name == 'nt':
+            paths = [
+                r"C:\Program Files\MPC-HC\mpc-hc64.exe",
+                r"C:\Program Files\MPC-HC\mpc-hc.exe",
+                r"C:\Program Files (x86)\MPC-HC\mpc-hc.exe",
+                r"C:\Program Files\K-Lite Codec Pack\MPC-HC64\mpc-hc64.exe"
+            ]
+            for p in paths:
+                if os.path.exists(p):
+                    mpc_path = p
+                    break
+        if mpc_path:
+            players['MPC-HC'] = mpc_path
+
+        return players
+
+    def play(self, url: str, title: str, player_type: str = 'ask', headers: Optional[dict] = None):
+        if not url or not (url.startswith("http://") or url.startswith("https://") or url.startswith("rtmp://")):
+            msg = "Error: Extracted stream URL is invalid or empty."
+            if self.console:
+                from rich.text import Text
+                self.console.print(Text(msg, style="bold red"))
+            else:
+                print(msg, file=sys.stderr)
+            return
+
+        available_players = self.get_available_players()
+        
+        if not available_players:
+            msg = "No video players found on your computer. Please download and install VLC Media Player from https://www.videolan.org/vlc/"
+            if self.console:
+                from rich.text import Text
+                self.console.print(Text(msg, style="bold red"))
+                input("Press Enter to continue...")
+            else:
+                print(msg, file=sys.stderr)
+                input("Press Enter to continue...")
+            return
+
+        player_names = list(available_players.keys())
+        selected_player = None
+
+        if len(player_names) == 1:
+            selected_player = player_names[0]
+        else:
+            if self.console:
+                from rich.prompt import Prompt
+                from rich.panel import Panel
+                from rich.text import Text
+                from rich.align import Align
+                
+                options_text = "\n".join([f"[{i+1}] {name}" for i, name in enumerate(player_names)])
+                panel = Panel(options_text, title=Text("Select Video Player", style="bold cyan"), border_style="cyan", padding=(1, 4))
+                self.console.print()
+                self.console.print(Align.center(panel))
+                
+                choice = Prompt.ask(
+                    "Enter the number of the player", 
+                    choices=[str(i+1) for i in range(len(player_names))], 
+                    default="1", 
+                    console=self.console
+                )
+                selected_player = player_names[int(choice)-1]
+            else:
+                print("\nAvailable Video Players:")
+                for i, name in enumerate(player_names):
+                    print(f"{i+1}. {name}")
+                
+                while True:
+                    try:
+                        choice = input(f"Choose a video player (1-{len(player_names)}) [1]: ")
+                        if not choice.strip():
+                            choice = "1"
+                        choice_idx = int(choice) - 1
+                        if 0 <= choice_idx < len(player_names):
+                            selected_player = player_names[choice_idx]
+                            break
+                        print("Invalid choice.")
+                    except ValueError:
+                        print("Invalid input.")
+
+        try:
+            if selected_player == 'VLC':
+                self._play_vlc(url, title, available_players['VLC'], headers)
+            elif selected_player == 'MPV':
+                self._play_mpv(url, title, available_players['MPV'], headers)
+            elif selected_player == 'MPC-HC':
+                self._play_mpc(url, title, available_players['MPC-HC'], headers)
+        except Exception as e:
+            if self.console:
+                from rich.text import Text
+                self.console.print(Text(f"Error launching player: {str(e)}", style="bold red"))
+                input("Press Enter to continue...")
+            else:
+                print(f"Error launching player: {str(e)}", file=sys.stderr)
+                input("Press Enter to continue...")
+
+    def _play_vlc(self, url: str, title: str, vlc_path: str = None, headers: dict = None):
+        if not vlc_path:
+            vlc_path = self.get_available_players().get('VLC')
+
+        if not vlc_path:
+            raise FileNotFoundError("VLC not found")
+
+        vlc_args = [
+            vlc_path,
+            '--fullscreen',
+            '--play-and-exit',
+            '--meta-title', title,
+        ]
+        if headers and headers.get('Referer'):
+            vlc_args += ['--http-referrer=' + headers['Referer']]
+        vlc_args.append(url)
+
+        subprocess.run(
+            vlc_args,
+            check=False,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL
+        )
+
+    def _play_mpv(self, url: str, title: str, mpv_path: str = None, headers: dict = None):
+        if not mpv_path:
+            mpv_path = self.get_available_players().get('MPV')
+
+        if not mpv_path or (mpv_path != 'mpv' and not os.path.exists(mpv_path)):
+            raise FileNotFoundError(f"MPV not found at: {mpv_path}")
+
+        mpv_args = [
+            mpv_path,
+            '--fullscreen',
+            '--keep-open=yes',
+            '--cache=yes',
+            '--demuxer-max-bytes=256M',
+            '--demuxer-max-back-bytes=128M',
+            '--cache-secs=30',
+            '--hwdec=auto-safe',
+            '--sub-auto=fuzzy',
+            '--force-media-title=' + title,
+            '--force-window=yes',
+        ]
+        if headers:
+            ua = headers.get('User-Agent')
+            if ua:
+                mpv_args += ['--user-agent=' + ua]
+            ref = headers.get('Referer')
+            if ref:
+                mpv_args += ['--referrer=' + ref]
+        mpv_args.append(url)
+
+        result = subprocess.run(
+            mpv_args,
+            check=False,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            stdin=subprocess.DEVNULL
+        )
+
+        if result.returncode != 0:
+            if self.console:
+                from rich.text import Text
+                self.console.print(Text(f"MPV exited with error code {result.returncode}", style="bold red"))
+                input("Press Enter to continue...")
+
+    def _play_mpc(self, url: str, title: str, mpc_path: str = None, headers: dict = None):
+        if not mpc_path:
+            mpc_path = self.get_available_players().get('MPC-HC')
+
+        if not mpc_path:
+            raise FileNotFoundError("MPC-HC not found")
+
+        mpc_args = [
+            mpc_path,
+            url,
+            '/fullscreen',
+            '/play',
+            '/close'
+        ]
+
+        subprocess.run(
+            mpc_args,
+            check=False,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL
+        )

ani_cli_arabic/scrapers/english.py

@@ -0,0 +1,316 @@
+import json
+import re
+import time
+import hashlib
+import base64
+from typing import Optional
+from urllib.parse import urljoin
+
+import requests
+from Cryptodome.Cipher import AES
+
+ALLANIME_CDN = "https://cdn.mkissa.net/all/mk/_app/immutable"
+ALLANIME_REFR = "https://mkissa.to"
+ALLANIME_BASE = "allanime.day"
+ALLANIME_API = "https://api.mkissa.net"
+ALLANIME_QUERY_HASH = "f4662f4b7510b26795dd53ef824a0bf1740fbbc5d1273fab18222ac831bca8d0"
+KEYGEN_URL = "https://raw.githubusercontent.com/sdaqo/anipy-cli/refs/heads/key-gen/scripts/keygen/keygen.json"
+USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:150.0) Gecko/20100101 Firefox/150.0"
+
+PROVIDER_PRIORITY = ["Yt-mp4", "S-Mp4", "Uv-mp4", "Ak", "Default"]
+
+_HEX_MAP = {
+    "79": "A", "7a": "B", "7b": "C", "7c": "D", "7d": "E", "7e": "F", "7f": "G",
+    "70": "H", "71": "I", "72": "J", "73": "K", "74": "L", "75": "M", "76": "N", "77": "O",
+    "68": "P", "69": "Q", "6a": "R", "6b": "S", "6c": "T", "6d": "U", "6e": "V", "6f": "W",
+    "60": "X", "61": "Y", "62": "Z",
+    "59": "a", "5a": "b", "5b": "c", "5c": "d", "5d": "e", "5e": "f", "5f": "g",
+    "50": "h", "51": "i", "52": "j", "53": "k", "54": "l", "55": "m", "56": "n", "57": "o",
+    "48": "p", "49": "q", "4a": "r", "4b": "s", "4c": "t", "4d": "u", "4e": "v", "4f": "w",
+    "40": "x", "41": "y", "42": "z",
+    "08": "0", "09": "1", "0a": "2", "0b": "3", "0c": "4", "0d": "5", "0e": "6", "0f": "7",
+    "00": "8", "01": "9",
+    "15": "-", "16": ".", "67": "_", "46": "~", "02": ":", "17": "/", "07": "?",
+    "1b": "#", "63": "[", "65": "]", "78": "@", "19": "!", "1c": "$", "1e": "&",
+    "10": "(", "11": ")", "12": "*", "13": "+", "14": ",", "03": ";", "05": "=", "1d": "%",
+}
+
+def _decode_hex_url(encoded: str) -> str:
+    if not encoded.startswith("--"):
+        return encoded
+    hex_str = encoded[2:]
+    out = []
+    for i in range(0, len(hex_str), 2):
+        pair = hex_str[i:i+2]
+        out.append(_HEX_MAP.get(pair, "?"))
+    result = "".join(out)
+    result = result.replace("/clock", "/clock.json")
+    return result
+
+
+class AllAnimeScraper:
+    def __init__(self):
+        self.session = requests.Session()
+        self.session.headers.update({"User-Agent": USER_AGENT})
+        self._aes_key: Optional[str] = None
+        self._epoch: Optional[int] = None
+        self._static_key: Optional[str] = None
+
+    # ------------------------------------------------------------------ #
+    #  Key derivation – replicates bash fetch_keys() + keygen fallback   #
+    # ------------------------------------------------------------------ #
+
+    def _fetch_keys_from_page(self):
+        html = self.session.get(ALLANIME_REFR, timeout=15).text
+
+        m = re.search(r'"epoch":(\d+)', html)
+        if not m:
+            raise RuntimeError("epoch not found on page")
+        self._epoch = int(m.group(1))
+
+        m = re.search(r'"partB":"([^"]*)"', html)
+        if not m:
+            raise RuntimeError("partB not found on page")
+        part_b_b64 = m.group(1)
+
+        m = re.search(rf'{re.escape(ALLANIME_CDN)}/entry/app\.[A-Za-z0-9_.-]+\.js', html)
+        if not m:
+            raise RuntimeError("app.js URL not found on page")
+        app_js_url = m.group(0)
+
+        app_js = self.session.get(app_js_url, timeout=15).text
+        chunk_refs = re.findall(r'"[.][.]/chunks/[A-Za-z0-9_.-]+\.js"', app_js)
+        js_parts = []
+        for ref in chunk_refs[:5]:
+            url = f"{ALLANIME_CDN}/{ref.strip('\"').lstrip('../')}"
+            try:
+                js_parts.append(self.session.get(url, timeout=15).text)
+            except requests.RequestException:
+                pass
+        js_body = "".join(js_parts)
+
+        m = re.search(r'[0-9a-f]{64}', js_body)
+        if not m:
+            raise RuntimeError("mask hex not found in JS chunks")
+        aa_mask_hex = m.group(0)
+
+        part_b_hex = base64.b64decode(part_b_b64).hex()
+        key_hex = ""
+        for i in range(0, 128, 2):
+            m_byte = int(aa_mask_hex[i:i+2], 16)
+            p_byte = int(part_b_hex[i:i+2], 16)
+            key_hex += f"{m_byte ^ p_byte:02x}"
+        self._aes_key = key_hex
+
+    def _fetch_keys_from_keygen(self):
+        resp = requests.get(KEYGEN_URL, timeout=15)
+        resp.raise_for_status()
+        kg = resp.json()
+        self._epoch = kg["epoch"]
+        self._aes_key = kg["key"]
+        self._static_key = kg.get("static_key")
+
+    def _ensure_keys(self):
+        if self._aes_key is not None:
+            return
+        try:
+            self._fetch_keys_from_page()
+        except Exception:
+            self._fetch_keys_from_keygen()
+
+    # ---------------------------------------------------------------- #
+    #  aaReq token generation – matches bash get_aa_req()               #
+    # ---------------------------------------------------------------- #
+
+    def _build_aa_req(self) -> str:
+        self._ensure_keys()
+        ts = int(time.time() * 1000) // 300000 * 300000
+        payload = {"v": 1, "ts": ts, "epoch": self._epoch, "qh": ALLANIME_QUERY_HASH}
+        iv = hashlib.sha256(
+            f"{self._epoch}:{ALLANIME_QUERY_HASH}:{ts}".encode()
+        ).digest()[:12]
+        cipher = AES.new(bytes.fromhex(self._aes_key), AES.MODE_GCM, nonce=iv)
+        ct, tag = cipher.encrypt_and_digest(
+            json.dumps(payload, separators=(",", ":")).encode()
+        )
+        return base64.b64encode(b"\x01" + iv + ct + tag).decode()
+
+    # ---------------------------------------------------------------- #
+    #  tobeparsed decryption – matches bash process_tobeparsed()        #
+    # ---------------------------------------------------------------- #
+
+    def _decrypt_tobeparsed(self, tbp_b64: str):
+        raw = base64.b64decode(tbp_b64)
+        iv, ct, tag = raw[1:13], raw[13:-16], raw[-16:]
+        candidates = [bytes.fromhex(self._aes_key)]
+        if self._static_key:
+            candidates.append(self._static_key.encode())
+        for key in candidates:
+            try:
+                plain = AES.new(key, AES.MODE_GCM, nonce=iv).decrypt_and_verify(ct, tag)
+                return json.loads(plain.decode("utf-8"))
+            except (ValueError, KeyError):
+                continue
+        raise ValueError("tobeparsed could not be decrypted")
+
+    # ---------------------------------------------------------------- #
+    #  Public API – search / episodes / video                           #
+    # ---------------------------------------------------------------- #
+
+    def search(self, query: str, mode: str = "sub"):
+        gql = (
+            "query($search: SearchInput $limit: Int $page: Int "
+            "$translationType: VaildTranslationTypeEnumType "
+            "$countryOrigin: VaildCountryOriginEnumType) { "
+            "shows(search: $search limit: $limit page: $page "
+            "translationType: $translationType "
+            "countryOrigin: $countryOrigin) { "
+            "edges { _id name availableEpisodes airedStart __typename } } }"
+        )
+        resp = self.session.post(
+            f"{ALLANIME_API}/api",
+            json={
+                "variables": {
+                    "search": {"allowAdult": False, "allowUnknown": False, "query": query},
+                    "limit": 40,
+                    "page": 1,
+                    "translationType": mode,
+                    "countryOrigin": "ALL",
+                },
+                "query": gql,
+            },
+            headers={"Content-Type": "application/json", "Referer": ALLANIME_REFR},
+            timeout=15,
+        )
+        data = resp.json()
+        out = []
+        for edge in data.get("data", {}).get("shows", {}).get("edges", []):
+            out.append({
+                "id": edge["_id"],
+                "name": edge["name"],
+                "available_episodes": edge.get("availableEpisodes", {}),
+            })
+        return out
+
+    def get_episodes(self, show_id: str, mode: str = "sub"):
+        gql = "query($showId: String!) { show(_id: $showId) { _id availableEpisodesDetail } }"
+        resp = self.session.post(
+            f"{ALLANIME_API}/api",
+            json={"variables": {"showId": show_id}, "query": gql},
+            headers={"Content-Type": "application/json", "Referer": ALLANIME_REFR},
+            timeout=15,
+        )
+        data = resp.json()
+        detail = data.get("data", {}).get("show", {}).get("availableEpisodesDetail", {})
+        eps = detail.get(mode, detail.get("sub", []))
+        return sorted(float(e) for e in eps)
+
+    def get_video_sources(self, show_id: str, episode_num, mode: str = "sub"):
+        aa_req = self._build_aa_req()
+        variables = json.dumps({
+            "showId": show_id,
+            "translationType": mode,
+            "episodeString": str(int(float(episode_num))),
+        })
+        extensions = json.dumps({
+            "persistedQuery": {"version": 1, "sha256Hash": ALLANIME_QUERY_HASH},
+            "aaReq": aa_req,
+        })
+        resp = self.session.get(
+            f"{ALLANIME_API}/api",
+            params={"variables": variables, "extensions": extensions},
+            headers={"Referer": ALLANIME_REFR, "Origin": ALLANIME_REFR},
+            timeout=15,
+        )
+        payload = resp.json()
+
+        data = payload.get("data", {})
+        if "tobeparsed" in data:
+            try:
+                data = self._decrypt_tobeparsed(data["tobeparsed"])
+            except ValueError:
+                return []
+
+        sources = []
+        episode = data.get("episode") if isinstance(data, dict) else None
+        if episode is None:
+            return sources
+
+        for src in episode.get("sourceUrls", []):
+            if src.get("sourceName") in PROVIDER_PRIORITY:
+                sources.append({
+                    "source_name": src["sourceName"],
+                    "source_url": src["sourceUrl"],
+                    "priority": src.get("priority", 0),
+                    "type": src.get("type", ""),
+                    "stype": src.get("stype", ""),
+                })
+
+        sources.sort(key=lambda x: -x["priority"])
+        return sources
+
+    def _fetch_provider_links(self, decoded_path: str) -> list:
+        url = f"https://{ALLANIME_BASE}{decoded_path}"
+        try:
+            resp = self.session.get(
+                url,
+                headers={"Referer": ALLANIME_REFR, "User-Agent": USER_AGENT},
+                timeout=15,
+            )
+            data = resp.json()
+        except Exception:
+            return []
+
+        links = []
+        for entry in data.get("links", []):
+            raw = entry.get("rawUrls", {})
+            vids = raw.get("vids", [])
+            for vid in vids:
+                vid_url = vid.get("url", "")
+                height = vid.get("height", 0)
+                links.append({
+                    "url": vid_url,
+                    "resolution": height,
+                    "headers": {"Referer": ALLANIME_REFR, "User-Agent": USER_AGENT},
+                })
+
+            link = entry.get("link", "")
+            if not vids and link:
+                resolution = 0
+                rs = entry.get("resolutionStr", "")
+                if rs:
+                    try:
+                        resolution = int(rs.replace("p", "").split()[0])
+                    except (ValueError, IndexError):
+                        resolution = 0
+                links.append({
+                    "url": link,
+                    "resolution": resolution,
+                    "headers": {
+                        "Referer": entry.get("headers", {}).get("Referer", ALLANIME_REFR),
+                        "User-Agent": USER_AGENT,
+                    },
+                })
+        return links
+
+    def resolve_stream_url(self, show_id: str, episode_num, mode: str = "sub"):
+        sources = self.get_video_sources(show_id, episode_num, mode)
+        if not sources:
+            return None, {}
+        src = sources[0]
+        headers = {"Referer": ALLANIME_REFR, "User-Agent": USER_AGENT}
+
+        if "tools.fast4speed.rsvp" in src["source_url"]:
+            return src["source_url"], headers
+
+        if src.get("stype") == "t":
+            return src["source_url"], headers
+
+        decoded_path = _decode_hex_url(src["source_url"])
+        provider_links = self._fetch_provider_links(decoded_path)
+        if not provider_links:
+            return src["source_url"], headers
+
+        provider_links.sort(key=lambda x: -x["resolution"])
+        best = provider_links[0]
+        return best["url"], best["headers"]

ani_cli_arabic/settings.py

@@ -0,0 +1,54 @@
+import json
+from pathlib import Path
+from .storage import atomic_write_json
+
+class SettingsManager:
+    def __init__(self):
+        self.config_file = self._get_config_path()
+        self.settings = self._load_settings()
+
+    def _get_config_path(self) -> Path:
+        home_dir = Path.home()
+        db_dir = home_dir / ".ani-cli-arabic" / "database"
+        db_dir.mkdir(parents=True, exist_ok=True)
+        return db_dir / "config.json"
+
+    def _load_settings(self) -> dict:
+        defaults = {
+            "default_quality": "1080p",
+            "default_download_quality": "1080p",
+            "download_mode": "internal",
+            "download_directory": "downloads",
+            "player": "mpv",
+            "auto_next": False,
+            "discord_rpc": True,
+            "theme": "blue",
+            "analytics": True,
+            "preferred_language": "Arabic Sub"
+        }
+        
+        if not self.config_file.exists():
+            return defaults
+            
+        try:
+            with open(self.config_file, 'r', encoding='utf-8') as f:
+                saved = json.load(f)
+                if not isinstance(saved, dict):
+                    return defaults
+                return {**defaults, **saved}
+        except (json.JSONDecodeError, IOError, OSError):
+            return defaults
+
+    def save(self):
+        try:
+            atomic_write_json(self.config_file, self.settings, indent=4, ensure_ascii=False)
+        except (IOError, OSError, ValueError, TypeError) as e:
+            import sys
+            print(f"Warning: Failed to save settings: {e}", file=sys.stderr)
+
+    def get(self, key, default=None):
+        return self.settings.get(key, default)
+
+    def set(self, key, value):
+        self.settings[key] = value
+        self.save()

ani_cli_arabic/storage.py

@@ -0,0 +1,28 @@
+import json
+import os
+import tempfile
+from pathlib import Path
+from typing import Any
+
+
+def atomic_write_json(path: Path, data: Any, indent: int = 4, ensure_ascii: bool = False) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+    fd, temp_path = tempfile.mkstemp(
+        prefix=f".{path.name}.",
+        suffix=".tmp",
+        dir=str(path.parent),
+    )
+
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as handle:
+            json.dump(data, handle, indent=indent, ensure_ascii=ensure_ascii)
+            handle.flush()
+            os.fsync(handle.fileno())
+        os.replace(temp_path, path)
+    finally:
+        try:
+            if os.path.exists(temp_path):
+                os.remove(temp_path)
+        except OSError:
+            pass