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