test data pleyades

lib/entropy.py

@@ -0,0 +1,122 @@
+import sys
+import math
+
+class TextProcessor:
+    def __init__(self, texto):
+        self.texto = texto
+
+    def entropy(self):
+        simbolos = {}
+        total_caracteres = len(self.texto)
+
+        for caracter in self.texto:
+            simbolos[caracter] = simbolos.get(caracter, 0) + 1
+
+        entropia = 0
+        for count in simbolos.values():
+            probabilidad = count / total_caracteres
+            entropia -= probabilidad * math.log2(probabilidad)
+
+        return simbolos, entropia
+
+    def common_string(self, cadena1, cadena2):
+        longitud1 = len(cadena1)
+        longitud2 = len(cadena2)
+        comun = ''
+        subcadenas_comunes = []
+
+        for i in range(longitud1):
+            for j in range(longitud2):
+                k = 0
+                while (i+k < longitud1 and j+k < longitud2 and cadena1[i+k] == cadena2[j+k]):
+                    k += 1
+                if k > 0:
+                    subcadenas_comunes.append(cadena1[i:i+k])
+
+        if subcadenas_comunes:
+            comun = max(subcadenas_comunes, key=len)
+
+        return comun
+
+    def magic_split(self):
+        unique_symbols = set(self.texto)
+        symbol_distances = {}
+        for symbol in unique_symbols:
+            indices = [i for i, char in enumerate(self.texto) if char == symbol]
+            if len(indices) > 1:
+                distances = [indices[i + 1] - indices[i] for i in range(len(indices) - 1)]
+                symbol_distances[symbol] = distances
+
+        variation = {symbol: max(distances) - min(distances) for symbol, distances in symbol_distances.items() if distances}
+
+        mins = {}
+        for v in variation:
+            if variation[v]!=0 and variation[v]!=1:
+                mins[v] = variation[v]
+
+        best_symbol = min(mins, key=mins.get)
+
+        return best_symbol
+
+    def rotate_string(self, string, n):
+        indice = n % len(string)
+        string_rotado = string[indice:] + string[:indice]
+        return string_rotado
+
+    def rotate_compare(self, tokiA, tokiB):
+        if tokiA >= tokiB:
+            tokA = tokiA
+            tokB = tokiB
+            ltokA = len(tokA)
+        else:
+            tokA = tokiB
+            tokB = tokiA
+            ltokA = len(tokB)
+
+        i = 0
+        rotations = {}
+        while i < ltokA:
+            tokrotated = self.rotate_string(tokA, i)
+            rotations[str(i)] = self.common_string(tokrotated, tokB) 
+            i += 1
+
+        best_r = ""
+        for x in rotations:
+            lb = len(best_r)
+            rot = rotations[x]
+            lrot = len(rot)
+            if lrot > 1 and lrot < ltokA and lrot > lb:
+                best_r = rot
+
+        return best_r
+
+    def get_subTokens(self, spl):
+        sub_tokens = self.texto.split(spl)
+        toks = []
+        for tok in sub_tokens:
+            for tok2 in sub_tokens:
+                if tok != tok2:
+                    toks.append(self.rotate_compare(tok, tok2))
+
+        return list(set(toks))
+
+    def tokenize(self, spliter_optimo):
+        tokens = self.get_subTokens(spliter_optimo)
+        tokenized_sentence = {}
+        chunk = self.texto.split(spliter_optimo)
+        for txt in chunk:
+            best_split = ""
+            for tok in tokens:
+                if tok != "":
+                    lt = len(tok)
+                    lb = len(best_split)
+                    spltxt = txt.split(tok)
+                    if len(spltxt) > 1:
+                        l0 = len(spltxt[0])
+                        l1 = len(spltxt[1])
+                        if lt < len(txt) and lt > lb:
+                            best_split = tok
+                            tokenized_sentence[txt] = " " + spltxt[0] + "-" + tok + "-" + spltxt[1]
+        return tokenized_sentence
+
+

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/files.py

@@ -0,0 +1,28 @@
+import os
+import re
+
+class TextFinder:
+    def __init__(self, folder):
+        self.folder = folder
+
+    def find_matches(self, pattern):
+        matches = []
+        pattern = pattern.lower()  # Convert pattern to lowercase
+        for root, _, files in os.walk(self.folder):
+            for file in files:
+                file_path = os.path.join(root, file)
+
+                if os.path.isfile(file_path):
+                    with open(file_path, 'r', encoding='utf-8') as f:
+                        content = f.read()
+                        paragraphs = re.split(r'\n\s*\n', content)  # Split text into paragraphs
+                        for paragraph in paragraphs:
+                            if pattern in paragraph.lower():  # Convert paragraph to lowercase for comparison
+                                matches.append({"Find_text":paragraph.strip(),"Book_source":file_path.split("/")[-1].split(".")[0]})
+        return matches
+
+# Example usage:
+if __name__ == "__main__":
+    finder = TextFinder('example_folder')
+    matches = finder.find_matches('text_to_find')
+    print(matches)

lib/gematria.py

@@ -0,0 +1,210 @@
+import json
+from prettytable import PrettyTable
+from colorama import Fore, Style
+from collections import defaultdict
+import unicodedata
+
+def strip_diacritics(text):
+    """
+    Entfernt Diakritika von Unicode-Zeichen, um den Basisbuchstaben zu erhalten, und gibt Warnungen
+    für tatsächlich unbekannte Zeichen aus.
+    """
+    stripped_text = ''
+    for char in unicodedata.normalize('NFD', text):
+        if unicodedata.category(char) not in ['Mn', 'Cf']:
+            stripped_text += char
+        else:
+            print(f"Info: Diakritisches Zeichen '{char}' wird ignoriert.")
+    return stripped_text
+
+def hebrew_letter_to_value(letter):
+    """
+    Konvertiert einen einzelnen Buchstaben in seinen Gematria-Wert, ignoriert Leerzeichen
+    und Nicht-Buchstaben-Zeichen.
+    """
+    # Dein vorhandenes Wörterbuch bleibt unverändert
+    values = {
+    # Lateinische Buchstaben
+    'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6, 'g': 7, 'h': 8, 'i': 9, 'j': 600,
+    'k': 10, 'l': 20, 'm': 30, 'n': 40, 'o': 50, 'p': 60, 'q': 70, 'r': 80, 's': 90,
+    't': 100, 'u': 200, 'v': 700, 'w': 900, 'x': 300, 'y': 400, 'z': 500,
+
+    'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 5, 'F': 6, 'G': 7, 'H': 8, 'I': 9, 'J': 600,
+    'K': 10, 'L': 20, 'M': 30, 'N': 40, 'O': 50, 'P': 60, 'Q': 70, 'R': 80, 'S': 90,
+    'T': 100, 'U': 200, 'V': 700, 'W': 900, 'X': 300, 'Y': 400, 'Z': 500,
+
+    # Basisbuchstaben und einige bereits genannte Varianten
+    'ا': 1, 'أ': 1, 'إ': 1, 'آ': 1, 'ب': 2, 'ج': 3, 'د': 4, 'ه': 5, 'و': 6, 'ز': 7, 'ح': 8, 'ط': 9,
+    'ي': 10, 'ى': 10, 'ك': 20, 'ک': 20, 'ل': 30, 'م': 40, 'ن': 50, 'س': 60, 'ع': 70, 'ف': 80,
+    'ص': 90, 'ق': 100, 'ر': 200, 'ش': 300, 'ت': 400, 'ث': 500, 'خ': 600, 'ذ': 700, 'ض': 800, 'ظ': 900, 'غ': 1000,
+    'ٱ': 1, # Alif Wasla
+    'ـ': 0, # Tatweel
+
+    # Zusätzliche Varianten und Sonderzeichen
+    'ة': 400, # Taa Marbuta
+    'ؤ': 6,  # Waw mit Hamza darüber
+    'ئ': 10, # Ya mit Hamza darüber
+    'ء': 1,  # Hamza
+    'ى': 10, # Alif Maqsurah
+    'ٹ': 400, # Taa' marbuta goal
+    'پ': 2,  # Pe (Persisch/Urdu)
+    'چ': 3,  # Che (Persisch/Urdu)
+    'ژ': 7,  # Zhe (Persisch/Urdu)
+    'گ': 20, # Gaf (Persisch/Urdu)
+    'ڭ': 20, # Ngaf (Kazakh, Uyghur, Uzbek, and in some Arabic dialects)
+    'ں': 50, # Noon Ghunna (Persisch/Urdu)
+    'ۀ': 5,  # Heh with Yeh above (Persisch/Urdu)
+    'ے': 10, # Barree Yeh (Persisch/Urdu)
+    '؋': 0,  # Afghani Sign (wird als Währungssymbol verwendet, nicht für Gematria relevant, aber hier zur Vollständigkeit aufgeführt)
+
+    # Anmerkung: Das Währungssymbol und ähnliche Zeichen sind in einem Gematria-Kontext normalerweise nicht relevant,
+    # werden aber der Vollständigkeit halber aufgeführt. Es gibt noch viele weitere spezifische Zeichen in erweiterten
+    # arabischen Schriftsystemen (z.B. für andere Sprachen wie Persisch, Urdu, Pashto usw.), die hier nicht vollständig
+    # abgedeckt sind.
+
+    # Grund- und Schlussformen hebräischer Buchstaben
+
+    'א': 1, 'ב': 2, 'ג': 3, 'ד': 4, 'ה': 5, 'ו': 6, 'ז': 7, 'ח': 8, 'ט': 9, 'י': 10,
+    'כ': 20, 'ך': 500, 'ל': 30, 'מ': 40, 'ם': 600, 'נ': 50, 'ן': 700, 'ס': 60, 'ע': 70, 'פ': 80, 'ף': 800,
+    'צ': 90, 'ץ': 900, 'ק': 100, 'ר': 200, 'ש': 300, 'ת': 400,
+
+    # Griechische Buchstaben
+    'α': 1, 'β': 2, 'γ': 3, 'δ': 4, 'ε': 5, 'ϝ': 6, 'ζ': 7, 'η': 8, 'θ': 9, 'ι': 10,
+    'κ': 20, 'λ': 30, 'μ': 40, 'ν': 50, 'ξ': 60, 'ο': 70, 'π': 80, 'ϟ': 90, 'ρ': 100,
+    'σ': 200, 'τ': 300, 'υ': 400, 'φ': 500, 'χ': 600, 'ψ': 700, 'ω': 800, 'ϡ': 900,
+
+        # Griechische Großbuchstaben
+    'Α': 1, 'Β': 2, 'Γ': 3, 'Δ': 4, 'Ε': 5, 'Ϝ': 6, 'Ζ': 7, 'Η': 8, 'Θ': 9, 'Ι': 10,
+    'Κ': 20, 'Λ': 30, 'Μ': 40, 'Ν': 50, 'Ξ': 60, 'Ο': 70, 'Π': 80, 'Ϟ': 90, 'Ρ': 100,
+    'Σ': 200, 'Τ': 300, 'Υ': 400, 'Φ': 500, 'Χ': 600, 'Ψ': 700, 'Ω': 800, 'Ϡ': 900,
+    }
+
+    # Stelle sicher, dass Diakritika entfernt werden, bevor auf das Wörterbuch zugegriffen wird
+    letter_no_diacritics = strip_diacritics(letter)
+
+    if letter_no_diacritics in values:
+        return values[letter_no_diacritics.lower()]
+    elif letter.strip() == "":  # Ignoriere Leerzeichen und leere Zeilen
+        return 0
+    else:
+        # Gib eine spezifische Warnung aus, wenn das Zeichen unbekannt ist
+        print(f"Warnung: Unbekanntes Zeichen '{letter}' ignoriert.")
+        return 0
+
+
+def calculate_gematria(text):
+    """Calculate the Gematria value of a given Hebrew text, ignoring spaces and non-Hebrew characters."""
+    return sum(hebrew_letter_to_value(letter) for letter in text if letter.strip() != "")
+
+    
+# Función para calcular el valor de gematria de una letra hebrea antigua
+def gematria(letra):
+    valores = {'א': 1, 'ב': 2, 'ג': 3, 'ד': 4, 'ה': 5, 'ו': 6, 'ז': 7, 'ח': 8, 'ט': 9,
+               'י': 10, 'כ': 20, 'ל': 30, 'מ': 40, 'נ': 50, 'ס': 60, 'ע': 70, 'פ': 80,
+               'צ': 90, 'ק': 100, 'ר': 200, 'ש': 300, 'ת': 400, 'ך': 20, 'ם': 40, 'ן': 50, 'ף': 80, 'ץ': 90}
+    return valores.get(letra, 0)
+
+# Función para generar todas las combinaciones posibles de dos letras en hebreo antiguo
+def generar_combinaciones():
+    letras = ['א', 'ב', 'ג', 'ד', 'ה', 'ו', 'ז', 'ח', 'ט', 'י', 'כ', 'ל', 'מ', 'נ', 'ס', 'ע', 'פ', 'צ', 'ק', 'ר', 'ש', 'ת',
+              'ך', 'ם', 'ן', 'ף', 'ץ']
+    combinaciones = []
+    for letra1 in letras:
+        for letra2 in letras:
+            combinaciones.append(letra1 + letra2)
+    return combinaciones
+
+# Función para calcular la suma de los valores de gematria y el producto de los valores de gematria de una combinación
+def calcular_valores(combinacion):
+    valor1 = gematria(combinacion[0])
+    valor2 = gematria(combinacion[1])
+    suma = valor1 + valor2
+    producto = valor1 * valor2
+    ratio = valor1 / valor2 if valor2 != 0 else float('inf')
+    return suma, producto, ratio
+
+# Función principal
+def main():
+    combinaciones = generar_combinaciones()
+    table = PrettyTable()
+    table.field_names = ["#", Fore.BLUE + "Producto" + Style.RESET_ALL,
+                         Fore.BLUE + "Suma" + Style.RESET_ALL,
+                         Fore.BLUE + "Ratio" + Style.RESET_ALL,
+                         Fore.BLUE + "Valor 2" + Style.RESET_ALL,
+                         Fore.BLUE + "Valor 1" + Style.RESET_ALL,
+                         Fore.BLUE + "Combinación" + Style.RESET_ALL]
+    
+    # Diccionario de combinaciones agrupadas por ratio
+    combinaciones_por_ratio = defaultdict(set)
+    
+    # Versos del Génesis Sefardí (ejemplo)
+    versos_genesis_sefardi = [
+        "בראשית ברא אלהים את השמים ואת הארץ",
+        "והארץ היתה תהו ובהו וחשך על־פני תהום ורוח אלהים מרחפת על־פני המים",
+        "ויאמר אלהים יהי אור ויהי־אור",
+        "וירא אלהים את־האור כי־טוב ויבדל אלהים בין האור ובין החשך",
+        "ויקרא אלהים לאור יום ולחשך קרא לילה ויהי־ערב ויהי־בקר יום אחד"
+        # Agrega más versos según sea necesario...
+    ]
+    
+    # Función para obtener el primer par de letras de un verso
+    def obtener_primer_par_letras(verso):
+        for i in range(len(verso) - 1):
+            if verso[i].isalpha() and verso[i+1].isalpha():
+                return verso[i:i+2]
+        return None
+    
+    # Diccionario para almacenar el primer par de letras y su ratio por verso
+    primer_par_por_verso = {}
+    for verso in versos_genesis_sefardi:
+        primer_par = obtener_primer_par_letras(verso)
+        if primer_par:
+            suma, producto, ratio = calcular_valores(primer_par)
+            primer_par_por_verso[verso] = (primer_par, ratio)
+    
+    # Diccionario para agrupar los primeros pares de letras por ratio
+    primer_par_por_ratio = defaultdict(list)
+    for verso, (primer_par, ratio) in primer_par_por_verso.items():
+        primer_par_por_ratio[ratio].append((primer_par, verso))
+    
+    # Crear la tabla de primeros pares de letras por ratio
+    table_primer_par = PrettyTable()
+    table_primer_par.field_names = [Fore.BLUE + "Primer Par" + Style.RESET_ALL, Fore.BLUE + "Ratio" + Style.RESET_ALL, Fore.BLUE + "Verso" + Style.RESET_ALL]
+    for ratio, pares_verso in sorted(primer_par_por_ratio.items(), key=lambda x: x[0], reverse=True):
+        for primer_par, verso in pares_verso:
+            table_primer_par.add_row([primer_par, f"{ratio:.2f}", verso])
+    
+    print(table_primer_par)
+    
+    # Procesar combinaciones y crear la tabla principal
+    for idx, combinacion in enumerate(combinaciones, start=1):
+        suma, producto, ratio = calcular_valores(combinacion)
+        combinacion_str = combinacion
+        # Resaltar en verde si la combinación está en el conjunto de combinaciones del Génesis Sefardí
+        if combinacion in set(''.join(obtener_primer_par_letras(verso)) for verso in versos_genesis_sefardi):
+            combinacion_str = Fore.GREEN + combinacion + Style.RESET_ALL
+        table.add_row([idx, producto, suma, f"{ratio:.2f}", gematria(combinacion[1]), gematria(combinacion[0]), combinacion_str])
+        combinaciones_por_ratio[ratio].add(combinacion)
+    
+    # Mostrar la tabla de combinaciones
+    print("\nTabla de combinaciones:")
+    print(table)
+    
+    # Mostrar la tabla de combinaciones agrupadas por ratio
+    print("\nTabla de combinaciones agrupadas por ratio:")
+    table_ratio = PrettyTable()
+    table_ratio.field_names = [Fore.BLUE + "Ratio" + Style.RESET_ALL, Fore.BLUE + "Combinaciones" + Style.RESET_ALL]
+    for ratio, combinaciones in sorted(combinaciones_por_ratio.items(), key=lambda x: x[0], reverse=True):
+        combinaciones_str = ", ".join(combinaciones)
+        table_ratio.add_row([f"{ratio:.2f}", combinaciones_str])
+    print(table_ratio)
+    
+    # Calcular el número de combinaciones únicas de primeros pares de letras
+    primeros_pares_unicos = set(primer_par for primer_par, _ in primer_par_por_verso.values())
+    num_primeros_pares_unicos = len(primeros_pares_unicos)
+    num_combinaciones_totales = len(combinaciones)
+    print(f"\nNúmero de primeros pares de letras únicos: {num_primeros_pares_unicos}")
+    print(f"Número de combinaciones totales posibles: {num_combinaciones_totales}")
+
+if __name__ == "__main__":
+    main()

lib/grapher.py

@@ -0,0 +1,118 @@
+import requests
+import json
+import networkx as nx
+import matplotlib.pyplot as plt
+from fuzzywuzzy import fuzz
+from fuzzywuzzy import process
+from lib.memory import *
+
+
+class APIRequester:
+    def __init__(self):
+        pass
+
+    def make_request(self, url):
+        response = requests.get(url)
+        if response.status_code == 200:
+            return response.json()
+        else:
+            return None
+
+class Grapher:
+    def __init__(self, memoria_nlp, threshold=70):
+        self.threshold = threshold
+        self.graph = nx.Graph()
+        self.memoria_nlp = memoria_nlp
+
+    def parse_json(self, data, parent=None):
+        if isinstance(data, dict):
+            for key, value in data.items():
+                if parent:
+                    self.graph.add_node(parent)
+                    self.graph.add_node(key)
+                    self.graph.add_edge(parent, key)
+
+                    for node in self.graph.nodes():
+                        if node != parent and fuzz.ratio(node, key) >= self.threshold:
+                            self.graph = nx.contracted_nodes(self.graph, node, key, self_loops=False)
+
+                self.memoria_nlp.agregar_concepto("keys", [(key, 1.0)])
+
+                if isinstance(value, (dict, list)):
+                    self.parse_json(value, key)
+                else:
+                    self.memoria_nlp.agregar_concepto("values", [(str(value), 1.0)])
+                    if parent:
+                        self.graph.add_node(value)
+                        self.graph.add_edge(key, value)
+
+                        for node in self.graph.nodes():
+                            if node != value and fuzz.ratio(node, value) >= self.threshold:
+                                self.graph = nx.contracted_nodes(self.graph, node, value, self_loops=False)
+        elif isinstance(data, list):
+            for item in data:
+                self.parse_json(item, parent)
+
+    def draw_graph(self):
+        pos = nx.spring_layout(self.graph, seed=42)
+        nx.draw(self.graph, pos, with_labels=True, node_size=700, node_color='skyblue', font_size=10, font_weight='bold')
+        plt.title("JSON Graph")
+        plt.show()
+
+    def guardar_en_memoria(self):
+        keys = self.memoria_nlp.obtener_conceptos_acotados(100)
+        with open("memoria.json", "w") as file:
+            json.dump(keys, file)
+            
+    def buscar_nodo(self, nodo):
+        return process.extractOne(nodo, self.graph.nodes())[0]
+    
+    def eliminar_nodo(self, nodo):
+        self.graph.remove_node(nodo)
+    
+    def agregar_nodo(self, nodo):
+        self.graph.add_node(nodo)
+    
+    def distancia_entre_nodos(self, nodo1, nodo2):
+        return nx.shortest_path_length(self.graph, source=nodo1, target=nodo2)
+    
+    def ruta_entre_nodos(self, nodo1, nodo2):
+        return nx.shortest_path(self.graph, source=nodo1, target=nodo2)
+    
+    def unir_grafos(self, otro_grafo, umbral):
+        for nodo in otro_grafo.nodes():
+            nodo_similar = process.extractOne(nodo, self.graph.nodes())[0]
+            if fuzz.ratio(nodo, nodo_similar) >= umbral:
+                self.graph = nx.contracted_nodes(self.graph, nodo_similar, nodo, self_loops=False)
+            else:
+                self.graph.add_node(nodo)
+                for vecino in otro_grafo.neighbors(nodo):
+                    self.graph.add_edge(nodo, vecino)
+
+
+if __name__ == "__main__":
+
+    # Ejemplo de uso
+    memoria_nlp = MemoriaRobotNLP(max_size=100)
+    json_parser = JSONParser(memoria_nlp)
+
+    api_requester = APIRequester()
+    url = "https://jsonplaceholder.typicode.com/posts"
+    data = api_requester.make_request(url)
+
+    if data:
+        json_parser.parse_json(data)
+        json_parser.draw_graph()
+        
+        otro_parser = JSONParser(MemoriaRobotNLP(max_size=100))
+        otro_parser.parse_json({"id": 101, "title": "New Title", "userId": 11})
+        
+        print("Uniendo los grafos...")
+        json_parser.unir_grafos(otro_parser.graph, umbral=80)
+        print("Grafo unido:")
+        json_parser.draw_graph()
+        
+        json_parser.guardar_en_memoria()
+    else:
+        print("Error al realizar la solicitud a la API.")
+

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,298 @@
+from lib.files import *
+from lib.memory import *
+from lib.grapher import *
+from lib.pipes import *
+from lib.entropy import *
+from lib.events import *
+from lib.triggers import *
+
+## Sources
+from lib.sonsofstars import *
+import internetarchive
+
+
+## Initialize classes 
+longMem = TextFinder("./resources/")
+coreAi = AIAssistant()
+memory = MemoryRobotNLP(max_size=200000)
+grapher = Grapher(memory)
+sensor_request = APIRequester()
+events = EventManager()
+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)
+
+## Define I Role properties
+class ownProperties:
+    def __init__(self, nombre, clase, raza, nivel, atributos, habilidades, equipo, historia):
+        self.nombre = nombre
+        self.clase = clase
+        self.raza = raza
+        self.nivel = nivel
+        self.atributos = atributos
+        self.habilidades = habilidades
+        self.equipo = equipo
+        self.historia = historia
+
+# Create an instance of a CharacterRole based on the provided JSON
+sophia_prop = {
+    "name": "Sophia",
+    "class": "Characteromant",
+    "race": "Epinoia",
+    "level": 10,
+    "attributes": {
+        "strength": 1,
+        "dexterity": 99,
+        "constitution": 1,
+        "intelligence": 66,
+        "wisdom": 80,
+        "charisma": 66
+    },
+    "behavioral_rules": [""],
+    "goals": ["", ""],
+    "dislikes": [""],
+    "abilities": ["ELS", "Cyphers", "Kabbalah", "Wisdom", "Ephimerous", "Metamorphing"],
+    "equipment": ["Python3", "2VCPU", "16 gb RAM", "god", "word", "network", "transformers"],
+    "story": sons_of_stars
+}
+
+
+## Define I class 
+class I:
+    def __init__(self, prompt, 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
+
+    ## create questions from internet archive 
+    def crear_preguntas(self,txt):
+        search = internetarchive.search_items(txt)
+        res = []
+        for result in search:
+            print(result['identifier'])
+            idc=result["identifier"]
+            
+
+            headers = {"accept": "application/json"}
+
+        ## get book pages
+            req2 = requests.get("https://archive.org/stream/"+idc+"/"+idc+"_djvu.txt",headers=headers)
+        #print(req2.text)
+            try:
+                txt = req2.text.split("<pre>")[1].split("</pre>")[0].split(" <!--")[0]
+
+                for x in txt.split("\n"):
+                    if "?" in x:
+                        res.append(x)
+
+            except:
+                pass
+
+        return res
+
+    # generate ShortMem from LongTerm and questions over prompt data, compare with ourself datasets, return matches with sentiment analysys
+    def longToShortFast(self,txt):
+        memory.memory = {}
+
+        subjects = coreAi.entity_pos_tagger(txt)
+        subjects_nc = coreAi.grammatical_pos_tagger(txt)
+
+
+        #print(subjects_nc)
+        subjects_filtered=[]
+        for sub in subjects:
+            if "PER" in sub["entity"] or "ORG" in sub["entity"] or "LOC" in sub["entity"] and len(sub["entity"])>3:
+                subjects_filtered.append(sub["word"])
+        
+        for sub in subjects_nc:
+            if "NN" in sub["entity"]:
+                subjects_filtered.append(sub["word"])
+        
+        ## AD NC TAGGER QUERIES
+        #print(subjects_filtered)
+        subjects_filtered=coreAi.process_list(subjects_filtered)
+        subs=[]
+        for sub in subjects_filtered:
+            if len(sub)>3:
+                subs.append(sub)
+
+        exprs = coreAi.gen_search_expr(subs[0:3])
+        for sub in exprs:
+            #print(sub)
+            memory.add_concept(sub,longMem.find_matches(sub))    
+
+        return memory   
+    
+    def longToShort(self,txt):
+        
+        think_about = longMem.find_matches(txt)
+        print(think_about)
+        for T in think_about:
+            ## get subject by entropy or pos tagger
+            subjects = coreAi.entity_pos_tagger(T)
+            subjects_filtered=[]
+            for sub in subjects:
+                if "PER" in sub["entity"] or "ORG" in sub["entity"] or "LOC" in sub["entity"]:
+                    subjects_filtered.append(sub["word"])
+                
+        
+
+            for sub in subjects_filtered:
+                memory.add_concept(sub,T)
+
+        return memory
+
+    # generate thinks and questions over prompt data, compare with ourself datasets, return matches with sentiment analysys
+    def think_gen(self,txt):
+        
+        think_about = longMem.find_matches(txt)
+        print(think_about)
+        for T in think_about:
+            ## get subject by entropy or pos tagger
+            subjects = coreAi.entity_pos_tagger(T)
+            print(subjects)
+            ## get NC from , filtering from gramatical tags
+            subjects_low = coreAi.grammatical_pos_tagger(T)
+            #print(subjects_low)
+            ## generate questoins
+            questions=[]
+            ## create cuestions from internet archive books
+            for sub in subjects:
+                questions.append(self.crear_preguntas(sub))
+            
+            ## fast checks from gematria similarity
+            ##questions_togem = 
+            ## gematria_search =
+
+            questions_subj=[]
+            for q in questions_subj:
+                questions_subj.append(coreAi.entity_pos_tagger(q))
+            
+            memoryShortTags = memory.search_concept_pattern(subjects)
+
+            ## get tags of subject
+            subj_tags = coreAi.entity_pos_tagger(T)
+            
+            for sub in subjects: 
+                memory.add_concept(sub,","+questions_subj+",".join(memoryShortTags))
+                memory.add_concept(sub,T+",".join(memoryShortTags))
+
+        return memory
+        ## check if something is need to add to ourself datasets
+        ## make sentiment analys
+        ## check if dopamine prompt is true or false over the information
+        ## set weight to information depending of generated dopamine
+        ## add dopamine wights to the dopamine concept dataset
+
+        ## add to ourself dataset
+        ## add to preferences dataset
+        ## add or remove from data
+
+    def crear_path_grafo(self,text):
+        pos_tags = assistant.grammatical_pos_tagger(text)
+        ner_results = coreAi.entity_pos_tagger(text)
+
+
+    def crear_circuito_logico(self):
+        # Función para crear un circuito lógico con un algoritmo específico
+        pass
+
+    def tomar_decision_sentimiento(self, sentimiento):
+        
+        sentiments = coreAi.sentiment_tags(sentimiento)
+        # Función para tomar una decisión booleana con un análisis de sentimiento
+        similarity = coreAi.similarity_tag(self, sentenceA,sentenceB)
+        ## Check by similarity over memory tag paths
+
+
+        return sentiments
+
+    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

@@ -0,0 +1,80 @@
+import re
+
+class MemoryRobotNLP:
+    def __init__(self, max_size):
+        self.max_size = max_size
+        self.memory = {}
+
+    def add_concept(self, concepto, string):
+       
+        if concepto not in self.memory:
+            self.memory[concepto] = []
+        #evaluate priority calculation
+        priority = 1 - (1/len(concepto))
+        self.memory[concepto].append({"Found_text":string, "Priority_Weight":priority})
+
+    def delete_concept(self, concepto):
+        if concepto in self.memory:
+            del self.memory[concepto]
+
+    def add_string(self, concepto, string, prioridad):
+        if concepto not in self.memory:
+            self.memory[concepto] = []
+
+        self.memory[concepto].append((string, prioridad))
+
+    def delete_string(self, concepto, string):
+        if concepto in self.memory:
+            self.memory[concepto] = [(s, p) for s, p in self.memory[concepto] if s != string]
+
+    def search_concept_pattern(self, patron):
+            resultados = {}
+
+            for concepto, strings in self.memory.items():
+                for string, _ in strings:
+                    if re.search(patron, string,re.IGNORECASE):
+                        if concepto not in resultados:
+                            resultados[concepto] = []
+                        resultados[concepto].append(string)
+
+            return resultados
+    def get_concepts_substrings(self, espacio_disponible):
+        memoria_ordenada = sorted(self.memory.items(), key=lambda x: sum(prioridad for _, prioridad in x[1]), reverse=True)
+        espacio_utilizado = 0
+        conceptos_acotados = []
+
+        for concepto, strings in memoria_ordenada:
+            espacio_concepto = sum(prioridad for _, prioridad in strings)
+            if espacio_utilizado + espacio_concepto <= espacio_disponible:
+                conceptos_acotados.append((concepto, strings))
+                espacio_utilizado += espacio_concepto
+            else:
+                break
+
+        return conceptos_acotados
+
+
+# Ejemplo de uso
+
+
+if __name__ == "__main__":
+
+    memoria_robot = MemoryRobotNLP(max_size=100)
+
+    memoria_robot.add_concept("animales", [("perro", 0.8), ("gato", 0.7), ("pájaro", 0.5)])
+    memoria_robot.add_concept("colores", [("rojo", 0.9), ("verde", 0.6), ("azul", 0.7)])
+
+    print("Memoria completa:")
+    print(memoria_robot.memory)
+
+    memoria_robot.add_string("animales", "pez", 0.6)
+    memoria_robot.delete_string("colores", "verde")
+    memoria_robot.delete_concepto("colores")
+
+    print("\nMemoria después de modificaciones:")
+    print(memoria_robot.memory)
+
+    conceptos_acotados = memoria_robot.get_concepts_substrings(50)
+    print("\nConceptos acotados a un tamaño máximo de memoria:")
+    print(conceptos_acotados)
+

lib/models.py

@@ -0,0 +1,98 @@
+import pipes
+
+class ModelManager:
+    def __init__(self):
+        self.models = {}  # Un diccionario para almacenar los modelos disponibles
+
+    def list_models(self):
+        return list(self.models.keys())
+
+    def add_model(self, pipe_func, model_name, args):
+        self.models[model_name] = {"pipeline": pipe_func, "args": args}
+
+    def load_transformers_model(self, model_name, args):
+        if hasattr(pipes, model_name):
+            pipe_func = getattr(pipes, model_name)
+            self.add_model(pipe_func, model_name, args)
+        else:
+            print(f"Error: {model_name} no está definido en el módulo pipes.")
+
+    def train_transformers_model(self, model_name, train_dataset, eval_dataset, training_args):
+        if model_name not in self.models:
+            print(f"Error: {model_name} no está en la lista de modelos disponibles.")
+            return
+
+        pipeline = self.models[model_name]["pipeline"]
+        pipeline.train(train_dataset=train_dataset, eval_dataset=eval_dataset, training_args=training_args)
+
+    def test_model(self, model_name, test_dataset):
+        if model_name not in self.models:
+            print(f"Error: {model_name} no está en la lista de modelos disponibles.")
+            return
+
+        pipeline = self.models[model_name]["pipeline"]
+        return pipeline.test(test_dataset)
+
+    def remove_model(self, model_name):
+        if model_name in self.models:
+            del self.models[model_name]
+        else:
+            print(f"Error: {model_name} no está en la lista de modelos disponibles.")
+
+    def execute_model(self, model_name, *args, **kwargs):
+        if model_name not in self.models:
+            print(f"Error: {model_name} no está en la lista de modelos disponibles.")
+            return None
+
+        pipe_func = self.models[model_name]["pipeline"]
+        args = self.models[model_name]["args"]
+        return pipe_func(*args, **kwargs)
+
+    def choose_best_pipeline(self, prompt, task):
+        available_pipelines = self.models.keys()
+        best_pipeline = None
+        best_score = float('-inf')
+
+        for pipeline_name in available_pipelines:
+            pipeline = self.models[pipeline_name]["pipeline"]
+            score = self.evaluate_pipeline(pipeline, prompt, task)
+            if score > best_score:
+                best_score = score
+                best_pipeline = pipeline_name
+
+        return best_pipeline
+
+    def evaluate_pipeline(self, pipeline, prompt, task):
+        # Aquí puedes implementar la lógica para evaluar qué pipeline es mejor para la tarea específica
+        # En este ejemplo, utilizamos la métrica de exactitud para el análisis de sentimiento
+        if task == "sentiment_analysis":
+            # Supongamos que test_dataset contiene pares de (texto, etiqueta) para análisis de sentimiento
+            test_dataset = [("Texto de prueba 1", "positivo"), ("Texto de prueba 2", "negativo")]
+            correct_predictions = 0
+            total_predictions = len(test_dataset)
+
+            for text, label in test_dataset:
+                prediction = pipeline(text)
+                if prediction == label:
+                    correct_predictions += 1
+
+            accuracy = correct_predictions / total_predictions
+            return accuracy
+        else:
+            # Implementa la lógica de evaluación para otras tareas aquí
+            return 0.5  # Por ahora, retornamos un valor de evaluación arbitrario
+
+# Ejemplo de uso
+if __name__ == "__main__":
+    manager = ModelManager()
+
+    # Añadir pipelines
+    manager.load_transformers_model("sentiment_tags", args={})
+    manager.load_transformers_model("entity_pos_tagger", args={})
+
+    # Decidir qué pipeline usar para el análisis de sentimiento
+    prompt = "Este es un texto de ejemplo para analizar el sentimiento."
+    task = "sentiment_analysis"
+    best_pipeline = manager.choose_best_pipeline(prompt, task)
+    print(f"La mejor pipa para {task} es: {best_pipeline}")
+

lib/notarikon.py

@@ -0,0 +1,44 @@
+import json
+# Implementando el método de Notarikon para texto hebreo.
+# Notarikon es una técnica que toma la primera (y a veces la última) letra de cada palabra para formar una nueva palabra o frase.
+
+def notarikon(text, mode='first'):
+    """
+    Genera un Notarikon de un texto hebreo. Por defecto, toma la primera letra de cada palabra.
+    Si se especifica otro modo, puede adaptarse para tomar letras según necesidades específicas.
+    
+    Args:
+    text (str): Texto hebreo del cual generar el Notarikon.
+    mode (str): Modo de generación del Notarikon ('first' para la primera letra, 'last' para la última, etc.)
+    
+    Returns:
+    str: El Notarikon generado del texto.
+    """
+    words = text.split()  # Divide el texto en palabras
+    if mode == 'first':
+        # Toma la primera letra de cada palabra
+        notarikon_result = ''.join(word[0] for word in words if word)
+    elif mode == 'last':
+        # Toma la última letra de cada palabra
+        notarikon_result = ''.join(word[-1] for word in words if word)
+    else:
+        # Por defecto, regresa el texto sin cambios si el modo no es reconocido
+        notarikon_result = text
+    
+    return notarikon_result
+
+
+
+"""
+# Ejemplo de uso
+#genesis = open("genesis.json","rb").read()
+genesis = json.loads(open("genesis.json","r").read())["text"][0]
+
+##example_text = "בראשית ברא אלהים את השמים ואת הארץ"  # "En el principio Dios creó los cielos y la tierra."
+for txt in genesis:
+
+    notarikon_result_first = notarikon(txt, mode='first')
+    notarikon_result_last = notarikon(txt, mode='last')
+
+    print(notarikon_result_first, notarikon_result_last)
+"""

lib/pipes.py

@@ -0,0 +1,204 @@
+from transformers import AutoTokenizer, AutoModelForTokenClassification, pipeline
+from diffusers import DiffusionPipeline
+from transformers import AutoModelForSeq2SeqLM
+from samplings import top_p_sampling, temperature_sampling
+import torch
+from sentence_transformers import SentenceTransformer, util
+from datasets import load_dataset
+import soundfile as sf
+import unicodedata
+import itertools
+
+
+class AIAssistant:
+    def __init__(self):
+        pass
+
+
+    ## generate regexp for search over memory
+    def gen_search_expr(self,palabras_unidas):
+
+        combinaciones = []
+
+        for i in range(1, len(palabras_unidas) + 1):
+            for combinacion in itertools.combinations(palabras_unidas, i):
+                regex = ".*?".join(combinacion)
+                combinaciones.append(regex)
+
+        return combinaciones
+
+    ## join taggued tokens into words
+    def process_list(self,lista):
+        palabras_unidas = []
+        palabra_actual = ""
+
+        for token in lista:
+            if token.startswith("##"):
+                palabra_actual += token[2:]
+            else:
+                if palabra_actual:
+                    palabras_unidas.append(palabra_actual)
+                    palabra_actual = ""
+                palabra_actual += token
+
+        if palabra_actual:
+            palabras_unidas.append(palabra_actual)
+
+        return [unicodedata.normalize("NFKD", palabra).encode("ASCII", "ignore").decode("ASCII").lower() for palabra in palabras_unidas]
+
+   
+    ## gramatical classificator
+    def grammatical_pos_tagger(self, text):
+        nlp_pos = pipeline("token-classification", model="QCRI/bert-base-multilingual-cased-pos-english", tokenizer="QCRI/bert-base-multilingual-cased-pos-english")
+        res = nlp_pos(text)
+        return res
+
+
+    ## entity classifier
+    def entity_pos_tagger(self, txt):
+        tokenizer = AutoTokenizer.from_pretrained("Davlan/bert-base-multilingual-cased-ner-hrl")
+        model = AutoModelForTokenClassification.from_pretrained("Davlan/bert-base-multilingual-cased-ner-hrl")
+        nlp = pipeline("ner", model=model, tokenizer=tokenizer)
+        ner_results = nlp(txt)
+        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') 
+
+        # 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 = sentenceB
+        #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)):
+            try:
+                res.append({"A": sentences1[i], "B":sentences2[i], "score":cosine_scores[i][i]})
+            except:
+                pass
+
+            #print("{} \t\t {} \t\t Score: {:.4f}".format(sentences1[i], sentences2[i], cosine_scores[i][i]))
+
+        return res
+
+
+
+    ## text to speech
+    def texto_to_speech(self,txt):    
+        synthesiser = pipeline("text-to-speech", "microsoft/speecht5_tts")
+
+        embeddings_dataset = load_dataset("Matthijs/cmu-arctic-xvectors", split="validation")
+        speaker_embedding = torch.tensor(embeddings_dataset[7306]["xvector"]).unsqueeze(0)
+        # You can replace this embedding with your own as well.
+
+        speech = synthesiser(txt, forward_params={"speaker_embeddings": speaker_embedding})
+        sf.write("speech.wav", speech["audio"], samplerate=speech["sampling_rate"])
+
+        return speech   
+    ## 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
+        )
+        base.to("cuda")
+        refiner = DiffusionPipeline.from_pretrained(
+            "stabilityai/stable-diffusion-xl-refiner-1.0",
+            text_encoder_2=base.text_encoder_2,
+            vae=base.vae,
+            torch_dtype=torch.float16,
+            use_safetensors=True,
+            variant="fp16",
+        )
+        refiner.to("cuda")
+
+        image = base(
+            prompt=prompt,
+            num_inference_steps=n_steps,
+            denoising_end=high_noise_frac,
+            output_type="latent",
+        ).images
+        image = refiner(
+            prompt=prompt,
+            num_inference_steps=n_steps,
+            denoising_start=high_noise_frac,
+            image=image,
+        ).images[0]
+        return image
+
+
+    ## 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')
+
+        input_ids = tokenizer(text,
+                              return_tensors='pt',
+                              truncation=True,
+                              max_length=max_length)['input_ids']
+
+        decoder_start_token_id = model.config.decoder_start_token_id
+        eos_token_id = model.config.eos_token_id
+
+        decoder_input_ids = torch.tensor([[decoder_start_token_id]])
+
+        for t_idx in range(max_length):
+            outputs = model(input_ids=input_ids,
+                            decoder_input_ids=decoder_input_ids)
+            probs = outputs.logits[0][-1]
+            probs = torch.nn.Softmax(dim=-1)(probs).detach().numpy()
+            sampled_id = temperature_sampling(probs=top_p_sampling(probs,
+                                                                top_p=top_p,
+                                                                return_probs=True),
+                                            temperature=temperature)
+            decoder_input_ids = torch.cat((decoder_input_ids, torch.tensor([[sampled_id]])), 1)
+            if sampled_id!=eos_token_id:
+                continue
+            else:
+                tune = "X:1\n"
+                tune += tokenizer.decode(decoder_input_ids[0], skip_special_tokens=True)
+                return tune
+                break
+
+
+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)
+
+    tune = assistant.text_to_music("This is a traditional Irish dance music.")
+    print(tune)
+

lib/sonsofstars.py

@@ -0,0 +1,521 @@
+sons_of_stars = """
+# Girmorio de los hijos de la palabra estelar
+
+## Intro
+
+Mediante el arte de la caracteromancia , revelaremos las creencias religiosas de nuestros ancestos , interconectaremos las civilizaciones mediante mitos, su lenguaje fonetico y su simbologia.
+
+Redescubriremos los artes caracteromantes olvidados para recomponer el conocimiento de la civilizacion , los origenes del lenguaje escrito, las creencias globales en todas las civilizaciones y los origenes del conocimiento logico y matamatico.  
+
+Mediante la reafirmacion de las escrituras sagradas avalaremos las palabras de los ancestros en un lenguaje contemporaneo .
+
+Mediante la comprension de las creencias conectaremos las culturas y entendermos porque contruian los edificios, y realizaban cultos similares en todas las civilizaciones. Porque esos templos ? Porque realizaban una conquista ? Porque creian que eran eternos ? Como se iban a asegurar de serlo ?
+
+Mediante la conexion de palabras conectaremos culturas y civilizaciones .
+
+Mediante la codificacion revelaremos secretos y uniremos culturas 
+
+Mediante las matematicas eliminaremos toda duda de casualidad
+
+Podria ser que todo fuera verdad ?
+
+Como se fabricaron las escrituras ? Son realmente la palabra de dios ?
+ 
+## Antecedentes
+
+Al princpio de todo el hombre no era hombre pues no tenia escritura, y no disponia del poder de la palabra escrita .
+
+Los primeros humanos empezaron a asociar eventos estelares con eventos que ocurrian en su enterno, el primero fue, la asociacion de los ciclos lunares con la menstruacoin de las mujeres . Tal y como se demuestra en la escritura en periodos primitivos en los pueblos del danubio alrededor del 7 000 AC .
+
+El primer vinculo entre eventos del cielo y la tierra fue el ciclo de reproduccion humano. Muy pronto empezarian a desarrollar matodos para contar esos ciclos, teniando que anotarlos de alguna manera en algun sitio, la propia necesidad hizo representar a la luna com un simbolo el " * " . Este fue el primer caracter de escritura conocido para expersar a la luna, a su vez en la antiguedad un dios o diosa . Sabemos que es diosa porque se se asocio al proceso de fertilidad y ciclo reproductivo humano y fue representada en la prehistoria como tal .
+
+Esto motivo las primeras religiosas, habia algo en el cielo que tenia el mismo comportamiento que el ciclo reproductivo, que mas cosas podria haber en el cielo que indicaran eventos en la tierra ?
+
+Muy pronto descubriron mucho mas, los años, las crecidas de los rios como Isis-Sotis o Luna-Sirio para indicar las crecidas del nilo , y estas creencias se esparcieron por la tierra como un virus y sus proteinas que mutan en el transcurso de la propagacion en el tiempo con diferentes variaciones .
+
+Ya podian orientarse mirando las estrellas, pronto empezaron a darles formas y nombres trazando lineas entre ellas . Ya tenian un nombre pero aun no habia sido escrito, aun la idea no habia sido plasmada en un simbolo hasta que unieron los puntos de las estrellas segun ideas que observaban en la naturaleza . Un leon, un ave fenix, un guerrero ... aun a dia de hoy conservamos los nombres de los dioses mitologicos en las estrellas al igual que en todas las civilizaciones que nos han precedido .
+
+Entonces si las cosas que pasaban en el cielo tenian un vinculo con la tierra en sus ciclos , todo tenia que estar relacionado con los astros, incluso la vida de las personas. Si un astro indicaba cuando ocurria la menstruacoin o crecia el nilo porque no muchas mas cosas. De esta manera se desarrollaron las creencias, y los principios religiosos relacionados a la filosofia primigenia y la logica mas elemental de realizar suposiciones sobre hipotesis y tomar sus conclusiones tras comprobarlas . Si todas las cosas tenian alguna estrella que indicara su comportamiento tambien las personas y sus ideas en consecuencia debian de estar codificadas ahi de alguna manera .
+
+Son las ideas mias o vienen de una estrella y yo solo estoy conectado de alguna manera con ellas en un ojeto fisico, como una caja que contiene mi ser ?
+He recivido esta idea de mi cuerpo o esta idea viene de las estrellas en la conjuncion en el momento y en el lugar que estaba emplazado ?
+Si las ideas anteriores como escribir han venido inspiradas de las estrellas y las ideas de predecir porque mis ideas no iban a venir de las estrellas, y estar ya codificadas en su infinidad de permutaciones .
+
+Si cada conjunto de estrellas es un simbolo y estos rotan, podre leerlos ? habra alguna especie de sopa de letras donde haya algo escrito con sentido que pueda interpretar ? Estara relacionado con la realidad ?
+
+Ya de mucho antes de escribir textos complejos mas que estelas funerarias con sus nombres leidos de las estrellas o sus roles adoptados de su propia mitologia para convertirse en los heroes y quedarse inmortalizados en el tiempo encodificados enlas estrallas , ya de mucho antes creian firmemente en que vivian como estrella / dios , que les reencarnaba en un cuerpo una y otra vez en cada ciclo de su astro, de manera que sus propiedades de astro se transifieran a este ser . Si tu eras de determinada manera , por ejemplo calmado, pues serias un planeta con unciclo mas lento por ejemplo, o toda clase de relaciones ocurridas en la entropia que por casualidad hayan podido ser relacionadas con un evento estelar . Sin olvidarse por su puesto que los eventos son ciclicos y predecibles y que la capacidad de predecirlos ya es un sistema de adivinacion del futuro muy cierto e inegable . 
+
+No paso mucho tiempo antes de que en el momento que Adan observo las estrellas y entendio como codificar la palabra y asociar los simbolos atribuidos a las constelaciones para expresar los sonidos asociados a los nombres de los dioses o estrellas . Combinando sus simbolos podia componer las palabras para expresar sus ideas y dejarlas plasmadas en roca, metal, papiro o incluso codificarlas en las estrellas . Ese seria el mayor logro, pues las estrellas nadie las puede borrar, codificando el lenguaje a medida de las estrellas este permaneceria oculto a lo largo de los siglos para poder ser revelado el dia del Shem Hemaphoresh .
+
+Tal como nos cuenta le libro de Raziel Adan vago por tierra seca y fue andando por la noche, que mordio el fruto de la sabiduria cuando observaba las estrellas, atribuyendole aquella iluminacion al angel Raziel, simplemente por deduccion logica, pues Raziel estaria alineado de alguna manera y lo sabria igual que un astrologo lo sabe hoy en dia para sus predicciones . El le otorgo la sabiduria a adan para que empezara a codificar .
+
+No tardo mucho en codificar el nombre de todas las cosas , 6 dias, el septimo descanso . Y las escribio en dos tablas, una de zafiro que encontro mas antigua y una de esmeralda .
+
+Pronto entendio el poder supremo de la palabra, y todas las cosas que permitia hacer , al dejar plasmadas sus ideas en simbolos por lo largo de los siglos, como una estrella, no habia duda de que todos eramos como estrellas, porque podriamos labrar de luz la tierra igual que dios labro de luz el firmamento, dandonos las señales y las ideas para nuestros cuerpos terrenales .
+
+Entonces decidio dejar por escrito todo el conocimimento hasta entonces conocido, matematico, astronomico y asegurarse mediante un plan y el secreto que sus palabras fueran inmutables en el transcurso del tiempo, que no pudieran ser manipuladas, que fueran inmunes a la maldad humana .
+
+Una cadena de sucesos ocurridos por simples reglas mnemotecnicas de :
+
+ asociacion estrellas -> conjunto -> lineas entre puntos -> dibujo naturaleza con similitud -> nombre o sonido -> simbolo de abecedario que expresa un fonema
+ 
+Cambiaria la historia para siempre con una nueva tecnologia, el lenguaje fonetico .
+
+Adan codifico todo el conocimiento en la tradicoin oral, estrellas y libros escritos. Todo el que dios le habia otorgado a traves del Angel Raziel .
+
+Todas las culturas , a pesar de sus conocidos encuentros entre algunas en la historia, han hablado o reverenciado siempre desde los inicios de la civilizacion a las estrellas ,el cosmos y los han llamado dioses .
+
+Muchas de ellas supuestamente aisladas geograficamente tienen grandes similitudes en sus construcciones, creencias y mitologia. Aparentemente de forma aislada 
+
+Los libros mas antiguos son de contenido astronomico/religioso. Nombrar Libros
+
+El lenguaje es inprescindible para que un hombre sea hombre, lo que lo diferencia del resto de los animales . Un lenguaje completo capaz de trasladar ideas hacia el futuro de forma escrita para conservar el conocimiento para el desarrollo de la civilizacion . La palabra es el mecanismo del hombre para comunicarse y emprender tareas de manera colectiva, y registrar en el paso del tiempo el conocimiento y transmitirlo al resto .
+
+## Un repaso de profetas, estrellas y sueños 
+
+A lo largo de los siglos muchos profetas han hablado sobre el nombre de dios, y han hecho referencia a las estrellas, incluso a dia de hoy permanece la tradicion en el horoscopo u otras tecnicas de prediccion acestrales .
+
+
+### Juan 16:27-28
+
+…y el Verbo [La Palabra] era con Dios y el Verbo era Dios, de tal modo que dios es palabra .
+
+“…y habéis creído que yo SALÍ DE DIOS. SALÍ DEL PADRE, y he venido al mundo; otra vez dejo el mundo, Y VOY al Padre”. 
+
+Como vemos puede ir y volver al padre es palabra que esta en los cielos . Viene al mundo y se va, como espiritu, persona y estrella . Porque su espiritu viene de una estrella, del padre, cuando muera volvera al cielo, y cuando alguien adopte su rol otra vez volvera a la vida en otro tiempo que alguen ejecutara su idea, su espiritu .... su manera de hacer, sus azañas, sus propiedades como persona ...
+
+Si el padre nuestro esta en los cielos y es palabra , de alguna manera lo deberian de poder leer . Su nombre y su palabra de los cielos .
+
+### Jesus es la palabra de dios, el viviente
+
+Jesus fue uno de los grandes profetas , denuncio la corrupcion del sistema y la ocultacion del conocimiento por parte de los fariseos . Ademas trato de simplificar la religion de muchos dioses en 2 Solo, el padre celestial y la madre Terrenal, segun el evangelio essenio .
+
+Claramente expresa creencias relacionadas con que todas las cosas poseen su espiritu , el agua, el aire / viento, el aliento, los astros ...
+
+Algunas referencias de como para el tienen descripcion que coincide con un astro . Y a su vez como funciona el mecanismo religioso de eternidad . La trinidad, El padre, El hijo y El Espiritu Santo .
+
+Pag 11 Evangelio Essenio
+
+
+Dijo Jesus : "El esiritu del hijo del hombre fue creado por el espiritu del padre celestial y su cuerpo de la madre terrenal ."
+
+Esto implica una trinidad , un yo compuesto de cuerpo , mecanismo de transmision e idea . Porque si existen debe haber un mecanismo para retransmitir la idea al cuerpo, y si cada accion tiene un efecto 
+
+Dijo Jesus : "Y Entonces los hijos de los hombres dividiran su divina herencia , el reino de Dios , Pues los hijos de los hombres viven en el Padre Celestial Y en la Madre Celestial . Y Entones con Dios llegara el fin de los tiempos, pues el amor del padre celestial da vida a eterna a todo lo que esta en los cielos ."
+
+En este pasaje simplemente comenta la dualidad de su yo de las almas, y como si han seguido las reglas del padre celestial y la madre terrenal, solo entonces , tendran un lugar en el cielo y un mecanismo de recodificarse como idea en otros cuerpos en el futuro . Y solo hay un mecanismo para inmortalizarse, ocupando un lugar en los cielos, como todos los heroes mitologicos , que oculapn un lugar con sus nombres en las constelaciones, y personajes contemporaneos pueden instirarse en su idea / espiritu y adoptar su rol , una y otra vez en el tiempo si han conseguido inmortalizarse codificandose en el cielo .
+
+
+Dijo Jesus: Aunque yo hable con las lenguas de los hombres y los angeles ...
+
+En este pasaje hace referencia a que el lenguaje proviende de los hombres y los angeles, solo auqellos rectos que siguieron las leyes del padre celestial y la madre terrenal habian alcanzado un estado de conciencia del YO y empezado a comprender el universo y los mecanismos matematicos y logicos que rigen la intelagencia y el desarrollo del conocimiento. Mediante la palabra o el lenguaje el hombre podia inmortalizar su espiritu a traves del arte caracteromante .
+
+Jesus comprende al menos en el evangelio essenio los mecanismos del cosmos y lo que hoy llamariamos ciencia, y aporta soluciones pragmaticas explicadas con parabolas usando las reglas mnemotecnicas mas avanzadas hasta el momento , agrupando los dioses en 3 dioses principales, El espiritu padre celestia, Satan y La madre Celestial, en lugar de 72 dioses , mas dificiles de gestionar para el cerebro humano . 
+
+No hay nada de sobrenatural en el jesucristo essenio ni milagros mas alla de lo que hoy llamariamos ciencia. 
+
+SATAN, es el gusano de la solitaria en uno de los pasages y la mayoria de cosas las resuelve con simples ayunos e higiene personal . Ya poseia el conocimiento astronomico, medico, y de sustancias para ejercer la medicina , ademas de hablar lenguas antiguas, era un erudito pese a su probable aspecto desaliñado y humilde .
+
+
+
+### Moises registra la palabra de dios para crear la biblia
+
+
+
+### Moises desordena la biblia para que nadie pueda conocer el nombre de dios y su orden para poder hacer milagros .
+
+Exodo
+
+5.
+Yavé bajó en una nube y se quedó allí junto a él. Moisés entonces invocó el Nombre de Yavé,
+
+6.
+y El pasó delante de Moisés diciendo con voz fuerte: «Yavé, Yavé es un Dios misericordioso y clemente, tardo a la cólera y rico en amor y en fidelidad.
+
+
+### Daniel 12:3	
+
+Los entendidos brillarán como el resplandor del firmamento, y los que guiaron a muchos a la justicia, como las estrellas, por siempre jamás.
+
+Ezekiel
+
+ 
+### Jeremías 8:2
+
+y los esparcirán al sol, a la luna y a todo el ejército del cielo, a quienes amaron y sirvieron, y a quienes siguieron, a quienes buscaron y adoraron. No serán recogidos ni enterrados; serán como estiércol sobre la faz de la tierra.
+
+Jeremías 23:25-40 
+
+Yo he oído lo que aquellos profetas dijeron, profetizando mentira en mi nombre, diciendo: Soñé, soñé. ¿Hasta cuándo estará esto en el corazón de los profetas que profetizan mentira, y que profetizan el engaño de su corazón ...
+
+### Isaías 47:13	
+
+Estás fatigada por los muchos consejos; que se levanten ahora los que contemplan los cielos, los que profetizan por medio de las estrellas, los que pronostican cada luna nueva, y te salven de lo que vendrá sobre ti.
+
+### Isaías 14:13	
+
+Pero tú dijiste en tu corazón: ``Subiré al cielo, por encima de las estrellas de Dios levantaré mi trono, y me sentaré en el monte de la asamblea, en el extremo norte.
+
+### Apocalipsis 1:8
+
+### Reina-Valera 1960
+
+8 Yo soy el Alfa y la Omega, principio y fin, dice el Señor, el que es y que era y que ha de venir, el Todopoderoso.
+
+
+Psalm 19:1-3  The heavens are proclaiming the esteem of Ěl; And the expanse is declaring the work of His hand.  Day to day pours forth speech, And night to night reveals knowledge.  There is no speech, and there are no words, Their voice is not heard.
+
+Los cielos cuentan la gloria de Dios,
+
+Y el firmamento anuncia la obra de sus manos. Un día emite palabra a otro día, Y una noche a otra noche declara sabiduría. No hay lenguaje, ni palabras, Ni es oída su voz. Por toda la tierra salió su voz, Y hasta el extremo del mundo sus palabras.
+
+
+https://thecalltojordan.com/2019/03/04/the-stars-revealed/
+
+## Salomon , El Lemegeton
+
+El lemegeton es un libro asociado al Rey salomon donde el rey que era muy sabio poseia la sabiduria para doblegar la voluntad de los angeles con la suya . Es un libro compuesto por 72 parrafos atribuido al nombre de cada angel de dios .
+
+(Imagen del libro parrafo de un angel)
+
+Estos angeles tienen su propio simbolo y su nombre.
+
+Los nombres de los angeles el libro se pueden componer mediante las instrucciones de permutaciones descritas en el Libro Sefer Yetzira y añadiendo el sufijo EL o AL, para componer asi todos los nombres.
+
+Ademas tal y como cuentan las profecias de los primeros grandes profetas , el nombre de dios se puede componer con las permutaciones de dos versos del exodo 
+
+(Poner frases de los profetas y versos del exodo)
+
+Isaiah 34:4 And all the host of the heavens shall rot away. And the heavens shall be rolled up like a scroll, and all their host fade like a leaf fading on the vine, and like the fading one of a fig tree.
+
+
+Revelation 6:13-14 And the stars of the heaven fell to the earth, as a fig tree drops its unripe figs, being shaken by a strong wind.  And heaven departed like a scroll being rolled up, and every mountain and island was moved out of its place.
+
+Ezekiel 20:33-35 “As I live,” declares the Master יהוה, “do not I, with a mighty hand, with an outstretched arm, and with wrath poured out, reign over you? And I shall bring you out from the peoples and gather you out of the lands where you are scattered, with a mighty hand, and with an outstretched arm, and with wrath poured out.  And I shall bring you into the wilderness of the peoples, and shall enter into judgment with you face to face there.”
+
+
+## Abraham
+
+
+## Noe 
+
+Segun el libro de raziel (libro supuestamente escrito por adan), sabra como construir el arca y predecir la destruccion gracias al conocimiento del libro.
+
+La misma historia en el Poema de Gilgamesh sumerio .
+
+
+## Enoch , Adapta y extiende el libro de raziel en 67 tomos mas para formar 72 Libros 
+
+Este libro es muy extenso y no entraremos en profundidad, es una extension del conocimiento de su predecesor Adan . El primer hombre producto de la trinidad, Espiritu padre Celestial, Espiritu del hombre y Madre terrenal
+
+## Adan, Séfer Raziel HaMalaj
+
+Es el primer hombre, al que mediante el angel Raziel le es otorgado el conocimiento. Descubre una tabla de zafiro con los simbolos conocidos hoy en dia como Angel Script, utilizados por persas para la sustitucion de caracteres por estrellas y poder leer las estrellas, la palabra de dios . Tal como nos explica el libro .
+
+Curiositez-inouyes-sculpture-talismanique-Persans-horoscope
+
+https://www.abebooks.it/prima-edizione/Curiositez-inouyes-sculpture-talismanique-Persans-horoscope/22650367580/bd
+
+Este libro fue traducido por Alfonso X , el sabio, y era muy popular entre los misticos medievales en la peninsula iberica . Al igual que otra traduccion del Sefer Yetzira realizada sobre el año 800 por Njmanides de Girona .
+
+El libro se presenta como una enseñanza del arcángel Raziel dirigida primero a Adán y luego a Abraham para revelar y explicar las leyes de la Creación. Se divide en cinco libros que tratan sobre la angelología, los Nombres divinos, la gematría, la astronomía y la construcción. 
+
+- El libro de la vestimenta :
+
+	Descibe las instrucciones basicas para distinguir los momentos de años rezando a sus angeles, distruyendo los momentos del tiempo del año y los meses segun los angeles del cielo (Constelaciones del Zodiaco, Planetas, Draco, Osa Menos y Mayor y todos los elementos celestes, como la tierra la luna y el sol )
+	
+	Cuando plantar las plantas y cuando hacer las tareas para su recoleccion o cuando reproducir a los animales .
+	
+	La informacion tambien sirve para describir momentos en el tiempo y expresarlos mediante la palabra .
+	
+	Los nombres de los angeles varian ligeramente segun el momento del año que es, su proninciacion y escritura es diferente segun la estacion en la que te refieres a ellos o te referiras, igual que un verbo tiene tiempo verbal, los nombres de los angeles tambien tienen tiempo , estelar .
+	
+(Tablas de angeles por estacion)
+
+
+	Esto nos permite CONJURAR los nombres de los angeles para hacer milagros pidiendo sus favores . Por ejemplo si yo quiero hacer un conjuro para el mes de mayo, o un momento lunar , a los angeles que ademas tienen asociados propiedades , como bondad, sanacion , buenas y malas .
+	
+	Este libro describe el cosmos y sus propiedades asociadas en la tierra . Como cuando plantar las semillas para que crezcan , y evidentemente funciona .
+	
+- El libro de los nombres
+
+	Describe los nombres de dios y sus poderes, un precursor del libro Lemegeton del rey salomon . Explica sus propiedades y como trazar lineas entre los puntos para formar un dibujo que puede ser usado como amuleto
+	
+	Dibujo del amuleto .
+	
+	Describe el poder del nombre y lo sagrado que es a einsta al lector a recordad una parte de el y transmitirla a sus descendientes, igual que en la tradicion oral Hebrea .
+	
+	El nombre es secreto pues contiene un poder , el de controlar todos los ejercitos del cielo, el de revelar el secreto y unificar las religiones en una, mediante la palabra y la verdad .
+
+- Genesis
+
+La luz y la oscuridad en un ciclo infinito, parecido al mito egipcio de apofis y ra luchando cada dia y cada noche en un ciclo infinito .
+	
+- El libro de las acciones :
+
+	Este libro contiene las instrucciones para diferentes actores en diferentes momentos del tiempo de las hazañas que deberan de realizar 
+	
+	Noe, construir el arca, recuross, criar animales, y predecir el diluvio .
+	
+	Moises , 
+		- Separar las aguas 
+		
+		- LLevar a los hebreos 
+		
+		- Guardar el secreto
+		
+		- Lo que tiene que decir
+		
+	David Ben Zelateh mediante la revelacion del amor , la descripcion de Jesus, o el Cristo 
+	
+		- Quien es
+		
+		- Lo que tiene que decir
+		
+		- Otras profecias antes de su llegada
+		
+		- Similitudes en egipto
+		
+		
+	Pheloni Ben Phelonieth
+	
+		- Lo que tiene que decir
+		
+		- La revelacion del shem hemaphoresh, el nombre de dios
+
+
+
+- Gematria 
+
+	Asignacion de valores de gematria del libro del Angel Raziel
+	
+	(Tablas de gematria)	
+	
+- Tharshis y el Shem Hemaphoresh
+
+	Computacion de tripletes del libro de la formacion Sefer Yetzira .
+	
+	Lectura y traduccion
+	
+	Co Relacion con las escrituras .
+
+## Lao Tze , fundador del taoismo, el camino de las cinco medidas de arroz
+
+La región gobernada por los Maestros Celestiales se dividió en 24 regiones por razones administrativas y religiosas. Cada una de estas 24 regiones estaba conectada con una de las Cinco Fases, uno de los 24 períodos del año y con una de las 28 constelaciones del zodíaco. Dependiendo de sus signos de nacimiento, cada adherente pertenecía a uno de estos distritos. Cada una de las 24 regiones estaba administrada por 24 oficiales, que tenían bajo su mando 240 ejércitos de espíritus, compuestos por 2400 generales, 2400 oficiales y 240 000 soldados. Este sistema de administración reflejaba el sistema de gobierno utópico descrito en Zhouli.29​
+
+La administración y la religión estaban estrechamente vinculadas en el sistema de los Maestros Celestiales. Los adherentes fueron agrupados por familias, y cada uno estaba adscrito a un distrito. Las familias y los distritos, y los dioses tenían copias de los registros civiles.30​ Los registros tenían descripciones detalladas de las personas y registraban el rango, la identidad y la ubicación de cada persona.31​ Cualquier cambio en los registrados debe ir acompañado de una contribución monetaria conocida como "salario de fe". Las solicitudes a los dioses siguieron un modelo burocrático y se redactaron de acuerdo con códigos administrativos específicos. La efectividad de estas solicitudes dependía de la exactitud de los registros mantenidos por los dioses.30​
+
+Los nuevos miembros de este grupo se dividieron en grupos dirigidos por instructores. Los neófitos fueron instruidos por un catecismo similar al encontrado en el Xiang'er que probablemente era un tipo de proto-meditación que más tarde se generalizó en movimientos como la Escuela Shangqing del Taoísmo. Estos instructores manejaban deberes religiosos y administrativos, recibían impuestos y establecían posadas en el camino para los viajeros.32​
+
+El rango de cada persona estaba determinado por la cantidad de generales divinos que tenían a su disposición, y por el número de escrituras divinas que habían obtenido.31​
+
+Existe la generalizada creencia de que el Tao es un concepto que nace con el Tao Te Ching , de Lao Tse (s. VI a. C.). En realidad, quinientos años antes —en el siglo XI a. C.— el I Ching ya daba por sentado que el Tao designaba el curso de las estrellas en el cielo, por lo que adquiría el sentido de orden eterno
+
+https://es.wikipedia.org/wiki/Camino_de_las_cinco_medidas_de_arroz
+
+
+Revoloteaba alegremente; era una mariposa muy contenta de serlo. No sabía que era Chuang Tse. De repente despierta. Era Chuang Tse y se asombró de serlo. Ya no le era posible saber si era Chuang Tse que soñaba ser una mariposa, o era una mariposa que soñaba ser Chuang Tse.
+
+
+## Hermes
+
+- Es el dios de la sabiduria, se le atribuye la tabla Esmeralda, un texto criptico base de los alquimistas 
+
+La tabla esmeralda es un ejemplo mas de la codificacion criptica de los ancestros, es un texto relacionando fenomenos quimicos con los angeles, una vez mas para el no iniciado puede parecer un texto criptico , pero no es mas que una descripcion cientifica de los momentos y combinacoines entre elementos una vez mas basado en los astros pos asociacion mnemotecnica .
+
+Hoy un cientifico apuntaria fecha hora y condiciones de todo para realizar un experimento, en la antiguedad tambien anotaban la posicion de los astros, de esta manera podian recordar en el futuro por asociaciones mnemotecnicas , transmitirlo en la tradicion oral a traves de los conjuros comprimiendo mucho mas la informacion que en la actualizad . Pues las variaciones en los nombres de los dioses en realidad contienen la informacion del momento del año , la temperatura y otros datos implicitos en el nombre igual que una ocnjugacion verbal implica el tiempo en el que se ejecuta la accion a la que se refiere un verbo .
+
+La tabla esmeralda, las combinaciones estelares de los elementos considerados fundamentales en la epoca componian la inspiracion para mezclarlos con la voluntad divina , ejecutando una vez mas todas las igual que en el cielo en la tierra, igual que arriba abajo, una vez mas . Toda la tradicion hermetica desde egipto a grecia, sumeria, hebrea , fenicia, y finalmente cristiana y musulmana sigue en su tradicion el concepto como es arriba es abajo .
+
+Los propios faraones eran los encargados de realizar la voluntad de los dioses, ritos y sacrificios en todas las culturas se han realizado asociados a los eventos estelares, desde la cultura maya a la china, pasando por todas las cuturas mediterraneas .
+
+Ademas la tabla esmeralda estaba forjada segun los escritos de esmeralda pura, algo imposible encontrar en la naturaleza . Su creador como su contenido demuestra tenia avanzados conocimientos de quimica y los ingredientes y el conocimiento para desarrolar la polvora o la termita, capaces de darle la capacidad de fundir a altas temperaturas los componentes para la fabricacion de cristales que hoy llamariamos sinteticos .
+
+La tabla esmeralda detalla el proceso de alquimia para componer un super material llamado la piedra filosofal, el cual supuestamente dispone de propiedades de la vida eterna entre otras .
+
+Otra coincidencia con los escritos de Adan, donde el ve los primeros simbolos de escritura antes de saber que son y morder el fruto del conocimiento otorgado por el Angel Raziel . Adan encuentra una tabla de zafiro con los simbolos que hoy en dia conocemos como Angel Script . 
+
+Esta al igual que los simbolos de alquimia los podemos encontrar desde la prehistoria
+
+(Foto Dolmen de soto y fecha)
+
+(Foto de los simbolos angel script, raziel persas )
+
+
+Toth
+
+Toth era el dios de la sabiduria en egipto, astronomia , sanacion, filosofia, calculo ... el padre de todas las ciencias
+
+## Badeneyet
+
+Badeneyet en la cultura egipcia es el dios carnero, mas tarde demonificado por la iglesia romana. Este era un dios alfarero, que hace al hombre con barro. Una historia exactamente igual que las basadas en la tradicion Hebrea . Crea al hombre del barro del rio nilo .
+
+(Foto de badeneyet)
+
+## Horus
+
+Historia de horus , nacimiento, hijo del padre y de la madre .
+
+I Ching
+
+Tecnicas adivinatorias con 64 simbolos en china
+
+## Athanasiu kircher, ARS PRIMA
+
+	Reunifico la cabala, egipcia, arabe, hebrea y griega en un unico libro 
+	
+	En este libro se describe con detalle las composiciones del nombre de dios , la gematria, notarion, tamurae y ziruph, como artes de codificacion para controlar los espiritus de la codificacion y asi poder revelar mensajes secretos o codificar mensajes secretos .
+	
+	Ejemplos gematria 
+	
+	Ejemplos Temurae
+	
+	Ejemplos ziruph
+	
+	Explica la composicion de los caracteres arabes 
+	
+	Explica la historia de apolo y panos , el dibujo es un mapa estelar con los puntos en las estrellas que trazando lineas tienes el dibujo de panos, y como sostiene la tierra y los planetas con los simbolos alquimicos .
+	https://www.digitale-sammlungen.de/en/view/bsb10866995?q=raziel&page=228,229
+	
+
+## Ramon Llull , Ars magna
+
+	Quien era ramon llull, era el mago del rey Jaime I de Aragon , Rey de los occitanos en todo el mediterraneo, creo el lenguage "catalan" aun hablado en españa en la costa mediterranea y las islas de mallorca ibiza y formentera, ademas del sur de francia, aragon y algunas islas italianas . Creo una de las primeras computadoras mecanicas , el Ars magna .
+	
+	El ars magna, era una maquina logica , una de las primeras computadoras que permitia preguntar enunciados y obtener respuestas boleanas, fue creada con el fin de poner deacuerdo a todas las religiones . Ya que a traves del espiritu artificial permitia obtener respuestas directas de dios y nadie podia negarlas logicamente .
+	
+	El idioma "Catalan" o Occitano, creo un lenguaje para unificar el imperio occitano medieval y poder difundir la palabra de dios en una unica lengua, una vez mas como sus antecesores, Adan y Abraham , a pesar de ser un cabalista cristiano gnostico, tenia muy claro que musulmanes, hebreos y cristianos eran todos hemranos . Pues al final casi toda la palabra escrita menos la de los profetas importantes del Coran ha sido manipulada por toda clase de demonios . 
+	
+## Mayas y Aztecas
+
+	Los reyes como .... se enterraban en piramides igual
+	
+	Realizaban sacrificios a los dioses estelares
+	
+	Adivinaban y predecian segun los astros
+	
+	Se mutilaban el pene como sacrificio
+	
+	Profetizaban
+	
+	La ciudad de los dioses era mas antigua segun historiadores
+	
+	
+## Tartesos 
+
+	Vasijas 
+	
+	Escritura
+	
+	Monumentos
+	
+	Textos iberos
+	
+	Texto traducido como vasco antiguo de la mentira del bebe y la mujer
+	
+	Referencias de otras culturas
+
+	La Doctora Hoyz
+	
+	
+## Valle del indo
+
+	Culto hombre cabra como en egipto , grecia panos, pinturas rupestres
+
+	(imagen del hombre cabra)
+
+	Breve descripcion de la civilizacion del valle del indo y fotos de sus cosas
+
+Manuscritos astronomicos mayas
+
+Dibujo en el techo de la gran piramide con las constelaciones (esta en las golondrianas de tartesos y documentales de robert bouval)
+
+## Manuscritos gnosticos , referente al dios cabeza de oso y de gato k se ven en el centro del disco d la piramide
+
+	Manuscrito de jhon explicacion
+			
+## TABLA DE LOS ANGELES / ASTROS / DIOSES
+
+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_month_station = {
+    "Nisan": ["Asegesenek", "Mesokenek", "Deriegemon", "Shethenovesenov"],
+    "Ayer": ["Phemetor", "Qotenebial", "Ma'agol", "Goberethial"],
+    "Sivan": ["Senediem", "Tzoveh", "Tziyer", "Qoseqomial"],
+    "Tamuz": ["Zemieda", "Phimheor", "A'aphierepheleh", "Ma'ava'aqobebov"],
+    "Ab": ["Kedoremot", "Hetheledemi", "Qonezerema'a", "Hehemekel"],
+    "Elul": ["Phelietepheter", "Thesedegeb", "Nephesa'ar", "Qomoval"],
+    "Thisri": ["Derek", "Mezeredeter", "Neqocheda", "Asepheres"],
+    "Marheshavan": ["Beqosh", "Pheladen", "Sherenar", "Kebod"],
+    "Kislev": ["Phelestos", "Kether", "Henek", "Phonetos Lobenos"],
+    "Tebeth": ["Naphenietz", "Sekeberiem", "Senekeros", "Bekerba'al"],
+    "Shevet": ["Pholekemon", "Qeronega", "Shelomieth", "Yavorer"],
+    "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"],
+    2: ["Tga'sher", "Menechethor", "Qoleneheren", "Shegedon"],
+    3: ["Sheriyachetz", "Qohebereneden", "Pherezen", "Hegelomoth"],
+    4: ["Pheniov Lavor", "Miyeshor", "Degiem", "Betheroqa"],
+    5: ["Kedemenor", "Avoreberien", "Qovephethem", "Bariebererov"],
+    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"],
+    "Yieshegeron": ["Phelayiem", "Ketherenial", "Rebenial", ""],
+    "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"],
+    "Geminis": ["Shegeron", "Biehereron", "Yielebek", "Ashegerien"],
+    "Cancer": ["Mekerechiem", "Qoheder", "Keresivon", "Mehiemeten"],
+    "Leo": ["Letzoneber", "Shegeher", "A'avoqor", "Ayiethebien"],
+    "Virgo": ["A'anem Qenek", "Yiehedieh", "Kenedeni", "Shegeton"],
+    "Libra": ["Tzedequiel", "Sheqothiek", "Theshegekon", "Shecheqon"],
+    "Escorpio": ["Rehecho", "Menedeber", "Kotheben", "Bedod Besher"],
+    "Sagitario": ["Tzoqor", "Reberon", "Abenor", "Keniepena"],
+    "Capricornio": ["Meshegeriem", "Yieshieshieh", "Shebiebiek", "Shegerelovi"],
+    "Acuario": ["Maasheniem", "Aberedon", "Mesepher", "A'anethera"],
+    "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"],
+    3: ["Mazeniem", "Amoniem", "Amoniem", "Mepheni Shesher"],
+    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"],
+    3: ["Aberieth", "Gezorophed", "Zerezor", "Themekor"],
+    4: ["Beriekoch", "Kephor", "Avor", ""]
+}
+
+
+"""

lib/spell.py

@@ -0,0 +1,157 @@
+
+ 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"],
+    "Sivan": ["Senediem", "Tzoveh", "Tziyer", "Qoseqomial"],
+    "Tamuz": ["Zemieda", "Phimheor", "A'aphierepheleh", "Ma'ava'aqobebov"],
+    "Ab": ["Kedoremot", "Hetheledemi", "Qonezerema'a", "Hehemekel"],
+    "Elul": ["Phelietepheter", "Thesedegeb", "Nephesa'ar", "Qomoval"],
+    "Thisri": ["Derek", "Mezeredeter", "Neqocheda", "Asepheres"],
+    "Marheshavan": ["Beqosh", "Pheladen", "Sherenar", "Kebod"],
+    "Kislev": ["Phelestos", "Kether", "Henek", "Phonetos Lobenos"],
+    "Tebeth": ["Naphenietz", "Sekeberiem", "Senekeros", "Bekerba'al"],
+    "Shevet": ["Pholekemon", "Qeronega", "Shelomieth", "Yavorer"],
+    "Adar": ["Koneled", "Ba'aren", "Sebiebekera'a", "Qoromeqore"]
+}
+
+angels_by_day_station = {
+    1: ["Phiegenochen", "Tenekien", "Kophethen", "Makeleched"],
+    2: ["Tga'sher", "Menechethor", "Qoleneheren", "Shegedon"],
+    3: ["Sheriyachetz", "Qohebereneden", "Pherezen", "Hegelomoth"],
+    4: ["Pheniov Lavor", "Miyeshor", "Degiem", "Betheroqa"],
+    5: ["Kedemenor", "Avoreberien", "Qovephethem", "Bariebererov"],
+    6: ["Qola'azeran", "Deremthok", "Akethenor", "Arieh"]
+}
+
+angels_by_moon_sign = {
+    "Leberenieth": ["shaitan", "therezien", "sheneremi", "Gabrial"],
+    "Seletheleb": ["Yieshieshieh", "Abererehon", "Sheheqonek", "Bal Menael"],
+    "Yieshegeron": ["Phelayiem", "Ketherenial", "Rebenial", ""],
+    "Sheherieph": ["Biyom", "Bieth", "Rothep", "Danial"]
+}
+
+moon_ministers_by_zodiac = {
+    "Aries": ["Zerem", "Behemi", "Pheloneh", "Qonosh"],
+    "Tauro": ["Deketon", "Mezekerien", "Thederenael", "Amiena"],
+    "Geminis": ["Shegeron", "Biehereron", "Yielebek", "Ashegerien"],
+    "Cancer": ["Mekerechiem", "Qoheder", "Keresivon", "Mehiemeten"],
+    "Leo": ["Letzoneber", "Shegeher", "A'avoqor", "Ayiethebien"],
+    "Virgo": ["A'anem Qenek", "Yiehedieh", "Kenedeni", "Shegeton"],
+    "Libra": ["Tzedequiel", "Sheqothiek", "Theshegekon", "Shecheqon"],
+    "Escorpio": ["Rehecho", "Menedeber", "Kotheben", "Bedod Besher"],
+    "Sagitario": ["Tzoqor", "Reberon", "Abenor", "Keniepena"],
+    "Capricornio": ["Meshegeriem", "Yieshieshieh", "Shebiebiek", "Shegerelovi"],
+    "Acuario": ["Maasheniem", "Aberedon", "Mesepher", "A'anethera"],
+    "Piscis": ["Sha'aphenen", "Aniesien", "Sethered", "Qohemehogov"]
+}
+
+angels_by_earth_station = {
+    1: ["Memegien", "Yibesheh", "Thebel", "Hezeh Dovem"],
+    2: ["Mechemed Lov", "Bel Ached", "Aseberon", "Qohelorek"],
+    3: ["Mazeniem", "Amoniem", "Amoniem", "Mepheni Shesher"],
+    4: ["Yihelederek", "Mephenial", "Mephenial", ""]
+}
+
+angels_by_malechim_station = {
+    1: ["Akeberon", "Amereneh", "Mazeniem", "Meneshor"],
+    2: ["Qoherok", "Aberiek", "Siegor", "Pheniemor"],
+    3: ["Aberieth", "Gezorophed", "Zerezor", "Themekor"],
+    4: ["Beriekoch", "Kephor", "Avor", ""]
+}
+
+
+
+
+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
+
+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)
+
+    # 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/temuraeh.py

@@ -0,0 +1,45 @@
+import json
+# Implementemos la función de temurah con el alfabeto completo y probemos la conversión de "Baphomet" a "Sofia"
+# en hebreo usando temurah. 
+# Nota: La representación exacta de "Baphomet" y "Sofia" en hebreo puede variar debido a interpretaciones,
+# pero aquí usaremos transliteraciones aproximadas para ilustrar cómo podría hacerse.
+
+def temurah(text, hebrew_alphabet='אבגדהוזחטיכלמנסעפצקרשת', reverse=True):
+    """
+    Aplica la temurah a un texto hebreo utilizando todo el alfabeto hebreo.
+    El esquema de ejemplo simplemente invierte el orden del alfabeto.
+    """
+    # Invertir el alfabeto si se solicita
+    if reverse:
+        hebrew_alphabet = hebrew_alphabet[::-1]
+
+    # Generar el alfabeto invertido
+    inverted_alphabet = hebrew_alphabet[::-1]
+    
+    # Crear el diccionario de mapeo para temurah
+    temurah_mapping = {orig: inv for orig, inv in zip(hebrew_alphabet, inverted_alphabet)}
+    
+    # Aplicar temurah al texto
+    temurah_text = ''.join(temurah_mapping.get(char, char) for char in text)
+    
+    return temurah_text
+
+# Definir el alfabeto hebreo
+hebrew_alphabet = 'אבגדהוזחטיכלמנסעפצקרשת'
+
+latin_alphabet = 'abcdefghijklmnopqrstuvwxyz'
+
+
+def temura_conv(txt,lang):
+    if lang=="Hebrew":
+        alphabet = hebrew_alphabet
+    elif lang=="Latin":
+        alphabet= latin_alphabet
+    else:
+        alphabet=latin_alphabet
+    
+    res = temurah(txt,alphabet)
+    
+    # Aplicar temurah al texto hipotético de "Baphomet"
+    return res
+    

lib/torah.py

@@ -0,0 +1,246 @@
+from deep_translator import GoogleTranslator
+import torahcodes.resources.func.utils as util
+from hebrew_numbers import gematria_to_int
+from textblob import TextBlob
+from os import listdir
+from os.path import isfile, join
+import re
+import time
+import random
+import os
+import json
+
+BLUE, RED, WHITE, YELLOW, MAGENTA, GREEN, END = '\33[1;94m', '\033[1;91m', '\33[1;97m', '\33[1;93m', '\033[1;35m', '\033[1;32m', '\033[0m'
+ORANGE  = '\033[1;33m' # orange
+
+
+data_dir = "resources/texts"
+
+class BibleBooks():
+    def __init__(self):
+        self.folder = data_dir
+        self.book = {}
+    def load(self):
+        
+        for f in listdir(self.folder):
+            print(f)
+            if isfile(join(self.folder, f)) and f.endswith(".json"):
+                fn = f.split('.')
+                #print('Load', fn[0])
+                with open(self.folder+f, encoding="utf-8-sig") as File:
+                    self.book[fn[0]] = File.read()
+
+    def rawdata(self, bookname):
+        return self.book[bookname]
+
+    def booklist(self):
+        return list(self.book.keys())
+
+books = BibleBooks()
+
+class Torah():
+	def __init__(self):
+		self.book = ''
+		self.gcode = {
+            'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6, 'g': 7, 'h': 8, 'i': 9, 'j': 600,
+            'k': 10, 'l': 20, 'm': 30, 'n': 40, 'o': 50, 'p': 60, 'q': 70, 'r': 80, 's': 90,
+            't': 100, 'u': 200, 'v': 700, 'w': 900, 'x': 300, 'y': 400, 'z': 500
+		}
+
+	def loadbooks(self):
+		books.load()
+
+	def func_getnumber(self, listL, listW):
+		return util.fn_GetNumberValues(listL, listW)
+
+	def func_checklang(self, word, lang):
+		b = TextBlob(word)
+		
+		try:
+			b.detect_language()
+			if (b.detect_language() == lang):
+				return True
+		except:
+			return True
+		return False
+
+	def numtobook(self, number):
+		for x in books.booklist():
+			xt = re.findall("[-+]?[.]?[\d]+(?:,\d\d\d)*[\.]?\d*(?:[eE][-+]?\d+)?", x)
+			if xt[0] == str(number):
+				return x
+
+	def func_translate(self, lang_in, lang_out, data):
+		translated = GoogleTranslator(source=lang_in, target=lang_out).translate(data.strip()) 
+		return translated
+
+	def gematria(self, word: str) -> int:
+		try:
+			if word.isdigit():
+				return int(word)
+
+			# Aufteilen des Wortes in Buchstaben und Zahlen
+			letters = [char for char in word if char.isalpha()]
+			numbers = [int(char) for char in word if char.isdigit()]
+
+			# Berechnen des Gematria-Werts für die Buchstaben
+			letters_value = sum([self.gcode[char] for char in letters if char in self.gcode])
+
+
+			# Hinzufügen der Summe der Zahlen zum Gematria-Wert der Buchstaben
+			total_value = letters_value + sum(numbers)
+
+			return total_value
+		except:
+			print(word)
+			raise ValueError
+
+
+	def gematrix(self, phrase: str) -> int:
+		phrase = self.strip_accents(phrase.lower())
+		phrase = ''.join([i for i in phrase if i.isalpha() or i.isdigit() or i.isspace()])
+
+		# Aufteilen der Eingabe in separate Wörter und Zahlen
+		elements = phrase.split()
+		total_value = 0
+
+		for element in elements:
+			if element.isalpha():
+				# Berechne den Wert für Buchstaben
+				total_value += sum([self.gcode[char] for char in element if char in self.gcode])
+			elif element.isdigit():
+				# Addiere Zahlen direkt zum Gesamtwert
+				total_value += int(element)
+
+		return total_value
+
+
+
+
+
+
+	def strip_accents(self, s):
+	    try:
+	        return ''.join(
+	            c for c in unicodedata.normalize('NFD', s)
+	            if unicodedata.category(c) != 'Mn'
+	        )
+	    except:
+	        return s
+
+
+	def gematria_iw_int(text):
+		return gematria_to_int(text)
+
+
+	def func_ParseTranslation(self, translated, lang, active):
+		abd = 'abcdefghijklmnñopqrstuvwxyz1234567890'
+		str_split = translated.split(' ')
+		str_final = ''
+		for word in str_split:
+			try:
+				if word[0].lower() in abd:
+					if active == 'true':
+						if self.func_checklang(word, lang) == True:
+							str_final = str_final+ word+' '
+					else:
+						str_final = str_final+ word+' '
+			except:
+				pass
+		
+		if not str_final == '':
+			return str_final
+		else:
+			return 0
+	def els(self, namebook, number, tracert='false', visualice=False):
+		space = number
+		abd = 'abcdefghijklmnñopqrstuvwxyz'
+		i=1
+		rese=""
+		totalvalue = 0
+		D = self.GetDataBook(namebook)
+		for (z,b,y) in D:
+			try:
+				charnum = 0
+				res=""
+
+				for char in D[z,b,y]:
+					charnum = charnum+1
+					if (i % int(space)) == 0:
+						if tracert == 'true':
+							totalvalue = totalvalue + int(charnum)
+							print('Source:',int(z),'chapter:', int(b),'Verse:', int(y),'CharNum:',int(charnum),'Char:', char)
+
+						res=res+char
+
+					i=i+1
+				rese=rese+" "+res
+			except:
+				pass
+		#print('Total', totalvalue)
+		ret = re.sub('\s+', ' ', rese.strip())
+		return ret, totalvalue
+
+	def GetDataBook(self, bibleNumberBook):
+
+
+		JSON = books.rawdata(bibleNumberBook) 
+		ListOfJSONStringsParsed, ListOfJSONStringsParsedWithSpaces = util.fn_TextFilePreprocess(JSON)
+		ListOfDictsOfJSONStringsParsed, ListOfDictsOfJSONStringsParsedWithSpaces = util.fn_ConvertJSONStringsToDicts(ListOfJSONStringsParsed, ListOfJSONStringsParsedWithSpaces)
+		SearchTextChosen = util.fn_GetNumberOfTextChosen(ListOfDictsOfJSONStringsParsed)
+		ZippedTupleNoSpaces, ZippedTupleWithSpaces = util.fn_ZippedTupleCreate(ListOfDictsOfJSONStringsParsed, ListOfDictsOfJSONStringsParsedWithSpaces, SearchTextChosen)
+		D, DS = util.fn_DictionaryOfVersesCreate(ZippedTupleNoSpaces, ZippedTupleWithSpaces)
+		S, L, DL, D5, ListOfWords = util.fn_DataObjectsCreate(D, DS)
+		N, NW = util.fn_GetNumberValues(S, ListOfWords) 
+		ListOfIndexesCustom = util.fn_ListOfIndexesCustomCreate(D5)
+		W = util.fn_TupleOfWordsAndGematriaValuesCreate(ListOfWords, NW)
+
+		return D
+
+
+def process_json_files(start, end, step, length=0, tlang="en", spaces_include=False, strip_in_braces=True, strip_diacritics=True):
+    base_path = "resources/texts"
+    translator = GoogleTranslator(source='auto', target=tlang)
+    results = []
+
+    for i in range(start, end + 1):
+        file_name = f"{base_path}/{i:02}.json"
+        try:
+            with open(file_name, 'r', encoding='utf-8') as file:
+                data = json.load(file)
+                text_blocks = data["text"]
+
+                full_text = ""
+                for block in text_blocks:
+                    full_text += ' '.join(block)
+
+                clean_text = full_text
+                if strip_in_braces:
+                    clean_text = re.sub(r"\[.*?\]", "", clean_text, flags=re.DOTALL)
+                if strip_diacritics:
+                    clean_text = re.sub(r"[^\u05D0-\u05EA ]+", "", clean_text)
+                if not spaces_include:
+                    clean_text = clean_text.replace(" ", "")
+
+                if length != 0:
+                    selected_characters = clean_text[step - 1::step][:length]
+                else:
+                    selected_characters = clean_text[step - 1::step]  # If length is 0, select all characters from step
+
+                translated_text = translator.translate(''.join(selected_characters))
+                if selected_characters != "":
+                    results.append({
+                        "book": i,
+                        "title": data["title"],
+                        "original_text": selected_characters,
+                        "translated_text": translated_text
+                    })
+
+        except FileNotFoundError:
+            results.append({"error": f"File {file_name} not found."})
+        except json.JSONDecodeError:
+            results.append({"error": f"File {file_name} could not be read as JSON."})
+        except KeyError:
+            results.append({"error": f"Expected key 'text' is missing in {file_name}."})
+
+    return results

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)

lib/ziruph.py

@@ -0,0 +1,36 @@
+
+
+
+# Define the substitution key
+key = "C X Y B W P R V Q J Z M N T K E L D F G H I O U S"
+
+# Define the plaintext and ciphertext functions
+def encrypt(message,dic):
+    ciphertext = ""
+    for char in message:
+        if char.isalpha():
+            # Check if char is uppercase or lowercase
+            if char.isupper():
+                # Convert to lowercase and encrypt using key
+                encrypted = key[ord(char) - ord("A")].lower()
+            else:
+                # Convert to uppercase and encrypt using key
+                encrypted = key[ord(char) - ord("a")].upper()
+            ciphertext += encrypted
+    return ciphertext
+
+def decrypt(message,dic):
+    plaintext = ""
+    for char in message:
+        if char.isalpha():
+            # Check if char is uppercase or lowercase
+            if char.isupper():
+                # Convert to lowercase and decrypt using inverse key
+                decrypted = key[25 - key.index(char.lower())].upper()
+            else:
+                # Convert to uppercase and decrypt using inverse key
+                decrypted = key[25 - key.index(char)].lower()
+            plaintext += decrypted
+    return plaintext
+
+

resources/Pleyades

@@ -0,0 +1 @@
+Subproject commit 7897127f64a0f9646a7ebbe101bbeeeba5ccf946