name: str

def modify(self, prop: schema.Property):

if x is None:

return None

if isinstance(x, str):

return x

if not isinstance(cls, type):

raise schema.Error(f"Only class definitions allowed in schema, found {cls}")

# we must check that going to dbscheme names and back is preserved

# In particular this will not happen if uppercase acronyms are included in the name

to_underscore_and_back = inflection.camelize(inflection.underscore(cls.__name__), uppercase_first_letter=True)

if cls.__name__ != to_underscore_and_back:

raise schema.Error(f"Class name must be upper camel-case, without capitalized acronyms, found {cls.__name__} "

f"instead of {to_underscore_and_back}")

if len({b._group for b in cls.__bases__ if hasattr(b, "_group")}) > 1:

raise schema.Error(f"Bases with mixed groups for {cls.__name__}")

if any(getattr(b, "_null", False) for b in cls.__bases__):

raise schema.Error(f"Null class cannot be derived")

return schema.Class(name=cls.__name__,

bases=[b.__name__ for b in cls.__bases__ if b is not object],

derived={d.__name__ for d in cls.__subclasses__()},

# getattr to inherit from bases

group=getattr(cls, "_group", ""),

hideable=getattr(cls, "_hideable", False),

test_with=_get_name(getattr(cls, "_test_with", None)),

# in the following we don't use `getattr` to avoid inheriting

pragmas=cls.__dict__.get("_pragmas", []),

synth=cls.__dict__.get("_synth", None),

properties=[

a | _PropertyNamer(n)

for n, a in cls.__dict__.get("__annotations__", {}).items()

],

doc=schema.split_doc(cls.__doc__),

default_doc_name=cls.__dict__.get("_doc_name"),

groups = {}

ret = {}

for name, cls in classes.items():

groups.setdefault(cls.group, []).append(name)

for group, grouped in sorted(groups.items()):

inheritance = {name: classes[name].bases for name in grouped}

for name in toposort_flatten(inheritance):

ret[name] = classes[name]

""" Take a dictionary where the `synth` field is filled for all explicitly synthesized classes

if not classes:

return

is_synth: typing.Dict[str, bool] = {}

def fill_is_synth(name: str):

if name not in is_synth:

cls = classes[name]

for d in cls.derived:

fill_is_synth(d)

if cls.synth is not None:

is_synth[name] = True

elif not cls.derived:

is_synth[name] = False

else:

is_synth[name] = all(is_synth[d] for d in cls.derived)

root = next(iter(classes))

fill_is_synth(root)

for name, cls in classes.items():

if cls.synth is None and is_synth[name]:

""" Update the class map propagating the `hideable` attribute upwards in the hierarchy """

todo = [cls for cls in classes.values() if cls.hideable]

while todo:

cls = todo.pop()

for base in cls.bases:

supercls = classes[base]

if not supercls.hideable:

supercls.hideable = True

for cls in classes.values():

if cls.test_with is not None and classes[cls.test_with].test_with is not None:

raise schema.Error(f"{cls.name} has test_with {cls.test_with} which in turn "

includes = set()

classes = {}

known = {"int", "string", "boolean"}

known.update(n for n in m.__dict__ if not n.startswith("__"))

import misc.codegen.lib.schemadefs as defs

null = None

for name, data in m.__dict__.items():

if hasattr(defs, name):

continue

if name == "__includes":

includes = set(data)

continue

if name.startswith("__"):

continue

cls = _get_class(data)

if classes and not cls.bases:

raise schema.Error(

f"Only one root class allowed, found second root {name}")

cls.check_types(known)

classes[name] = cls

if getattr(data, "_null", False):

if null is not None:

raise schema.Error(f"Null class {null} already defined, second null class {name} not allowed")

null = name

cls.is_null_class = True

_fill_synth_information(classes)

_fill_hideable_information(classes)

_check_test_with(classes)

spec = importlib.util.spec_from_file_location("schema", path)

module = importlib.util.module_from_spec(spec)

spec.loader.exec_module(module)