1import importlib
  2import re
  3
  4
  5class BridgeKeeper:
  6    def __init__(self, module_name):
  7        self.module_name = module_name
  8
  9    def __enter__(self):
 10        module = importlib.import_module(self.module_name)
 11        allowed = {}
 12
 13        for name in dir(module):
 14            obj = getattr(module, name)
 15
 16            if (
 17                self._passes_name(obj)
 18                and self._passes_callable(obj)
 19                and self._passes_third_question(obj)
 20            ):
 21                allowed[name] = obj
 22
 23        return FilteredModule(allowed)
 24
 25    def __exit__(self, exc_type, exc, tb):
 26        return False
 27
 28    def _passes_name(self, obj):
 29        if not hasattr(obj, "__name__"):
 30            return False
 31        name = obj.__name__
 32        return isinstance(name, str) and name[:1].isupper()
 33
 34    def _passes_callable(self, obj):
 35        if not callable(obj):
 36            return False
 37
 38        params = self._parse_docstring(obj)
 39
 40        try:
 41            args = [self._dummy_value(t) for t in params]
 42            obj(*args)
 43            return True
 44        except Exception:
 45            return False
 46
 47    def _parse_docstring(self, obj):
 48        doc = obj.__doc__
 49        if not doc:
 50            return []
 51
 52        match = re.search(r"Parameters\s*-+\s*((?:.+\n)+?)(?:\n\s*\n|$)", doc)
 53        if not match:
 54            return []
 55
 56        params_block = match.group(1)
 57        types = re.findall(r"\w+\s*:\s*([^\n]+)", params_block)
 58
 59        return [t.strip() for t in types]
 60
 61    def _dummy_value(self, type_str):
 62        # union
 63        if "|" in type_str:
 64            type_str = type_str.split("|")[0].strip()
 65
 66        if type_str.startswith("list["):
 67            inner = type_str[5:-1]
 68            return [self._dummy_value(inner)]
 69
 70        if type_str.startswith("tuple["):
 71            inner = type_str[6:-1]
 72            return (self._dummy_value(inner),)
 73
 74        if type_str.startswith("set["):
 75            inner = type_str[4:-1]
 76            return {self._dummy_value(inner)}
 77
 78        if type_str.startswith("dict["):
 79            inner = type_str[5:-1]
 80            k, v = map(str.strip, inner.split(","))
 81            return {self._dummy_value(k): self._dummy_value(v)}
 82
 83        mapping = {
 84            "int": 1,
 85            "float": 1.0,
 86            "str": "a",
 87            "bool": True,
 88        }
 89
 90        return mapping.get(type_str, None)
 91
 92    def _passes_third_question(self, obj):
 93        for attr in dir(obj):
 94            if attr.startswith("__") and attr.endswith("__"):
 95                continue
 96
 97            if self._valid_attribute_name(attr):
 98                return True
 99
100        return False
101
102    def _valid_attribute_name(self, name):
103        if re.search(r"[aeiou]{4,}", name):
104            return False
105
106        letters = [c for c in name if c.isalpha()]
107        if not letters:
108            return False
109
110        return letters[-1].isupper()
111
112
113class FilteredModule:
114    def __init__(self, allowed):
115        self._allowed = allowed
116
117    def __getattr__(self, name):
118        if name in self._allowed:
119            return self._allowed[name]
120        raise AttributeError(f"{name} is not allowed")
121
122    def __dir__(self):
123        return list(self._allowed.keys())