1# ~/~ begin <<README.md#checkdeps/__init__.py>>[init]
  2from __future__ import annotations
  3
  4import subprocess
  5proc_eval = subprocess.run(
  6    ["awk", "-f", "eval_shell_pass.awk"],
  7    input=open("README.md", "rb").read(), capture_output=True)
  8proc_label = subprocess.run(
  9    ["awk", "-f", "noweb_label_pass.awk"],
 10    input=proc_eval.stdout, capture_output=True)
 11__doc__ = proc_label.stdout.decode()
 12
 13# ~/~ begin <<README.md#imports>>[init]
 14import sys
 15import tomllib
 16from dataclasses import dataclass, field
 17from typing import Optional, List, Mapping, Tuple, Callable, TypeVar
 18from enum import Enum
 19import asyncio
 20import re
 21from contextlib import contextmanager, redirect_stdout
 22import textwrap
 23import io
 24# ~/~ end
 25# ~/~ begin <<README.md#boilerplate>>[init]
 26assert sys.version_info[0] == 3, "This script only works with Python 3."
 27
 28class ConfigError(Exception):
 29    pass
 30
 31T = TypeVar("T")
 32# ~/~ end
 33
 34# ~/~ begin <<README.md#relation>>[init]
 35class Relation(Enum):
 36    """Encodes ordinal relations among versions. Currently six operators are
 37    supported: `>=`, `<=`, `<`, `>`, `==`, `!=`.""" 
 38    GE = 1
 39    LE = 2
 40    LT = 3
 41    GT = 4
 42    EQ = 5
 43    NE = 6
 44
 45    def __str__(self):
 46        return {
 47            Relation.GE: ">=",
 48            Relation.LE: "<=",
 49            Relation.LT: "<",
 50            Relation.GT: ">",
 51            Relation.EQ: "==",
 52            Relation.NE: "!="}[self]
 53# ~/~ end
 54# ~/~ begin <<README.md#version>>[init]
 55@dataclass
 56class Version:
 57    """Stores a version in the form of a tuple of ints and an optional string extension.
 58    This class supports (in)equality operators listed in `Relation`."""
 59    number: tuple[int, ...]
 60    extra: Optional[str]
 61
 62    # ~/~ begin <<README.md#version-methods>>[init]
 63    def __lt__(self, other):
 64        for n, m in zip(self.number, other.number):
 65            if n < m:
 66                return True
 67            elif n > m:
 68                return False
 69        return False
 70
 71    def __gt__(self, other):
 72        return other < self
 73
 74    def __le__(self, other):
 75        for n, m in zip(self.number, other.number):
 76            if n < m:
 77                return True
 78            elif n > m:
 79                return False
 80        return True
 81
 82    def __ge__(self, other):
 83        return other <= self
 84
 85    def __eq__(self, other):
 86        for n, m in zip(self.number, other.number):
 87            if n != m:
 88                return False
 89            return True
 90
 91    def __ne__(self, other):
 92        return not self == other
 93
 94    def __str__(self):
 95        return ".".join(map(str, self.number)) + (self.extra or "")
 96    # ~/~ end
 97# ~/~ end
 98# ~/~ begin <<README.md#version-constraint>>[init]
 99@dataclass
100class VersionConstraint:
101    """A VersionConstraint is a product of a `Version` and a `Relation`."""
102    version: Version
103    relation: Relation
104
105    def __call__(self, other: Version) -> bool:
106        method = f"__{self.relation.name}__".lower()
107        return getattr(other, method)(self.version)
108
109    def __str__(self):
110        return f"{self.relation}{self.version}"
111# ~/~ end
112# ~/~ begin <<README.md#parsing>>[init]
113def split_at(split_chars: str, x: str) -> Tuple[str, str]:
114    """Tries to split at character `x`. Returns a 2-tuple of the string
115    before and after the given separator."""
116    a = x.split(split_chars, maxsplit=1)
117    if len(a) == 2:
118        return a[0], a[1]
119    else:
120        return a[0], ""
121
122
123def parse_split_f(split_chars: str, f: Callable[[str], T], x: str) \
124        -> Tuple[T, str]:
125    """Given a string, splits at given character `x` and passes the left value
126    through a function (probably a parser). The second half of the return tuple is the
127    remainder of the string."""
128    item, x = split_at(split_chars, x)
129    val = f(item)
130    return val, x
131
132
133def parse_version(x: str) -> Tuple[Version, str]:
134    """Parse a given string to a `Version`. A sequence of dot `.` separated integers
135    is put into the numerical version component, while the remaining text ends up in
136    the `extra` component."""
137    _x = x
138    number = []
139    extra = None
140
141    while True:
142        try:
143            n, _x = parse_split_f(".", int, _x)
144            number.append(n)
145        except ValueError:
146            if len(x) > 0:
147                m = re.match("([0-9]*)(.*)", _x)
148                if lastn := m and m.group(1):
149                    number.append(int(lastn))
150                if suff := m and m.group(2):
151                    extra = suff or None
152                else:
153                    extra = _x
154            break
155
156    if not number:
157        raise ConfigError(f"A version needs a numeric component, got: {x}")
158
159    return Version(tuple(number), extra), _x
160
161
162def parse_relation(x: str) -> Tuple[Relation, str]:
163    """Parses the operator of the version constraint."""
164    op_map = {
165        "<=": Relation.LE,
166        ">=": Relation.GE,
167        "<": Relation.LT,
168        ">": Relation.GT,
169        "==": Relation.EQ,
170        "!=": Relation.NE}
171    for sym, op in op_map.items():
172        if x.startswith(sym):
173            return (op, x[len(sym):])
174    raise ConfigError(f"Not a comparison operator: {x}")
175
176
177def parse_version_constraint(x: str) -> Tuple[VersionConstraint, str]:
178    relation, x = parse_relation(x)
179    version, x = parse_version(x)
180    return VersionConstraint(version, relation), x
181# ~/~ end
182# ~/~ begin <<README.md#running>>[init]
183def async_cache(f):
184    """Caches results from the `async` function `f`. This assumes `f` is a
185    member of a class, where we have `_lock`, `_result` and `_done` members
186    available."""
187    async def g(self, *args, **kwargs):
188        async with self._lock:
189            if self._done:
190                return self._result
191            self._result = await f(self, *args, **kwargs)
192            self._done = True
193            return self._result
194    return g
195# ~/~ end
196# ~/~ begin <<README.md#running>>[1]
197@dataclass
198class Result:
199    test: VersionTest
200    success: bool
201    failure_text: Optional[str] = None
202    found_version: Optional[Version] = None
203
204    def __bool__(self):
205        return self.success
206# ~/~ end
207# ~/~ begin <<README.md#running>>[2]
208@dataclass
209class VersionTest:
210    name: str
211    require: VersionConstraint
212    get_version: str
213    platform: Optional[str] = None
214    pattern: Optional[str] = None
215    suggestion_text: Optional[str] = None
216    suggestion: Optional[str] = None
217    depends: List[str] = field(default_factory=list)
218    template: Optional[str] = None
219
220    _lock: asyncio.Lock = field(default_factory=asyncio.Lock)
221    _done: bool = False
222
223    def print_formatted(self, msg):
224        prefix = f"{self.name} {self.require}"
225        print(f"{prefix:25}: {msg}")
226
227    def print_not_found(self):
228        self.print_formatted("not found")
229
230    @async_cache
231    async def run(self, recurse):
232        for dep in self.depends:
233            if not await recurse(dep):
234                return Result(self, False,
235                              failure_text=f"Failed dependency: {dep}")
236
237        proc = await asyncio.create_subprocess_shell(
238            self.get_version,
239            stdout=asyncio.subprocess.PIPE,
240            stderr=asyncio.subprocess.PIPE)
241        (stdout, stderr) = await proc.communicate()
242        if proc.returncode != 0:
243            self.print_not_found()
244            return Result(
245                self,
246                success=False,
247                failure_text=f"{stderr.decode().strip()}")
248        try:
249            if self.pattern is not None:
250                m = re.match(self.pattern, stdout.decode())
251                if m is not None:
252                    out, _ = parse_version(m.group(1).strip())
253                else:
254                    self.print_not_found()
255                    msg = f"No regex match on pattern '{self.pattern}'"
256                    return Result(self, False, failure_text=msg)
257            else:
258                out, _ = parse_version(stdout.decode().strip())
259        except ConfigError as e:
260            return Result(self, False, failure_text=str(e))
261
262        if self.require(out):
263            self.print_formatted(f"{str(out):10} Ok")
264            return Result(self, True)
265        else:
266            self.print_formatted(f"{str(out):10} Fail")
267            return Result(self, False, failure_text="Too old.",
268                          found_version=out)
269# ~/~ end
270# ~/~ begin <<README.md#running>>[3]
271def parse_config(name: str, config: Mapping[str, str], templates):
272    if "template" in config.keys():
273        _config = {}
274        if config["template"] not in templates.keys():
275            raise ConfigError(f"Template {config['template']} not found. Templates: {list(templates.keys())}")
276
277        for k, v in templates[config["template"]].items():
278            if isinstance(v, str):
279                _config[k] = v.format(name=name)
280            else:
281                _config[k] = v
282        _config.update(config)
283    else:
284        _config = dict(config)
285
286    _deps = map(str.strip, _config.get("depends", "").split(","))
287    deps = list(filter(lambda x: x != "", _deps))
288
289    assert "require" in _config, "Every item needs a `require` field"
290    assert "get_version" in _config, "Every item needs a `get_version` field"
291
292    require, _ = parse_version_constraint(_config["require"])
293
294    return VersionTest(
295        name=name,
296        require=require,
297        get_version=_config["get_version"],
298        platform=_config.get("platform", None),
299        pattern=_config.get("pattern", None),
300        suggestion_text=_config.get("suggestion_text", None),
301        suggestion=_config.get("suggestion", None),
302        depends=deps,
303        template=_config.get("template", None))
304# ~/~ end
305# ~/~ begin <<README.md#running>>[4]
306@contextmanager
307def indent(prefix: str):
308    f = io.StringIO()
309    with redirect_stdout(f):
310        yield
311    output = f.getvalue()
312    print(textwrap.indent(output, prefix), end="")
313# ~/~ end
314# ~/~ begin <<README.md#running>>[5]
315async def main():
316    config = tomllib.load(open("dependencies.toml", "rb"))
317
318    if "template" in config.keys():
319        templates = config["template"]
320        del config["template"]
321    else:
322        templates = dict()
323
324    try:
325        tests = {
326            name: parse_config(name, config[name], templates)
327            for name in config if ":" not in name and name != "DEFAULT"
328        }
329    except (AssertionError, ConfigError) as e:
330        print("Configuration error:", e)
331        sys.exit(1)
332
333    async def test_version(name: str):
334        assert name in tests, f"unknown dependency {name}"
335        x = await tests[name].run(test_version)
336        return x
337
338    result = await asyncio.gather(*(test_version(k) for k in tests))
339    if all(r.success for r in result):
340        print("Success")
341        sys.exit(0)
342    else:
343        print("Failure")
344        with indent("  |  "):
345            for r in (r for r in result if not r.success):
346                if r.failure_text:
347                    print(f"{r.test.name}: {r.failure_text}")
348                if r.found_version:
349                    print(f"    found version {r.found_version}")
350        sys.exit(1)
351
352
353if __name__ == "__main__":
354    asyncio.run(main())
355# ~/~ end
356# ~/~ end