def __init__(self,
verb,
*flags,
index=None,
key=None,
name=None,
value=None,
actions=None,
escapes=None):
'''
Construct the action do.
@param verb: string
The perform action verb, basically what it should do.
@param flags: arguments[string]
The flags associated with the action perform.
@param index: string|None
The index to associated with the action perform.
@param key: string|None
The block key to associated with the action perform.
@param name: string|None
The name to associated with the action perform.
@param value: string|None
The value to associated with the action perform.
@param actions: tuple(string)|None
The action names to associated with the action perform.
@param escapes: dictionary{string: string}
The escape dictionary, as a key the value that needs to be escaped and as a value the replacing value.
'''
assert isinstance(verb, str), 'Invalid verb %s' % verb
assert index is None or isinstance(index,
str), 'Invalid index %s' % index
assert key is None or isinstance(key, str), 'Invalid key %s' % key
assert name is None or isinstance(name, str), 'Invalid name %s' % name
assert value is None or isinstance(value,
str), 'Invalid value %s' % value
if actions is None: actions = ()
elif not isinstance(actions, tuple): actions = tuple(actions)
if escapes is None: escapes = immut()
elif not isinstance(escapes, immut): escapes = immut(escapes)
assert isinstance(actions, tuple), 'Invalid actions %s' % actions
assert isinstance(escapes, dict), 'Invalid escapes %s' % escapes
if __debug__:
for flag in flags:
assert isinstance(flag, str), 'Invalid flag %s' % flag
for action in actions:
assert isinstance(action, str), 'Invalid action %s' % action
for replaced, replacer in escapes.items():
assert isinstance(replaced,
str), 'Invalid replaced value %s' % replaced
assert isinstance(replacer,
str), 'Invalid replacer value %s' % replacer
self.verb = verb
self.flags = frozenset(flags)
self.index = index
self.key = key
self.name = name
self.value = value
self.actions = actions
self.escapes = escapes
def property(self, name, value, indexBlock=None):
'''
@see: IRender.property
@param indexBlock: string
Index the object with the provided index.
'''
assert isinstance(name, str), 'Invalid name %s' % name
assert isinstance(value, (str, list, dict)), 'Invalid value %s' % value
if indexBlock is None and not self._block: indexBlock = NAME_BLOCK
self.begin(name, indexBlock=indexBlock)
if isinstance(value, list):
for item in value:
assert isinstance(item, str), 'Invalid list item %s' % item
self.startElement(NAME_LIST_ITEM, immut())
self.characters(item)
self.endElement(NAME_LIST_ITEM)
elif isinstance(value, dict):
for key, item in value.items():
assert isinstance(key, str), 'Invalid dictionary key %s' % key
assert isinstance(item,
str), 'Invalid dictionary value %s' % item
self.startElement(NAME_DICT_ENTRY, immut())
self.startElement(NAME_DICT_KEY, immut())
self.characters(key)
self.endElement(NAME_DICT_KEY)
self.startElement(NAME_DICT_VALUE, immut())
self.characters(item)
self.endElement(NAME_DICT_VALUE)
self.endElement(NAME_DICT_ENTRY)
else:
self.characters(value)
self.end()
def property(self, name, value, indexBlock=None):
'''
@see: IRender.property
@param indexBlock: string
Index the object with the provided index.
'''
assert isinstance(name, str), 'Invalid name %s' % name
assert isinstance(value, (str, list, dict)), 'Invalid value %s' % value
if indexBlock is None and not self._block: indexBlock = NAME_BLOCK
self.begin(name, indexBlock=indexBlock)
if isinstance(value, list):
for item in value:
assert isinstance(item, str), 'Invalid list item %s' % item
self.startElement(NAME_LIST_ITEM, immut())
self.characters(item)
self.endElement(NAME_LIST_ITEM)
elif isinstance(value, dict):
for key, item in value.items():
assert isinstance(key, str), 'Invalid dictionary key %s' % key
assert isinstance(item, str), 'Invalid dictionary value %s' % item
self.startElement(NAME_DICT_ENTRY, immut())
self.startElement(NAME_DICT_KEY, immut())
self.characters(key)
self.endElement(NAME_DICT_KEY)
self.startElement(NAME_DICT_VALUE, immut())
self.characters(item)
self.endElement(NAME_DICT_VALUE)
self.endElement(NAME_DICT_ENTRY)
else:
self.characters(value)
self.end()
def __new__(cls, name, bases, namespace):
if not bases: return super().__new__(cls, name, bases, namespace)
attributes = {}
for key, value in namespace.items():
if isinstance(value, Attribute): attributes[key] = value
namespace = {
key: value
for key, value in namespace.items() if key not in attributes
}
namespace['__slots__'] = tuple(attributes)
self = super().__new__(cls, name, bases, namespace)
for key, attribute in attributes.items():
assert isinstance(attribute, Attribute)
attribute.name = key
attribute.clazz = self
attribute.descriptor = getattr(self, key)
attribute.locked = True
setattr(self, key, attribute)
# Adding also the parent attributes.
for base in bases:
if base is Bean: continue
if isinstance(base, BeanMetaClass):
assert isinstance(base, BeanMetaClass)
attributes.update(base.__attributes__)
self.__attributes__ = immut(attributes)
return self
def value(self, name, value):
'''
@see: IRender.value
'''
self.xml.startElement(name, immut())
self.xml.characters(value)
self.xml.endElement(name)
def __new__(cls, name, bases, namespace):
if not bases: return super().__new__(cls, name, bases, namespace)
attributes = {}
for key, value in namespace.items():
if isinstance(value, Attribute): attributes[key] = value
namespace = {key:value for key, value in namespace.items() if key not in attributes}
namespace['__slots__'] = tuple(attributes)
self = super().__new__(cls, name, bases, namespace)
for key, attribute in attributes.items():
assert isinstance(attribute, Attribute)
attribute.name = key
attribute.clazz = self
attribute.descriptor = getattr(self, key)
attribute.locked = True
setattr(self, key, attribute)
# Adding also the parent attributes.
for base in bases:
if base is Bean: continue
if isinstance(base, BeanMetaClass):
assert isinstance(base, BeanMetaClass)
attributes.update(base.__attributes__)
self.__attributes__ = immut(attributes)
return self
def __new__(cls, name, bases, namespace):
if not bases:
definer = namespace.pop('__definer__', None)
if not definer: raise TypeError('Invalid context definition, has no __definer__')
self = super().__new__(cls, name, bases, namespace)
self.__definer__ = definer
self.__attributes__ = immut()
return self
definer = namespace.get('__definer__')
if not definer:
first = bases[0]
if not isinstance(first, ContextMetaClass):
raise TypeError('The first inherited class need to be a context class, invalid class %s' % first)
assert isinstance(first, ContextMetaClass)
definer = first.__definer__
assert callable(definer), 'Invalid definer %s' % definer
self = super().__new__(cls, *definer(name, bases, namespace))
for name, attribute in self.__attributes__.items():
assert isinstance(attribute, IAttribute)
attribute.place(self, name)
return self
def __new__(cls, name, bases, namespace):
if not bases: return super().__new__(cls, name, bases, namespace)
attributes = {}
for key, value in namespace.items():
if key in ALLOWED: continue
if not isinstance(value, Attribute):
raise TypeError('Invalid attribute \'%s\' for name \'%s\'' % (value, key))
attributes[key] = value
namespace = {key:value for key, value in namespace.items() if key not in attributes}
namespace['__slots__'] = tuple(attributes)
self = super().__new__(cls, name, bases, namespace)
for key, attribute in attributes.items():
assert isinstance(attribute, Attribute)
attribute.name = key
attribute.clazz = self
attribute.descriptor = getattr(self, key)
attribute.locked = True
setattr(self, key, attribute)
# Adding also the parent attributes.
for base in bases:
if base is Context: continue
if not isinstance(base, ContextMetaClass):
raise TypeError('A context class can only inherit other context classes, invalid class %s' % base)
assert isinstance(base, ContextMetaClass)
attributes.update(base.__attributes__)
self.__attributes__ = immut(attributes)
return self
def objectStart(self, name, attributes=None):
'''
@see: IRender.objectStart
'''
if not self.processing: self.xml.startDocument() # Start the document
self.processing.append(name)
self.xml.startElement(name, attributes or immut())
def value(self, name, value):
'''
@see: IRender.value
'''
self.xml.startElement(name, immut())
self.xml.characters(value)
self.xml.endElement(name)
def collectionStart(self, name, attributes=None):
'''
@see: IRender.collectionStart
'''
if not self.processing: self.xml.startDocument() # Start the document
self.processing.append(name)
self.xml.startElement(name, attributes or immut())
def __init__(self, verb, *flags, index=None, key=None, name=None, value=None, actions=None, escapes=None):
'''
Construct the action do.
@param verb: string
The perform action verb, basically what it should do.
@param flags: arguments[string]
The flags associated with the action perform.
@param index: string|None
The index to associated with the action perform.
@param key: string|None
The block key to associated with the action perform.
@param name: string|None
The name to associated with the action perform.
@param value: string|None
The value to associated with the action perform.
@param actions: tuple(string)|None
The action names to associated with the action perform.
@param escapes: dictionary{string: string}
The escape dictionary, as a key the value that needs to be escaped and as a value the replacing value.
'''
assert isinstance(verb, str), 'Invalid verb %s' % verb
assert index is None or isinstance(index, str), 'Invalid index %s' % index
assert key is None or isinstance(key, str), 'Invalid key %s' % key
assert name is None or isinstance(name, str), 'Invalid name %s' % name
assert value is None or isinstance(value, str), 'Invalid value %s' % value
if actions is None: actions = ()
elif not isinstance(actions, tuple): actions = tuple(actions)
if escapes is None: escapes = immut()
elif not isinstance(escapes, immut): escapes = immut(escapes)
assert isinstance(actions, tuple), 'Invalid actions %s' % actions
assert isinstance(escapes, dict), 'Invalid escapes %s' % escapes
if __debug__:
for flag in flags: assert isinstance(flag, str), 'Invalid flag %s' % flag
for action in actions: assert isinstance(action, str), 'Invalid action %s' % action
for replaced, replacer in escapes.items():
assert isinstance(replaced, str), 'Invalid replaced value %s' % replaced
assert isinstance(replacer, str), 'Invalid replacer value %s' % replacer
self.verb = verb
self.flags = frozenset(flags)
self.index = index
self.key = key
self.name = name
self.value = value
self.actions = actions
self.escapes = escapes
def definerContext(name, bases, namespace):
'''
Process the provided context definition parameters.
@param name: string
The class name.
@param bases: tuple(class)
The inherited classes.
@param namespace: dictionary{string, object}
The context name space definition.
@return: tuple(string, tuple(classes), dictionary{string, object})
The name, basses and namespace to use in constructing the context class.
'''
assert isinstance(namespace, dict), 'Invalid namespace %s' % namespace
assert isinstance(bases, tuple), 'Invalid bases %s' % bases
assert bases, 'At least one base class is required'
attributes = {}
for key, value in namespace.items():
if key in ALLOWED: continue
if not isinstance(value, IAttribute):
raise TypeError('Invalid attribute \'%s\' for name \'%s\'' %
(value, key))
attributes[key] = value
# Adding also the parent attributes.
for base in bases:
if base is Context: continue
if not isinstance(base, ContextMetaClass):
raise TypeError(
'A context class can only inherit other context classes, invalid class %s'
% base)
assert isinstance(base, ContextMetaClass)
if base.__definer__ != definerContext:
raise TypeError(
'Cannot define because of inherited context class %s' % base)
for key, attribute in base.__attributes__.items():
if key not in attributes: attributes[key] = attribute
namespace['__attributes__'] = immut(attributes)
return name, bases, namespace
def definerContext(name, bases, namespace):
'''
Process the provided context definition parameters.
@param name: string
The class name.
@param bases: tuple(class)
The inherited classes.
@param namespace: dictionary{string, object}
The context name space definition.
@return: tuple(string, tuple(classes), dictionary{string, object})
The name, basses and namespace to use in constructing the context class.
'''
assert isinstance(namespace, dict), 'Invalid namespace %s' % namespace
assert isinstance(bases, tuple), 'Invalid bases %s' % bases
assert bases, 'At least one base class is required'
attributes = {}
for key, value in namespace.items():
if key in ALLOWED: continue
if not isinstance(value, IAttribute):
raise TypeError('Invalid attribute \'%s\' for name \'%s\'' % (value, key))
attributes[key] = value
for key in attributes: namespace.pop(key)
# Adding also the parent attributes.
for base in bases:
if base is Context: continue
if not isinstance(base, ContextMetaClass):
raise TypeError('A context class can only inherit other context classes, invalid class %s' % base)
assert isinstance(base, ContextMetaClass)
if base.__definer__ != definerContext:
raise TypeError('Cannot define because of inherited context class %s' % base)
for key, attribute in base.__attributes__.items():
if key not in attributes: attributes[key] = attribute
namespace['__attributes__'] = immut(attributes)
return name, bases, namespace
def begin(self, name, attributes=None, indexBlock=None, indexAttributesCapture=immut()):
'''
Begins a XML tag.
@param attributes: dictionary{string: string}
The attributes to associate with the object.
@param indexBlock: string
Index the object with the provided index.
@param indexAttributesCapture: dictionary{string: string}
The dictionary containing as a key the attribute name and as a value the key name as registered
to associate with the attribute capture.
'''
isAdjust = False
if self._adjust:
self.startDocument() # Start the document
if indexBlock is None:
assert indexBlock is None, 'No index block expected, but got %s' % indexBlock
assert not indexAttributesCapture, 'No attributes capture expected, but got %s' % indexAttributesCapture
index = self._index(NAME_XML_START_ADJUST)
index(IND_DECL)
isAdjust = True
self._adjust = False
if not isAdjust:
if self._block:
assert indexBlock is None, 'No index block expected, but got %s' % indexBlock
assert not indexAttributesCapture, 'No attributes capture expected, but got %s' % indexAttributesCapture
index = None
elif indexBlock:
assert isinstance(indexBlock, str), 'Invalid index block %s' % indexBlock
assert isinstance(indexAttributesCapture, dict), 'Invalid index attributes capture %s' % indexAttributesCapture
index = self._index(PATTERN_XML_BLOCK % indexBlock)
self._block = True
else: index = None
if self._pending_start_element:
self._write('>')
if self._pendingStart: self._pendingStart(EIND_TAG)
self._pending_start_element = False
self._pendingStart = None
if index: index(SIND_TAG)
self._write('<')
if index: index(SIND_NAME)
self._write(name)
if index: index(EIND_NAME)
if index: index(SIND_ATTRS)
if attributes:
assert isinstance(attributes, dict), 'Invalid attributes %s' % attributes
for nameAttr, valueAttr in attributes.items():
assert isinstance(nameAttr, str), 'Invalid attribute name %s' % nameAttr
assert isinstance(valueAttr, str), 'Invalid attribute value %s' % valueAttr
iname = indexAttributesCapture.get(nameAttr)
if iname:
self._write(' %s=' % nameAttr)
index(PSIND_ATTR_CAPTURE % iname, offset=1) # offset +1 for the comma
self._write(quoteattr(valueAttr))
index(PEIND_ATTR_CAPTURE % iname, offset= -1) # offset -1 for the comma
else: self._write(' %s=%s' % (nameAttr, quoteattr(valueAttr)))
if index: index(EIND_ATTRS)
if self._short_empty_elements:
self._pending_start_element = True
self._pendingStart = index
else:
self._write('>')
if index: index(EIND_TAG)
self._stack.append((name, index, isAdjust))
return self
'''
from ally.api.config import GET, INSERT, UPDATE, DELETE
from ally.api.operator.container import Service, Call
from ally.api.operator.type import TypeModel, TypeModelProperty, TypeService
from ally.api.type import typeFor, Input
from ally.core.impl.invoker import InvokerRestructuring, InvokerCall
from ally.core.impl.node import NodePath, NodeProperty, MatchProperty
from ally.core.spec.resources import Match, Node, Path, ConverterPath, \
IResourcesRegister, Invoker, PathExtended
from ally.support.util import immut
from collections import deque, Iterable
# --------------------------------------------------------------------
METHOD_NODE_ATTRIBUTE = immut({GET: 'get', INSERT: 'insert', UPDATE: 'update', DELETE: 'delete'})
# Mapping of method and node attribute where the invoker is kept for that method.
# --------------------------------------------------------------------
def pushMatch(matches, match):
'''
Adds the match to the matches list, returns True if the match(es) have been added successfully, False if no
match was added.
@param matches: list[Match]
The matches to push the match.
@param match: boolean|list[Match]|tuple(Match)|Match
The match to push to the the matches list.
@return: boolean
True if the match(es) have been added successfully, False if no match was added.
Provides HTTP server specification.
'''
from ally.api.config import GET, DELETE, INSERT, UPDATE
from ally.http.spec.server import METHOD_GET, METHOD_DELETE, METHOD_POST, \
METHOD_PUT, METHOD_OPTIONS
from ally.support.util import immut
import abc
# --------------------------------------------------------------------
# Additional HTTP methods.
OPTIONS = 16
UNKNOWN = -1
METHODS_TO_CORE = immut({METHOD_GET: GET, METHOD_DELETE: DELETE, METHOD_POST: INSERT,
METHOD_PUT: UPDATE, METHOD_OPTIONS: OPTIONS})
CORE_TO_METHODS = immut({GET: METHOD_GET, DELETE: METHOD_DELETE, INSERT: METHOD_POST,
UPDATE: METHOD_PUT, OPTIONS: METHOD_OPTIONS})
# --------------------------------------------------------------------
class IEncoderPath(metaclass=abc.ABCMeta):
'''
Provides the path encoding.
'''
@abc.abstractmethod
def encode(self, path, parameters=None):
'''
Encodes the provided path to a full request path.
def begin(self,
name,
attributes=None,
indexBlock=None,
indexAttributesCapture=immut()):
'''
Begins a XML tag.
@param attributes: dictionary{string: string}
The attributes to associate with the object.
@param indexBlock: string
Index the object with the provided index.
@param indexAttributesCapture: dictionary{string: string}
The dictionary containing as a key the attribute name and as a value the key name as registered
to associate with the attribute capture.
'''
isAdjust = False
if self._adjust:
self.startDocument() # Start the document
if indexBlock is None:
assert indexBlock is None, 'No index block expected, but got %s' % indexBlock
assert not indexAttributesCapture, 'No attributes capture expected, but got %s' % indexAttributesCapture
index = self._index(NAME_XML_START_ADJUST)
index(IND_DECL)
isAdjust = True
self._adjust = False
if not isAdjust:
if self._block:
assert indexBlock is None, 'No index block expected, but got %s' % indexBlock
assert not indexAttributesCapture, 'No attributes capture expected, but got %s' % indexAttributesCapture
index = None
elif indexBlock:
assert isinstance(indexBlock,
str), 'Invalid index block %s' % indexBlock
assert isinstance(
indexAttributesCapture, dict
), 'Invalid index attributes capture %s' % indexAttributesCapture
index = self._index(PATTERN_XML_BLOCK % indexBlock)
self._block = True
else:
index = None
if self._pending_start_element:
self._write('>')
if self._pendingStart: self._pendingStart(EIND_TAG)
self._pending_start_element = False
self._pendingStart = None
if index: index(SIND_TAG)
self._write('<')
if index: index(SIND_NAME)
self._write(name)
if index: index(EIND_NAME)
if index: index(SIND_ATTRS)
if attributes:
assert isinstance(attributes,
dict), 'Invalid attributes %s' % attributes
for nameAttr, valueAttr in attributes.items():
assert isinstance(nameAttr,
str), 'Invalid attribute name %s' % nameAttr
assert isinstance(
valueAttr, str), 'Invalid attribute value %s' % valueAttr
iname = indexAttributesCapture.get(nameAttr)
if iname:
self._write(' %s=' % nameAttr)
index(PSIND_ATTR_CAPTURE % iname,
offset=1) # offset +1 for the comma
self._write(quoteattr(valueAttr))
index(PEIND_ATTR_CAPTURE % iname,
offset=-1) # offset -1 for the comma
else:
self._write(' %s=%s' % (nameAttr, quoteattr(valueAttr)))
if index: index(EIND_ATTRS)
if self._short_empty_elements:
self._pending_start_element = True
self._pendingStart = index
else:
self._write('>')
if index: index(EIND_TAG)
self._stack.append((name, index, isAdjust))
return self
def begin(self,
name,
of,
attributes=None,
indexBlock=None,
indexAttributesCapture=immut()):
'''
Used to open a JSON object.
@param attributes: dictionary{string: string}
The attributes to associate with the object.
@param indexBlock: string
Index the object with the provided index.
@param indexAttributesCapture: dictionary{string: string}
The dictionary containing as a key the attribute name and as a value the key name as registered
to associate with the attribute capture.
'''
hasNameProp = self._stack and self._stack[0][0] == OF_OBJECT
isAdjust, hasName = False, of == OF_COLLECTION or hasNameProp
if self._adjust:
if indexBlock is None:
assert not indexAttributesCapture, 'No attributes capture expected, but got %s' % indexAttributesCapture
assert of in (
OF_OBJECT,
OF_COLLECTION), 'Invalid adjusting for of %s action' % of
index = self._index(NAME_JSON_START_ADJUST)
isAdjust = True
self._adjust = False
if not isAdjust:
if self._block:
assert indexBlock is None, 'No index block expected, but got %s' % indexBlock
assert not indexAttributesCapture, 'No attributes capture expected, but got %s' % indexAttributesCapture
index = None
elif indexBlock:
assert isinstance(indexBlock,
str), 'Invalid index block %s' % indexBlock
assert isinstance(
indexAttributesCapture, dict
), 'Invalid index attributes capture %s' % indexAttributesCapture
if hasName:
index = self._index(PATTERN_JSON_BLOCK_NAMED % indexBlock)
else:
index = self._index(PATTERN_JSON_BLOCK_UNAMED % indexBlock,
{KEY_NAME: name})
self._block = True
else:
index = None
if index: index(SIND_ENTRY, SIND_COMMA)
if not self._first:
self._out.write(',')
if of == OF_PROPERTY: self._first = False
else: self._first = True
if index: index(EIND_COMMA)
if hasNameProp:
if index: index(SIND_NAME, offset=1) # offset +1 for the comma
self._out.write('"%s"' % name)
if index: index(EIND_NAME, offset=-1) # offset -1 for the comma
self._out.write(':')
elif index:
index(SIND_NAME, EIND_NAME)
self._stack.appendleft((of, index, isAdjust))
if of == OF_PROPERTY: return
if index: index(SIND_VALUE)
self._out.write('{')
if index: index(SIND_ATTRS)
if attributes:
assert isinstance(attributes,
dict), 'Invalid attributes %s' % attributes
for nameAttr, valueAttr in attributes.items():
assert isinstance(nameAttr,
str), 'Invalid attribute name %s' % nameAttr
if self._first: self._first = False
else: self._out.write(',')
self._out.write('"%s"' % nameAttr)
self._out.write(':')
iname = indexAttributesCapture.get(nameAttr)
if iname:
offset = 1 if isinstance(valueAttr, str) else 0
index(PSIND_ATTR_CAPTURE % iname,
offset=offset) # offset +1 for the comma
self._out.write(encode(valueAttr))
index(PEIND_ATTR_CAPTURE % iname,
offset=-offset) # offset -1 for the comma
else:
self._out.write(encode(valueAttr))
if index: index(EIND_ATTRS)
if of == OF_COLLECTION:
if not self._first:
self._out.write(',')
self._first = True
if index: index(SIND_NAME, offset=1) # offset +1 for the comma
self._out.write('"%s"' % name)
if index: index(EIND_NAME, offset=-1) # offset -1 for the comma
self._out.write(':[')
if isAdjust: index(IND_DECL)
def begin(self, name, of, attributes=None, indexBlock=None, indexAttributesCapture=immut()):
'''
Used to open a JSON object.
@param attributes: dictionary{string: string}
The attributes to associate with the object.
@param indexBlock: string
Index the object with the provided index.
@param indexAttributesCapture: dictionary{string: string}
The dictionary containing as a key the attribute name and as a value the key name as registered
to associate with the attribute capture.
'''
hasNameProp = self._stack and self._stack[0][0] == OF_OBJECT
isAdjust, hasName = False, of == OF_COLLECTION or hasNameProp
if self._adjust:
if indexBlock is None:
assert not indexAttributesCapture, 'No attributes capture expected, but got %s' % indexAttributesCapture
assert of in (OF_OBJECT, OF_COLLECTION), 'Invalid adjusting for of %s action' % of
index = self._index(NAME_JSON_START_ADJUST)
isAdjust = True
self._adjust = False
if not isAdjust:
if self._block:
assert indexBlock is None, 'No index block expected, but got %s' % indexBlock
assert not indexAttributesCapture, 'No attributes capture expected, but got %s' % indexAttributesCapture
index = None
elif indexBlock:
assert isinstance(indexBlock, str), 'Invalid index block %s' % indexBlock
assert isinstance(indexAttributesCapture, dict), 'Invalid index attributes capture %s' % indexAttributesCapture
if hasName: index = self._index(PATTERN_JSON_BLOCK_NAMED % indexBlock)
else: index = self._index(PATTERN_JSON_BLOCK_UNAMED % indexBlock, {KEY_NAME: name})
self._block = True
else: index = None
if index: index(SIND_ENTRY, SIND_COMMA)
if not self._first:
self._out.write(',')
if of == OF_PROPERTY: self._first = False
else: self._first = True
if index: index(EIND_COMMA)
if hasNameProp:
if index: index(SIND_NAME, offset=1) # offset +1 for the comma
self._out.write('"%s"' % name)
if index: index(EIND_NAME, offset= -1) # offset -1 for the comma
self._out.write(':')
elif index: index(SIND_NAME, EIND_NAME)
self._stack.appendleft((of, index, isAdjust))
if of == OF_PROPERTY: return
if index: index(SIND_VALUE)
self._out.write('{')
if index: index(SIND_ATTRS)
if attributes:
assert isinstance(attributes, dict), 'Invalid attributes %s' % attributes
for nameAttr, valueAttr in attributes.items():
assert isinstance(nameAttr, str), 'Invalid attribute name %s' % nameAttr
if self._first: self._first = False
else: self._out.write(',')
self._out.write('"%s"' % nameAttr)
self._out.write(':')
iname = indexAttributesCapture.get(nameAttr)
if iname:
offset = 1 if isinstance(valueAttr, str) else 0
index(PSIND_ATTR_CAPTURE % iname, offset=offset) # offset +1 for the comma
self._out.write(encode(valueAttr))
index(PEIND_ATTR_CAPTURE % iname, offset= -offset) # offset -1 for the comma
else: self._out.write(encode(valueAttr))
if index: index(EIND_ATTRS)
if of == OF_COLLECTION:
if not self._first:
self._out.write(',')
self._first = True
if index: index(SIND_NAME, offset=1) # offset +1 for the comma
self._out.write('"%s"' % name)
if index: index(EIND_NAME, offset= -1) # offset -1 for the comma
self._out.write(':[')
if isAdjust: index(IND_DECL)
from ally.api.config import GET, INSERT, UPDATE, DELETE
from ally.api.operator.container import Service, Call
from ally.api.operator.type import TypeModel, TypeModelProperty, TypeService
from ally.api.type import typeFor, Input
from ally.core.impl.invoker import InvokerRestructuring, InvokerCall
from ally.core.impl.node import NodePath, NodeProperty, MatchProperty
from ally.core.spec.resources import Match, Node, Path, ConverterPath, \
IResourcesRegister, Invoker, PathExtended
from ally.support.util import immut
from collections import deque, Iterable
# --------------------------------------------------------------------
METHOD_NODE_ATTRIBUTE = immut({
GET: 'get',
INSERT: 'insert',
UPDATE: 'update',
DELETE: 'delete'
})
# Mapping of method and node attribute where the invoker is kept for that method.
# --------------------------------------------------------------------
def pushMatch(matches, match):
'''
Adds the match to the matches list, returns True if the match(es) have been added successfully, False if no
match was added.
@param matches: list[Match]
The matches to push the match.
@param match: boolean|list[Match]|tuple(Match)|Match
def populate(self, identifier, obj):
'''
Populates the gateway based on the provided dictionary object.
@see: gateway-http/gateway.http.gateway
@param identifier: Identifier
The identifier object to populate.
@param obj: dictionary{string: string|list[string]}
The dictionary used for defining the gateway object, the object as is defined from response.
@return: Identifier
The populated identifier object.
'''
assert isinstance(identifier, Identifier), 'Invalid identifier %s' % identifier
assert isinstance(obj, dict), 'Invalid object %s' % obj
pattern = obj.get('Pattern')
if pattern:
assert isinstance(pattern, str), 'Invalid pattern %s' % pattern
identifier.pattern = re.compile(pattern)
headers = obj.get('Headers', immut()).get('Headers')
if headers:
assert isinstance(headers, list), 'Invalid headers %s' % headers
if __debug__:
for header in headers: assert isinstance(header, str), 'Invalid header value %s' % header
identifier.headers.extend(re.compile(header) for header in headers)
methods = obj.get('Methods', immut()).get('Methods')
if methods:
assert isinstance(methods, list), 'Invalid methods %s' % methods
if __debug__:
for method in methods: assert isinstance(method, str), 'Invalid method value %s' % method
identifier.methods.update(method.upper() for method in methods)
errors = obj.get('Errors', immut()).get('Errors')
if errors:
assert isinstance(errors, list), 'Invalid errors %s' % errors
for error in errors:
try: identifier.errors.add(int(error))
except ValueError: raise ValueError('Invalid error value \'%s\'' % error)
gateway = identifier.gateway
assert isinstance(gateway, GatewayRepository), 'Invalid gateway %s' % gateway
gateway.filters = obj.get('Filters', immut()).get('Filters')
if __debug__ and gateway.filters:
assert isinstance(gateway.filters, list), 'Invalid filters %s' % gateway.filters
for item in gateway.filters: assert isinstance(item, str), 'Invalid filter value %s' % item
# gateway.host = obj.get('Host')
# assert not gateway.host or isinstance(gateway.host, str), 'Invalid host %s' % gateway.host
#
# gateway.protocol = obj.get('Protocol')
# assert not gateway.protocol or isinstance(gateway.protocol, str), 'Invalid protocol %s' % gateway.protocol
gateway.navigate = obj.get('Navigate')
assert not gateway.navigate or isinstance(gateway.navigate, str), 'Invalid navigate %s' % gateway.navigate
putHeaders = obj.get('PutHeaders', immut()).get('PutHeaders')
if putHeaders:
assert isinstance(putHeaders, list), 'Invalid put headers %s' % putHeaders
if __debug__:
for putHeader in putHeaders:
assert isinstance(putHeader, str), 'Invalid put header value %s' % putHeader
assert len(putHeader.split(':')), 'Invalid put header value %s' % putHeader
gateway.putHeaders = [putHeader.split(':', 1) for putHeader in putHeaders]
return identifier
