Как проанализировать один шаблон STIX для создания нескольких шаблонов для логики ИЛИ?

Question

У меня есть шаблон STIX, как показано ниже:

stix_ptn_and_or_case2 = '''[(x:x.x = 'A' OR x:x.x = 'B' ) AND ( x:x.x = 'C' OR x:x.x = 'D' )]'''

Логика паттерна (A OR B) AND (C OR D)

Шаблон может быть проанализирован в дереве выражений с помощью dendrol (python lib), как показано ниже

Логика (A OR B) AND (C OR D) может быть разделена на 4 маленьких и AND only logic ниже

• A AND C
• A AND D
• B AND C
• B AND D

Я хочу разобрать дерево выражений, чтобы получить 4 AND only logic

Итак, я написал код на python, как показано ниже. Python lib dendrol может преобразовать шаблон STIX в дерево выражений.

import os, sys, datetime, copy
from dendrol import Pattern

stix_ptn_and_or_case2 = '''[(x:x.x = 'A' OR x:x.x = 'B' ) AND ( x:x.x = 'C' OR x:x.x = 'D' )]'''

ptn = Pattern(stix_ptn_and_or_case2)
pdt = ptn.to_dict_tree()
obj = pdt['pattern']
all_ptn_element_list = []

# the recursion function for expression tree to and-only logic
def ptnct(obj, ptn_element_list):
    if('observation' in obj or 'expression' in obj):
        if('observation' in obj):
            join = obj['observation']['join']
            expressions  = obj['observation']['expressions']
        else:
            join = obj['expression']['join']
            expressions  = obj['expression']['expressions']
        if(join=='AND' or join==None):
            for exp in expressions:
                p = ptnct(exp, ptn_element_list)
                if(p!=None):
                    ptn_element_list.append(p)
            if(len(ptn_element_list)==len(expressions)):# all and 
                all_ptn_element_list.append(ptn_element_list)
        elif(join=='OR'):
            for exp in expressions:
                p = ptnct(exp, ptn_element_list)
                tmp = copy.deepcopy( ptn_element_list )
                tmp.append(p)
                all_ptn_element_list.append(tmp)                    

    elif('comparison' in obj):
        exp = obj
        tag = '{0}:{1}.{2}'.format(exp['comparison']['object'], exp['comparison']['path'][0], exp['comparison']['path'][1])
        value = exp['comparison']['value']
        return value

x=ptnct(obj, [])
print(all_ptn_element_list)

Вывод кода

[[u'A'], [u'B'], [u'C'], [u'D']]

Но желаемый результат -

[[u'A', u'C'], [u'A', u'D'], [u'B', u'C'], [u'B', u'D']]

На самом деле код работает в большинстве случаев, но не в этом.

Есть ли предложения по синтаксическому анализу дерева логических выражений И-ИЛИ для выражений (шаблонов) только-И? *

Answer 1

Используя всегда удобные itertools.product и itertools.chain, мы можем преобразовать дерево несвязанных выражений в список всех возможных сопряженных выражений

from itertools import product, chain

from dendrol import Pattern


def extract_atomic_chunks(root):
    container = root.get('observation') or root.get('expression')
    comparison = root.get('comparison')

    if container:
        join = container['join']
        expressions = container['expressions']

        if join == 'OR':
            # Return all possibilities under this node
            return chain(
                extract_atomic_chunks(expression)
                for expression in expressions
            )

        elif join == 'AND':
            # Generate all possible N-tuples, where N=len(expressions) 
            groups = [
                extract_atomic_chunks(expression)
                for expression in expressions
            ]
            return product(*groups)

    elif comparison:
        return comparison['value']


if __name__ == '__main__':
    stix_expr = "[(x:x.x = 'A' OR x:x.x = 'B') AND (x:x.x = 'C' OR x:x.x = 'D')]"

    pattern = Pattern(stix_expr)
    tree = pattern.to_dict_tree()
    root = tree['pattern']

    print(list(extract_atomic_chunks(root)))

Я думаю, что вы попадете туда, куда хотите

[('A', 'C'), ('A', 'D'), ('B', 'C'), ('B', 'D')]