def test_odd_identifiers(self):
t = cast(JSGPairDef, parse("'String' : INT", "pairDef", JSGPairDef))
self.assertEqual('pairDef: String : valueType: LEXER_ID_REF: INT',
str(t))
self.assertEqual([('String', 'INT')], t.members_entries())
self.assertEqual([('String', 'typing.Optional[INT]')],
t.members_entries(True))
self.assertEqual(['String: str = None'], t.signatures())
self.assertEqual(['self.String = String'], t.initializers())
self.assertEqual("pairDef: String : valueType: LEXER_ID_REF: INT",
str(t))
t = cast(JSGPairDef, parse("'def' : INT", "pairDef", JSGPairDef))
self.assertEqual('pairDef: def : valueType: LEXER_ID_REF: INT', str(t))
self.assertEqual([('def', 'INT')], t.members_entries())
self.assertEqual(['def_: str = None'], t.signatures())
self.assertEqual([
"setattr(self, 'def', def_ if def_ is not None else _kwargs.get('def', None))"
], t.initializers())
self.assertEqual("pairDef: def : valueType: LEXER_ID_REF: INT", str(t))
t = cast(JSGPairDef, parse("'a var' : @number", "pairDef", JSGPairDef))
self.assertEqual(
"pairDef: a var : valueType: builtinValueType: @number", str(t))
self.assertEqual([('a var', 'jsg.Number')], t.members_entries())
self.assertEqual([], t.signatures())
self.assertEqual(
["setattr(self, 'a var', _kwargs.get('a var', None))"],
t.initializers())
def test_single_option(self):
t = cast(JSGDocParser, parse("macro = labeledShapeOr ; labeledShapeOr {}", "doc", JSGDocParser))
exec(t.as_python(self.__class__.__name__), dict())
t = cast(JSGDocParser, parse("macro = a:@int | b:@int ;", "doc", JSGDocParser))
exec(t.as_python(self.__class__.__name__), dict())
t = cast(JSGDocParser, parse("macro = a| b ; a {} b {}", "doc", JSGDocParser))
exec(t.as_python(self.__class__.__name__), dict())
def test_array(self):
t = cast(JSGValueType,
parse('id = [.] ;', "valueTypeMacro", JSGValueType))
self.assertEqual(
'valueType: arrayExpr: [valueType: builtinValueType: jsg.AnyType]',
str(t))
self.assertEqual([], t.dependency_list())
self.assertEqual([], t.members_entries())
self.assertEqual('typing.List[object]', t.python_type())
self.assertEqual(
"jsg.ArrayFactory('{name}', _CONTEXT, jsg.AnyTypeFactory('{name}', _CONTEXT), 0, None)",
t.signature_type())
self.assertEqual('None', t.mt_value())
t = cast(
JSGValueType,
parse('id = [@int | "AB*" +] ;', "valueTypeMacro", JSGValueType))
self.assertEqual(
"valueType: arrayExpr: [(valueType: builtinValueType: "
"@int | valueType: STRING: pattern: r'AB\*')+]", str(t))
self.assertEqual(['_Anon1'], t.dependency_list())
self.assertEqual([], t.members_entries())
self.assertEqual('typing.List[typing.Union[int, str]]',
t.python_type())
self.assertEqual(
"jsg.ArrayFactory('{name}', _CONTEXT, typing.Union[jsg.Integer, _Anon1], 1, None)",
t.signature_type())
self.assertEqual('None', t.mt_value())
def test_ref_escapes(self):
self.assertEqual(
"Undefined(Class)",
cast(JSGValueType, parse("Class", "valueType",
JSGValueType)).signature_type())
t = cast(JSGValueType, parse("class", "valueType", JSGValueType))
self.assertEqual("Undefined(class_)", t.signature_type())
self.assertEqual("Undefined(class_)", t.python_type())
self.assertEqual([], t.members_entries())
def test_basics(self):
ty = cast(JSGValueType, parse('"[a-z]+"', 'valueType', JSGValueType))
for te in self.tests:
t = cast(JSGEbnf, parse(te.text, "ebnfSuffix", JSGEbnf))
self.assertEqual(str(t), te.text.replace(' ', ''))
self.assertEqual(te.min, t.min, te.text)
self.assertEqual(te.max, t.max, te.text)
self.assertEqual(te.ptype, t.python_cardinality("k"), te.text)
self.assertEqual(te.stype, t.signature_cardinality("k"), te.text)
self.assertEqual(te.oneopt, t.one_optional_element, te.text)
self.assertEqual(te.mult, t.multiple_elements, te.text)
def test_all_optional(self):
t = cast(JSGEbnf, parse('?', 'ebnfSuffix', JSGEbnf))
self.assertEqual('typing.Optional[k]', t.python_cardinality('k', True))
self.assertEqual("typing.Optional[k]",
t.signature_cardinality('k', True))
t = cast(JSGEbnf, parse('+', 'ebnfSuffix', JSGEbnf))
self.assertEqual('typing.Optional[typing.List[k]]',
t.python_cardinality('k', True))
self.assertEqual(
"typing.Optional[jsg.ArrayFactory('{name}', _CONTEXT, k, 1, None)]",
t.signature_cardinality('k', True))
def test_1(self):
outf = StringIO()
with redirect_stderr(outf):
d = cast(JSGDocParser, parse("a a {}", "objectDef", JSGDocParser))
self.assertIsNone(d)
self.assertEqual("line 1:2 extraneous input 'a' expecting OBRACE",
outf.getvalue().strip())
def test_pairdef_valuetype_ref(self):
text = "nonobj = {a:@string b:@number?}; obj = {nonobj}"
t = cast(JSGPairDef, parse(text, "grammarElt", JSGPairDef))
self.assertEqual([
'a: typing.Optional[float] = None',
'b: typing.Optional[float] = None'
], t.signatures())
def test_pairdef_builtins(self):
for text, sig, init, s in builtins:
t = cast(JSGPairDef, parse(text, "pairDef", JSGPairDef))
self.assertEqual(sig, t.signatures())
self.assertEqual(init, t.initializers())
self.assertEqual(s, str(t))
self.assertEqual([], t.dependency_list())
self.assertEqual([('k', 'jsg.String')], t.members_entries())
def test_options(self):
txt = "exclusions [(objectValue|LanguageStem) +]"
t = cast(JSGArrayExpr, parse(txt, "arrayDef", JSGArrayExpr))
self.check(t, (
'arrayExpr: [valueType: (Undefined(objectValue) | Undefined(LanguageStem))+]',
'typing.List[typing.Union[Undefined(objectValue), Undefined(LanguageStem)]]',
['objectValue', 'LanguageStem'],
"jsg.ArrayFactory('{name}', _CONTEXT, typing.Union[Undefined(objectValue), Undefined(LanguageStem)], 1, None)",
'None', []))
def test_objectmacro_opts(self):
t = cast(
JSGValueType,
parse("a = @string | KT | {} ;", "valueTypeMacro", JSGValueType))
self.assertEqual('valueType: (jsg.String | KT | _Anon1)', str(t))
self.assertEqual('typing.Union[jsg.String, KT, _Anon1]',
t.signature_type())
self.assertEqual('typing.Union[str, str, _Anon1]', t.python_type())
self.assertEqual('None', t.mt_value())
self.assertEqual([], t.members_entries())
def test_simple_pairdef(self):
for text, sig, py, deps, sigs, memins, v in tests:
t = cast(JSGPairDef, parse(text, "pairDef", JSGPairDef))
self.assertEqual(v, str(t))
self.assertEqual(sig, t.signature_type(), text)
self.assertEqual(py, t.python_type(), text)
self.assertEqual(deps, t.dependency_list(), text)
self.assertEqual(sigs, t.signatures(), text)
self.assertEqual(memins, t.members_entries(), text)
self.assertEqual(initializers[text], t.initializers())
def test1(self):
i = 0
for text, k, rslt, s in tests:
i += 1
t = cast(JSGLexerRuleBlock,
parse(terminals + text, "lexerRules", JSGLexerRuleBlock))
self.assertEqual(s, str(t))
t_python = t.as_python(k)
self.assertEqual(rslt, t_python.strip())
exec(t_python, globals(), locals())
def test_multi_types(self):
txt = "x [objectValue | languageStem {3,7}]"
t = cast(JSGArrayExpr, parse(txt, "arrayDef", JSGArrayExpr))
self.check(t, (
'arrayExpr: [(valueType: ID: objectValue | valueType: ID: '
'languageStem){3,7}]',
'typing.List[typing.Union[Undefined(objectValue), Undefined(languageStem)]]',
['objectValue', 'languageStem'],
"jsg.ArrayFactory('{name}', _CONTEXT, typing.Union[Undefined(objectValue), Undefined(languageStem)], 3, 7)",
'None', []))
def test_any(self):
t = cast(JSGValueType, parse("id = .;", "valueTypeMacro",
JSGValueType))
self.assertEqual("object", t.python_type())
self.assertEqual("jsg.AnyTypeFactory('{name}', _CONTEXT)",
t.signature_type())
self.assertEqual("jsg.Empty", t.mt_value())
self.assertEqual([], t.members_entries())
self.assertEqual([], t.dependency_list())
self.assertEqual("valueType: builtinValueType: jsg.AnyType", str(t))
def test_basics(self):
d = cast(JSGDocParser,
parse('a ' + test_entries[0][0], "objectDef", JSGDocParser))
t = d._context.reference('a')
self.assertEqual("None", t.mt_value())
for te in test_entries:
text = "a " + te[0]
e = te[1]
d = cast(JSGDocParser, parse(text, "objectDef", JSGDocParser))
self.assertIsNotNone(d, f"Parse error: {text}")
t = d._context.reference('a')
self.assertEqual(e.name, str(t))
self.assertEqual('a', t.signature_type(), text)
self.assertEqual('a', t.python_type(), text)
self.assertEqual(e.deps, t.dependency_list(), text)
self.assertEqual(e.sigs, t.signatures(), text)
self.assertEqual(e.membs, t.members_entries(), text)
self.assertEqual(e.inits, t.initializers(), text)
def test_lexeridref(self):
t = cast(JSGValueType,
parse('("[a-z]*" | "0-9*")', "valueType", JSGValueType))
self.assertEqual(
"valueType: STRING: pattern: r'(\[a\-z\]\*)|(0\-9\*)'", str(t))
self.assertEqual("_Anon1", t.signature_type())
self.assertEqual("str", t.python_type())
self.assertEqual("None", t.mt_value())
self.assertEqual([], t.members_entries())
t = cast(JSGValueType,
parse('("[a-z]*" | "0-9*" | ID)', "valueType", JSGValueType))
self.assertEqual(
"valueType: ((STRING: pattern: r'(\[a\-z\]\*)|(0\-9\*)') | ID)",
str(t))
self.assertEqual("typing.Union[_Anon1, ID]", t.signature_type())
self.assertEqual("typing.Union[str, str]", t.python_type())
self.assertEqual("None", t.mt_value())
self.assertEqual([], t.members_entries())
def test_anon_typeid(self):
t = cast(JSGValueType,
parse("{a: @int b: @string+}", "valueType", JSGValueType))
self.assertEqual(
'valueType: (anonymous: _Anon1): objectExpr: simple object',
str(t))
self.assertEqual('_Anon1', t.signature_type())
self.assertEqual('_Anon1', t.python_type())
self.assertEqual('None', t.mt_value())
self.assertEqual([], t.members_entries())
def test_builtins(self):
for text, sig, typ_, mt_typ in builtin_tests:
t = cast(JSGValueType, parse(text, "valueType", JSGValueType))
self.assertEqual(sig, t.signature_type(), text)
self.assertEqual(typ_, t.python_type(), text)
self.assertEqual(
f"valueType: builtinValueType: {'jsg.AnyType' if text == '.' else text}",
str(t), text)
self.assertEqual(mt_typ, t.mt_value(), text)
self.assertEqual([], t.members_entries(), text)
self.assertEqual([], t.dependency_list(), text)
def test_anonymous_entries(self):
for te in test_entries:
e = te[2]
t = cast(JSGObjectExpr, parse(te[0], "objectExpr", JSGObjectExpr))
self.assertIsNotNone(t, f"Parse error: {e.text}")
self.assertEqual(e.name, str(t))
self.assertEqual('_Anon1', t.signature_type(), e.text)
self.assertEqual('_Anon1', t.python_type(), e.text)
self.assertEqual(e.deps, t.dependency_list(), e.text)
self.assertEqual(e.sigs, t.signatures(), e.text)
self.assertEqual(e.membs, t.members_entries(), e.text)
self.assertEqual(e.inits, t.initializers(), e.text)
def test_basics(self):
t = cast(JSGArrayExpr, parse("id [@string] ", "arrayDef",
JSGArrayExpr))
self.check(
t, ('arrayExpr: [valueType: builtinValueType: @string]',
'typing.List[str]', [],
"jsg.ArrayFactory('{name}', _CONTEXT, jsg.String, 0, None)",
'None', []))
t = cast(JSGArrayExpr, parse("id [@int] ", "arrayDef", JSGArrayExpr))
self.check(
t, ('arrayExpr: [valueType: builtinValueType: @int]',
'typing.List[int]', [],
"jsg.ArrayFactory('{name}', _CONTEXT, jsg.Integer, 0, None)",
'None', []))
t = cast(JSGArrayExpr, parse("id [.] ", "arrayDef", JSGArrayExpr))
self.check(t, (
'arrayExpr: [valueType: builtinValueType: jsg.AnyType]',
'typing.List[object]', [],
"jsg.ArrayFactory('{name}', _CONTEXT, jsg.AnyTypeFactory('{name}', _CONTEXT), 0, None)",
'None', []))
t = cast(JSGArrayExpr,
parse("id [(Aa|BB|'foo')] ", "arrayDef", JSGArrayExpr))
self.check(t, (
"arrayExpr: [valueType: ((STRING: pattern: r'foo') | Undefined(Aa) | BB)]",
'typing.List[typing.Union[str, Undefined(Aa), str]]',
['_Anon1', 'Aa', 'BB'],
"jsg.ArrayFactory('{name}', _CONTEXT, typing.Union[_Anon1, Undefined(Aa), BB], 0, None)",
'None', []))
t = cast(JSGArrayExpr,
parse("id [(Aa|BB|'foo'){0,}] ", "arrayDef", JSGArrayExpr))
self.check(t, (
"arrayExpr: [valueType: ((STRING: pattern: r'foo') | Undefined(Aa) | BB){0,}]",
'typing.List[typing.Union[str, Undefined(Aa), str]]',
['_Anon1', 'Aa', 'BB'],
"jsg.ArrayFactory('{name}', _CONTEXT, typing.Union[_Anon1, Undefined(Aa), BB], 0, None)",
'None', []))
def test_refs(self):
for text, typ in ref_tests:
t = cast(JSGValueType, parse(text, "valueType", JSGValueType))
self.assertEqual(
f'Undefined({text})' if typ != 'LEXER_ID_REF' else text,
t.signature_type())
self.assertEqual(
f'Undefined({text})' if typ != 'LEXER_ID_REF' else 'str',
t.python_type())
self.assertEqual(f"valueType: {typ}: {text}", str(t))
self.assertEqual([text], t.dependency_list())
self.assertEqual([], t.members_entries())
self.assertEqual("None", t.mt_value())
def test_alternatives(self):
t = cast(JSGValueType,
parse("id = ('x'|'y') ;", "valueTypeMacro", JSGValueType))
self.assertEqual("_Anon1", t.signature_type())
self.assertEqual("str", t.python_type())
self.assertEqual("valueType: STRING: pattern: r'(x)|(y)'", str(t))
t = cast(
JSGValueType,
parse("id = (Aa | Bb | (Cc | Dd)) ;", "valueTypeMacro",
JSGValueType))
self.assertEqual(
"typing.Union[Undefined(Aa), Undefined(Bb), typing.Union[Undefined(Cc), Undefined(Dd)]]",
t.signature_type())
self.assertEqual(
"typing.Union[Undefined(Aa), Undefined(Bb), typing.Union[Undefined(Cc), Undefined(Dd)]]",
t.python_type())
self.assertEqual(t.dependency_list(), ['Aa', 'Bb', 'Cc', 'Dd'])
self.assertEqual(
"valueType: (Undefined(Aa) | Undefined(Bb) | typing.Union[Undefined(Cc), Undefined(Dd)])",
str(t))
self.assertEqual([], t.members_entries())
t = cast(
JSGValueType,
parse("id = (Aa | Bb | 'foo' | (Cc | Dd) | 'bar') ;",
"valueTypeMacro", JSGValueType))
self.assertEqual(
"typing.Union[_Anon1, Undefined(Aa), Undefined(Bb), "
"typing.Union[Undefined(Cc), Undefined(Dd)]]", t.signature_type())
self.assertEqual(
"typing.Union[str, Undefined(Aa), Undefined(Bb), typing.Union[Undefined(Cc), Undefined(Dd)]]",
t.python_type())
self.assertEqual(['_Anon1', 'Aa', 'Bb', 'Cc', 'Dd'],
t.dependency_list())
self.assertEqual(
"valueType: ((STRING: pattern: r'(foo)|(bar)') | Undefined(Aa) | Undefined(Bb) | "
"typing.Union[Undefined(Cc), Undefined(Dd)])", str(t))
def test_opt_choice_branch(self):
text = '{id: @string |}'
t = cast(JSGObjectExpr, parse(text, 'objectExpr', JSGObjectExpr))
self.assertIsNotNone(t, f"Parse error")
self.assertEqual('objectExpr: object choices', str(t))
self.assertEqual('_Anon1', t.signature_type(), text)
self.assertEqual('_Anon1', t.python_type(), text)
self.assertEqual(['_Anon1_1_', '_Anon1_2_'], t.dependency_list(), text)
self.assertEqual(['opts_: typing.Union[_Anon1_1_, _Anon1_2_] = None'],
t.signatures(), text)
self.assertEqual([('id', 'typing.Optional[jsg.String]')],
t.members_entries(), text)
self.assertEqual([
'if opts_ is not None:', ' if isinstance(opts_, _Anon1_1_):',
' self.id = opts_.id',
' elif isinstance(opts_, _Anon1_2_):', ' pass',
' else:',
' raise ValueError(f"Unrecognized value type: {opts_}")'
], t.initializers(), text)
def test_pairdef_reference(self):
text = """
Patient {name: @string+ age: @int}
b {Patient*}
"""
d = cast(JSGDocParser, parse(text, "doc", JSGDocParser))
self.assertIsNotNone(d)
t = d._context.reference('b')
self.assertEqual('objectExpr: simple object', str(t))
self.assertEqual(['name: typing.List[str] = None', 'age: int = None'],
t.signatures())
self.assertEqual(['self.name = name', 'self.age = age'],
t.initializers())
self.assertEqual(['Patient'], t.dependency_list())
self.assertEqual([(
'name',
"jsg.ArrayFactory('name', _CONTEXT, jsg.ArrayFactory('name', _CONTEXT, jsg.String, 1, None), 0, None)"
), ('age', "jsg.ArrayFactory('age', _CONTEXT, jsg.Integer, 0, None)")],
t.members_entries())
self.assertEqual('None', t.mt_value())
def test_pairdef_shorthand(self):
text = "(x1 'v 2' 'class') : @number {3,17}"
t = cast(JSGPairDef, parse(text, "pairDef", JSGPairDef))
self.assertEqual([
'x1: typing.List[float] = None',
'class_: typing.List[float] = None'
], t.signatures())
self.assertEqual([
'self.x1 = x1', "setattr(self, 'v 2', _kwargs.get('v 2', None))",
"setattr(self, 'class', class_ if class_ is not None else "
"_kwargs.get('class', None))"
], t.initializers())
self.assertEqual(
"pairDef: (x1 | v 2 | class) : valueType: builtinValueType: @number{3,17}",
str(t))
self.assertEqual([], t.dependency_list())
text = "(x1 'v 2' 'class') : @bool ?"
t = cast(JSGPairDef, parse(text, "pairDef", JSGPairDef))
self.assertEqual([
'x1: typing.Optional[bool] = None',
'class_: typing.Optional[bool] = None'
], t.signatures())
self.assertEqual([
'self.x1 = x1', "setattr(self, 'v 2', _kwargs.get('v 2', None))",
"setattr(self, 'class', class_ if class_ is not None else _kwargs.get('class', None))"
], t.initializers())
self.assertEqual(
"pairDef: (x1 | v 2 | class) : valueType: builtinValueType: @bool?",
str(t))
self.assertEqual([], t.dependency_list())
self.assertEqual([('x1', 'typing.Optional[jsg.Boolean]'),
('v 2', 'typing.Optional[jsg.Boolean]'),
('class', 'typing.Optional[jsg.Boolean]')],
t.members_entries())
text = "(x1 'v 2' 'class') : @null"
t = cast(JSGPairDef, parse(text, "pairDef", JSGPairDef))
self.assertEqual(
['x1: type(None) = jsg.Empty', 'class_: type(None) = jsg.Empty'],
t.signatures())
self.assertEqual([
'self.x1 = x1',
"setattr(self, 'v 2', _kwargs.get('v 2', jsg.Empty))",
"setattr(self, 'class', class_ if class_ is not jsg.Empty else _kwargs.get('class', jsg.Empty))"
], t.initializers())
self.assertEqual(
"pairDef: (x1 | v 2 | class) : valueType: builtinValueType: @null",
str(t))
self.assertEqual([], t.dependency_list())
self.assertEqual([('x1', 'jsg.JSGNull'), ('v 2', 'jsg.JSGNull'),
('class', 'jsg.JSGNull')], t.members_entries())
text = "(def 'v 2' class) : @null"
t = cast(JSGPairDef, parse(text, "pairDef", JSGPairDef))
self.assertEqual([
"setattr(self, 'def', def_ if def_ is not jsg.Empty else _kwargs.get('def', "
'jsg.Empty))',
"setattr(self, 'v 2', _kwargs.get('v 2', jsg.Empty))",
"setattr(self, 'class', class_ if class_ is not jsg.Empty else "
"_kwargs.get('class', jsg.Empty))"
], t.initializers())
def test_double_optional(self):
t = cast(JSGEbnf, parse('?', 'ebnfSuffix', JSGEbnf))
self.assertEqual('typing.Optional[k]',
t.python_cardinality('typing.Optional[k]'))
self.assertEqual('typing.Optional[k]',
t.signature_cardinality('typing.Optional[k]'))
def test_objectmacro(self):
t = cast(
JSGObjectExpr,
parse(
"stringFacet = (length minlength maxlength):"
"INTEGER pattern:STRING flags:STRING? ;", "objectMacro",
JSGObjectExpr))
self.assertEqual(
"""class stringFacet(jsg.JSGObject):
_reference_types = []
_members = {'length': INTEGER,
'minlength': INTEGER,
'maxlength': INTEGER,
'pattern': STRING,
'flags': typing.Optional[STRING]}
_strict = True
def __init__(self,
length: str = None,
minlength: str = None,
maxlength: str = None,
pattern: str = None,
flags: typing.Optional[str] = None,
**_kwargs: typing.Dict[str, object]):
super().__init__(_CONTEXT, **_kwargs)
self.length = length
self.minlength = minlength
self.maxlength = maxlength
self.pattern = pattern
self.flags = flags""",
t.as_python('stringFacet').strip())
self.assertEqual(['INTEGER', 'STRING'], t.dependency_list())
t = cast(
JSGObjectExpr,
parse(
"stringFacet = (length minlength maxlength):INTEGER "
"pattern:STRING | flags:STRING? ;", "objectMacro",
JSGObjectExpr))
self.assertEqual(
"""class stringFacet(jsg.JSGObject):
_reference_types = [_Anon1_1_, _Anon1_2_]
_members = {'length': typing.Optional[INTEGER],
'minlength': typing.Optional[INTEGER],
'maxlength': typing.Optional[INTEGER],
'pattern': typing.Optional[STRING],
'flags': typing.Optional[STRING]}
_strict = True
def __init__(self,
opts_: typing.Union[_Anon1_1_, _Anon1_2_] = None,
**_kwargs: typing.Dict[str, object]):
super().__init__(_CONTEXT, **_kwargs)
if opts_ is not None:
if isinstance(opts_, _Anon1_1_):
self.length = opts_.length
self.minlength = opts_.minlength
self.maxlength = opts_.maxlength
self.pattern = opts_.pattern
elif isinstance(opts_, _Anon1_2_):
self.flags = opts_.flags
else:
raise ValueError(f"Unrecognized value type: {opts_}")""",
t.as_python('stringFacet').strip())
self.assertEqual(['INTEGER', 'STRING', '_Anon1_1_', '_Anon1_2_'],
t.dependency_list())
t = cast(
JSGObjectExpr,
parse("x = a:@number | b:@null | ;", "objectMacro", JSGObjectExpr))
self.assertEqual(
"""class stringFacet(jsg.JSGObject):
_reference_types = [_Anon1_1_, _Anon1_2_, _Anon1_3_]
_members = {'a': typing.Optional[jsg.Number],
'b': typing.Optional[jsg.JSGNull]}
_strict = True
def __init__(self,
opts_: typing.Union[_Anon1_1_, _Anon1_2_, _Anon1_3_] = None,
**_kwargs: typing.Dict[str, object]):
super().__init__(_CONTEXT, **_kwargs)
if opts_ is not None:
if isinstance(opts_, _Anon1_1_):
self.a = opts_.a
elif isinstance(opts_, _Anon1_2_):
self.b = opts_.b
elif isinstance(opts_, _Anon1_3_):
pass
else:
raise ValueError(f"Unrecognized value type: {opts_}")""",
t.as_python('stringFacet').strip())
self.assertEqual(['_Anon1_1_', '_Anon1_2_', '_Anon1_3_'],
t.dependency_list())
def test_literals(self):
t = cast(JSGValueType, parse("'literal'", "valueType", JSGValueType))
self.assertEqual("_Anon1", t.signature_type())
self.assertEqual("str", t.python_type())
self.assertEqual("valueType: STRING: pattern: r'literal'", str(t))
