bible.py

import logging
logger = logging.getLogger(__name__)


import json
import os
import re
from deep_translator import GoogleTranslator
from gematria import calculate_gematria
import math


# Hebrew gematria values for relevant characters
gematria_values = {
    'א': 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
}

# Reverse dictionary for converting gematria values back to Hebrew characters
reverse_gematria_values = {v: k for k, v in gematria_values.items()}

# Function to convert a Hebrew string to its gematria values
def string_to_gematria(s):
    return [gematria_values.get(char, 0) for char in s]  # Handle characters not in the dictionary

# Function to convert a single gematria value to Hebrew characters
def gematria_to_string(value):
    result = []
    for val in sorted(reverse_gematria_values.keys(), reverse=True):
        while value >= val:
            result.append(reverse_gematria_values[val])
            value -= val
    return ''.join(result)

# Function to calculate the average gematria values of corresponding characters and convert them to Hebrew characters
def average_gematria(str1, str2):
    # Convert strings to gematria values
    gematria1 = string_to_gematria(str1)
    gematria2 = string_to_gematria(str2)

    # Handle cases where strings have different lengths by padding with 0s
    max_len = max(len(gematria1), len(gematria2))
    gematria1.extend([0] * (max_len - len(gematria1)))
    gematria2.extend([0] * (max_len - len(gematria2)))

    # Calculate the average of corresponding gematria values and apply math.ceil
    average_gematria_values = [math.ceil((g1 + g2) / 2) for g1, g2 in zip(gematria1, gematria2)]

    # Convert the average gematria values back to Hebrew characters
    return ''.join(gematria_to_string(val) for val in average_gematria_values)


from deep_translator import GoogleTranslator
import os
import re
import csv


def process_json_files(start=1, end=66, step=1, rounds="1", length=0, tlang="en", strip_spaces=True,
                       strip_in_braces=True, strip_diacritics=True, average_compile=False):
    file_name = "texts/bible/OpenGNT_version3_3.csv"
    translator = GoogleTranslator(source='auto', target=tlang)
    results = []

    # Dictionary für die 27 Bücher des Neuen Testaments (Englische Namen)
    nt_books = {
        40: "Matthew",
        41: "Mark",
        42: "Luke",
        43: "John",
        44: "Acts",
        45: "Romans",
        46: "1. Corinthians",
        47: "2. Corinthians",
        48: "Galatians",
        49: "Ephesians",
        50: "Philippians",
        51: "Colossians",
        52: "1. Thessalonians",
        53: "2. Thessalonians",
        54: "1. Timothy",
        55: "2. Timothy",
        56: "Titus",
        57: "Philemon",
        58: "Hebrews",
        59: "James",
        60: "1. Peter",
        61: "2. Peter",
        62: "1. John",
        63: "2. John",
        64: "3. John",
        65: "Jude",
        66: "Revelation"
    }

    try:
        with open(file_name, 'r', encoding='utf-8') as file:
            reader = csv.DictReader(file, delimiter='\t')

            book_texts = {}
            current_book = None
            for row in reader:
                book = int(row['〔Book｜Chapter｜Verse〕'].split('｜')[0][1:])
                if book < start or book > end:
                    continue
                if current_book != book:
                    current_book = book
                    book_texts[book] = ""
                greek_text = row['〔OGNTk｜OGNTu｜OGNTa｜lexeme｜rmac｜sn〕']
                greek_text = greek_text.split('〔')[1]
                greek_text = greek_text.split('｜')[0]
                book_texts[book] += greek_text + " "

            for book, full_text in book_texts.items():
                logger.debug(f"Processing book {book}")
                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"[^\u0370-\u03FF\u1F00-\u1FFF ]+", "", clean_text)
                if strip_spaces:
                    clean_text = clean_text.replace(" ", "")
                else:
                    clean_text = clean_text.replace("  ", " ")
                    clean_text = clean_text.replace("  ", " ")
                    clean_text = clean_text.replace("  ", " ")

                text_length = len(clean_text)

                selected_characters_per_round = {}
                for round_num in map(int, rounds.split(',')):
                    if not (round_num == 1 and step > text_length) and not (round_num == -1 and step > text_length):
                        if round_num > 0:
                            current_position = step - 1
                        else:
                            current_position = text_length - 1 if step == 1 else text_length - step

                        completed_rounds = 0
                        selected_characters = ""

                        while completed_rounds < abs(round_num):
                            selected_characters += clean_text[current_position % text_length]
                            current_position += step if round_num > 0 else -step

                            if (round_num > 0 and current_position >= text_length * (completed_rounds + 1)) or \
                               (round_num < 0 and current_position < 0):
                                completed_rounds += 1

                        selected_characters_per_round[round_num] = selected_characters

                if average_compile and len(selected_characters_per_round) > 1:
                    result_text = ""
                    keys = sorted(selected_characters_per_round.keys())
                    for i in range(len(keys) - 1):
                        result_text = average_gematria(selected_characters_per_round[keys[i]], selected_characters_per_round[keys[i+1]])
                else:
                    result_text = ''.join(selected_characters_per_round.values())

                if length != 0:
                    result_text = result_text[:length]

                translated_text = translator.translate(result_text) if result_text else ""

                result_sum = calculate_gematria(result_text)

                if result_text:
                    logger.debug(f"Result for book {book}: {result_text}")
                    result = {
                        'book': f"Bible {book}.",  # Use the correct 'book' variable
                        'title': nt_books.get(book, "Unknown Book"),  # Get book name from dictionary
                        'result_text': result_text,
                        'result_sum': result_sum,  # Make sure result_sum is calculated correctly
                        'translated_text': translated_text
                    }
                    results.append(result)


    except FileNotFoundError:
        results.append({"error": f"File {file_name} not found."})

    return results
        # Tests
test_results = [
    #(process_json_files(1, 1, 21, rounds="3", length=0), ""),
    #(process_json_files(1, 1, 22, rounds="1", length=0), ""), 
    #(process_json_files(1, 1, 22, rounds="3", length=0), ""),
    #(process_json_files(1, 1, 23, rounds="3", length=0), ""),
    #(process_json_files(1, 1, 11, rounds="1", length=0), ""),
    #(process_json_files(1, 1, 2, rounds="1", length=0), ""),
    #(process_json_files(1, 1, 23, rounds="1", length=0), None),  # Expect None, when no results
    #(process_json_files(1, 1, 23, rounds="-1", length=0), None),  # Expect None, when no results
    #(process_json_files(1, 1, 22, rounds="-1", length=0), ""),
    #(process_json_files(1, 1, 22, rounds="-2", length=0), ""),
    #(process_json_files(1, 1, 1, rounds="-1", length=0), ""), # Reversed Hebrew alphabet
    #(process_json_files(1, 1, 1, rounds="1,-1", length=0), ""), # Combined rounds
    #(process_json_files(1, 1, 22, rounds="1,-1", length=0, average_compile=True), ""),  # average compile test (400+1) / 2 = math.ceil(200.5)=201=200+1="רא"
]

all_tests_passed = True
for result, expected in test_results:
    if expected is None:  # Check if no result is expected
        if not result:
            logger.info(f"Test passed: Expected no results, got no results.")
        else:
            logger.error(f"Test failed: Expected no results, but got: {result}")
            all_tests_passed = False
    else:
        # Check if result is not empty before accessing elements
        if result: 
            #result_text = result[0]['result_text']
            result_text = None
            if result_text == expected:
                logger.info(f"Test passed: Expected '{expected}', got '{result_text}'")
            else:
                logger.error(f"Test failed: Expected '{expected}', but got '{result_text}'")
                all_tests_passed = False
        else:
            logger.error(f"Test failed: Expected '{expected}', but got no results")
            all_tests_passed = False

if all_tests_passed:
    logger.info("All round tests passed.")