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 __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)
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)