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