v0.166.0
  1import re
  2from collections.abc import Generator
  3from pathlib import Path
  4
  5import httpx
  6import tomlkit
  7from plain.assets.finders import _APP_ASSETS_DIR
  8
  9from .exceptions import (
 10    UnknownContentTypeError,
 11    VersionMismatchError,
 12)
 13
 14VENDOR_DIR = _APP_ASSETS_DIR / "vendor"
 15
 16
 17def iter_next_version(version: str) -> Generator[str]:
 18    if len(version.split(".")) == 2:
 19        major, minor = version.split(".")
 20        yield f"{int(major) + 1}.0"
 21        yield f"{major}.{int(minor) + 1}"
 22    elif len(version.split(".")) == 3:
 23        major, minor, patch = version.split(".")
 24        yield f"{int(major) + 1}.0.0"
 25        yield f"{major}.{int(minor) + 1}.0"
 26        yield f"{major}.{minor}.{int(patch) + 1}"
 27    else:
 28        raise ValueError(f"Unable to iterate next version for {version}")
 29
 30
 31class Dependency:
 32    def __init__(self, name: str, **config: str | bool):
 33        self.name = name
 34        # Config values for these keys are always strings
 35        self.url: str = str(config.get("url", ""))
 36        self.installed: str = str(config.get("installed", ""))
 37        self.filename: str = str(config.get("filename", ""))
 38        # sourcemap can be bool (True/False) or str (custom filename)
 39        self.sourcemap: bool | str = config.get("sourcemap", False)
 40
 41    @staticmethod
 42    def parse_version_from_url(url: str) -> str:
 43        if match := re.search(r"\d+\.\d+\.\d+", url):
 44            return match.group(0)
 45
 46        if match := re.search(r"\d+\.\d+", url):
 47            return match.group(0)
 48
 49        return ""
 50
 51    def __str__(self) -> str:
 52        return f"{self.name} -> {self.url}"
 53
 54    def download(self, version: str) -> tuple[str, httpx.Response]:
 55        # If the string contains a {version} placeholder, replace it
 56        download_url = self.url.replace("{version}", version)
 57
 58        response = httpx.get(download_url, follow_redirects=True)
 59        response.raise_for_status()
 60
 61        content_type = response.headers.get("content-type", "").lower()
 62        allowed_types = (
 63            "application/javascript",
 64            "text/javascript",
 65            "application/json",
 66            "text/css",
 67        )
 68        if not any(content_type.startswith(allowed) for allowed in allowed_types):
 69            raise UnknownContentTypeError(
 70                f"Unknown content type for {self.name}: {content_type}"
 71            )
 72
 73        # Good chance it will redirect to a more final URL (which we hope is versioned)
 74        url = str(response.url)
 75        version = self.parse_version_from_url(url)
 76
 77        return version, response
 78
 79    def install(self) -> Path:
 80        if self.installed:
 81            version, response = self.download(self.installed)
 82            if version and version != self.installed:
 83                raise VersionMismatchError(
 84                    f"Version mismatch for {self.name}: {self.installed} != {version}"
 85                )
 86            return self.vendor(response)
 87        else:
 88            return self.update()
 89
 90    def update(self) -> Path:
 91        def try_version(v: str) -> tuple[str, httpx.Response | None]:
 92            try:
 93                version, response = self.download(v)
 94                return version, response
 95            except httpx.HTTPError:
 96                return "", None
 97
 98        if not self.installed:
 99            # If we don't know the installed version yet,
100            # just use the url as given
101            version, response = self.download("")
102        else:
103            version, response = try_version("latest")  # A lot of CDNs support this
104            if not version:
105                # Try the next few versions
106                for v in iter_next_version(self.installed):
107                    version, response = try_version(v)
108                    if version:
109                        break
110
111                    # TODO ideally this would keep going -- if we move to 2.0, and no 3.0, try 2.1, 2.2, etc.
112
113        if not version:
114            # Use the currently installed version if we found nothing else
115            version, response = self.download(self.installed)
116
117        if not response:
118            raise httpx.HTTPError("Unable to download dependency")
119
120        vendored_path = self.vendor(response)
121        self.installed = version
122
123        if self.installed:
124            # If the exact version was in the string, replace it with {version} placeholder
125            self.url = self.url.replace(self.installed, "{version}")
126
127        self.save_config()
128        return vendored_path
129
130    def save_config(self) -> None:
131        with open("pyproject.toml") as f:
132            pyproject = tomlkit.load(f)
133
134        # Force [tool.plain.vendor.dependencies] to be a table
135        dependencies = tomlkit.table()
136        dependencies.update(
137            pyproject.get("tool", {})
138            .get("plain", {})
139            .get("vendor", {})
140            .get("dependencies", {})
141        )
142
143        # Force [tool.plain.vendor.dependencies.{name}] to be an inline table
144        # name = { url = "https://example.com", installed = "1.0.0" }
145        dependencies[self.name] = tomlkit.inline_table()
146        dependencies[self.name]["url"] = self.url  # ty: ignore[invalid-assignment]
147        dependencies[self.name]["installed"] = self.installed  # ty: ignore[invalid-assignment]
148        if self.filename:
149            dependencies[self.name]["filename"] = self.filename  # ty: ignore[invalid-assignment]
150        if self.sourcemap:
151            dependencies[self.name]["sourcemap"] = self.sourcemap  # ty: ignore[invalid-assignment]
152
153        # Have to give it the right structure in case they don't exist
154        if "tool" not in pyproject:
155            pyproject["tool"] = tomlkit.table()
156        if "plain" not in pyproject["tool"]:  # ty: ignore[unsupported-operator]
157            pyproject["tool"]["plain"] = tomlkit.table()  # ty: ignore[invalid-assignment]
158        if "vendor" not in pyproject["tool"]["plain"]:  # ty: ignore[unsupported-operator, not-subscriptable]
159            pyproject["tool"]["plain"]["vendor"] = tomlkit.table()  # ty: ignore[not-subscriptable, invalid-assignment]
160
161        pyproject["tool"]["plain"]["vendor"]["dependencies"] = dependencies  # ty: ignore[not-subscriptable, invalid-assignment]
162
163        with open("pyproject.toml", "w") as f:
164            f.write(tomlkit.dumps(pyproject))
165
166    def vendor(self, response: httpx.Response) -> Path:
167        if not VENDOR_DIR.exists():
168            VENDOR_DIR.mkdir(parents=True)
169
170        response_url = str(response.url)
171
172        if self.filename:
173            # Use a specific filename from config
174            filename = self.filename
175        else:
176            # Otherwise, use the filename from the URL
177            filename = response_url.split("/")[-1]
178            # Remove any query string or fragment
179            filename = filename.split("?")[0].split("#")[0]
180
181        vendored_path = VENDOR_DIR / filename
182
183        with open(vendored_path, "wb") as f:
184            f.write(response.content)
185
186        # If a sourcemap is requested, download it as well
187        if self.sourcemap:
188            if self.sourcemap is True:
189                # Default: append .map to the filename
190                sourcemap_filename = f"{filename}.map"
191            else:
192                # Use a specific filename from config
193                sourcemap_filename = str(self.sourcemap)
194
195            sourcemap_url = "/".join(
196                response_url.split("/")[:-1] + [sourcemap_filename]
197            )
198            sourcemap_response = httpx.get(sourcemap_url, follow_redirects=True)
199            sourcemap_response.raise_for_status()
200
201            sourcemap_path = VENDOR_DIR / sourcemap_filename
202
203            with open(sourcemap_path, "wb") as f:
204                f.write(sourcemap_response.content)
205
206        return vendored_path
207
208
209def get_deps() -> list[Dependency]:
210    with open("pyproject.toml") as f:
211        pyproject = tomlkit.load(f)
212
213    config = (
214        pyproject.get("tool", {})
215        .get("plain", {})
216        .get("vendor", {})
217        .get("dependencies", {})
218    )
219
220    deps = []
221
222    for name, data in config.items():
223        deps.append(Dependency(name, **data))
224
225    return deps