gistfile1.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-
from pprint import pprint


inp = [
    {
        'type': 'input',
        'result': ['a','b','c','d']
    },
    {
        'type': 'func',
        'name': 'AA',
        'req': ['a','b'],
        'result': ['SAA']
    },
    {
        'type': 'func',
        'name': 'AB',
        'req': ['c','SAA'],
        'result': ['SAB']
    },
    {
        'type': 'func',
        'name': 'AC',
        'req': ['d','SAA'],
        'result': ['SAC']
    },

    {
        'type': 'cond',
        'op': 'BA',
        'req': ['SAB','SAC'],
        'true': [
            {
                'type': 'cond',
                'op': 'BB',
                'req': ['SAA','d'],
                'true': [
                    {
                        'type': 'output',
                        'req': ['SAA','SAC']
                    }
                ],
                'false': [
                    {
                        'type': 'func',
                        'name': 'CA',
                        'req': ['SAA','b'],
                        'result': ['SCA']
                    },
                    {
                        'type': 'func',
                        'name': 'CB',
                        'req': ['SAA','SAC'],
                        'result': ['SCB']
                    },
                    {
                        'type': 'output',
                        'req': ['SAA','SCA','SCB'],
                    }
                ]
            }
        ],
        'false': [
            {
                'type': 'func',
                'name': 'DA',
                'req': ['SAA','SAB'],
                'result': ['SDA']
            },
            {
                'type': 'func',
                'name': 'DB',
                'req': ['SAA','SAC'],
                'result': ['SDB']
            },
            {
                'type': 'output',
                'req': ['SDB','SDA','SAC'],
            }
        ]

    }
]

def make_parallel(inp, in_var,l_var):
    var = in_var
    last_var = l_var
    prev_type = ''
    i = 0
    # мало ли, что перезатираем в inp
    sinp = list(inp)
#    last_var = []
    #for block in inp:
    for block in sinp:
        print ()
        #print block['type'] , len(inp)
        print()
        print()
        i = i + 1
        print "\nIteration #",i
        pprint(block)
        print " -- var -- "
        pprint(var)
         #       try:
         #         print("Connected-- ". connected)
         #     except:
         #         print('Poka connceted nema :(')
         #    raw_input()
         # ПРИ ВЫЗОВЕ РЕКУРСИИ ЭТОТ ИФ ИГНОРИРУЕТСЯ
        if block['type'] == 'input':
            last_var = block['result'][:]
            var = var + block['result'][:]
        elif block['type'] == 'func':
            for r in block['req']:
                if r not in var:
                    print("Ne hvataet ishodnih dannih v var")
                    return None
            # connceted = False;  connected - flag na parallelnost
            connected = True
            print "---FUNCTION DETECTED---"
            print "last_var-- ",last_var
            print "block[req]-- ", block['req']
            for lv in block['req']:
                # edited: --lv not in last_var
                # esli perem opredelilas na pred shage, to posledovatelno, inache parallelno!
                if lv in last_var:
                    connected = False
                    print "\n---ПОСЛЕДОВАТЕЛЬНО?????\n"
            print "текущий тип оператора: " , block['type'],  "предыдущий тип: ", prev_type
            if block['type']==prev_type:
                print "Parallelno? -- ", connected
            # edited: was if connected
            # i>2 - необходимая итерация, чтобы не поставить параллельно блок ввода-вывода с АА
            if connected and block['type'] == prev_type:
                preprevind = inp.index(block)-2
                #print "ПЕРЕД\n" , inp
                prev = inp.pop(inp.index(block)-1)
                curr = inp.pop(inp.index(block))

                temp_block = {
                    'type': 'parallel',
                    'elems': [
                        prev,
                        curr
                    ]
                }
                print "prev-- ", prev
                print "curr-- ", curr
                inp = inp[:preprevind+1] + [temp_block] + inp[preprevind+1:]
                print inp
                #print "ПОСЛЕ\n" , inp

            last_var = block['result'][:]
            var = var + block['result'][:]
            print "\n--last_var:",last_var
            print "--var:", var
            print "\nINPUT LENGTH? ", len(sinp)

        elif block['type'] == 'cond':
            print "--CONDITION DETECTED--"
            print "==block[true]:\n", block['true']
            print "==block[false]:\n", block['false']
            true = make_parallel(block['true'], var,last_var)
            print "\n++++ ВЕТВЬ TRUE +++++\n" , true
            false = make_parallel(block['false'], var,last_var)
            print "\n---- ВЕТВЬ FALSE -----\n" , false
            # ?
            block['true'] = true
            block['false'] = false
        elif block['type'] == 'output':
            for r in block['req']:
                if r in var:
                    print("Блок вывода данных: "+str(var)+str(block['req']))
                    return inp
        prev_type = block['type']
    return inp
#print " -- Исходный алгоритм: -- "
#pprint(sinp)
print()
res = make_parallel(inp, [],None)

print ("\n\n-- RESULT -- \n")
pprint(res)