def __init__(self):
assert isinstance(self.descriptions,
list), 'Invalid descriptions %s' % self.descriptions
assert isinstance(
self.charSet,
str), 'Invalid character set encoding %s' % self.charSet
assert isinstance(self.type,
str), 'Invalid content type %s' % self.type
resolvers = resolversFor(dict(Definition=Definition))
for verifier, descriptions, data in self.descriptions:
assert isinstance(verifier,
IVerifier), 'Invalid verifier %s' % verifier
assert isinstance(descriptions,
tuple), 'Invalid descriptions %s' % descriptions
assert isinstance(data, dict), 'Invalid data %s' % data
if __debug__:
for desc in descriptions:
assert isinstance(desc,
str), 'Invalid description %s' % desc
verifier.prepare(resolvers)
for value in data.values():
if isinstance(value, IValue):
assert isinstance(value, IValue)
value.prepare(resolvers)
super().__init__(**resolvers)
def introspectProcessing() -> Processing:
assert introspectContexts(), 'At least a set of contexts is required'
contexts = iter(introspectContexts())
resolvers = resolversFor(next(contexts))
for context in contexts: solve(resolvers, context)
return assemblyIntrospection().create(**resolvers)
def resolversForDescriptions(descriptions):
'''
Creates the resolvers for the provided descriptions verifiers.
:param descriptions: The descriptions to use on the definition in order to index the description for definition.
:type descriptions: list[tuple(IVerifier, tuple(string), dictionary{string: object})]
:returns: dictionary{string: IResolver} -- The resolved dictionary.
'''
assert isinstance(descriptions,
list), 'Invalid descriptions %s' % descriptions
resolvers = resolversFor(dict(Definition=Definition))
for verifier, descriptions, data in descriptions:
assert isinstance(verifier,
IVerifier), 'Invalid verifier %s' % verifier
assert isinstance(descriptions,
tuple), 'Invalid descriptions %s' % descriptions
assert isinstance(data, dict), 'Invalid data %s' % data
if __debug__:
for desc in descriptions:
assert isinstance(desc, str), 'Invalid description %s' % desc
verifier.prepare(resolvers)
for value in data.values():
if isinstance(value, IValue):
assert isinstance(value, IValue)
value.prepare(resolvers)
return resolvers
def __init__(self):
assert isinstance(self.assembly,
Assembly), 'Invalid assembly %s' % self.assembly
super().__init__(self)
self.done = False
self.resolvers = {}
self.extensions = {}
self.wrappers = {}
self.calls = []
if self.assembly.reportUnused: self.report = ReportUnused()
else: self.report = ReportNone()
sources = resolversFor(dict(register=Register, Invoker=Invoker))
for processor in self.assembly.processors:
assert isinstance(processor,
IProcessor), 'Invalid processor %s' % processor
processor.register(sources, self.resolvers, self.extensions,
self.calls, self.report)
for processor in self.processors:
processor.finalized(sources, self.resolvers, self.extensions,
self.report)
solve(self.resolvers, sources)
for name, resolver in self.resolvers.items():
self.wrappers[name] = ResolverWrapper(resolver)
def introspectProcessing() -> Processing:
assert introspectContexts(), 'At least a set of contexts is required'
contexts = iter(introspectContexts())
resolvers = resolversFor(next(contexts))
for context in contexts:
solve(resolvers, context)
return assemblyIntrospection().create(**resolvers)
def __init__(self):
assert isinstance(self.errors, list), 'Invalid errors %s' % self.list
resolvers = resolversFor(dict(Invoker=Invoker))
for code, verifier, messages in self.errors:
assert isinstance(code, str), 'Invalid code %s' % code
assert isinstance(verifier,
IVerifier), 'Invalid verifier %s' % verifier
assert isinstance(messages,
tuple), 'Invalid messages %s' % messages
for message in messages:
assert isinstance(message, str), 'Invalid message %s' % message
verifier.prepare(resolvers)
super().__init__(**resolvers)
def __init__(self):
assert isinstance(self.descriptions, list), 'Invalid descriptions %s' % self.descriptions
assert isinstance(self.charSet, str), 'Invalid character set encoding %s' % self.charSet
assert isinstance(self.type, str), 'Invalid content type %s' % self.type
resolvers = resolversFor(dict(Definition=Definition))
for verifier, descriptions, data in self.descriptions:
assert isinstance(verifier, IVerifier), 'Invalid verifier %s' % verifier
assert isinstance(descriptions, tuple), 'Invalid descriptions %s' % descriptions
assert isinstance(data, dict), 'Invalid data %s' % data
if __debug__:
for desc in descriptions: assert isinstance(desc, str), 'Invalid description %s' % desc
verifier.prepare(resolvers)
for value in data.values():
if isinstance(value, IValue):
assert isinstance(value, IValue)
value.prepare(resolvers)
super().__init__(**resolvers)
def __init__(self):
assert isinstance(self.assembly, Assembly), 'Invalid assembly %s' % self.assembly
super().__init__(self)
self.done = False
self.resolvers = {}
self.extensions = {}
self.wrappers = {}
self.calls = []
if self.assembly.reportUnused: self.report = ReportUnused()
else: self.report = ReportNone()
sources = resolversFor(dict(register=Register, Invoker=Invoker))
for processor in self.assembly.processors:
assert isinstance(processor, IProcessor), 'Invalid processor %s' % processor
processor.register(sources, self.resolvers, self.extensions, self.calls, self.report)
for processor in self.processors:
processor.finalized(sources, self.resolvers, self.extensions, self.report)
solve(self.resolvers, sources)
for name, resolver in self.resolvers.items(): self.wrappers[name] = ResolverWrapper(resolver)
p1 = defines(str)
class C(Context):
p2 = defines(int)
class D(Context):
p2 = defines(str)
class F(D):
p3 = defines(str)
class E(F, D):
p2 = optional(str)
p3 = optional(str)
resolvers = resolversFor(dict(I=B))
merge(resolvers, dict(I=F))
ctx = create(resolvers)
I = ctx['I']
# --------------------------------------------------------------------
class TestDesign(unittest.TestCase):
def testContext(self):
i = I()
self.assertIsInstance(i, Context)
self.assertNotIsInstance(i, A)
self.assertIsInstance(i, B)
self.assertNotIsInstance(i, C)
self.assertIsInstance(i, D)
def __init__(self, Target, **arg):
super().__init__()
self.Target = resolverFor(Target)
self.arg = resolversFor(arg)
class D(Context):
p2 = defines(str)
class F(D):
p3 = defines(str)
class E(F, D):
p2 = optional(str)
p3 = optional(str)
resolvers = resolversFor(dict(I=B))
merge(resolvers, dict(I=F))
ctx = create(resolvers)
I = ctx['I']
# --------------------------------------------------------------------
class TestDesign(unittest.TestCase):
def testContext(self):
i = I()
self.assertIsInstance(i, Context)
self.assertNotIsInstance(i, A)
self.assertIsInstance(i, B)
self.assertNotIsInstance(i, C)
self.assertIsInstance(i, D)