def process(self, chain, decoding: Decoding, parameter: Parameter,
invoker: Invoker, **keyargs):
'''
@see: HandlerProcessor.process
Indexed the parameter decodings.
'''
assert isinstance(decoding, Decoding), 'Invalid decoding %s' % decoding
assert isinstance(parameter,
Parameter), 'Invalid parameter %s' % parameter
assert isinstance(invoker, Invoker), 'Invalid invoker %s' % invoker
if not decoding.doDecode: return
name = self.separator.join(parameter.path)
if invoker.decodingsParameter is None: invoker.decodingsParameter = {}
if name in invoker.decodingsParameter:
log.error(
'Cannot use because there is the parameters for \'%s\' and \'%s\' have the same path \'%s\'',
findFirst(decoding, Decoding.parent, Decoding.input) or name,
findFirst(invoker.decodingsParameter[name], Decoding.parent,
Decoding.input) or name, name)
raise Abort(decoding)
invoker.decodingsParameter[name] = decoding
def process(self, chain, processing, create:Create, invoker:Invoker, **keyargs):
'''
HandlerBranching.process
Process the content decoding.
'''
assert isinstance(processing, Processing), 'Invalid processing %s' % processing
assert isinstance(create, Create), 'Invalid create %s' % create
assert isinstance(invoker, Invoker), 'Invalid invoker %s' % invoker
if not create.decodings: return
keyargs.update(create=create, invoker=invoker)
for decoding in create.decodings:
assert isinstance(decoding, Decoding), 'Invalid decoding %s' % decoding
if decoding.doDecode: continue
arg = processing.execute(decoding=decoding, **keyargs)
assert isinstance(arg.decoding, Decoding), 'Invalid decoding %s' % arg.decoding
if not arg.decoding.doDecode: continue
if invoker.decodingContent:
log.error('Cannot use because there are more then one content inputs %s, %s',
findFirst(invoker.decodingContent, Decoding.parent, Decoding.input),
findFirst(decoding, Decoding.parent, Decoding.input))
raise Abort(invoker.decodingContent, decoding)
invoker.decodingContent = arg.decoding
def process(self, chain, create:Create, decoding:Decoding, invoker:Invoker, **keyargs):
'''
@see: HandlerProcessor.process
Register the injected path decodings.
'''
assert isinstance(chain, Chain), 'Invalid chain %s' % chain
assert isinstance(create, Create), 'Invalid create %s' % create
assert isinstance(decoding, Decoding), 'Invalid decoding %s' % decoding
assert isinstance(invoker, Invoker), 'Invalid invoker %s' % invoker
if not decoding.property: return
if not invoker.path: return
for el in invoker.path:
assert isinstance(el, Element), 'Invalid path element %s' % el
if el.node and el.isInjected and el.property == decoding.property:
if create.pathInjected is None: create.pathInjected = {}
create.pathInjected[el.node] = decoding
inp = findFirst(decoding, Decoding.parent, Decoding.input)
assert isinstance(inp, Input), 'Invalid input %s' % inp
if invoker.solved is None: invoker.solved = set()
invoker.solved.add(inp)
chain.cancel() # Cancel the decode creation
break
def indexFailures(self, failures):
'''
Indexes the failures, iterates (name, definitions, values, messages)
'''
assert isinstance(failures, list), 'Invalid failures %s' % failures
indexed = {}
for decoding, value, messages, data in failures:
assert value is not None, 'None value is not allowed'
assert isinstance(decoding,
Decoding), 'Invalid decoding %s' % decoding
defin = findFirst(decoding, Decoding.parent,
Decoding.parameterDefinition)
assert isinstance(
defin,
Definition), 'Invalid definition %s for %s' % (defin, decoding)
assert isinstance(defin.name,
str), 'Invalid definition name %s' % defin.name
byName = indexed.get(defin.name)
if byName is None: byName = indexed[defin.name] = ([], [], [])
defins, values, msgs = byName
defins.append(defin)
values.append(value)
msgs.extend(msg % data for msg in messages)
for name in sorted(indexed):
yield (name, ) + indexed[name]
def iterAvailable(self, node):
'''
Iterates all the available nodes for node.
'''
assert isinstance(node, Node), 'Invalid node %s' % node
target = None
if not node.invokers or HTTP_GET not in node.invokers: return
# The available paths are compiled only for nodes that have a get invoker that can use them.
invoker = node.invokers[HTTP_GET]
assert isinstance(invoker, Invoker), 'Invalid invoker %s' % invoker
if invoker.isModel and invoker.target: target = invoker.target
if target:
for cname, cnode in self.iterTarget('', node, target): yield cname, cnode
for cname, cnode in self.iterChildByName('', node):
if invoker.isModel:
if cnode.parent and findFirst(cnode.parent, Node.parent, Node.child): yield cname, cnode
else: yield cname, cnode
if target:
for cname, cnode in self.iterTarget(cname, cnode, target): yield cname, cnode
if target and node.invokersGet:
for parent in inheritedTypesFrom(target.clazz, TypeModel):
assert isinstance(parent, TypeModel), 'Invalid parent %s' % parent
if not parent.propertyId: continue
propInvoker = node.invokersGet.get(parent.propertyId)
if propInvoker and propInvoker.node:
assert isinstance(propInvoker, Invoker), 'Invalid invoker %s' % propInvoker
for cname, cnode in self.iterTarget('', propInvoker.node, parent): yield cname, cnode
def indexFailures(self, failures):
'''
Indexes the failures, iterates (name, definitions, values, messages)
'''
assert isinstance(failures, list), 'Invalid failures %s' % failures
indexed = {}
for decoding, value, messages, data in failures:
assert value is not None, 'None value is not allowed'
assert isinstance(decoding, Decoding), 'Invalid decoding %s' % decoding
defin = findFirst(decoding, Decoding.parent, Decoding.parameterDefinition)
assert isinstance(defin, Definition), 'Invalid definition %s for %s' % (defin, decoding)
assert isinstance(defin.name, str), 'Invalid definition name %s' % defin.name
byName = indexed.get(defin.name)
if byName is None: byName = indexed[defin.name] = ([], [], [])
defins, values, msgs = byName
defins.append(defin)
values.append(value)
msgs.extend(msg % data for msg in messages)
for name in sorted(indexed):
yield (name,) + indexed[name]
def process(self, chain, create: Create, decoding: Decoding,
invoker: Invoker, **keyargs):
'''
@see: HandlerProcessor.process
Register the injected path decodings.
'''
assert isinstance(chain, Chain), 'Invalid chain %s' % chain
assert isinstance(create, Create), 'Invalid create %s' % create
assert isinstance(decoding, Decoding), 'Invalid decoding %s' % decoding
assert isinstance(invoker, Invoker), 'Invalid invoker %s' % invoker
if not decoding.property: return
if not invoker.path: return
for el in invoker.path:
assert isinstance(el, Element), 'Invalid path element %s' % el
if el.node and el.isInjected and el.property == decoding.property:
if create.pathInjected is None: create.pathInjected = {}
create.pathInjected[el.node] = decoding
inp = findFirst(decoding, Decoding.parent, Decoding.input)
assert isinstance(inp, Input), 'Invalid input %s' % inp
if invoker.solved is None: invoker.solved = set()
invoker.solved.add(inp)
chain.cancel() # Cancel the decode creation
break
def indexFailures(self, failures):
'''
Indexes the failures, iterates (name, definitions, values, messages)
'''
assert isinstance(failures, list), 'Invalid failures %s' % failures
indexed = {}
for decoding, value, messages, data in failures:
assert isinstance(decoding, Decoding), 'Invalid decoding %s' % decoding
defin = findFirst(decoding, Decoding.parent, lambda decoding: decoding.contentDefinitions.get(self.category)
if decoding.contentDefinitions else None)
if defin:
assert isinstance(defin, Definition), 'Invalid definition %s for %s' % (defin, decoding)
assert isinstance(defin.name, str), 'Invalid definition name %s' % defin.name
name = defin.name
else: name = None
byName = indexed.get(name)
if byName is None: byName = indexed[name] = ([], [], [])
defins, values, msgs = byName
if defin: defins.append(defin)
if value: values.append(value)
msgs.extend(msg % data for msg in messages)
last = indexed.pop(None, None)
for name in sorted(indexed):
yield (name,) + indexed[name]
if last:
yield (None,) + last
def isValid(self, definition):
'''
@see: IVerifier.isValid
'''
assert isinstance(definition, InputType.Definition), 'Invalid definition %s' % definition
if not definition.decoding: return False
prop = findFirst(definition.decoding, Property.Decoding.parent, Property.Decoding.property)
if prop:
assert isinstance(prop, TypeProperty), 'Invalid property type %s' % prop
return isinstance(prop.type, self.types)
return False
def isValid(self, definition):
'''
@see: IVerifier.isValid
'''
assert isinstance(definition, InputType.Definition), 'Invalid definition %s' % definition
if not definition.decoding: return False
input = findFirst(definition.decoding, InputType.Decoding.parent, InputType.Decoding.input)
if input:
assert isinstance(input, Input), 'Invalid input %s' % input
for typ in self.types:
if self.check(typ, input.type): return True
return False
def isValid(self, definition):
'''
@see: IVerifier.isValid
'''
assert isinstance(definition, InputType.Definition), 'Invalid definition %s' % definition
if not definition.decoding: return False
prop = findFirst(definition.decoding, Property.Decoding.parent, Property.Decoding.property)
if prop:
assert isinstance(prop, TypeProperty), 'Invalid property type %s' % prop
for clazz in self.classes:
if prop.isOf(clazz): return True
return False
def isValid(self, definition):
'''
@see: IVerifier.isValid
'''
assert isinstance(definition, InputType.Definition), 'Invalid definition %s' % definition
if not definition.decoding: return False
property = findFirst(definition.decoding, Property.Decoding.parent, Property.Decoding.property)
if property:
if property in self.properties: return True
for prop in self.properties:
if isCompatible(prop, property): return True
return False
def process(self, chain, decoding: Decoding, invoker: Invoker, **keyargs):
'''
@see: HandlerProcessor.process
Mark the solved decodings decoding.
'''
assert isinstance(decoding, Decoding), 'Invalid decoding %s' % decoding
assert isinstance(invoker, Invoker), 'Invalid invoker %s' % invoker
if not decoding.doDecode: return
inp = findFirst(decoding, Decoding.parent, Decoding.input)
assert isinstance(inp, Input), 'Invalid input %s' % inp
if invoker.solved is None: invoker.solved = set()
invoker.solved.add(inp)
def process(self, chain, decoding:Decoding, invoker:Invoker, **keyargs):
'''
@see: HandlerProcessor.process
Mark the solved decodings decoding.
'''
assert isinstance(decoding, Decoding), 'Invalid decoding %s' % decoding
assert isinstance(invoker, Invoker), 'Invalid invoker %s' % invoker
if not decoding.doDecode: return
inp = findFirst(decoding, Decoding.parent, Decoding.input)
assert isinstance(inp, Input), 'Invalid input %s' % inp
if invoker.solved is None: invoker.solved = set()
invoker.solved.add(inp)
def isValid(self, definition):
'''
@see: IVerifier.isValid
'''
assert isinstance(
definition,
InputType.Definition), 'Invalid definition %s' % definition
if not definition.decoding: return False
prop = findFirst(definition.decoding, Property.Decoding.parent,
Property.Decoding.property)
if prop:
assert isinstance(prop,
TypeProperty), 'Invalid property type %s' % prop
return isinstance(prop.type, self.types)
return False
def isValid(self, definition):
'''
@see: IVerifier.isValid
'''
assert isinstance(
definition,
InputType.Definition), 'Invalid definition %s' % definition
if not definition.decoding: return False
property = findFirst(definition.decoding, Property.Decoding.parent,
Property.Decoding.property)
if property:
if property in self.properties: return True
for prop in self.properties:
if isCompatible(prop, property): return True
return False
def isValid(self, definition):
'''
@see: IVerifier.isValid
'''
assert isinstance(
definition,
InputType.Definition), 'Invalid definition %s' % definition
if not definition.decoding: return False
input = findFirst(definition.decoding, InputType.Decoding.parent,
InputType.Decoding.input)
if input:
assert isinstance(input, Input), 'Invalid input %s' % input
for typ in self.types:
if self.check(typ, input.type): return True
return False
def isValid(self, definition):
'''
@see: IVerifier.isValid
'''
assert isinstance(
definition,
InputType.Definition), 'Invalid definition %s' % definition
if not definition.decoding: return False
prop = findFirst(definition.decoding, Property.Decoding.parent,
Property.Decoding.property)
if prop:
assert isinstance(prop,
TypeProperty), 'Invalid property type %s' % prop
for clazz in self.classes:
if prop.isOf(clazz): return True
return False
def iterAvailable(self, node):
'''
Iterates all the available nodes for node.
'''
assert isinstance(node, Node), 'Invalid node %s' % node
target = None
if not node.invokers or HTTP_GET not in node.invokers: return
# The available paths are compiled only for nodes that have a get invoker that can use them.
invoker = node.invokers[HTTP_GET]
assert isinstance(invoker, Invoker), 'Invalid invoker %s' % invoker
if invoker.isModel and invoker.target: target = invoker.target
if target:
for cname, cnode in self.iterTarget('', node, target):
yield cname, cnode
for cname, cnode in self.iterChildByName('', node):
if invoker.isModel:
if cnode.parent and findFirst(cnode.parent, Node.parent,
Node.child):
yield cname, cnode
else:
yield cname, cnode
if target:
for cname, cnode in self.iterTarget(cname, cnode, target):
yield cname, cnode
if target and node.invokersGet:
for parent in inheritedTypesFrom(target.clazz, TypeModel):
assert isinstance(parent,
TypeModel), 'Invalid parent %s' % parent
if not parent.propertyId: continue
propInvoker = node.invokersGet.get(parent.propertyId)
if propInvoker and propInvoker.node:
assert isinstance(
propInvoker,
Invoker), 'Invalid invoker %s' % propInvoker
for cname, cnode in self.iterTarget(
'', propInvoker.node, parent):
yield cname, cnode
