def _setup_context(data, context, finalizer, convention):
if context is None:
context = contexts.Context(
convention=convention or conventions.CamelCaseConvention())
if finalizer is None:
@specs.parameter('iterator', yaqltypes.Iterable())
@specs.name('#iter')
def limit(iterator):
return iterator
@specs.inject('limiter', yaqltypes.Delegate('#iter'))
@specs.inject('engine', yaqltypes.Engine())
@specs.name('#finalize')
def finalize(obj, limiter, engine):
if engine.options.get('yaql.convertOutputData', True):
return utils.convert_output_data(obj, limiter, engine)
return obj
context.register_function(limit)
context.register_function(finalize)
else:
context.register_function(finalizer)
if data is not utils.NO_VALUE:
context['$'] = utils.convert_input_data(data)
return context
def test_delegate_factory(self):
@specs.parameter('name', yaqltypes.String())
@specs.inject('__df__', yaqltypes.Delegate())
def call_func(__df__, name, *args, **kwargs):
return __df__(name, *args, **kwargs)
context = self.context.create_child_context()
context.register_function(call_func)
self.assertEqual([1, 2],
self.eval('callFunc(list, 1, 2)', context=context))
self.assertEqual(
6, self.eval("callFunc('#operator_*', 2, 3)", context=context))
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from oslo_serialization import jsonutils
import yaml
from yaql.language import specs
from yaql.language import yaqltypes
@specs.method
@specs.inject('finalizer', yaqltypes.Delegate('#finalize'))
def to_yaml(finalizer, receiver):
return yaml.safe_dump(finalizer(receiver))
@specs.method
@specs.inject('finalizer', yaqltypes.Delegate('#finalize'))
def to_json(finalizer, receiver):
return jsonutils.dumps(finalizer(receiver))
def register(context):
context.register_function(to_yaml)
context.register_function(to_json)
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import itertools
import six
from yaql.language import specs
from yaql.language import utils
from yaql.language import yaqltypes
import yaql.standard_library.queries
@specs.parameter('args', nullable=True)
@specs.inject('delegate', yaqltypes.Delegate('to_list', method=True))
def list_(delegate, *args):
def rec(seq):
for t in seq:
if utils.is_iterator(t):
for t2 in rec(t):
yield t2
else:
yield t
return delegate(rec(args))
@specs.method
@specs.parameter('collection', yaqltypes.Iterable())
def flatten(collection):
# implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import exceptions
from oslo_log import log as logging
from yaql.language import specs
from yaql.language import yaqltypes
from murano.dsl import dsl
NAME_TEMPLATE = 'applications.{0}'
inject_format = specs.inject('_Logger__yaql_format_function',
yaqltypes.Delegate('format'))
@dsl.name('io.murano.system.Logger')
class Logger(object):
"""Logger object for MuranoPL.
Instance of this object returned by 'logger' YAQL function
and should not be instantiated directly
"""
def __init__(self, logger_name):
self._underlying_logger = logging.getLogger(
NAME_TEMPLATE.format(logger_name))
@inject_format
def trace(__self, __yaql_format_function, __message, *args, **kwargs):
__self._log(__self._underlying_logger.trace, __yaql_format_function,
@specs.parameter('group', yaqltypes.String())
@specs.parameter('setting', yaqltypes.String())
def config(group, setting):
return cfg.CONF[group][setting]
@specs.parameter('setting', yaqltypes.String())
@specs.name('config')
def config_default(setting):
return cfg.CONF[setting]
@specs.parameter('string', yaqltypes.String())
@specs.parameter('start', int)
@specs.parameter('length', int)
@specs.inject('delegate', yaqltypes.Delegate('substring', method=True))
@specs.extension_method
def substr(delegate, string, start, length=-1):
return delegate(string, start, length)
@specs.extension_method
def patch_(engine, obj, patch):
if not isinstance(patch, tuple):
patch = (patch, )
patch = dsl.to_mutable(patch, engine)
patch = jsonpatch.JsonPatch(patch)
try:
obj = dsl.to_mutable(obj, engine)
return patch.apply(obj, in_place=True)
except jsonpointer.JsonPointerException:
:arg receiver: object to evaluate expression
:argType receiver: any
:arg expr: expression
:argType expr: expression that can be evaluated as a method
:returnType: expression result type
.. code::
yaql> [0, 1].select($+1)
[1, 2]
"""
return expr(receiver)
@specs.parameter('expr', yaqltypes.YaqlExpression())
@specs.inject('operator', yaqltypes.Delegate('#operator_.'))
@specs.name('#operator_?.')
def elvis_operator(operator, receiver, expr):
""":yaql:operator ?.
Evaluates expr on receiver if receiver isn't null and returns the result.
If receiver is null returns null.
:signature: receiver?.expr
:arg receiver: object to evaluate expression
:argType receiver: any
:arg expr: expression
:argType expr: expression that can be evaluated as a method
:returnType: expression result or null
.. code::
def is_instance_of(obj, type_):
if obj is None:
return False
return type_.type.is_compatible(obj)
def is_object(value):
return isinstance(value,
(dsl_types.MuranoObject, dsl_types.MuranoTypeReference))
@specs.name('call')
@specs.parameter('name', yaqltypes.String())
@specs.parameter('args', yaqltypes.Sequence())
@specs.parameter('kwargs', utils.MappingType)
@specs.inject('op_dot', yaqltypes.Delegate('#operator_.', with_context=True))
@specs.inject('base', yaqltypes.Super(with_context=True))
def call_func(context,
op_dot,
base,
name,
args,
kwargs,
receiver=utils.NO_VALUE):
if isinstance(receiver,
(dsl_types.MuranoObject, dsl_types.MuranoTypeReference)):
kwargs = utils.filter_parameters_dict(kwargs)
args += tuple(
expressions.MappingRuleExpression(expressions.KeywordConstant(
key), value) for key, value in kwargs.items())
function = expressions.Function(name, *args)
:argType maxSplits: integer
:returnType: list
.. code::
yaql> "abc de f".rightSplit()
["abc", "de", "f"]
yaql> "abc de f".rightSplit(maxSplits => 1)
["abc de", "f"]
"""
return string.rsplit(separator, max_splits)
@specs.parameter('sequence', yaqltypes.Iterable())
@specs.parameter('separator', yaqltypes.String())
@specs.inject('str_delegate', yaqltypes.Delegate('str'))
@specs.method
def join(sequence, separator, str_delegate):
""":yaql:join
Returns a string with sequence elements joined by the separator.
:signature: sequence.join(separator)
:receiverArg sequence: chain of values to be joined
:argType sequence: sequence of strings
:arg separator: value to be placed between joined pairs
:argType separator: string
:returnType: string
.. code::
@specs.parameter('predicate', yaqltypes.Lambda())
@specs.method
def where(collection, predicate):
return six.moves.filter(predicate, collection)
@specs.parameter('collection', yaqltypes.Iterable())
@specs.parameter('selector', yaqltypes.Lambda())
@specs.method
def select(collection, selector):
return six.moves.map(selector, collection)
@specs.parameter('collection', yaqltypes.Iterable())
@specs.parameter('attribute', yaqltypes.Keyword(expand=False))
@specs.inject('operator', yaqltypes.Delegate('#operator_.'))
@specs.name('#operator_.')
def collection_attribution(collection, attribute, operator):
return six.moves.map(
lambda t: operator(t, attribute), collection)
@specs.parameter('collection', yaqltypes.Iterable())
@specs.parameter('count', int, nullable=False)
@specs.method
def skip(collection, count):
return itertools.islice(collection, count, None)
@specs.parameter('collection', yaqltypes.Iterable())
@specs.parameter('count', int, nullable=False)
@specs.parameter('left', int)
@specs.parameter('right', int)
def shift_bits_right(left, right):
return left >> right
@specs.parameter('left', int)
@specs.parameter('right', int)
def shift_bits_left(left, right):
return left << right
@specs.parameter('a', nullable=True)
@specs.parameter('b', nullable=True)
@specs.inject('operator', yaqltypes.Delegate('#operator_>'))
def max_(a, b, operator):
if operator(b, a):
return b
return a
@specs.inject('operator', yaqltypes.Delegate('#operator_>'))
def min_(a, b, operator):
if operator(b, a):
return a
return b
@specs.parameter('a', yaqltypes.Number())
@specs.parameter('b', yaqltypes.Number())
