epc.py

class Evento:
  def __init__(self, nome):
    self.nome = nome

class Funcao:
  def __init__(self, nome, acao):
    self.nome = nome
    self.acao = acao


class Conector:
  def __init__(self, entradas = None, saidas = None):
    if entradas is None:
      entradas = []
    if saidas is None:
      saidas = []

    self.entradas = entradas #Lista de Eventos ou Funções que atuam como entradas
    self.saidas = saidas # Lista de Eventos ou Funções que atuam como saidas

  def adicionar_entrada(self, entrada):
    self.entradas.append(entrada)

  def adicionar_saida(self, saida):
    self.saidas.append(saida)

  def executar(self, contexto):
    pass


class Conector(AND):
  def executar(self, contexto):
    # Verifica se todas as entradas estão presentes no contexto
    if all(contexto.get(entrada, False) for entrada in self.entradas):
      # Se todas as condições de entrada são satisfeitas, ativa todas as saidas
      for saida in self.saidas:
        contexto[saida] = True
        


class ConectorOR(Conector):
  def executar(self, contexto):
    # Verifica se pelo menos uma das entradas está presente no contexto
    if any(contexto.get(entrada, False) for entrada in self.entradas):
      # Se pelo menos uma das condições de entrada é satisfeita, ativa todas as saidas
      for saida in self.saidas:
        contexto[saida] = True

def ConectorXOR(Conector):
  def executar(self, contexto):
    # Verifica se apenas uma das entradas está presente no contexto
    if sum(contexto.get(entrada, False) for entrada in self.entradas) == 1:
      # Se apenas uma das condições de entrada é satisfeita, ativa todas as saidas
      for saida in self.saidas:
        contexto[saida] = True

class ContextoDeExecucao:
  def __init__(self):
    self.variaveis = {}

class Processo:
  def __init__(self):
    self.elementos = []
    self.contexto = ContextoDeExecucao()

  def adicionar_elemento(self, elemento):
    # Adiciona um elemento (evento, funcao, ou conector) ao processo
    self.elementos.append(elemento)

  def executar(self):
    """Executa o processo, seguindo a ordem lógica definida pelos elementos"""
    for elemento in self.elementos:
      if isinstance(elemento, (Funcao, Conector)):
        elemento.executar(self.contexto)
    

main.py

import datetime
import sqlite3
from random import choice
from tabulate import tabulate
from remi import App, start, gui

"""
Agentes
Recursos
Eventos
"""


class REAC:

  def __init__(self):
    self.agentes = {}
    self.recursos = set()
    self.eventos = {}
    self.funcoes = {}
    self.registros = []
    self.compromissos = []

  def novo_agente(self, nome):
    self.agentes[nome] = {}

  def novo_recurso_do_agente(self, nome, recursos):
    for requerimento in recursos:
      recurso, quantidade = requerimento.values()
      if recurso not in self.agentes[nome]:
        self.agentes[nome][recurso] = 0

  def novo_recurso(self, nome, quantidade=0):
    self.recursos.add(nome)

  def novo_evento(self,
                  nome,
                  tipo="Compromisso",
                  tempo_em_dias=0,
                  repeticao_em_dias=0):
    self.eventos[nome] = {
      'Tipo': tipo,
      'Tempo': tempo_em_dias,
      'Repetir': repeticao_em_dias,
      'Entradas': [],
      'Saidas': [],
    }

  def nova_transferencia(self, evento, entradas=None, saidas=None):
    if not isinstance(entradas, list):
      entradas = [entradas]
    if not isinstance(saidas, list):
      saidas = [saidas]

    for entrada in entradas:
      if entrada is not None:
        self.nova_entrada(evento, entrada["Agente"], entrada["Recursos"])

    for saida in saidas:
      if saida is not None:
        self.nova_saida(evento, saida["Agente"], saida["Recursos"])

  def nova_entrada(self, evento, agente, recursos):
    self.eventos[evento]['Entradas'].append({
      'Agente': agente,
      'Recursos': recursos
    })
    self.novo_recurso_do_agente(agente, recursos)

  def nova_saida(self, evento, agente, recursos):
    self.eventos[evento]['Saidas'].append({
      'Agente': agente,
      'Recursos': recursos
    })
    self.novo_recurso_do_agente(agente, recursos)

  def __call__(self, acao, data=None):
    print(f"\n -> Iniciando {acao}")

    if data is None:
      data = datetime.date.today()

    evento = self.eventos[acao]
    tabela = 'compromissos' if evento['Tipo'] == 'Compromisso' else 'registros'

    # Imprime os recursos antes de qualquer transformação
    self.imprime_recursos()
    print('\n')

    # Executa um processo para transformar recursos

    for fluxo in ('Entradas', 'Saidas'):
      reverso = 'Saidas' if fluxo == 'Entradas' else 'Entradas'
      de_para = 'de' if fluxo == 'Entradas' else 'para'

      for requerimentos in evento[fluxo]:
        agente = requerimentos['Agente']

        for requerimento in requerimentos['Recursos']:
          recurso, qtd = requerimento.values()
          print(
            f'Registrando {evento["Tipo"]} {reverso} {qtd} {recurso}(s) {de_para} {agente}'
          )

          saldo_inicial = self.agentes[agente][recurso]
          valor = qtd

          if fluxo == 'Entradas':
            saldo_final = saldo_inicial - valor
          else:
            saldo_final = saldo_inicial + valor

          if evento['Tipo'] == 'Efetividade':
            self.agentes[agente][recurso] = saldo_final

            entrada = self.gera_entrada(data, evento['Tipo'], acao, fluxo,
                                        recurso, saldo_inicial, valor,
                                        saldo_final, agente)

            self.efetiva_compromisso(entrada)
          else:
            data_planejada = None
            if evento['Tempo']:
              data_planejada = data + datetime.timedelta(days=evento['Tempo'])
            entrada = self.gera_entrada(data, evento['Tipo'], acao, fluxo,
                                        recurso, saldo_inicial, valor,
                                        saldo_final, agente, data_planejada)

          getattr(self, tabela).append(entrada)

    # Imprime o registro de mudanças
    self.imprime_tabela(tabela, acao)

    # Imprime os recursos com as mundaças
    self.imprime_recursos()

    print(f'\n <- Finalizando {acao}\n')

  def gera_entrada(self,
                   data,
                   tipo,
                   acao,
                   fluxo,
                   recurso,
                   valor_inicial,
                   mudanca,
                   valor_final,
                   agente,
                   data_planejada=None):

    entrada = {
      "DataEHora": datetime.datetime.now(),
      "DataTransacao": data,
      "Acao": acao,
      "Fluxo": fluxo,
      "Recurso": recurso,
      "SaldoInicial": valor_inicial,
      "Valor": mudanca,
      "SaldoFinal": valor_final,
      "Agente": agente
    }

    if tipo == 'Compromisso':
      entrada.update({
        "DataPlanejada": data_planejada,
        "Efetivado": False,
        'DataEfetivacao': None
      })

    return entrada

  def efetiva_compromisso(self, entrada):
    """Marca um compromisso como efetivo"""
    for compromisso in self.compromissos:
      condicoes = []
      campos = ('Fluxo', 'Recurso', 'SaldoFinal', 'Agente')
      for campo in campos:
        condicoes.append(compromisso[campo] == entrada[campo])
      if all(condicoes):
        compromisso['Efetivado'] = True
        compromisso['DataEfetivacao'] = entrada['DataTransacao']

  def obter_quantidade_recurso(self, agente, recurso, data=None):
    """Retorna a quantidade de recurso disponivel em um agente
    Caso uma data seja
    """
    if data is None:
      return self.agentes[agente].get(recurso, 0)

  def obter_tabela(self, tabela, acao=None):
    cabecalho, dados = [], []
    for linha in getattr(self, tabela):
      if not cabecalho:
        cabecalho = linha.keys()

      if acao and linha['Acao'] != acao:
        continue

      dados.append(linha.values())

    return (cabecalho, dados)

  def obter_tabela_recursos(self):
    agentes = self.agentes.keys()
    cabecalho = ['Recurso'] + list(agentes)
    corpo = []
    for recurso in sorted(self.recursos):
      linha = [recurso]
      for agente in agentes:
        linha.append(self.agentes[agente].get(recurso, 0))
      corpo.append(linha)

    return (cabecalho, corpo)

  def imprime_tabela(self, tabela, evento=None):
    cabecalho, corpo = self.obter_tabela(tabela, evento)
    print('\n')
    print(tabulate(corpo, cabecalho))

  def imprime_recursos(self):
    cabecalho, corpo = self.obter_tabela_recursos()
    print('\n')
    print(tabulate(corpo, cabecalho))


class REACGUI(App):

  def __init__(self, reac, *args):
    super(REACGUI, self).__init__(*args)

    self.reac = reac

    self.conn = sqlite3.connect('reac.db')
    self.cursor = self.conn.cursor()

    # cria a tabela de entidades
    self.cursor.executescript('''
    CREATE TABLE IF NOT EXISTS reac_entidades (
      id INTEGER NOT NULL UNIQUE PRIMARY KEY AUTOINCREMENT,
      nome TEXT
    );

    CREATE TABLE IF NOT EXISTS reac_atributos (
      id INTEGER NOT NULL UNIQUE PRIMARY KEY AUTOINCREMENT,
      reac_entidades_id INTEGER NOT NULL,
      nome TEXT,
      FOREIGN KEY(reac_entidades_id) references reac_references(id)      
    );
    ''')

    # cria os widgets da interface
    self.entidade_label = gui.Label('Nome da Entidade:')
    self.entidade_input = gui.TextInput()
    self.entidade_button = gui.Button('Salvar Entidade')
    self.entidade_button.onclick.connect(self.salvar_entidade)

    self.atributo_label = gui


def terminal():
  reac = REAC()

  # Adiciona os agentes
  reac.novo_agente('Empresa')
  reac.novo_agente('Empregado')
  reac.novo_agente('Cliente')
  reac.novo_agente('Fornecedor')

  # Adiciona os recursos
  reac.novo_recurso('Produto')
  reac.novo_recurso('Matéria Prima')
  reac.novo_recurso('Dinheiro')
  reac.novo_recurso('Tempo')

  # Adiciona os Eventos
  reac.novo_evento('Contratar', 'Compromisso', 30)
  reac.novo_evento('Comprar M/P', 'Compromisso', 30)
  reac.novo_evento('Receber M/P', 'Efetividade', 1)
  reac.novo_evento('Produzir produto', 'Efetividade', 1)
  reac.novo_evento('Vender produto', 'Compromisso', 10)
  reac.novo_evento('Entregar produto', 'Efetividade')
  reac.novo_evento('Receber pagamento', 'Efetividade')
  reac.novo_evento('Pagar M/P', 'Efetividade')
  reac.novo_evento('Pagar salario', 'Efetividade')

  # Adiciona os Recursos necessários em cada evento
  reac.nova_transferencia(
    "Contratar", {
      "Agente": "Empregado",
      "Recursos": [{
        "Recurso": "Tempo",
        "Quantidade": 240
      }],
    }, {
      "Agente": "Empresa",
      "Recursos": [{
        "Recurso": "Dinheiro",
        "Quantidade": 1200
      }]
    })

  reac.nova_transferencia(
    "Comprar M/P", {
      "Agente": "Empresa",
      "Recursos": [{
        "Recurso": "Dinheiro",
        "Quantidade": 200
      }]
    }, {
      "Agente": "Fornecedor",
      "Recursos": [{
        "Recurso": "Matéria Prima",
        "Quantidade": 25
      }]
    })

  reac.nova_transferencia(
    "Receber M/P",
    [{
      "Agente": "Fornecedor",
      "Recursos": [{
        "Recurso": "Matéria Prima",
        "Quantidade": 25
      }]
    }], [{
      "Agente": "Empresa",
      "Recursos": [{
        "Recurso": "Matéria Prima",
        "Quantidade": 25
      }]
    }])

  reac.nova_transferencia(
    "Produzir produto",
    [{
      "Agente": "Empregado",
      "Recursos": [{
        "Recurso": "Tempo",
        "Quantidade": 8
      }]
    }, {
      "Agente": "Empresa",
      "Recursos": [{
        "Recurso": "Matéria Prima",
        "Quantidade": 20
      }]
    }], {
      "Agente": "Empresa",
      "Recursos": [{
        "Recurso": "Produto",
        "Quantidade": 1
      }]
    })

  reac.nova_transferencia(
    "Vender produto", {
      "Agente": "Cliente",
      "Recursos": [{
        "Recurso": "Dinheiro",
        "Quantidade": 2400
      }]
    }, {
      "Agente": "Empresa",
      "Recursos": [{
        "Recurso": "Produto",
        "Quantidade": 1
      }]
    })

  reac.nova_transferencia("Entregar produto", {
    "Agente": "Empresa",
    "Recursos": [{
      "Recurso": "Produto",
      "Quantidade": 1
    }]
  }, {
    "Agente": "Cliente",
    "Recursos": [{
      "Recurso": "Produto",
      "Quantidade": 1
    }]
  })

  reac.nova_transferencia(
    "Receber pagamento", {
      "Agente": "Cliente",
      "Recursos": [{
        "Recurso": "Dinheiro",
        "Quantidade": 2400
      }]
    }, {
      "Agente": "Empresa",
      "Recursos": [{
        "Recurso": "Dinheiro",
        "Quantidade": 2400
      }]
    })

  reac.nova_transferencia(
    "Pagar M/P", {
      "Agente": "Empresa",
      "Recursos": [{
        "Recurso": "Dinheiro",
        "Quantidade": 250
      }]
    }, {
      "Agente": "Fornecedor",
      "Recursos": [{
        "Recurso": "Dinheiro",
        "Quantidade": 250
      }]
    })

  reac.nova_transferencia(
    "Pagar salario", {
      "Agente": "Empresa",
      "Recursos": [{
        "Recurso": "Dinheiro",
        "Quantidade": 1200
      }]
    }, {
      "Agente": "Empregado",
      "Recursos": [{
        "Recurso": "Dinheiro",
        "Quantidade": 1200
      }]
    })

  data_base = datetime.date.today()

  # Ativa o processo
  reac("Contratar", data_base)
  #for i in range(0, 50):
  #print(f'Simulando dia {i+1}')
  reac("Vender produto", data_base)
  reac("Produzir produto", data_base)
  reac("Entregar produto", data_base)
  reac("Receber pagamento", data_base)
  #if i > 0 and (i % 30 == 0):
  #  reac("Pagar salario", data_base)
  #data_base = data_base + datetime.timedelta(days=1)

  print('\n')
  reac.imprime_recursos()
  print('\n')
  reac.imprime_tabela('compromissos')
  print('\n')
  reac.imprime_tabela('registros')


if __name__ == '__main__':
  terminal()