示例#1
0
    def merge_schema(cls, source1, source2, overwrite=True):
        properties = utils.merge_dicts(
            copy.deepcopy(source1.get('properties', {})),
            copy.deepcopy(source2.get('properties', {})),
            overwrite=overwrite
        )

        required = list(
            set(copy.deepcopy(source1.get('required', []))).union(
                set(copy.deepcopy(source2.get('required', []))))
        )

        additional = (
            source1.get('additionalProperties', True) and
            source2.get('additionalProperties', True)
        )

        schema = {
            'type': 'object',
            'properties': properties,
            'required': sorted(required)
        }

        if not additional:
            schema['additionalProperties'] = additional

        return schema
示例#2
0
    def test_dict_merge_overwrite_false(self):
        left = copy.deepcopy(LEFT)
        right = copy.deepcopy(RIGHT)

        utils.merge_dicts(left, right, overwrite=False)

        expected = {
            'k1': '123',
            'k2': 'abc',
            'k3': {
                'k31': True,
                'k32': 1.0,
                'k33': {
                    'k331': 'foo'
                }
            },
            'k4': 'bar'
        }

        self.assertDictEqual(left, expected)
示例#3
0
    def on_task_complete(self, task, context=None):
        self.wf_ex_graph.update_task(task['id'], state=task['state'])

        context = utils.merge_dicts(
            context or {},
            {'__task_states': self.wf_ex_graph.get_task_attributes('state')},
            overwrite=True
        )

        tasks = []
        outbounds = []

        for seq in self.wf_ex_graph.get_next_sequences(task['id']):
            evaluated_criteria = [
                expressions.evaluate(criterion, context)
                for criterion in seq[3]['criteria']
            ]

            if all(evaluated_criteria):
                outbounds.append(seq)

        for seq in outbounds:
            next_task_id, seq_key, attrs = seq[1], seq[2], seq[3]
            next_task = self.wf_ex_graph.get_task(next_task_id)

            if not attrs.get('satisfied', False):
                self.wf_ex_graph.update_sequence(
                    task['id'],
                    next_task_id,
                    key=seq_key,
                    satisfied=True
                )

            join_spec = next_task.get('join')

            if join_spec:
                inbounds = self.wf_ex_graph.get_prev_sequences(next_task_id)
                satisfied = [s for s in inbounds if s[3].get('satisfied')]
                join_spec = len(inbounds) if join_spec == 'all' else join_spec

                if len(satisfied) < join_spec:
                    continue

            tasks.append({'id': next_task_id, 'name': next_task['name']})

        return sorted(tasks, key=lambda x: x['name'])