Update backend.py

backend.py

@@ -1,73 +1,121 @@
 from flask import Flask, request, jsonify
 import requests
+import json
 
 app = Flask(__name__)
 
-class APIService:
-    """Basisklasse für alle API-Dienste."""
-    def __init__(self, api_key):
-        self.api_key = api_key
+# Laden der API-Keys aus einer Konfigurationsdatei
+def load_api_keys():
+    with open("config.json", "r") as file:
+        return json.load(file)
+
+# Speichern der API-Keys
+def save_api_keys(api_keys):
+    with open("config.json", "w") as file:
+        json.dump(api_keys, file)
+
+# API-Dienst für Synonyme (mit Fallback)
+class SynonymAPI:
+    def __init__(self, api_keys):
+        self.api_keys = api_keys
 
-    def fetch(self, *args, **kwargs):
-        raise NotImplementedError("Diese Methode muss von Unterklassen implementiert werden.")
+    def fetch(self, word, language='en'):
+        try:
+            response = self._fetch_from_primary_api(word, language)
+            if response.status_code == 200:
+                return response.json()['entries'][0]['synonyms']
+        except Exception:
+            # Fallback zur zweiten API, falls die erste nicht funktioniert
+            return self._fetch_from_secondary_api(word, language)
 
-class SynonymAPI(APIService):
-    """API-Dienst für Synonyme."""
-    def fetch(self, word):
-        url = f"https://lingua-robot.p.rapidapi.com/language/v1/synonyms?word={word}"
+    def _fetch_from_primary_api(self, word, language):
+        url = f"https://lingua-robot.p.rapidapi.com/language/v1/synonyms?word={word}&language={language}"
         headers = {
-            'x-rapidapi-key': self.api_key,
+            'x-rapidapi-key': self.api_keys['primary'],
             'x-rapidapi-host': "lingua-robot.p.rapidapi.com"
         }
-        response = requests.get(url, headers=headers)
-        return response.json()['entries'][0]['synonyms'] if response.status_code == 200 else []
+        return requests.get(url, headers=headers)
+
+    def _fetch_from_secondary_api(self, word, language):
+        url = f"https://api.datamuse.com/words?rel_syn={word}&ml={language}"
+        return requests.get(url)
+
+# API-Dienst für Grammatik
+class GrammarAPI:
+    def __init__(self, api_key):
+        self.api_key = api_key
 
-class GrammarAPI(APIService):
-    """API-Dienst für Grammatik."""
-    def fetch(self, text):
-        response = requests.post(self.api_key, data={'text': text, 'language': 'en'})
+    def fetch(self, text, language='en'):
+        response = requests.post(self.api_key, data={'text': text, 'language': language})
         return response.json()['matches'] if response.status_code == 200 else []
 
+# API Manager zum Verwalten der Dienste
 class APIManager:
-    """Verwalten der APIs (Synonym und Grammatik)."""
     def __init__(self):
         self.synonym_api = None
         self.grammar_api = None
 
-    def set_synonym_api(self, api):
-        self.synonym_api = api
-
-    def set_grammar_api(self, api):
-        self.grammar_api = api
+    def configure_apis(self, synonym_api_keys, grammar_api_key):
+        self.synonym_api = SynonymAPI(synonym_api_keys)
+        self.grammar_api = GrammarAPI(grammar_api_key)
 
-    def fetch_synonyms(self, word):
-        return self.synonym_api.fetch(word) if self.synonym_api else "Keine Synonym-API konfiguriert."
+    def fetch_synonyms(self, word, language='en'):
+        return self.synonym_api.fetch(word, language) if self.synonym_api else "Keine Synonym-API konfiguriert."
 
-    def fetch_grammar(self, text):
-        return self.grammar_api.fetch(text) if self.grammar_api else "Keine Grammatik-API konfiguriert."
+    def fetch_grammar(self, text, language='en'):
+        return self.grammar_api.fetch(text, language) if self.grammar_api else "Keine Grammatik-API konfiguriert."
 
-# Instanziierung
+# Instanziierung des API-Managers
 api_manager = APIManager()
 
-# API-Routen
+# API-Konfiguration
 @app.route('/configure', methods=['POST'])
 def configure_apis():
     data = request.json
-    synonym_api_key = data.get('synonym_api_key')
-    grammar_api_key = data.get('grammar_api_key')
-    api_manager.set_synonym_api(SynonymAPI(synonym_api_key))
-    api_manager.set_grammar_api(GrammarAPI(grammar_api_key))
+    api_keys = {
+        'synonym_api_keys': {
+            'primary': data.get('synonym_primary_api_key'),
+            'secondary': data.get('synonym_secondary_api_key')
+        },
+        'grammar_api_key': data.get('grammar_api_key')
+    }
+    save_api_keys(api_keys)
+    api_manager.configure_apis(api_keys['synonym_api_keys'], api_keys['grammar_api_key'])
     return jsonify({"status": "APIs erfolgreich konfiguriert."})
 
+# Textanalyse-API mit Zeichenanpassung
 @app.route('/analyze-text', methods=['POST'])
 def analyze_text():
     data = request.json
     text = data.get('text')
+    desired_length = data.get('desired_length', len(text))
+    language = data.get('language', 'en')
+
     word = text.split()[0]
-    synonyms = api_manager.fetch_synonyms(word)
-    grammar = api_manager.fetch_grammar(text)
-    return jsonify({"synonyms": synonyms, "grammar_suggestions": grammar})
+    synonyms = api_manager.fetch_synonyms(word, language)
+    grammar = api_manager.fetch_grammar(text, language)
+
+    # Zeichenanzahl berechnen und Anpassungsvorschläge geben
+    current_length = len(text)
+    length_difference = desired_length - current_length
+
+    response = {
+        "synonyms": synonyms,
+        "grammar_suggestions": grammar,
+        "current_length": current_length,
+        "desired_length": desired_length,
+        "length_difference": length_difference,
+        "adjustment_suggestions": []
+    }
+
+    # Vorschläge für Zeichenanzahl-Anpassung
+    if length_difference > 0:
+        response["adjustment_suggestions"].append(f"Fügen Sie {length_difference} Zeichen hinzu.")
+    elif length_difference < 0:
+        response["adjustment_suggestions"].append(f"Entfernen Sie {abs(length_difference)} Zeichen.")
+
+    return jsonify(response)
 
-# Start des Servers
+# Serverstart
 if __name__ == '__main__':
     app.run(debug=True)