rustore-apk 0.1.0__tar.gz

rustore_apk-0.1.0/LICENSE

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

rustore_apk-0.1.0/PKG-INFO

@@ -0,0 +1,86 @@
+Metadata-Version: 2.4
+Name: rustore-apk
+Version: 0.1.0
+Summary: Download APKs published in RuStore
+Author: Mffff4
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Mffff4/rustore-apk
+Project-URL: Repository, https://github.com/Mffff4/rustore-apk
+Project-URL: Issues, https://github.com/Mffff4/rustore-apk/issues
+Keywords: rustore,apk,downloader,android
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: System :: Software Distribution
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# rustore-apk
+
+[![PyPI version](https://img.shields.io/pypi/v/rustore-apk.svg)](https://pypi.org/project/rustore-apk/)
+[![Python](https://img.shields.io/pypi/pyversions/rustore-apk.svg)](https://pypi.org/project/rustore-apk/)
+
+A dependency-free CLI for downloading APK artifacts published in [RuStore](https://www.rustore.ru/). It uses Python's standard-library `urllib` only.
+
+## Install / run
+
+With [uv](https://docs.astral.sh/uv/):
+
+```bash
+uvx rustore-apk DangerousSlope.apk
+```
+
+A RuStore catalog URL works too:
+
+```bash
+uvx rustore-apk \
+  'https://www.rustore.ru/catalog/app/DangerousSlope.apk' \
+  --out ./downloads
+```
+
+`-o` is short for `--out`. A multi-file split APK bundle is downloaded as separate files into that directory.
+
+Show metadata without requesting a download link:
+
+```bash
+uvx rustore-apk DangerousSlope.apk --info
+```
+
+## Security behavior
+
+- Retrieves a temporary download URL through RuStore's public Android-client API flow.
+- Accepts only HTTPS download links returned from RuStore/VK CDN domains.
+- Checks that each downloaded artifact is a ZIP/APK container.
+- Prints SHA-256 for every saved artifact.
+- Does not send account credentials and does not require a RuStore account.
+
+TLS verification is on by default. If a minimal container has no valid CA roots, pass a PEM CA bundle:
+
+```bash
+rustore-apk DangerousSlope.apk --ca-file /path/to/ca-bundle.pem
+```
+
+`--insecure` disables TLS certificate validation. It is intended solely to diagnose a broken local CA store and is **not recommended** for routine downloads.
+
+## Development
+
+```bash
+uv sync --dev
+uv run ruff check .
+uv run pytest
+uv build
+```
+
+## Disclaimer
+
+This project is an unofficial client and is not affiliated with RuStore or VK. RuStore API behavior and availability may change. Download and use apps only where permitted by their publisher and RuStore's terms.
+
+## License
+
+MIT.

rustore_apk-0.1.0/README.md

@@ -0,0 +1,63 @@
+# rustore-apk
+
+[![PyPI version](https://img.shields.io/pypi/v/rustore-apk.svg)](https://pypi.org/project/rustore-apk/)
+[![Python](https://img.shields.io/pypi/pyversions/rustore-apk.svg)](https://pypi.org/project/rustore-apk/)
+
+A dependency-free CLI for downloading APK artifacts published in [RuStore](https://www.rustore.ru/). It uses Python's standard-library `urllib` only.
+
+## Install / run
+
+With [uv](https://docs.astral.sh/uv/):
+
+```bash
+uvx rustore-apk DangerousSlope.apk
+```
+
+A RuStore catalog URL works too:
+
+```bash
+uvx rustore-apk \
+  'https://www.rustore.ru/catalog/app/DangerousSlope.apk' \
+  --out ./downloads
+```
+
+`-o` is short for `--out`. A multi-file split APK bundle is downloaded as separate files into that directory.
+
+Show metadata without requesting a download link:
+
+```bash
+uvx rustore-apk DangerousSlope.apk --info
+```
+
+## Security behavior
+
+- Retrieves a temporary download URL through RuStore's public Android-client API flow.
+- Accepts only HTTPS download links returned from RuStore/VK CDN domains.
+- Checks that each downloaded artifact is a ZIP/APK container.
+- Prints SHA-256 for every saved artifact.
+- Does not send account credentials and does not require a RuStore account.
+
+TLS verification is on by default. If a minimal container has no valid CA roots, pass a PEM CA bundle:
+
+```bash
+rustore-apk DangerousSlope.apk --ca-file /path/to/ca-bundle.pem
+```
+
+`--insecure` disables TLS certificate validation. It is intended solely to diagnose a broken local CA store and is **not recommended** for routine downloads.
+
+## Development
+
+```bash
+uv sync --dev
+uv run ruff check .
+uv run pytest
+uv build
+```
+
+## Disclaimer
+
+This project is an unofficial client and is not affiliated with RuStore or VK. RuStore API behavior and availability may change. Download and use apps only where permitted by their publisher and RuStore's terms.
+
+## License
+
+MIT.

rustore_apk-0.1.0/pyproject.toml

@@ -0,0 +1,57 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "rustore-apk"
+version = "0.1.0"
+description = "Download APKs published in RuStore"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+authors = [{name = "Mffff4"}]
+keywords = ["rustore", "apk", "downloader", "android"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Environment :: Console",
+  "Intended Audience :: End Users/Desktop",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Topic :: Internet :: WWW/HTTP",
+  "Topic :: System :: Software Distribution",
+]
+dependencies = []
+
+[dependency-groups]
+dev = [
+  "build>=1.2",
+  "pytest>=8.0",
+  "ruff>=0.9",
+]
+
+[project.urls]
+Homepage = "https://github.com/Mffff4/rustore-apk"
+Repository = "https://github.com/Mffff4/rustore-apk"
+Issues = "https://github.com/Mffff4/rustore-apk/issues"
+
+[project.scripts]
+rustore-apk = "rustore_apk.cli:main"
+
+[tool.setuptools.packages.find]
+include = ["rustore_apk*"]
+
+[tool.setuptools.package-data]
+rustore_apk = ["py.typed"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+exclude = ["build", "dist", "rustore_urllib"]
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["."]

rustore_apk-0.1.0/rustore_apk/__init__.py

@@ -0,0 +1,3 @@
+"""Download APKs published in RuStore."""
+
+__version__ = "0.1.0"

rustore_apk-0.1.0/rustore_apk/cli.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+import argparse
+import ssl
+import sys
+from pathlib import Path
+
+from .client import Client, RuStoreError, package_from_argument, secure_context
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="rustore-apk",
+        description="Download APKs published in RuStore.",
+        epilog="Examples:\n"
+        "  rustore-apk DangerousSlope.apk\n"
+        "  rustore-apk https://www.rustore.ru/catalog/app/DangerousSlope.apk -o downloads\n"
+        "  rustore-apk DangerousSlope.apk --info",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument("app", help="RuStore catalog URL or Android package name")
+    parser.add_argument(
+        "-o", "--out", default=".", help="Output directory (default: current directory)"
+    )
+    parser.add_argument(
+        "--info", action="store_true", help="Print app metadata only; do not request download links"
+    )
+    parser.add_argument(
+        "--timeout", type=float, default=45.0, help="Network timeout in seconds (default: 45)"
+    )
+    parser.add_argument(
+        "--ca-file",
+        metavar="PATH",
+        help="PEM CA bundle for minimal containers without system trust roots",
+    )
+    parser.add_argument(
+        "--insecure",
+        action="store_true",
+        help="Disable TLS certificate verification (diagnostic use only; not recommended)",
+    )
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = _parser().parse_args(argv)
+    try:
+        context = (
+            ssl._create_unverified_context() if args.insecure else secure_context(args.ca_file)
+        )
+        client = Client(args.timeout, context)
+        app = client.app(package_from_argument(args.app))
+        version = app.version_name or "?"
+        print(f"{app.app_name} ({app.package_name}) v{version}")
+        if args.info:
+            return 0
+
+        output = Path(args.out)
+        output.mkdir(parents=True, exist_ok=True)
+        urls = client.download_urls(app.app_id)
+        for index, url in enumerate(urls, start=1):
+            target = output / client.file_name_from_url(url, f"{app.package_name}-{index}.apk")
+            count, digest = client.download(url, target)
+            print(f"saved {target} ({count} bytes)\nsha256 {digest}")
+        return 0
+    except RuStoreError as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

rustore_apk-0.1.0/rustore_apk/client.py

@@ -0,0 +1,211 @@
+from __future__ import annotations
+
+import base64
+import hashlib
+import hmac
+import http.cookiejar
+import json
+import re
+import secrets
+import ssl
+import zipfile
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+from urllib.error import HTTPError, URLError
+from urllib.parse import unquote, urlparse
+from urllib.request import HTTPCookieProcessor, HTTPSHandler, Request, build_opener
+
+HMAC_KEY = base64.b64decode("K+eeiCbnVFnZ71KEVal0g5siHaX6v6drh8upeLgEPoU=")
+APK_CERT_SHA256 = base64.b64decode("Zh8ggo73gN4LebxZ8mowhkMWNV8w5Pkc+hSiB5GDmRQ=")
+BASE_URL = "https://backapi.rustore.ru"
+NONCE_URL = "https://api.rustore.ru/v1/secure/nonce"
+CATALOG_RE = re.compile(r"(?:https?://)?(?:www\.)?rustore\.ru/catalog/app/([^/?#]+)")
+PACKAGE_RE = re.compile(r"^[A-Za-z][A-Za-z0-9_]*(?:\.[A-Za-z][A-Za-z0-9_]*)+$")
+DEVICE_MANUFACTURER = "Google"
+DEVICE_MODEL = "Pixel 8 Pro"
+DEVICE_HARDWARE = "husky"
+FIRMWARE_VER = "16"
+ANDROID_SDK_VER = "36"
+FIRMWARE_LANG = "ru"
+RUSTORE_VERSION = "1105002"
+USER_AGENT = (
+    f"RuStore/1.105.0.2 (Android {FIRMWARE_VER}; SDK {ANDROID_SDK_VER}; "
+    f"arm64-v8a; {DEVICE_MANUFACTURER} {DEVICE_MODEL}; {FIRMWARE_LANG})"
+)
+
+
+class RuStoreError(RuntimeError):
+    """Raised when RuStore does not return a usable app or download artifact."""
+
+
+@dataclass(frozen=True)
+class App:
+    app_id: int
+    package_name: str
+    app_name: str
+    version_name: str | None
+
+
+def package_from_argument(value: str) -> str:
+    """Extract a package name from a catalog URL or accept a package name directly."""
+    match = CATALOG_RE.search(value.strip())
+    package = unquote(match.group(1)) if match else value.strip()
+    if not PACKAGE_RE.fullmatch(package):
+        raise RuStoreError("Pass a RuStore catalog URL or a valid Android package name")
+    return package
+
+
+def secure_context(cafile: str | None) -> ssl.SSLContext:
+    try:
+        return ssl.create_default_context(cafile=cafile)
+    except FileNotFoundError as exc:
+        raise RuStoreError(f"CA file not found: {cafile}") from exc
+
+
+def _java_hash(value: str) -> int:
+    result = 0
+    for char in value:
+        result = (31 * result + ord(char)) & 0xFFFFFFFF
+    return result - 0x100000000 if result >= 0x80000000 else result
+
+
+def _device_id() -> str:
+    manufacturer, model, hardware = map(
+        _java_hash, (DEVICE_MANUFACTURER, DEVICE_MODEL, DEVICE_HARDWARE)
+    )
+    combined = hardware + ((hardware + ((model + manufacturer * 31) * 31)) * 31)
+    combined = (combined + 0x80000000) & 0xFFFFFFFF
+    if combined >= 0x80000000:
+        combined -= 0x100000000
+    return f"{secrets.token_hex(8)}-{combined}"
+
+
+class Client:
+    def __init__(self, timeout: float, ssl_context: ssl.SSLContext) -> None:
+        self.timeout = timeout
+        self.device_id = _device_id()
+        self.signature: str | None = None
+        self.opener = build_opener(
+            HTTPCookieProcessor(http.cookiejar.CookieJar()), HTTPSHandler(context=ssl_context)
+        )
+
+    def _headers(self, signed: bool = True) -> dict[str, str]:
+        headers = {
+            "deviceId": self.device_id,
+            "firmwareVer": FIRMWARE_VER,
+            "androidSdkVer": ANDROID_SDK_VER,
+            "deviceManufacturerName": DEVICE_MANUFACTURER,
+            "deviceModelName": DEVICE_MODEL,
+            "deviceModel": f"{DEVICE_MANUFACTURER} {DEVICE_MODEL}",
+            "firmwareLang": FIRMWARE_LANG,
+            "ruStoreVerCode": RUSTORE_VERSION,
+            "deviceType": "mobile",
+            "User-Agent": USER_AGENT,
+        }
+        if signed and self.signature:
+            headers["X-Client-Signature"] = self.signature
+        return headers
+
+    def _open(self, request: Request):
+        try:
+            return self.opener.open(request, timeout=self.timeout)
+        except HTTPError:
+            raise
+        except URLError as exc:
+            raise RuStoreError(f"Network error: {exc.reason}") from exc
+
+    def _sign(self, force: bool = False) -> None:
+        if self.signature and not force:
+            return
+        try:
+            request = Request(NONCE_URL, data=b"", method="POST", headers=self._headers(False))
+            with self._open(request) as response:
+                nonce = json.load(response).get("nonce")
+        except HTTPError as exc:
+            raise RuStoreError(f"Nonce request failed: HTTP {exc.code}") from exc
+        if not nonce:
+            raise RuStoreError("RuStore nonce response did not contain nonce")
+        digest = hmac.new(
+            HMAC_KEY, base64.b64decode(nonce) + APK_CERT_SHA256, hashlib.sha256
+        ).digest()
+        self.signature = base64.b64encode(digest).decode("ascii")
+
+    def _api(self, method: str, url: str, body: dict[str, Any] | None = None) -> dict[str, Any]:
+        self._sign()
+        raw = json.dumps(body, separators=(",", ":")).encode() if body is not None else None
+
+        def request() -> Request:
+            headers = self._headers()
+            if raw is not None:
+                headers["Content-Type"] = "application/json; charset=utf-8"
+            return Request(url, data=raw, method=method, headers=headers)
+
+        try:
+            with self._open(request()) as response:
+                return json.load(response)
+        except HTTPError as exc:
+            if exc.code != 419:
+                raise RuStoreError(f"RuStore API request failed: HTTP {exc.code}") from exc
+
+        self._sign(force=True)
+        try:
+            with self._open(request()) as response:
+                return json.load(response)
+        except HTTPError as exc:
+            raise RuStoreError(f"RuStore API retry failed: HTTP {exc.code}") from exc
+
+    def app(self, package_name: str) -> App:
+        payload = self._api("GET", f"{BASE_URL}/applicationData/overallInfo/{package_name}")
+        body = payload.get("body")
+        if payload.get("code") != "OK" or not isinstance(body, dict):
+            raise RuStoreError(f"Package not found in RuStore: {package_name}")
+        return App(
+            int(body["appId"]),
+            str(body["packageName"]),
+            str(body.get("appName") or body["packageName"]),
+            body.get("versionName"),
+        )
+
+    def download_urls(self, app_id: int) -> list[str]:
+        payload = self._api(
+            "POST",
+            f"{BASE_URL}/v3/showcase/apps/download-link",
+            {"appId": app_id, "firstInstall": True},
+        )
+        items = payload.get("downloadUrls") or payload.get("body", {}).get("downloadUrls") or []
+        urls = [str(item.get("url", "")) for item in items if isinstance(item, dict)]
+        urls = [url[:-4] + ".apk" if url.endswith(".zip") else url for url in urls]
+        if not urls:
+            raise RuStoreError("RuStore returned no APK download URLs")
+        for url in urls:
+            parsed = urlparse(url)
+            host = parsed.hostname or ""
+            if parsed.scheme != "https" or not (
+                host.endswith(".rustore.ru") or host.endswith(".vk.ru")
+            ):
+                raise RuStoreError(f"Unexpected download host from RuStore API: {host}")
+        return urls
+
+    @staticmethod
+    def file_name_from_url(url: str, fallback: str) -> str:
+        name = Path(urlparse(url).path).name or fallback
+        return name if name.endswith(".apk") else f"{name}.apk"
+
+    def download(self, url: str, target: Path) -> tuple[int, str]:
+        target.parent.mkdir(parents=True, exist_ok=True)
+        digest, total = hashlib.sha256(), 0
+        try:
+            request = Request(url, headers={"User-Agent": USER_AGENT})
+            with self._open(request) as response, target.open("wb") as output:
+                while chunk := response.read(256 * 1024):
+                    output.write(chunk)
+                    digest.update(chunk)
+                    total += len(chunk)
+        except HTTPError as exc:
+            target.unlink(missing_ok=True)
+            raise RuStoreError(f"APK download failed: HTTP {exc.code}") from exc
+        if not zipfile.is_zipfile(target):
+            target.unlink(missing_ok=True)
+            raise RuStoreError("Downloaded file is not a valid APK/ZIP container")
+        return total, digest.hexdigest()

rustore_apk-0.1.0/rustore_apk.egg-info/PKG-INFO

@@ -0,0 +1,86 @@
+Metadata-Version: 2.4
+Name: rustore-apk
+Version: 0.1.0
+Summary: Download APKs published in RuStore
+Author: Mffff4
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Mffff4/rustore-apk
+Project-URL: Repository, https://github.com/Mffff4/rustore-apk
+Project-URL: Issues, https://github.com/Mffff4/rustore-apk/issues
+Keywords: rustore,apk,downloader,android
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: System :: Software Distribution
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# rustore-apk
+
+[![PyPI version](https://img.shields.io/pypi/v/rustore-apk.svg)](https://pypi.org/project/rustore-apk/)
+[![Python](https://img.shields.io/pypi/pyversions/rustore-apk.svg)](https://pypi.org/project/rustore-apk/)
+
+A dependency-free CLI for downloading APK artifacts published in [RuStore](https://www.rustore.ru/). It uses Python's standard-library `urllib` only.
+
+## Install / run
+
+With [uv](https://docs.astral.sh/uv/):
+
+```bash
+uvx rustore-apk DangerousSlope.apk
+```
+
+A RuStore catalog URL works too:
+
+```bash
+uvx rustore-apk \
+  'https://www.rustore.ru/catalog/app/DangerousSlope.apk' \
+  --out ./downloads
+```
+
+`-o` is short for `--out`. A multi-file split APK bundle is downloaded as separate files into that directory.
+
+Show metadata without requesting a download link:
+
+```bash
+uvx rustore-apk DangerousSlope.apk --info
+```
+
+## Security behavior
+
+- Retrieves a temporary download URL through RuStore's public Android-client API flow.
+- Accepts only HTTPS download links returned from RuStore/VK CDN domains.
+- Checks that each downloaded artifact is a ZIP/APK container.
+- Prints SHA-256 for every saved artifact.
+- Does not send account credentials and does not require a RuStore account.
+
+TLS verification is on by default. If a minimal container has no valid CA roots, pass a PEM CA bundle:
+
+```bash
+rustore-apk DangerousSlope.apk --ca-file /path/to/ca-bundle.pem
+```
+
+`--insecure` disables TLS certificate validation. It is intended solely to diagnose a broken local CA store and is **not recommended** for routine downloads.
+
+## Development
+
+```bash
+uv sync --dev
+uv run ruff check .
+uv run pytest
+uv build
+```
+
+## Disclaimer
+
+This project is an unofficial client and is not affiliated with RuStore or VK. RuStore API behavior and availability may change. Download and use apps only where permitted by their publisher and RuStore's terms.
+
+## License
+
+MIT.

rustore_apk-0.1.0/rustore_apk.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+rustore_apk/__init__.py
+rustore_apk/cli.py
+rustore_apk/client.py
+rustore_apk/py.typed
+rustore_apk.egg-info/PKG-INFO
+rustore_apk.egg-info/SOURCES.txt
+rustore_apk.egg-info/dependency_links.txt
+rustore_apk.egg-info/entry_points.txt
+rustore_apk.egg-info/top_level.txt
+tests/test_client.py

rustore_apk-0.1.0/rustore_apk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

rustore_apk-0.1.0/rustore_apk.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+rustore-apk = rustore_apk.cli:main

rustore_apk-0.1.0/rustore_apk.egg-info/top_level.txt

@@ -0,0 +1 @@
+rustore_apk

rustore_apk-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

rustore_apk-0.1.0/tests/test_client.py

@@ -0,0 +1,31 @@
+from rustore_apk.client import Client, RuStoreError, package_from_argument
+
+
+def test_accepts_catalog_url() -> None:
+    assert (
+        package_from_argument("https://www.rustore.ru/catalog/app/DangerousSlope.apk")
+        == "DangerousSlope.apk"
+    )
+
+
+def test_accepts_package_name() -> None:
+    assert package_from_argument("com.example.app") == "com.example.app"
+
+
+def test_rejects_non_package_argument() -> None:
+    try:
+        package_from_argument("not a package")
+    except RuStoreError:
+        return
+    raise AssertionError("invalid package name was accepted")
+
+
+def test_filename_from_url() -> None:
+    assert (
+        Client.file_name_from_url("https://static-m.rustore.ru/path/app.apk", "fallback.apk")
+        == "app.apk"
+    )
+    assert (
+        Client.file_name_from_url("https://static-m.rustore.ru/path/app", "fallback.apk")
+        == "app.apk"
+    )