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