def load_spec_from_schema(schema):
cfg = schema.get('cfg::Config')
settings = []
for ptr_name, p in cfg.get_pointers(schema).items(schema):
pn = str(ptr_name)
if pn in ('id', '__type__'):
continue
ptype = p.get_target(schema)
if ptype.is_object_type():
pytype = staeval.object_type_to_python_type(
ptype, schema, base_class=types.CompositeConfigType)
else:
pytype = staeval.schema_type_to_python_type(ptype, schema)
attributes = {
a: json.loads(v.get_value(schema))
for a, v in p.get_annotations(schema).items(schema)
}
ptr_card = p.get_cardinality(schema)
set_of = ptr_card.is_multi()
deflt = p.get_default(schema)
if deflt is not None:
deflt = qlcompiler.evaluate_to_python_val(deflt.text,
schema=schema)
if set_of and not isinstance(deflt, frozenset):
deflt = frozenset((deflt, ))
backend_setting = attributes.get(sn.QualName('cfg', 'backend_setting'),
None)
if deflt is None:
if set_of:
deflt = frozenset()
elif backend_setting is None:
raise RuntimeError(f'cfg::Config.{pn} has no default')
setting = Setting(
pn,
type=pytype,
set_of=set_of,
internal=attributes.get(sn.QualName('cfg', 'internal'), False),
system=attributes.get(sn.QualName('cfg', 'system'), False),
requires_restart=attributes.get(
sn.QualName('cfg', 'requires_restart'), False),
backend_setting=backend_setting,
report=attributes.get(sn.QualName('cfg', 'report'), None),
affects_compilation=attributes.get(
sn.QualName('cfg', 'affects_compilation'), False),
default=deflt,
)
settings.append(setting)
return Spec(*settings)
def load_spec_from_schema(schema):
cfg = schema.get('cfg::Config')
settings = []
for pn, p in cfg.get_pointers(schema).items(schema):
if pn in ('id', '__type__'):
continue
ptype = p.get_target(schema)
if ptype.is_object_type():
pytype = staeval.object_type_to_python_type(
ptype, schema, base_class=types.CompositeConfigType)
else:
pytype = staeval.schema_type_to_python_type(ptype, schema)
attributes = {
a: json.loads(v.get_value(schema))
for a, v in p.get_annotations(schema).items(schema)
}
set_of = p.get_cardinality(schema) is qltypes.SchemaCardinality.MANY
deflt = p.get_default(schema)
if deflt is not None:
deflt = qlcompiler.evaluate_to_python_val(deflt.text,
schema=schema)
if set_of and not isinstance(deflt, frozenset):
deflt = frozenset((deflt, ))
if deflt is None:
if set_of:
deflt = frozenset()
else:
raise RuntimeError(f'cfg::Config.{pn} has no default')
setting = Setting(
pn,
type=pytype,
set_of=set_of,
internal=attributes.get('cfg::internal', False),
system=attributes.get('cfg::system', False),
requires_restart=attributes.get('cfg::requires_restart', False),
backend_setting=attributes.get('cfg::backend_setting', None),
default=deflt,
)
settings.append(setting)
return Spec(*settings)
def object_type_to_python_type(
objtype: s_types.Type,
schema: s_schema.Schema,
*,
base_class: typing.Optional[type] = None,
_memo: typing.Optional[typing.Mapping[s_types.Type,
type]] = None) -> type:
if _memo is None:
_memo = {}
fields = []
subclasses = []
for pn, p in objtype.get_pointers(schema).items(schema):
if pn in ('id', '__type__'):
continue
ptype = p.get_target(schema)
if ptype.is_object_type():
pytype = _memo.get(ptype)
if pytype is None:
pytype = object_type_to_python_type(ptype,
schema,
base_class=base_class,
_memo=_memo)
_memo[ptype] = pytype
for subtype in ptype.children(schema):
subclasses.append(
object_type_to_python_type(subtype,
schema,
base_class=pytype,
_memo=_memo))
else:
pytype = scalar_type_to_python_type(ptype, schema)
is_multi = p.get_cardinality(schema) is qltypes.Cardinality.MANY
if is_multi:
pytype = typing.FrozenSet[pytype]
default = p.get_default(schema)
if default is None:
if p.get_required(schema):
default = dataclasses.MISSING
else:
default = ql_compiler.evaluate_to_python_val(default.text,
schema=schema)
if is_multi and not isinstance(default, frozenset):
default = frozenset((default, ))
constraints = p.get_constraints(schema).objects(schema)
exclusive = schema.get('std::exclusive')
unique = (not ptype.is_object_type() and any(
c.issubclass(schema, exclusive) for c in constraints))
field = dataclasses.field(
compare=unique,
hash=unique,
repr=True,
default=default,
)
fields.append((pn, pytype, field))
return dataclasses.make_dataclass(
objtype.get_name(schema).name,
fields=fields,
bases=(base_class, ) if base_class is not None else (),
frozen=True,
namespace={'_subclasses': subclasses},
)
def object_type_to_python_type(
objtype: s_objtypes.ObjectType,
schema: s_schema.Schema,
*,
base_class: Optional[type] = None,
_memo: Optional[Dict[s_types.Type, type]] = None,
) -> type:
if _memo is None:
_memo = {}
default: Any
fields = []
subclasses = []
for pn, p in objtype.get_pointers(schema).items(schema):
str_pn = str(pn)
if str_pn in ('id', '__type__'):
continue
ptype = p.get_target(schema)
assert ptype is not None
if isinstance(ptype, s_objtypes.ObjectType):
pytype = _memo.get(ptype)
if pytype is None:
pytype = object_type_to_python_type(
ptype, schema, base_class=base_class, _memo=_memo)
_memo[ptype] = pytype
for subtype in ptype.children(schema):
subclasses.append(
object_type_to_python_type(
subtype, schema,
base_class=pytype, _memo=_memo))
else:
pytype = scalar_type_to_python_type(ptype, schema)
ptr_card = p.get_cardinality(schema)
is_multi = ptr_card.is_multi()
if is_multi:
pytype = FrozenSet[pytype] # type: ignore
default = p.get_default(schema)
if default is None:
if p.get_required(schema):
default = dataclasses.MISSING
else:
default = qlcompiler.evaluate_to_python_val(
default.text, schema=schema)
if is_multi and not isinstance(default, frozenset):
default = frozenset((default,))
constraints = p.get_constraints(schema).objects(schema)
exclusive = schema.get('std::exclusive', type=s_constr.Constraint)
unique = (
not ptype.is_object_type()
and any(c.issubclass(schema, exclusive) for c in constraints)
)
field = dataclasses.field(
compare=unique,
hash=unique,
repr=True,
default=default,
)
fields.append((str_pn, pytype, field))
bases: Tuple[type, ...]
if base_class is not None:
bases = (base_class,)
else:
bases = ()
ptype_dataclass = dataclasses.make_dataclass(
objtype.get_name(schema).name,
fields=fields,
bases=bases,
frozen=True,
namespace={'_subclasses': subclasses},
)
assert isinstance(ptype_dataclass, type)
return ptype_dataclass
