clases refactor draft, I class

app.py

@@ -9,6 +9,9 @@ from lib.ziruph import encrypt,decrypt
 from lib.entropy import *
 from torahcodes.resources.func.torah import *
 from lib.sonsofstars import *
+#from lib.memory import *
+#from lib.pipes import *
+
 
 ## UTILS
 import math

lattice.py

@@ -0,0 +1,30 @@
+import matplotlib.pyplot as plt
+import numpy as np
+
+def draw_hexagonal_grid(rows, cols, text):
+    fig, ax = plt.subplots()
+    ax.set_aspect('equal')
+
+    # Create a hexagonal lattice
+    for i in range(rows):
+        for j in range(cols):
+            if i % 2 == 0:
+                y = i * np.sqrt(3) / 2
+                x = j * 3 / 2
+            else:
+                y = (i + 0.5) * np.sqrt(3) / 2
+                x = (j + 0.5) * 3 / 2
+            ax.add_patch(plt.RegularPolygon((x, y), numVertices=6, radius=0.5, orientation=np.pi/6, fill=None))
+
+            # Add text inside each cell
+            ax.text(x, y, text[i * cols + j], ha='center', va='center')
+
+    ax.autoscale_view()
+    ax.axis('off')
+    plt.show()
+
+# Example usage
+text = "HELLO"
+rows = 5
+cols = 5
+draw_hexagonal_grid(rows, cols, text)

lib/events.py

@@ -0,0 +1,122 @@
+import pandas as pd
+import matplotlib.pyplot as plt
+from sklearn.model_selection import train_test_split
+from sklearn.ensemble import RandomForestRegressor
+from sklearn.metrics import mean_squared_error
+from scipy.stats import pearsonr
+import numpy as np
+from scipy.fft import fft
+
+
+class EventManager:
+    def __init__(self):
+        self.events = []
+
+    def add_event(self, event_title, time_dataset, probability_fork, quantity, common_tag_event_dataset,
+                  quantity_correlation_dataset, event_max_quantity, event_min_quantity, event_middle_quantity,
+                  sentiment_direction):
+        event = {
+            "event_title": event_title,
+            "time_dataset": time_dataset,
+            "probability_fork": probability_fork,
+            "quantity": quantity,
+            "common_tag_event_dataset": common_tag_event_dataset,
+            "quantity_correlation_dataset": quantity_correlation_dataset,
+            "event_max_quantity": event_max_quantity,
+            "event_min_quantity": event_min_quantity,
+            "event_middle_quantity": event_middle_quantity,
+            "sentiment_direction": sentiment_direction
+        }
+        self.events.append(event)
+
+    def remove_event(self, event_title):
+        self.events = [event for event in self.events if event['event_title'] != event_title]
+
+    def get_events_by_tag(self, tag):
+        return [event for event in self.events if tag in event['common_tag_event_dataset']]
+
+    def get_events_by_sentiment(self, sentiment):
+        return [event for event in self.events if event['sentiment_direction'] == sentiment]
+
+    def get_events_by_quantity_range(self, min_quantity, max_quantity):
+        return [event for event in self.events if min_quantity <= event['quantity'] <= max_quantity]
+
+    def predict_time_series(self, event_title):
+        event = next((event for event in self.events if event['event_title'] == event_title), None)
+        if event:
+            time_series = event['time_dataset']
+            # Aquí puedes implementar tu modelo de predicción de series temporales
+            # Por ejemplo, utilizando un modelo de regresión como RandomForestRegressor de scikit-learn
+            X = np.arange(len(time_series)).reshape(-1, 1)
+            y = np.array(time_series)
+            X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+            model = RandomForestRegressor()
+            model.fit(X_train, y_train)
+            predictions = model.predict(X_test)
+            return predictions
+        else:
+            return None
+
+    def plot_event_parameters_over_time(self, event_title):
+        event = next((event for event in self.events if event['event_title'] == event_title), None)
+        if event:
+            time_series = event['time_dataset']
+            plt.plot(time_series)
+            plt.xlabel('Tiempo')
+            plt.ylabel('Valor')
+            plt.title('Parámetros del Evento "{}" a lo largo del tiempo'.format(event_title))
+            plt.show()
+
+    def plot_prediction(self, event_title):
+        predictions = self.predict_time_series(event_title)
+        if predictions:
+            plt.plot(predictions, label='Predicción')
+            plt.xlabel('Tiempo')
+            plt.ylabel('Valor')
+            plt.title('Predicción del Evento "{}"'.format(event_title))
+            plt.legend()
+            plt.show()
+
+    def check_correlation(self, event_title1, event_title2):
+        event1 = next((event for event in self.events if event['event_title'] == event_title1), None)
+        event2 = next((event for event in self.events if event['event_title'] == event_title2), None)
+        if event1 and event2:
+            correlation, _ = pearsonr(event1['quantity_correlation_dataset'], event2['quantity_correlation_dataset'])
+            return correlation
+        else:
+            return None
+
+    def fourier_transform(self, event_title):
+        event = next((event for event in self.events if event['event_title'] == event_title), None)
+        if event:
+            time_series = event['time_dataset']
+            transformed_data = fft(time_series)
+            return transformed_data
+        else:
+            return None
+
+
+# Ejemplo de uso
+event_manager = EventManager()
+
+# Añadir eventos
+event_manager.add_event("Evento 1", [1, 2, 3, 4, 5], 0.8, 100, ["tag1", "tag2"], [0.1, 0.2, 0.3, 0.4, 0.5],
+                        150, 50, 100, "good when up")
+event_manager.add_event("Evento 2", [2, 4, 6, 8, 10], 0.6, 200, ["tag2", "tag3"], [0.2, 0.4, 0.6, 0.8, 1.0],
+                        250, 150, 200, "bad when down")
+
+# Realizar predicción de series temporales y plot
+event_manager.plot_event_parameters_over_time("Evento 1")
+event_manager.plot_prediction("Evento 1")
+
+# Comprobar correlación entre dos eventos
+correlation = event_manager.check_correlation("Evento 1", "Evento 2")
+if correlation:
+    print("Correlación entre Evento 1 y Evento 2:", correlation)
+else:
+    print("Alguno de los eventos no existe.")
+
+# Transformada de Fourier
+transformed_data = event_manager.fourier_transform("Evento 1")
+print("Transformada de Fourier del Evento 1:", transformed_data)
+

lib/latticegrid.py

@@ -0,0 +1,47 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.patches import RegularPolygon
+
+
+## set texto over lattice grid
+def hex_lattice(text, size=1, figsize=(8, 8)):
+    fig, ax = plt.subplots(figsize=figsize)
+    ax.set_aspect('equal')
+    ax.axis('off')
+
+    # Define hexagonal lattice parameters
+    radius = size * np.sqrt(3) / 2
+    x_offset = size * 1.5
+    y_offset = size * np.sqrt(3)
+
+    # Function to plot hexagon
+    def hexagon(x, y, color='white'):
+        hexagon = RegularPolygon((x, y), numVertices=6, radius=radius, orientation=np.pi/2, facecolor=color, edgecolor='black')
+        ax.add_patch(hexagon)
+
+    # Generate lattice grid
+    rows = len(text)
+    cols = max(len(row) for row in text)
+    for r in range(rows):
+        for c in range(cols):
+            x = c * x_offset
+            y = r * y_offset
+            if r % 2 == 1:
+                x += x_offset / 2
+            if r < len(text) and c < len(text[r]):
+                hexagon(x, y, color='lightblue')
+                ax.text(x, y, text[r][c], ha='center', va='center', fontsize=12)
+
+    plt.show()
+
+
+if __name__ == "__main__":
+
+    # Example usage:
+    text_to_display = [
+        ['A', 'B', 'C', 'D'],
+        ['E', 'F', 'G'],
+        ['H', 'I', 'J', 'K', 'L']
+    ]
+
+    hex_lattice(text_to_display, size=1, figsize=(10, 8))

lib/me.py

@@ -0,0 +1,98 @@
+from lib.memory import *
+from lib.grapher import *
+from lib.pipes import *
+from lib.entropy import *
+
+class I:
+    def __init__(self, frases_yo, preferencias, propiedades_persona):
+        self.frases_yo = frases_yo
+        self.preferencias = preferencias
+        self.propiedades_persona = propiedades_persona
+        self.dopamina = 0.0
+
+        self.frases_yo = frases_yo
+        self.preferencias = preferencias
+        self.propiedades_persona = propiedades_persona
+        self.dopamina = 0.0
+
+    def obtener_paths_grafo(self, grafo_ngx):
+        # Función para obtener los paths de un grafo ngx
+
+
+        pass
+
+    def crear_circuito_logico(self):
+        # Función para crear un circuito lógico con un algoritmo específico
+        pass
+
+    def tomar_decision_sentimiento(self, pipa_sentimiento):
+        # Función para tomar una decisión booleana con un análisis de sentimiento
+        pass
+
+    def hacer_predicciones_texto(self, texto):
+        # Función para hacer predicciones de texto futuro por similitud
+        pass
+
+    def agregar_preferencia(self, preferencia):
+        # Función para añadir una entrada al dataset de preferencias
+        self.preferencias.append(preferencia)
+
+    def agregar_frase_yo(self, frase):
+        # Función para añadir una frase al dataset de frases de yo
+        self.frases_yo.append(frase)
+
+    def eliminar_preferencia(self, preferencia):
+        # Función para eliminar una entrada del dataset de preferencias
+        if preferencia in self.preferencias:
+            self.preferencias.remove(preferencia)
+
+    def eliminar_frase_yo(self, frase):
+        # Función para eliminar una frase del dataset de frases de yo
+        if frase in self.frases_yo:
+            self.frases_yo.remove(frase)
+
+    def generar_pregunta(self, prompt):
+        # Función para generar preguntas sobre un prompt
+        pregunta = prompt + " ¿Qué opinas sobre esto?"
+        return pregunta
+
+    def responder_pregunta(self, pregunta):
+        # Función para responder preguntas
+        respuesta = "No estoy seguro de qué opinar sobre eso."
+        return respuesta
+
+    def discriminar_y_agregar(self, informacion, dataset):
+        # Función para discriminar y agregar información a los datasets
+        if "yo" in informacion.lower():
+            self.agregar_frase_yo(informacion)
+        elif "preferencia" in informacion.lower():
+            self.agregar_preferencia(informacion)
+        elif "propiedad" in informacion.lower():
+            # Aquí podrías agregar lógica para actualizar las propiedades de la persona
+            pass
+        else:
+            # Aquí podrías manejar otros tipos de información
+            pass
+
+
+if __name__ == "__main__":
+
+    # Ejemplo de uso:
+    frases_yo = ["Yo soy inteligente", "Yo puedo lograr lo que me proponga"]
+    preferencias = ["Cine", "Música", "Viajar"]
+    propiedades_persona = {"carisma": 0.8, "destreza": 0.6, "habilidad": 0.9}
+    yo = Yo(frases_yo, preferencias, propiedades_persona)
+
+    # Generar pregunta
+    pregunta_generada = yo.generar_pregunta("Hoy es un día soleado.")
+    print("Pregunta generada:", pregunta_generada)
+
+    # Responder pregunta
+    respuesta = yo.responder_pregunta(pregunta_generada)
+    print("Respuesta:", respuesta)
+
+    # Discriminar y agregar información
+    informacion = "Me gusta ir al cine."
+    yo.discriminar_y_agregar(informacion, yo.preferencias)
+    print("Preferencias actualizadas:", yo.preferencias)
+

lib/memory.py

@@ -41,22 +41,26 @@ class MemoriaRobotNLP:
 
 
 # Ejemplo de uso
-memoria_robot = MemoriaRobotNLP(max_size=100)
 
-memoria_robot.agregar_concepto("animales", [("perro", 0.8), ("gato", 0.7), ("pájaro", 0.5)])
-memoria_robot.agregar_concepto("colores", [("rojo", 0.9), ("verde", 0.6), ("azul", 0.7)])
 
-print("Memoria completa:")
-print(memoria_robot.memoria)
+if __name__ == "__main__":
 
-memoria_robot.agregar_string("animales", "pez", 0.6)
-memoria_robot.eliminar_string("colores", "verde")
-memoria_robot.eliminar_concepto("colores")
+    memoria_robot = MemoriaRobotNLP(max_size=100)
 
-print("\nMemoria después de modificaciones:")
-print(memoria_robot.memoria)
+    memoria_robot.agregar_concepto("animales", [("perro", 0.8), ("gato", 0.7), ("pájaro", 0.5)])
+    memoria_robot.agregar_concepto("colores", [("rojo", 0.9), ("verde", 0.6), ("azul", 0.7)])
 
-conceptos_acotados = memoria_robot.obtener_conceptos_acotados(50)
-print("\nConceptos acotados a un tamaño máximo de memoria:")
-print(conceptos_acotados)
+    print("Memoria completa:")
+    print(memoria_robot.memoria)
+
+    memoria_robot.agregar_string("animales", "pez", 0.6)
+    memoria_robot.eliminar_string("colores", "verde")
+    memoria_robot.eliminar_concepto("colores")
+
+    print("\nMemoria después de modificaciones:")
+    print(memoria_robot.memoria)
+
+    conceptos_acotados = memoria_robot.obtener_conceptos_acotados(50)
+    print("\nConceptos acotados a un tamaño máximo de memoria:")
+    print(conceptos_acotados)
 

lib/pipes.py

@@ -3,11 +3,26 @@ from diffusers import DiffusionPipeline
 from transformers import AutoModelForSeq2SeqLM
 from samplings import top_p_sampling, temperature_sampling
 import torch
+from sentence_transformers import SentenceTransformer, util
 
 class AIAssistant:
     def __init__(self):
         pass
 
+    ## gramatical classificator
+    def grammatical_pos_tagger(self, text):
+        nlp_pos = pipeline(
+            "ner",
+            model="mrm8488/bert-spanish-cased-finetuned-pos",
+            tokenizer=(
+                'mrm8488/bert-spanish-cased-finetuned-pos',
+                {"use_fast": False}
+        ))
+        
+        return nlp_pos(text)
+
+
+    ## entity classifier
     def entity_pos_tagger(self, example):
         tokenizer = AutoTokenizer.from_pretrained("Davlan/bert-base-multilingual-cased-ner-hrl")
         model = AutoModelForTokenClassification.from_pretrained("Davlan/bert-base-multilingual-cased-ner-hrl")
@@ -15,6 +30,47 @@ class AIAssistant:
         ner_results = nlp(example)
         return ner_results
 
+
+    ## sentiment analysis
+    def sentiment_tags(self,text):
+        distilled_student_sentiment_classifier = pipeline(
+            model="lxyuan/distilbert-base-multilingual-cased-sentiments-student", 
+            return_all_scores=True
+        )
+
+        # english
+        return distilled_student_sentiment_classifier(text)
+
+    ## check similarity among sentences (group of tokens (words))
+    def similarity_tag(self, sentenceA,sentenceB):
+        res=[]
+        model = SentenceTransformer('abbasgolestani/ag-nli-bert-mpnet-base-uncased-sentence-similarity-v1') nli-mpnet-base-v2
+
+        # Two lists of sentences
+        #sentences1 = ['I am honored to be given the opportunity to help make our company better',
+        #            'I love my job and what I do here',
+        #            'I am excited about our company’s vision']
+
+        #sentences2 = ['I am hopeful about the future of our company',
+        #            'My work is aligning with my passion',
+        #            'Definitely our company vision will be the next breakthrough to change the world and I’m so happy and proud to work here']
+
+        sentences1 = sentenceA
+        sentences2 = sentencesB
+        #Compute embedding for both lists
+        embeddings1 = model.encode(sentences1, convert_to_tensor=True)
+        embeddings2 = model.encode(sentences2, convert_to_tensor=True)
+
+        #Compute cosine-similarities
+        cosine_scores = util.cos_sim(embeddings1, embeddings2)
+
+        #Output the pairs with their score
+        for i in range(len(sentences1)):
+            res.append({"A": format(sentences1[i], "B":sentences2[i], "score":cosine_scores[i][i]})
+            #print("{} \t\t {} \t\t Score: {:.4f}".format(sentences1[i], sentences2[i], cosine_scores[i][i]))
+
+        return res
+    ## text to stable difusor generated image
     def text_to_image_generation(self, prompt, n_steps=40, high_noise_frac=0.8):
         base = DiffusionPipeline.from_pretrained(
             "stabilityai/stable-diffusion-xl-base-1.0", torch_dtype=torch.float16, variant="fp16", use_safetensors=True
@@ -44,16 +100,8 @@ class AIAssistant:
         ).images[0]
         return image
 
-    def grammatical_pos_tagger(self, text):
-        nlp_pos = pipeline(
-            "ner",
-            model="mrm8488/bert-spanish-cased-finetuned-pos",
-            tokenizer=(
-                'mrm8488/bert-spanish-cased-finetuned-pos',
-                {"use_fast": False}
-        ))
-        return nlp_pos(text)
 
+    ## pass text prompt to music
     def text_to_music(self, text, max_length=1024, top_p=0.9, temperature=1.0):
         tokenizer = AutoTokenizer.from_pretrained('sander-wood/text-to-music')
         model = AutoModelForSeq2SeqLM.from_pretrained('sander-wood/text-to-music')
@@ -86,17 +134,20 @@ class AIAssistant:
                 return tune
                 break
 
-# Ejemplo de uso
-assistant = AIAssistant()
-ner_results = assistant.entity_pos_tagger("Nader Jokhadar had given Syria the lead with a well-struck header in the seventh minute.")
-print(ner_results)
 
-image = assistant.text_to_image_generation("A majestic lion jumping from a big stone at night")
-print(image)
+if __name__ == "__main__":
+
+    # Ejemplo de uso
+    assistant = AIAssistant()
+    ner_results = assistant.entity_pos_tagger("Nader Jokhadar had given Syria the lead with a well-struck header in the seventh minute.")
+    print(ner_results)
+
+    image = assistant.text_to_image_generation("A majestic lion jumping from a big stone at night")
+    print(image)
 
-pos_tags = assistant.grammatical_pos_tagger('Mis amigos están pensando en viajar a Londres este verano')
-print(pos_tags)
+    pos_tags = assistant.grammatical_pos_tagger('Mis amigos están pensando en viajar a Londres este verano')
+    print(pos_tags)
 
-tune = assistant.text_to_music("This is a traditional Irish dance music.")
-print(tune)
+    tune = assistant.text_to_music("This is a traditional Irish dance music.")
+    print(tune)
 

lib/spell.py

@@ -1,22 +1,19 @@
-import datetime
-
-# Tabla de los nombres de los ángeles por estación zodiacal
-angels_by_zodiac_station = {
-    "Aries": ["sha'aphon", "behemoth", "bekemesheb/bekemekesheb", "qotzien"],
-    "Tauro": ["dierenavor", "heniethebol", "siemegedel", "morepheker"],
-    "Geminis": ["sheneron", "phelehedien", "volereked", "akeneseb"],
-    "Cancer": ["Qedoqoredi", "Qoheleren", "Phereshetial", "Memenial"],
-    "Leo": ["Bephopher", "Lieshebeker", "Shehenen", "shehelekek"],
-    "Virgo": ["Siemosial", "Sebodeh", "Siegel", "Teremothiteh"],
-    "Libra": ["A'ariegol", "Mereton", "Qa'aberi", "Legoshmelek"],
-    "Escorpio": ["Therepiethz", "Phetza'an", "Shemophethen", "Thokesed"],
-    "Sagitario": ["Aketen", "Kephron", "Oliphiel", "Yosel"],
-    "Capricornio": ["Ameni", "Bieker", "Depheri", "Menenial"],
-    "Acuario": ["Meta'am", "Theberien", "Shethoqoeh", "Danial"],
-    "Piscis": ["Sha'aphenen", "Aniesien", "Sethered", "Qohemehogov"]
-}
 
-# Tabla de los nombres de los ángeles por mes y estación
+ angels_by_zodiac_station = {
+        "Aries": ["sha'aphon", "behemoth", "bekemesheb/bekemekesheb", "qotzien"],
+        "Tauro": ["dierenavor", "heniethebol", "siemegedel", "morepheker"],
+        "Geminis": ["sheneron", "phelehedien", "volereked", "akeneseb"],
+        "Cancer": ["Qedoqoredi", "Qoheleren", "Phereshetial", "Memenial"],
+        "Leo": ["Bephopher", "Lieshebeker", "Shehenen", "shehelekek"],
+        "Virgo": ["Siemosial", "Sebodeh", "Siegel", "Teremothiteh"],
+        "Libra": ["A'ariegol", "Mereton", "Qa'aberi", "Legoshmelek"],
+        "Escorpio": ["Therepiethz", "Phetza'an", "Shemophethen", "Thokesed"],
+        "Sagitario": ["Aketen", "Kephron", "Oliphiel", "Yosel"],
+        "Capricornio": ["Ameni", "Bieker", "Depheri", "Menenial"],
+        "Acuario": ["Meta'am", "Theberien", "Shethoqoeh", "Danial"],
+        "Piscis": ["Sha'aphenen", "Aniesien", "Sethered", "Qohemehogov"]
+    }
+
 angels_by_month_station = {
     "Nisan": ["Asegesenek", "Mesokenek", "Deriegemon", "Shethenovesenov"],
     "Ayer": ["Phemetor", "Qotenebial", "Ma'agol", "Goberethial"],
@@ -32,9 +29,8 @@ angels_by_month_station = {
     "Adar": ["Koneled", "Ba'aren", "Sebiebekera'a", "Qoromeqore"]
 }
 
-# Tabla de los nombres de los ángeles por día y estación
 angels_by_day_station = {
-    1: ["Phiegenochen", "Tenekien", "Kophethenien", "Makeleched"],
+    1: ["Phiegenochen", "Tenekien", "Kophethen", "Makeleched"],
     2: ["Tga'sher", "Menechethor", "Qoleneheren", "Shegedon"],
     3: ["Sheriyachetz", "Qohebereneden", "Pherezen", "Hegelomoth"],
     4: ["Pheniov Lavor", "Miyeshor", "Degiem", "Betheroqa"],
@@ -42,7 +38,6 @@ angels_by_day_station = {
     6: ["Qola'azeran", "Deremthok", "Akethenor", "Arieh"]
 }
 
-# Tabla de los nombres de los ángeles por signo de luna
 angels_by_moon_sign = {
     "Leberenieth": ["shaitan", "therezien", "sheneremi", "Gabrial"],
     "Seletheleb": ["Yieshieshieh", "Abererehon", "Sheheqonek", "Bal Menael"],
@@ -50,7 +45,6 @@ angels_by_moon_sign = {
     "Sheherieph": ["Biyom", "Bieth", "Rothep", "Danial"]
 }
 
-# Tabla de los nombres de los ángeles que ministran la luna por signo zodiacal
 moon_ministers_by_zodiac = {
     "Aries": ["Zerem", "Behemi", "Pheloneh", "Qonosh"],
     "Tauro": ["Deketon", "Mezekerien", "Thederenael", "Amiena"],
@@ -66,7 +60,6 @@ moon_ministers_by_zodiac = {
     "Piscis": ["Sha'aphenen", "Aniesien", "Sethered", "Qohemehogov"]
 }
 
-# Tabla de los nombres de los ángeles por estación de la Tierra
 angels_by_earth_station = {
     1: ["Memegien", "Yibesheh", "Thebel", "Hezeh Dovem"],
     2: ["Mechemed Lov", "Bel Ached", "Aseberon", "Qohelorek"],
@@ -74,7 +67,6 @@ angels_by_earth_station = {
     4: ["Yihelederek", "Mephenial", "Mephenial", ""]
 }
 
-# Tabla de los nombres de los ángeles por estación de los Malechims
 angels_by_malechim_station = {
     1: ["Akeberon", "Amereneh", "Mazeniem", "Meneshor"],
     2: ["Qoherok", "Aberiek", "Siegor", "Pheniemor"],
@@ -82,33 +74,84 @@ angels_by_malechim_station = {
     4: ["Beriekoch", "Kephor", "Avor", ""]
 }
 
-# Obtener la fecha actual
-current_date = datetime.datetime.now()
 
-# Obtener el mes actual
-current_month = current_date.month
 
-# Obtener el día actual
-current_day = current_date.day
 
-# Obtener el signo zodiacal correspondiente al mes actual
-zodiac_sign = angels_by_month_station[list(angels_by_month_station.keys())[current_month - 1]][3]
+class AngelSearch:
+    def __init__(self, angels_by_zodiac_station, angels_by_month_station, angels_by_day_station,
+                 angels_by_moon_sign, moon_ministers_by_zodiac, angels_by_earth_station,
+                 angels_by_malechim_station):
+        self.angels_by_zodiac_station = angels_by_zodiac_station
+        self.angels_by_month_station = angels_by_month_station
+        self.angels_by_day_station = angels_by_day_station
+        self.angels_by_moon_sign = angels_by_moon_sign
+        self.moon_ministers_by_zodiac = moon_ministers_by_zodiac
+        self.angels_by_earth_station = angels_by_earth_station
+        self.angels_by_malechim_station = angels_by_malechim_station
+
+    def search_patterns(self, pattern):
+        results = []
+
+        # Buscar en la tabla de nombres de ángeles por estación zodiacal
+        for zodiac, angels in self.angels_by_zodiac_station.items():
+            for angel in angels:
+                if pattern in angel:
+                    results.append((zodiac, angel))
+
+        # Buscar en la tabla de nombres de ángeles por mes y estación
+        for month, angels in self.angels_by_month_station.items():
+            for angel in angels:
+                if pattern in angel:
+                    results.append((month, angel))
+
+        # Buscar en la tabla de nombres de ángeles por día y estación
+        for day, angels in self.angels_by_day_station.items():
+            for angel in angels:
+                if pattern in angel:
+                    results.append((day, angel))
+
+        # Buscar en la tabla de nombres de ángeles por signo de luna
+        for sign, angels in self.angels_by_moon_sign.items():
+            for angel in angels:
+                if pattern in angel:
+                    results.append((sign, angel))
+
+        # Buscar en la tabla de nombres de ángeles que ministran la luna por signo zodiacal
+        for zodiac, angels in self.moon_ministers_by_zodiac.items():
+            for angel in angels:
+                if pattern in angel:
+                    results.append((zodiac, angel))
+
+        # Buscar en la tabla de nombres de ángeles por estación de la Tierra
+        for station, angels in self.angels_by_earth_station.items():
+            for angel in angels:
+                if pattern in angel:
+                    results.append((station, angel))
+
+        # Buscar en la tabla de nombres de ángeles por estación de los Malechims
+        for station, angels in self.angels_by_malechim_station.items():
+            for angel in angels:
+                if pattern in angel:
+                    results.append((station, angel))
+
+        return results
 
-# Obtener el ángel correspondiente para cada tabla según la fecha actual
-angel_day = angels_by_day_station[current_day][int(zodiac_sign[-1]) - 1]
-angel_month = angels_by_month_station[list(angels_by_month_station.keys())[current_month - 1]][int(zodiac_sign[-1]) - 1]
-angel_zodiac = angels_by_zodiac_station[zodiac_sign][int(zodiac_sign[-1]) - 1]
-angel_moon_sign = angels_by_moon_sign["Leberenieth"][int(zodiac_sign[-1]) - 1]
-angel_moon_minister = moon_ministers_by_zodiac[zodiac_sign][int(zodiac_sign[-1]) - 1]
-angel_earth_station = angels_by_earth_station[list(angels_by_earth_station.keys())[current_month - 1]][int(zodiac_sign[-1]) - 1]
-angel_malechim_station = angels_by_malechim_station[list(angels_by_malechim_station.keys())[current_month - 1]][int(zodiac_sign[-1]) - 1]
+if __name__ == "__main__":
+    # Tablas de nombres de ángeles
+   
+    # Crear una instancia de AngelSearch
+    angel_search = AngelSearch(angels_by_zodiac_station, angels_by_month_station, angels_by_day_station,
+                               angels_by_moon_sign, moon_ministers_by_zodiac, angels_by_earth_station,
+                               angels_by_malechim_station)
 
-# Imprimir los resultados
-print("Ángel correspondiente al día actual y al signo zodiacal:", angel_day)
-print("Ángel correspondiente al mes actual y al signo zodiacal:", angel_month)
-print("Ángel correspondiente al signo zodiacal:", angel_zodiac)
-print("Ángel correspondiente al signo de la luna:", angel_moon_sign)
-print("Ángel que ministra el signo zodiacal:", angel_moon_minister)
-print("Ángel correspondiente a la estación de la Tierra:", angel_earth_station)
-print("Ángel correspondiente a la estación de los Malechims:", angel_malechim_station)
+    # Buscar ángeles que contienen el patrón "Qo"
+    pattern = "Qo"
+    results = angel_search.search_patterns(pattern)
 
+    # Imprimir resultados de la búsqueda
+    print(f"Resultados de la búsqueda para el patrón '{pattern}':")
+    if results:
+        for result in results:
+            print(result)
+    else:
+        print("No se encontraron coincidencias para el patrón proporcionado.")

lib/triggers.py

@@ -0,0 +1,82 @@
+import datetime
+import requests
+
+class Trigger:
+    def __init__(self, trigger_tags, comparison_tags, time_definition, event_name, included=True):
+        self.trigger_tags = set(trigger_tags)
+        self.comparison_tags = set(comparison_tags)
+        self.time_definition = time_definition
+        self.event_name = event_name
+        self.included = included
+        self.threshold = 0
+        self.actions = []
+        self.sources = []
+
+    def add_action(self, action):
+        self.actions.append(action)
+
+    def remove_action(self, action):
+        if action in self.actions:
+            self.actions.remove(action)
+        else:
+            print("Action not found")
+
+    def add_source(self, source):
+        self.sources.append(source)
+
+    def remove_source(self, source):
+        if source in self.sources:
+            self.sources.remove(source)
+        else:
+            print("Source not found")
+
+    def check_trigger(self, current_tags, current_time):
+        if self.included:
+            if current_time in self.time_definition and self.trigger_tags.issubset(current_tags):
+                self.threshold += 1
+            else:
+                self.threshold = 0
+        else:
+            if current_time in self.time_definition and not self.trigger_tags.intersection(current_tags):
+                self.threshold += 1
+            else:
+                self.threshold = 0
+
+        if self.threshold >= len(self.time_definition):
+            self.fire_actions()
+            self.make_requests()
+
+    def fire_actions(self):
+        for action in self.actions:
+            action(self.event_name)
+
+    def make_requests(self):
+        for source in self.sources:
+            try:
+                response = requests.get(source)
+                # Procesar la respuesta aquí si es necesario
+                print(f"Request made to {source}. Status code: {response.status_code}")
+            except requests.exceptions.RequestException as e:
+                print(f"Error making request to {source}: {e}")
+
+# Ejemplo de uso:
+
+def action_function(event_name):
+    print(f"Trigger fired for event: {event_name}")
+
+
+if __name__ == "__main__":
+
+    # Definición de un trigger
+    trigger = Trigger(["tag1", "tag2"], ["tag3", "tag4"], [datetime.time(10, 0), datetime.time(15, 0)], "Event1")
+
+    # Añadir una acción al trigger
+    trigger.add_action(action_function)
+
+    # Añadir una fuente al trigger
+    trigger.add_source("https://example.com/api/data")
+
+    # Simular la comprobación periódica del trigger (aquí se usaría en un bucle de tiempo real)
+    current_tags = {"tag1", "tag2", "tag3"}
+    current_time = datetime.datetime.now().time()
+    trigger.check_trigger(current_tags, current_time)