filtering, upgrade

app.py

@@ -36,7 +36,6 @@ def date_to_words(date_string):
     date_obj = datetime.strptime(date_string, "%Y-%m-%d")
     return format_date(date_obj, inf_engine)
 
-
 def month_year_to_words(date_string):
     """Converts a month and year in YYYY-MM format to English words."""
     inf_engine = inflect.engine()
@@ -44,9 +43,10 @@ def month_year_to_words(date_string):
     return format_date(date_obj, inf_engine)
 
 def format_date(date_obj, inf_engine):
+    """Formats day-month-year into English words with ordinal day."""
     year = date_obj.year
     if 1100 <= year <= 1999:
-        year_words = f"{inf_engine.number_to_words(year // 100, andword='') } hundred"
+        year_words = f"{inf_engine.number_to_words(year // 100, andword='')} hundred"
         if year % 100 != 0:
             year_words += f" {inf_engine.number_to_words(year % 100, andword='')}"
     else:
@@ -54,14 +54,11 @@ def format_date(date_obj, inf_engine):
     year_formatted = year_words.replace(',', '')
 
     month = date_obj.strftime("%B")
-    
-    try:  # Try getting the day, if available
-        day = date_obj.day
-        day_ordinal = number_to_ordinal_word(day)
-        return f"{day_ordinal} {month} {year_formatted}" # Return with day
-    except: 
-        return f"{month} {year_formatted}"  # Return without day
 
+    # Tag auslesen und in Ordinalform umwandeln
+    day = date_obj.day
+    day_ordinal = number_to_ordinal_word(day)
+    return f"{day_ordinal} {month} {year_formatted}"
 
 def format_year_to_words(year):
     """Formats a year as English words."""
@@ -75,17 +72,17 @@ def format_year_to_words(year):
     return year_words.replace(',', '')
 
 def perform_gematria_calculation_for_date_range(start_date, end_date):
-    """Performs gematria calculation for a date range and groups by sum."""
+    """Performs gematria calculation for each day in a date range and groups by sum."""
     logger.debug(f"Start Date: {start_date}, End Date: {end_date}")
     results = {}
     delta = timedelta(days=1)
     current_date = start_date
 
     processed_months = set()  # To track processed month-year combinations
-    processed_years = set()  # To track processed years
+    processed_years = set()   # To track processed years
 
     while current_date <= end_date:
-        # Full date calculation
+        # 1) Full date calculation
         date_string = current_date.strftime("%Y-%m-%d")
         date_words = date_to_words(date_string)
         gematria_sum = calculate_gematria_sum(date_words)
@@ -94,7 +91,7 @@ def perform_gematria_calculation_for_date_range(start_date, end_date):
             results[gematria_sum] = []
         results[gematria_sum].append({"date": date_string, "date_words": date_words})
 
-        # Month+Year calculation (processed once per month)
+        # 2) Month+Year calculation (only once per unique month-year)
         month_year_key = current_date.strftime("%Y-%m")
         if month_year_key not in processed_months:
             processed_months.add(month_year_key)
@@ -108,7 +105,7 @@ def perform_gematria_calculation_for_date_range(start_date, end_date):
                 "date_words": month_year_words
             })
 
-        # Year-only calculation (processed once per year)
+        # 3) Year-only calculation (only once per unique year)
         year_key = str(current_date.year)
         if year_key not in processed_years:
             processed_years.add(year_key)
@@ -126,40 +123,56 @@ def perform_gematria_calculation_for_date_range(start_date, end_date):
 
     return results
 
-
 # --- Event Handlers ---
-def perform_calculation(start_date, end_date, include_words):
-    """Performs the calculation and generates the JSON output."""
-    logger.debug(f"perform_calculation called with: start_date={start_date}, end_date={end_date}, include_words={include_words}")
-    results = perform_gematria_calculation_for_date_range(start_date, end_date)
-    json_result = generate_json_output(results, start_date, end_date, include_words)
-    return json_result
-
-
-def generate_json_output(results, start_date, end_date, include_words):
-    """Generates the JSON output with the date range and results."""
-    result = {
+def generate_json_output(results, start_date, end_date, include_words, min_results):
+    """
+    Erzeugt ein Dictionary (später für gr.JSON) mit Filterung nach Mindestanzahl,
+    wenn min_results nicht None ist.
+    """
+    output = {
         "DateRange": {
             "StartDate": start_date.strftime("%Y-%m-%d"),
             "EndDate": end_date.strftime("%Y-%m-%d")
         },
         "Results": []
     }
+
     for gematria_sum, entries in results.items():
+        # Falls eine Mindestanzahl gefordert ist, filtern
+        if min_results is not None and len(entries) < min_results:
+            continue
+
         group = {
             "GematriaSum": gematria_sum,
             "Entries": []
         }
         for entry in entries:
             entry_data = {"date": entry["date"]}
-            if include_words:  # Conditionally include `date_words`
+            if include_words:
                 entry_data["date_words"] = entry["date_words"]
             group["Entries"].append(entry_data)
-        result["Results"].append(group)
 
-    # Ensure JSON validity
-    return json.dumps(result, indent=4, ensure_ascii=False)
+        output["Results"].append(group)
+
+    return output  # <-- Wichtig: Als Dictionary zurückgeben
 
+def perform_calculation(start_date, end_date, include_words, min_results):
+    """
+    Führt die Gematria-Berechnung durch und gibt ein Dictionary zurück,
+    das direkt an gr.JSON übergeben werden kann.
+    """
+    results = perform_gematria_calculation_for_date_range(start_date, end_date)
+    return generate_json_output(results, start_date, end_date, include_words, min_results)
+
+def download_json(json_data, start_date, end_date):
+    """
+    Nimmt das Dictionary aus json_data (von gr.JSON), verwandelt es in einen JSON-String
+    und gibt es zum Downloaden als .json zurück.
+    """
+    filename = f"gematria_{start_date.strftime('%Y%m%d')}_{end_date.strftime('%Y%m%d')}.json"
+    # Hier wandeln wir das Dictionary in einen String um
+    json_string = json.dumps(json_data, indent=4, ensure_ascii=False)
+    return gr.File.update(value=json_string, filename=filename)
 
 # --- Main Gradio App ---
 with gr.Blocks() as app:
@@ -167,25 +180,52 @@ with gr.Blocks() as app:
         start_date = Calendar(type="datetime", label="Start Date")
         end_date = Calendar(type="datetime", label="End Date")
 
-    include_date_words = gr.Checkbox(value=True, label="Include Date-Words in JSON")
+    with gr.Row():
+        include_date_words = gr.Checkbox(
+            value=True, label="Include Date-Words in JSON"
+        )
+        filter_results = gr.Checkbox(
+            value=False, label="Filter to sums with at least"
+        )
+        min_results_input = gr.Number(
+            value=2, label="results", interactive=True, precision=0
+        )
 
     calculate_btn = gr.Button("Calculate Gematria for Date Range")
-    json_output = gr.Textbox(label="JSON Output")
+    json_output = gr.JSON(label="JSON Output")  # Präsentation als JSON
     download_btn = gr.Button("Download JSON")
     json_file = gr.File(label="Downloaded JSON")
 
-    # --- Event Triggers ---
+    # Damit wir den Wert von filter_results berücksichtigen können:
+    def handle_calculate(start_val, end_val, include_val, filter_val, min_val):
+        if not filter_val:  # Checkbox nicht gesetzt
+            # => Kein Filtern, also min_results=None
+            return perform_calculation(start_val, end_val, include_val, None)
+        else:
+            # => Filter aktiviert, also min_results = min_val
+            # min_val kann float sein; auf int casten, falls gewünscht
+            return perform_calculation(start_val, end_val, include_val, int(min_val))
+
+    # Button-Klick: wir rufen handle_calculate auf,
+    # das ggf. min_results auf None setzt oder den Wert übernimmt.
     calculate_btn.click(
-        perform_calculation,
-        inputs=[start_date, end_date, include_date_words],
+        handle_calculate,
+        inputs=[start_date, end_date, include_date_words, filter_results, min_results_input],
         outputs=[json_output],
         api_name="calculate_gematria"
     )
 
     download_btn.click(
-        lambda json_data, start_date, end_date: download_json(json_data, start_date, end_date),
+        download_json,
         inputs=[json_output, start_date, end_date],
-        outputs=[json_file],
+        outputs=[json_file]
+    )
+
+    # Aktiviert/Deaktiviert die Eingabe für min_results
+    filter_results.change(
+        lambda checked: gr.update(interactive=checked),
+        inputs=filter_results,
+        outputs=min_results_input
     )
 
 if __name__ == "__main__":

requirements.txt

@@ -1,5 +1,5 @@
-fastapi==0.112.3
-gradio==4.31.0
-deep_translator==1.11.4
-gradio_calendar==0.0.4
-inflect==7.2.1
+#fastapi==0.112.3
+gradio==5.5.0
+deep_translator
+gradio_calendar
+inflect