Upload app.py with huggingface_hub

app.py

@@ -249,10 +249,10 @@ def translate_internal(text: str, src_lang: str, tgt_lang: str) -> str:
 # API Functions
 # ============================================
 
-def translate(text: str, source_lang: str, target_lang: str) -> dict:
+def translate(text: str, source_lang: str, target_lang: str) -> str:
     """Translate text between Indian languages"""
     if not text or not text.strip():
-        return {"error": "No text provided", "translation": ""}
+        return json.dumps({"error": "No text provided", "translation": ""})
     try:
         tokenizer, model, model_name = get_translation_model()
         
@@ -275,21 +275,21 @@ def translate(text: str, source_lang: str, target_lang: str) -> dict:
         
         translation = tokenizer.decode(generated[0], skip_special_tokens=True)
         
-        return {
+        return json.dumps({
             "translation": translation,
             "source_lang": source_lang,
             "target_lang": target_lang,
             "model": model_name
-        }
+        })
     except Exception as e:
-        return {"error": str(e), "translation": ""}
-def check_grammar(text: str, language: str = "english") -> dict:
+        return json.dumps({"error": str(e), "translation": ""})
+def check_grammar(text: str, language: str = "english") -> str:
     """
     Check and correct grammar in text.
     For Indian languages: Translate to English -> Correct -> Translate back
     """
     if not text or not text.strip():
-        return {"error": "No text provided", "corrected": "", "suggestions": []}
+        return json.dumps({"error": "No text provided", "corrected": "", "suggestions": []})
     try:
         original_text = text
         is_indian = is_indian_language(language)
@@ -345,22 +345,22 @@ def check_grammar(text: str, language: str = "english") -> dict:
                 "type": "grammar"
             })
         
-        return {
+        return json.dumps({
             "corrected": corrected,
             "original": original_text,
             "suggestions": suggestions,
             "has_errors": has_errors,
             "language": language
-        }
+        })
     except Exception as e:
-        return {"error": str(e), "corrected": text, "original": text, "has_errors": False, "suggestions": []}
-def check_spelling(text: str, language: str = "english") -> dict:
+        return json.dumps({"error": str(e), "corrected": text, "original": text, "has_errors": False, "suggestions": []})
+def check_spelling(text: str, language: str = "english") -> str:
     """
     Check spelling in text.
     For Indian languages: Uses translation-based correction
     """
     if not text or not text.strip():
-        return {"error": "No text provided", "corrected": "", "misspelled": []}
+        return json.dumps({"error": "No text provided", "corrected": "", "misspelled": []})
     try:
         original_text = text
         is_indian = is_indian_language(language)
@@ -401,13 +401,13 @@ def check_spelling(text: str, language: str = "english") -> dict:
                         corrected_words.append(word)
                 
                 corrected = ' '.join(corrected_words)
-                return {
+                return json.dumps({
                     "corrected": corrected,
                     "original": original_text,
                     "misspelled": misspelled,
                     "has_errors": len(misspelled) > 0,
                     "language": language
-                }
+                })
             except ImportError:
                 pass
         
@@ -418,13 +418,13 @@ def check_spelling(text: str, language: str = "english") -> dict:
             
             has_errors = corrected.strip() != original_text.strip()
             
-            return {
+            return json.dumps({
                 "corrected": corrected if has_errors else original_text,
                 "original": original_text,
                 "misspelled": [],
                 "has_errors": has_errors,
                 "language": language
-            }
+            })
         # Fallback: use grammar model
         tokenizer, model = get_grammar_model()
         
@@ -444,21 +444,21 @@ def check_spelling(text: str, language: str = "english") -> dict:
         corrected = tokenizer.decode(outputs[0], skip_special_tokens=True)
         has_errors = corrected.strip() != original_text.strip()
         
-        return {
+        return json.dumps({
             "corrected": corrected if has_errors else original_text,
             "original": original_text,
             "has_errors": has_errors,
             "language": language
-        }
+        })
     except Exception as e:
-        return {"error": str(e), "corrected": text, "original": text, "has_errors": False}
-def rewrite_text(text: str, style: str = "formal", language: str = "english") -> dict:
+        return json.dumps({"error": str(e), "corrected": text, "original": text, "has_errors": False})
+def rewrite_text(text: str, style: str = "formal", language: str = "english") -> str:
     """
     Rewrite text in different styles.
     Uses translation-based approach for Indian languages.
     """
     if not text or not text.strip():
-        return {"error": "No text provided", "rewritten": ""}
+        return json.dumps({"error": "No text provided", "rewritten": ""})
     try:
         original_text = text
         is_indian = is_indian_language(language)
@@ -510,26 +510,26 @@ def rewrite_text(text: str, style: str = "formal", language: str = "english") ->
         else:
             rewritten = rewritten_english
         
-        return {
+        return json.dumps({
             "rewritten": rewritten,
             "original": original_text,
             "style": style,
             "language": language
-        }
+        })
     except Exception as e:
-        return {"error": str(e), "rewritten": text}
-def summarize_text(text: str, max_length: int = 150) -> dict:
+        return json.dumps({"error": str(e), "rewritten": text})
+def summarize_text(text: str, max_length: int = 150) -> str:
     """Summarize text (works for all languages via translation)"""
     if not text or not text.strip():
-        return {"error": "No text provided", "summary": ""}
+        return json.dumps({"error": "No text provided", "summary": ""})
     word_count = len(text.split())
     if word_count < 20:
-        return {
+        return json.dumps({
             "summary": text,
             "original_length": word_count,
             "summary_length": word_count,
             "note": "Text too short to summarize"
-        }
+        })
     try:
         script = detect_script(text)
         is_indian = script != "latin"
@@ -580,18 +580,18 @@ def summarize_text(text: str, max_length: int = 150) -> dict:
         else:
             summary = summary_english
         
-        return {
+        return json.dumps({
             "summary": summary,
             "original_length": word_count,
             "summary_length": len(summary.split()),
             "detected_language": detected_lang
-        }
+        })
     except Exception as e:
-        return {"error": str(e), "summary": ""}
-def paraphrase(text: str, language: str = "english") -> dict:
+        return json.dumps({"error": str(e), "summary": ""})
+def paraphrase(text: str, language: str = "english") -> str:
     """Paraphrase text while keeping the meaning"""
     if not text or not text.strip():
-        return {"error": "No text provided", "paraphrased": ""}
+        return json.dumps({"error": "No text provided", "paraphrased": ""})
     try:
         original_text = text
         is_indian = is_indian_language(language)
@@ -651,26 +651,26 @@ def paraphrase(text: str, language: str = "english") -> dict:
         else:
             paraphrased = paraphrased_english
         
-        return {
+        return json.dumps({
             "paraphrased": paraphrased,
             "original": original_text,
             "language": language
-        }
+        })
     except Exception as e:
-        return {"error": str(e), "paraphrased": text}
+        return json.dumps({"error": str(e), "paraphrased": text})
 # ============================================
 # LANGUAGE TOOL API FUNCTIONS (38 Tools)
 # Using lightweight models optimized for CPU Basic
 # ============================================
 
-def tool_grammar_checker(text: str, language: str = "english", tool_type: str = "grammar-checker") -> dict:
+def tool_grammar_checker(text: str, language: str = "english", tool_type: str = "grammar-checker") -> str:
     """
     Grammar checker for language tool pages.
     Uses grammarly/coedit-large model for better results.
     Supports: grammar-checker, sentence-corrector, paragraph-corrector, text-corrector, writing-checker
     """
     if not text or not text.strip():
-        return {"error": "No text provided", "result": ""}
+        return json.dumps({"error": "No text provided", "result": ""})
     try:
         original_text = text
         is_indian = is_indian_language(language)
@@ -714,22 +714,22 @@ def tool_grammar_checker(text: str, language: str = "english", tool_type: str =
         else:
             corrected = corrected_english
         
-        return {
+        return json.dumps({
             "result": corrected,
             "original": original_text,
             "tool": tool_type,
             "language": language,
             "has_corrections": corrected.strip() != original_text.strip()
-        }
+        })
     except Exception as e:
-        return {"error": str(e), "result": text, "tool": tool_type}
-def tool_spell_checker(text: str, language: str = "english", tool_type: str = "spell-checker") -> dict:
+        return json.dumps({"error": str(e), "result": text, "tool": tool_type})
+def tool_spell_checker(text: str, language: str = "english", tool_type: str = "spell-checker") -> str:
     """
     Spell checker for language tool pages.
     Uses lighter model for: spell-checker, punctuation-checker, autocorrect, spell-check-online
     """
     if not text or not text.strip():
-        return {"error": "No text provided", "result": ""}
+        return json.dumps({"error": "No text provided", "result": ""})
     try:
         original_text = text
         is_indian = is_indian_language(language)
@@ -769,23 +769,23 @@ def tool_spell_checker(text: str, language: str = "english", tool_type: str = "s
         else:
             corrected = corrected_english
         
-        return {
+        return json.dumps({
             "result": corrected,
             "original": original_text,
             "tool": tool_type,
             "language": language,
             "has_corrections": corrected.strip() != original_text.strip()
-        }
+        })
     except Exception as e:
-        return {"error": str(e), "result": text, "tool": tool_type}
-def tool_writing_assistant(text: str, language: str = "english", tool_type: str = "rewrite", style: str = "formal") -> dict:
+        return json.dumps({"error": str(e), "result": text, "tool": tool_type})
+def tool_writing_assistant(text: str, language: str = "english", tool_type: str = "rewrite", style: str = "formal") -> str:
     """
     Writing assistant for language tool pages.
     Uses flan-t5-base for: essay-corrector, content-writer, article-rewriter, blog-writer,
     proofreader, readability-checker, letter-writer, editor, paraphrasing-tool
     """
     if not text or not text.strip():
-        return {"error": "No text provided", "result": ""}
+        return json.dumps({"error": "No text provided", "result": ""})
     try:
         original_text = text
         is_indian = is_indian_language(language)
@@ -836,30 +836,30 @@ def tool_writing_assistant(text: str, language: str = "english", tool_type: str
         else:
             result = result_english
         
-        return {
+        return json.dumps({
             "result": result,
             "original": original_text,
             "tool": tool_type,
             "language": language,
             "style": style
-        }
+        })
     except Exception as e:
-        return {"error": str(e), "result": text, "tool": tool_type}
-def tool_summarizer(text: str, language: str = "english", max_length: int = 150) -> dict:
+        return json.dumps({"error": str(e), "result": text, "tool": tool_type})
+def tool_summarizer(text: str, language: str = "english", max_length: int = 150) -> str:
     """
     Summarizer for language tool pages.
     Uses flan-t5-base model.
     """
     if not text or not text.strip():
-        return {"error": "No text provided", "result": ""}
+        return json.dumps({"error": "No text provided", "result": ""})
     word_count = len(text.split())
     if word_count < 20:
-        return {
+        return json.dumps({
             "result": text,
             "original_length": word_count,
             "summary_length": word_count,
             "note": "Text too short to summarize"
-        }
+        })
     try:
         is_indian = is_indian_language(language)
         original_text = text
@@ -891,36 +891,36 @@ def tool_summarizer(text: str, language: str = "english", max_length: int = 150)
         else:
             summary = summary_english
         
-        return {
+        return json.dumps({
             "result": summary,
             "original": original_text,
             "original_length": word_count,
             "summary_length": len(summary.split()),
             "language": language,
             "tool": "summarizer"
-        }
+        })
     except Exception as e:
-        return {"error": str(e), "result": text, "tool": "summarizer"}
-def tool_translator(text: str, source_lang: str = "english", target_lang: str = "hindi") -> dict:
+        return json.dumps({"error": str(e), "result": text, "tool": "summarizer"})
+def tool_translator(text: str, source_lang: str = "english", target_lang: str = "hindi") -> str:
     """
     Translator for language tool pages.
     Uses NLLB translation model - same as main translate function.
     """
     if not text or not text.strip():
-        return {"error": "No text provided", "result": ""}
+        return json.dumps({"error": "No text provided", "result": ""})
     try:
         translated = translate_internal(text, source_lang, target_lang)
         
-        return {
+        return json.dumps({
             "result": translated,
             "original": text,
             "source_language": source_lang,
             "target_language": target_lang,
             "tool": "translator"
-        }
+        })
     except Exception as e:
-        return {"error": str(e), "result": text, "tool": "translator"}
-def tool_generic(text: str, language: str = "english", tool_type: str = "generic") -> dict:
+        return json.dumps({"error": str(e), "result": text, "tool": "translator"})
+def tool_generic(text: str, language: str = "english", tool_type: str = "generic") -> str:
     """
     Generic tool handler for tools that don't need heavy AI processing.
     Returns processed result based on tool type.
@@ -928,7 +928,7 @@ def tool_generic(text: str, language: str = "english", tool_type: str = "generic
     typing-tool, font-converter, unicode-converter, script-converter
     """
     if not text or not text.strip():
-        return {"error": "No text provided", "result": ""}
+        return json.dumps({"error": "No text provided", "result": ""})
     try:
         result_data = {
             "original": text,
@@ -975,15 +975,15 @@ def tool_generic(text: str, language: str = "english", tool_type: str = "generic
         return result_data
     
     except Exception as e:
-        return {"error": str(e), "result": text, "tool": tool_type}
-def tool_transliterate(text: str, source_lang: str = "english", target_lang: str = "hindi", mode: str = "roman") -> dict:
+        return json.dumps({"error": str(e), "result": text, "tool": tool_type})
+def tool_transliterate(text: str, source_lang: str = "english", target_lang: str = "hindi", mode: str = "roman") -> str:
     """
     Transliterate text between scripts.
     Modes: roman (English to target script), script (between Indian scripts)
     Uses translation model as a proxy for transliteration.
     """
     if not text or not text.strip():
-        return {"error": "No text provided", "result": ""}
+        return json.dumps({"error": "No text provided", "result": ""})
     try:
         # Use translation as proxy for transliteration
         # For roman typing: English -> target language
@@ -993,24 +993,24 @@ def tool_transliterate(text: str, source_lang: str = "english", target_lang: str
             # Script conversion: source script -> target script
             result = translate_internal(text, source_lang, target_lang)
         
-        return {
+        return json.dumps({
             "result": result,
             "original": text,
             "source_language": source_lang,
             "target_language": target_lang,
             "mode": mode,
             "tool": "transliterate"
-        }
+        })
     except Exception as e:
-        return {"error": str(e), "result": text, "tool": "transliterate"}
-def tool_dictionary(text: str, language: str = "english", mode: str = "meaning") -> dict:
+        return json.dumps({"error": str(e), "result": text, "tool": "transliterate"})
+def tool_dictionary(text: str, language: str = "english", mode: str = "meaning") -> str:
     """
     Dictionary/Thesaurus tool.
     Modes: meaning (dictionary), synonyms (thesaurus)
     Uses AI to provide definitions and synonyms.
     """
     if not text or not text.strip():
-        return {"error": "No text provided", "result": ""}
+        return json.dumps({"error": "No text provided", "result": ""})
     try:
         tokenizer, model, _ = get_text_generation_model()
         
@@ -1040,23 +1040,23 @@ def tool_dictionary(text: str, language: str = "english", mode: str = "meaning")
         if is_indian_language(language):
             result = translate_internal(result, "english", language)
         
-        return {
+        return json.dumps({
             "result": result,
             "original": text,
             "language": language,
             "mode": mode,
             "tool": "dictionary" if mode == "meaning" else "thesaurus"
-        }
+        })
     except Exception as e:
-        return {"error": str(e), "result": text, "tool": "dictionary"}
-def tool_generate(text: str, language: str = "english", mode: str = "sentence", count: int = 2) -> dict:
+        return json.dumps({"error": str(e), "result": text, "tool": "dictionary"})
+def tool_generate(text: str, language: str = "english", mode: str = "sentence", count: int = 2) -> str:
     """
     Text generation tool for various purposes.
     Modes: sentence (make sentences), content (write content), letter (write letter),
            blog (write blog), caption (generate captions), vocabulary (word lists)
     """
     if not text or not text.strip():
-        return {"error": "No text provided", "result": ""}
+        return json.dumps({"error": "No text provided", "result": ""})
     try:
         tokenizer, model, _ = get_text_generation_model()
         
@@ -1099,23 +1099,23 @@ def tool_generate(text: str, language: str = "english", mode: str = "sentence",
         else:
             result = result_english
         
-        return {
+        return json.dumps({
             "result": result,
             "original": text,
             "language": language,
             "mode": mode,
             "count": count,
             "tool": "generator"
-        }
+        })
     except Exception as e:
-        return {"error": str(e), "result": text, "tool": "generator"}
-def tool_analyze(text: str, language: str = "english", mode: str = "quality") -> dict:
+        return json.dumps({"error": str(e), "result": text, "tool": "generator"})
+def tool_analyze(text: str, language: str = "english", mode: str = "quality") -> str:
     """
     Text analysis tool for quality and readability.
     Modes: quality (writing quality score), email (email analysis), readability
     """
     if not text or not text.strip():
-        return {"error": "No text provided", "result": ""}
+        return json.dumps({"error": "No text provided", "result": ""})
     try:
         original_text = text
         is_indian = is_indian_language(language)
@@ -1174,7 +1174,7 @@ def tool_analyze(text: str, language: str = "english", mode: str = "quality") ->
         else:
             quality_level = "Needs Improvement"
         
-        return {
+        return json.dumps({
             "result": suggestion,
             "original": original_text,
             "language": language,
@@ -1188,9 +1188,9 @@ def tool_analyze(text: str, language: str = "english", mode: str = "quality") ->
                 "readability_score": round(readability_score),
                 "quality_level": quality_level
             }
-        }
+        })
     except Exception as e:
-        return {"error": str(e), "result": text, "tool": "analyzer"}
+        return json.dumps({"error": str(e), "result": text, "tool": "analyzer"})
 
 
 # ============================================