android-localisation 1.0.2__tar.gz → 1.0.4__tar.gz

{android_localisation-1.0.2/android_localisation.egg-info → android_localisation-1.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: android-localisation
-Version: 1.0.2
+Version: 1.0.4
 Summary: Zero-dependency Android strings.xml translation and verification using LLMs (Gemini, OpenAI, Anthropic, Ollama).
 License: MIT
 Project-URL: Homepage, https://github.com/BharathKmalviya/android-llm-localization

{android_localisation-1.0.2 → android_localisation-1.0.4}/android_localisation/__init__.py

@@ -2,4 +2,4 @@
 android-localisation: Zero-dependency Android strings.xml translation using LLMs.
 """
 
-__version__ = "1.0.2"
+__version__ = "1.0.4"

{android_localisation-1.0.2 → android_localisation-1.0.4}/android_localisation/fix.py

@@ -65,7 +65,11 @@ def main(args=None):
             content = f.read()
 
         def fix_match(m):
-            return m.group(1) + _fix_text(m.group(2)) + m.group(3)
+            opening_tag = m.group(1)
+            # Skip strings marked formatted="false" — their % signs are literal, not specifiers
+            if 'formatted="false"' in opening_tag.lower() or "formatted='false'" in opening_tag.lower():
+                return m.group(0)
+            return opening_tag + _fix_text(m.group(2)) + m.group(3)
 
         new_content = re.sub(
             r'(<string[^>]*name="[^"]*"[^>]*>)(.*?)(</string>)',

android_localisation-1.0.4/android_localisation/java/VerifyStrings.java

@@ -0,0 +1,219 @@
+import java.io.*;
+import java.util.*;
+import java.util.regex.*;
+
+/**
+ * Utility to verify that all translated Android strings containing format specifiers
+ * (like %1$d or %s) are syntactically valid and won't throw an UnknownFormatConversionException
+ * or MissingFormatArgumentException at runtime.
+ */
+public class VerifyStrings {
+
+    public static void main(String[] args) throws Exception {
+        String resDirPath = "app/src/main/res";
+        if (args.length > 0) {
+            resDirPath = args[0];
+        }
+
+        File resDir = new File(resDirPath);
+        if (!resDir.exists()) {
+            File fallback = new File("../" + resDirPath);
+            if (fallback.exists()) resDir = fallback;
+        }
+
+        if (!resDir.exists()) {
+            System.err.println("Fatal: Could not find resource directory at: " + resDirPath);
+            System.exit(1);
+        }
+
+        File englishDir = new File(resDir, "values");
+        File[] valuesDirs = resDir.listFiles((dir, name) -> name.startsWith("values-"));
+
+        if (valuesDirs == null || valuesDirs.length == 0) {
+            System.out.println("No values-* localized directories found.");
+            return;
+        }
+
+        System.out.println("Started Android String Format Verification...");
+        System.out.println("Scanning source strings in: " + englishDir.getPath());
+
+        // Parse English strings
+        Map<String, String> englishStrings = parseStringsFile(new File(englishDir, "strings.xml"));
+        Set<String> nonFormattedKeys = getNonFormattedKeys(new File(englishDir, "strings.xml"));
+
+        // Build expected arg type list per key from English strings
+        // e.g. "User %1$s has %2$d items at $%3$.2f" -> ['s', 'd', 'f']
+        Map<String, List<Character>> expectedArgTypes = new HashMap<>();
+        Pattern formatPattern = Pattern.compile("%(\\d+\\$)?([-#+ 0,(<]*)?(\\d+)?(\\.\\d+)?([tT]?[a-zA-Z])");
+
+        for (Map.Entry<String, String> entry : englishStrings.entrySet()) {
+            if (nonFormattedKeys.contains(entry.getKey())) continue;
+
+            Map<Integer, Character> indexedTypes = new TreeMap<>();
+            int autoIndex = 1;
+            // Strip %% (escaped percent) before scanning — otherwise the second % followed by a
+            // space-flag and a letter (e.g. "%% completed") gets misread as a format specifier.
+            String valueToScan = entry.getValue().replace("%%", "");
+            Matcher m = formatPattern.matcher(valueToScan);
+
+            while (m.find()) {
+                String convStr = m.group(5);
+                if (convStr == null || convStr.equals("%") || convStr.equals("n")) continue;
+                char conv = convStr.charAt(convStr.length() - 1);
+                String indexGroup = m.group(1);
+                if (indexGroup != null) {
+                    int idx = Integer.parseInt(indexGroup.replace("$", ""));
+                    indexedTypes.put(idx, conv);
+                } else {
+                    indexedTypes.put(autoIndex++, conv);
+                }
+            }
+
+            if (!indexedTypes.isEmpty()) {
+                List<Character> orderedTypes = new ArrayList<>();
+                int maxIdx = Collections.max(indexedTypes.keySet());
+                for (int i = 1; i <= maxIdx; i++) {
+                    orderedTypes.add(indexedTypes.getOrDefault(i, 's'));
+                }
+                expectedArgTypes.put(entry.getKey(), orderedTypes);
+            }
+        }
+
+        int totalErrors = 0;
+        int totalStringsVerified = 0;
+
+        for (File dir : valuesDirs) {
+            File stringsFile = new File(dir, "strings.xml");
+            if (!stringsFile.exists()) continue;
+
+            Map<String, String> localizedStrings = parseStringsFile(stringsFile);
+            Set<String> localNonFormatted = getNonFormattedKeys(stringsFile);
+
+            for (Map.Entry<String, String> entry : localizedStrings.entrySet()) {
+                String name = entry.getKey();
+                String text = entry.getValue();
+                totalStringsVerified++;
+
+                // Skip strings explicitly marked as non-formatted in either English or translation
+                if (nonFormattedKeys.contains(name) || localNonFormatted.contains(name)) continue;
+
+                List<Character> argTypes = expectedArgTypes.get(name);
+                if (argTypes == null || argTypes.isEmpty()) {
+                    // No format args expected — a bare unescaped % is an error
+                    String stripped = text.replace("%%", "");
+                    if (stripped.contains("%")) {
+                        System.err.println("ERROR: [" + dir.getName() + "] String '" + name
+                                + "' contains unescaped % but English has no format args.");
+                        System.err.println("  Text: " + text);
+                        totalErrors++;
+                    }
+                    continue;
+                }
+
+                // Build correctly-typed args array based on what English string expects
+                Object[] formatArgs = buildArgs(argTypes);
+
+                try {
+                    String.format(text, formatArgs);
+                } catch (UnknownFormatConversionException e) {
+                    System.err.println("CRASH: [" + dir.getName() + "] String '" + name
+                            + "' has an invalid conversion specifier: " + e.getConversion());
+                    System.err.println("  Text: " + text);
+                    totalErrors++;
+                } catch (MissingFormatArgumentException e) {
+                    System.err.println("CRASH: [" + dir.getName() + "] String '" + name
+                            + "' is missing format arguments or index is wrong: " + e.getFormatSpecifier());
+                    System.err.println("  Text: " + text);
+                    totalErrors++;
+                } catch (IllegalFormatConversionException e) {
+                    System.err.println("CRASH: [" + dir.getName() + "] String '" + name
+                            + "' uses wrong type for a format specifier: " + e.getMessage());
+                    System.err.println("  Text: " + text);
+                    System.err.println("  English: " + englishStrings.get(name));
+                    totalErrors++;
+                } catch (Exception e) {
+                    System.err.println("CRASH: [" + dir.getName() + "] String '" + name
+                            + "' failed String.format() -> " + e.getClass().getSimpleName() + ": " + e.getMessage());
+                    System.err.println("  Text: " + text);
+                    totalErrors++;
+                }
+            }
+        }
+
+        System.out.println("Verification Complete!");
+        System.out.println("Total Strings Verified: " + totalStringsVerified);
+
+        if (totalErrors > 0) {
+            System.out.println("Total Errors Found: " + totalErrors);
+            System.err.println("Verification Failed!");
+            System.exit(1);
+        } else {
+            System.out.println("Status: ALL STRINGS PASSED!");
+            System.exit(0);
+        }
+    }
+
+    /**
+     * Builds an Object[] matching the arg types detected from the English string.
+     * 's' -> String, 'd'/'i'/'o'/'x' -> Integer, 'f'/'e'/'g'/'a' -> Double, 'b' -> Boolean, 'c' -> Character
+     */
+    private static Object[] buildArgs(List<Character> argTypes) {
+        Object[] args = new Object[argTypes.size()];
+        for (int i = 0; i < argTypes.size(); i++) {
+            char type = Character.toLowerCase(argTypes.get(i));
+            switch (type) {
+                case 'd': case 'i': case 'o': case 'x': args[i] = 42;      break;
+                case 'f': case 'e': case 'g': case 'a': args[i] = 3.14;    break;
+                case 'b':                               args[i] = true;     break;
+                case 'c':                               args[i] = 'A';      break;
+                default:                                args[i] = "test";   break;
+            }
+        }
+        return args;
+    }
+
+    /**
+     * Returns keys that have formatted="false" — their % signs are literal, not format specifiers.
+     */
+    private static Set<String> getNonFormattedKeys(File file) throws Exception {
+        Set<String> keys = new HashSet<>();
+        if (!file.exists()) return keys;
+        String content = readFile(file);
+        // Match both attribute orderings
+        Pattern p1 = Pattern.compile("<string[^>]+name=\"([^\"]+)\"[^>]+formatted\\s*=\\s*\"false\"",
+                Pattern.CASE_INSENSITIVE);
+        Pattern p2 = Pattern.compile("<string[^>]+formatted\\s*=\\s*\"false\"[^>]+name=\"([^\"]+)\"",
+                Pattern.CASE_INSENSITIVE);
+        for (Pattern p : new Pattern[]{p1, p2}) {
+            Matcher m = p.matcher(content);
+            while (m.find()) keys.add(m.group(1));
+        }
+        return keys;
+    }
+
+    private static Map<String, String> parseStringsFile(File file) throws Exception {
+        Map<String, String> strings = new LinkedHashMap<>();
+        if (!file.exists()) return strings;
+        String content = readFile(file);
+        Pattern stringPattern = Pattern.compile(
+                "<string\\s+[^>]*name=\"([^\"]+)\"[^>]*>(.*?)</string>", Pattern.DOTALL);
+        Matcher m = stringPattern.matcher(content);
+        while (m.find()) {
+            String name = m.group(1);
+            String text = m.group(2);
+            text = text.replace("&lt;", "<").replace("&gt;", ">").replace("&amp;", "&");
+            text = text.replace("\\'", "'").replace("\\\"", "\"");
+            strings.put(name, text);
+        }
+        return strings;
+    }
+
+    private static String readFile(File file) throws Exception {
+        BufferedReader reader = new BufferedReader(new FileReader(file));
+        StringBuilder sb = new StringBuilder();
+        String line;
+        while ((line = reader.readLine()) != null) sb.append(line).append("\n");
+        reader.close();
+        return sb.toString();
+    }
+}

{android_localisation-1.0.2 → android_localisation-1.0.4}/android_localisation/translate.py

@@ -1,4 +1,5 @@
 import os
+import re
 import time
 import argparse
 import urllib.request
@@ -70,19 +71,24 @@ def read_source_xml(source_path):
 
 def build_prompt(source_xml, target_folder_name, app_context):
     context_str = f"an Android app ({app_context})" if app_context else "an Android application"
-    return f"""You are a professional mobile app localization expert.
+    return f"""You are a professional Android localization expert.
 
-I am sending you the complete English `strings.xml` for {context_str}.
-Your job is to translate it into the language corresponding to the Android resource directory: `{target_folder_name}`.
-For example, `values-hi` is Hindi, `values-es-rES` is Spanish (Spain), `values-zh-rTW` is Traditional Chinese, etc.
+Translate the English `strings.xml` below for {context_str} into the language for Android resource directory: `{target_folder_name}`.
+For example, `values-hi` is Hindi, `values-es-rES` is Spanish (Spain), `values-zh-rTW` is Traditional Chinese, `values-ar` is Arabic, etc.
 
 STRICT GUIDELINES:
-1. Preserve the exact meaning and intent of the English text.
-2. The language must be clear, natural, human-sounding, and understandable by all users (from rural to tier-1 cities).
-3. Do not sound like a machine translation. Use simple, everyday mobile UI language.
-4. NEVER modify string keys, XML structure, placeholders (like %s, %1$d), escape characters, \\n line breaks, or HTML tags.
-5. Keep it short and UI friendly.
-6. Return ONLY the raw updated XML content. Do not add markdown formatting like ```xml or any conversational text.
+1. Translate only the string values — never the keys, XML tags, or attributes.
+2. Use natural, human-sounding language. Simple everyday mobile UI tone. Not robotic or word-for-word.
+3. Preserve ALL placeholders exactly as-is: %s, %d, %1$s, %1$d, %2$s, etc.
+4. Preserve ALL escape sequences exactly as-is: \\n, \\', \\", \\\\.
+5. Preserve ALL HTML tags exactly as-is: <b>, <i>, <u>, <br/>, etc.
+6. Apostrophes in translated text MUST be escaped as \\' — never use a raw ' or a curly apostrophe.
+7. The output MUST use standard Android strings.xml format:
+   - Start with: <?xml version="1.0" encoding="utf-8"?>
+   - Use plain <resources> with NO namespace attributes (no xmlns:xliff or any other xmlns)
+   - Every string on its own line: <string name="key">translated value</string>
+   - No CDATA, no extra attributes on <string> tags except name and translatable
+8. Return ONLY the raw XML. No markdown, no code fences, no explanation.
 
 SOURCE XML:
 {source_xml}
@@ -93,13 +99,20 @@ def clean_xml_response(result):
     if not result:
         return ""
     result = result.strip()
+
+    # Strip markdown code fences
     if result.startswith("```xml"):
         result = result[6:]
     if result.startswith("```"):
         result = result[3:]
     if result.endswith("```"):
         result = result[:-3]
-    return result.strip()
+    result = result.strip()
+
+    # Strip any xmlns namespace attributes from <resources> tag — not valid in standard Android strings.xml
+    result = re.sub(r'(<resources)\s+[^>]*?(>)', r'\1\2', result)
+
+    return result
 
 
 def _read_error_body(e):
@@ -323,7 +336,7 @@ def main(args=None):
             folder, args.app_context, args.base_url, fallback_models
         )
 
-        if translated_xml and "<resources>" in translated_xml and "</resources>" in translated_xml:
+        if translated_xml and "<resources" in translated_xml and "</resources>" in translated_xml:
             os.makedirs(os.path.dirname(target_path), exist_ok=True)
             with open(target_path, "w", encoding="utf-8") as f:
                 f.write(translated_xml)
@@ -331,7 +344,14 @@ def main(args=None):
             action = "Created" if is_new_file else "Updated"
             print(f"✅ {action} {folder}/strings.xml{suffix}")
         else:
-            print(f"⚠️  Failed or got invalid XML for {folder}. Skipping.")
+            if translated_xml is None:
+                print(f"⚠️  [{folder}] API call failed — see error above. Skipping.")
+            elif "<resources" not in translated_xml:
+                preview = translated_xml[:200].replace("\n", " ") if translated_xml else "(empty response)"
+                print(f"⚠️  [{folder}] Response missing <resources> tag. Skipping.")
+                print(f"    Response preview: {preview}")
+            else:
+                print(f"⚠️  [{folder}] Response missing </resources> closing tag. Skipping.")
 
         if args.sleep > 0:
             time.sleep(args.sleep)

{android_localisation-1.0.2 → android_localisation-1.0.4/android_localisation.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: android-localisation
-Version: 1.0.2
+Version: 1.0.4
 Summary: Zero-dependency Android strings.xml translation and verification using LLMs (Gemini, OpenAI, Anthropic, Ollama).
 License: MIT
 Project-URL: Homepage, https://github.com/BharathKmalviya/android-llm-localization

{android_localisation-1.0.2 → android_localisation-1.0.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "android-localisation"
-version = "1.0.2"
+version = "1.0.4"
 description = "Zero-dependency Android strings.xml translation and verification using LLMs (Gemini, OpenAI, Anthropic, Ollama)."
 readme = "README.md"
 license = { text = "MIT" }

android_localisation-1.0.2/android_localisation/java/VerifyStrings.java

@@ -1,148 +0,0 @@
-import java.io.*;
-import java.util.*;
-import java.util.regex.*;
-
-/**
- * Utility to verify that all translated Android strings containing format specifiers 
- * (like %1$d or %s) are syntactically valid and won't throw an UnknownFormatConversionException 
- * or MissingFormatArgumentException at runtime.
- */
-public class VerifyStrings {
-    
-    public static void main(String[] args) throws Exception {
-        String resDirPath = "app/src/main/res";
-        if (args.length > 0) {
-            resDirPath = args[0];
-        }
-
-        File resDir = new File(resDirPath);
-        if (!resDir.exists()) {
-            // Try relative to scripts if the absolute/relative failed
-            File fallback = new File("../" + resDirPath);
-            if (fallback.exists()) {
-                resDir = fallback;
-            }
-        }
-        
-        if (!resDir.exists()) {
-            System.err.println("Fatal: Could not find resource directory at: " + resDirPath);
-            System.exit(1);
-        }
-
-        File englishDir = new File(resDir, "values");
-        File[] valuesDirs = resDir.listFiles((dir, name) -> name.startsWith("values-"));
-        
-        if (valuesDirs == null || valuesDirs.length == 0) {
-            System.err.println("No values- localized directories found!");
-            return;
-        }
-
-        System.out.println("Started Android String Format Verification...");
-        System.out.println("Scanning source strings in: " + englishDir.getPath());
-
-        // 1. First parse the English strings to know the expected format arguments
-        Map<String, String> englishStrings = parseStringsFile(new File(englishDir, "strings.xml"));
-        Map<String, List<String>> expectedFormats = new HashMap<>();
-        
-        // Regex for Android / Java format specifiers
-        Pattern formatPattern = Pattern.compile("%(\\d+\\$)?([-#+ 0,(<]*)?(\\d+)?(\\.\\d+)?([tT]?[a-zA-Z%])");
-        for (Map.Entry<String, String> entry : englishStrings.entrySet()) {
-            List<String> formats = new ArrayList<>();
-            Matcher m = formatPattern.matcher(entry.getValue());
-            while (m.find()) {
-                formats.add(m.group());
-            }
-            expectedFormats.put(entry.getKey(), formats);
-        }
-
-        int totalErrors = 0;
-        int totalStringsVerified = 0;
-
-        // 2. Now verify every language against Android String formatting rules
-        for (File dir : valuesDirs) {
-            File stringsFile = new File(dir, "strings.xml");
-            if (!stringsFile.exists()) continue;
-
-            Map<String, String> localizedStrings = parseStringsFile(stringsFile);
-            
-            for (Map.Entry<String, String> entry : localizedStrings.entrySet()) {
-                String name = entry.getKey();
-                String text = entry.getValue();
-                totalStringsVerified++;
-
-                List<String> englishFormats = expectedFormats.get(name);
-                if (englishFormats == null || englishFormats.isEmpty()) {
-                    // This string shouldn't have any format arguments.
-                    // If it has a %, it must be %%
-                    if (text.contains("%") && !text.matches("^(?:[^%]|%%)*$")) {
-                        System.err.println("ERROR: [" + dir.getName() + "] String '" + name + "' contains unescaped % but English doesn't use formatting.");
-                        System.err.println("  Text: " + text);
-                        totalErrors++;
-                    }
-                    continue;
-                }
-
-                // Try to format it via java natively
-                try {
-                    // Provide generic arguments to satisfy any index like %1$s, %1$d.
-                    // Our app primarily uses integers and strings up to 3 parameters.
-                    String.format(text, 100, "test_string", 50);
-                } catch (UnknownFormatConversionException e) {
-                    System.err.println("CRASH: [" + dir.getName() + "] String '" + name + "' has an invalid conversion specifier: " + e.getConversion());
-                    System.err.println("  Text: " + text);
-                    totalErrors++;
-                } catch (MissingFormatArgumentException e) {
-                    System.err.println("CRASH: [" + dir.getName() + "] String '" + name + "' is missing format arguments or index is wrong: " + e.getFormatSpecifier());
-                    System.err.println("  Text: " + text);
-                    totalErrors++;
-                } catch (IllegalFormatConversionException e) {
-                    System.err.println("CRASH: [" + dir.getName() + "] String '" + name + "' uses wrong variable type logic (e.g. used %d instead of %s): " + e.getMessage());
-                    System.err.println("  Text: " + text);
-                    System.err.println("  English expected: " + englishStrings.get(name));
-                    totalErrors++;
-                } catch (Exception e) {
-                    System.err.println("CRASH: [" + dir.getName() + "] String '" + name + "' failed native String.format() -> " + e.getClass().getSimpleName() + ": " + e.getMessage());
-                    System.err.println("  Text: " + text);
-                    totalErrors++;
-                }
-            }
-        }
-
-        System.out.println("Verification Complete!");
-        System.out.println("Total Strings Verified: " + totalStringsVerified);
-        
-        if (totalErrors > 0) {
-            System.out.println("Total Errors Found: " + totalErrors);
-            System.err.println("Verification Failed!");
-            System.exit(1);
-        } else {
-            System.out.println("Status: ALL STRINGS PASSED!");
-            System.exit(0);
-        }
-    }
-
-    private static Map<String, String> parseStringsFile(File file) throws Exception {
-        Map<String, String> strings = new HashMap<>();
-        BufferedReader reader = new BufferedReader(new FileReader(file));
-        StringBuilder sb = new StringBuilder();
-        String line;
-        while ((line = reader.readLine()) != null) {
-            sb.append(line).append("\n");
-        }
-        reader.close();
-
-        // This regex ensures we only grab actual text contents inside `<string>`
-        Pattern stringPattern = Pattern.compile("<string name=\"([^\"]+)\"[^>]*>(.*?)</string>", Pattern.DOTALL);
-        Matcher m = stringPattern.matcher(sb.toString());
-        while (m.find()) {
-            String name = m.group(1);
-            String text = m.group(2);
-            // Decode standard XML entity things that AAPT2 does automatically
-            text = text.replace("&lt;", "<").replace("&gt;", ">").replace("&amp;", "&");
-            // Unescape apostrophes and quotes as Java expects clean strings
-            text = text.replace("\\'", "'").replace("\\\"", "\"");
-            strings.put(name, text);
-        }
-        return strings;
-    }
-}