gptrans 1.6.6 → 1.6.8

package/README.md

@@ -27,6 +27,7 @@ GPTrans uses dotenv for environment configuration. Create a `.env` file in your
 ```env
 OPENAI_API_KEY=your_openai_api_key
 ANTHROPIC_API_KEY=your_anthropic_api_key
+GEMINI_API_KEY=for_image_translations
 ```
 
 ## 🚀 Quick Start
@@ -138,6 +139,33 @@ When using multiple models:
 - If the primary model fails (due to API errors, rate limits, etc.), GPTrans automatically falls back to the next model
 - This ensures higher availability and resilience of your translation service
 
+# 🖼️ Image Translation
+
+Intelligent image translation using Google's Gemini AI.
+
+## ✨ Smart Path Detection
+
+The translation system automatically detects if your image is already in a language folder and adjusts the output path accordingly:
+
+### Example
+
+```javascript
+// Input: en/image.jpg
+// Output: es/image.jpg (sibling folder at same level)
+
+const result = await gptrans.img('en/image.jpg');
+```
+
+**Directory Structure:**
+```
+project/
+├── en/
+│   └── image.jpg          ← Original
+└── es/
+    └── image.jpg          ← Translation (sibling folder)
+```
+
+
 ## Contributing
 
 Contributions are welcome! Please open an issue or submit a pull request on GitHub to contribute improvements or fixes.

package/demo/example-image-translation.js

@@ -0,0 +1,84 @@
+// Example usage based on user's requirements
+import GPTrans from '../index.js';
+import path from 'path';
+import fs from 'fs';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+async function main() {
+    try {
+        // Initialize GPTrans with Spanish as target
+        const gptrans = new GPTrans({
+            from: 'en-US',
+            target: 'es'
+        });
+
+        console.log('🌍 Testing Image Translation with Smart Path Detection\n');
+        console.log('═══════════════════════════════════════════════════\n');
+
+        // Example 1: Image in language folder (en/image.jpg -> es/image.jpg)
+        console.log('📁 Example 1: Image already in language folder');
+        console.log('   Input: en/image.jpg');
+        console.log('   Expected output: es/image.jpg (sibling folder)\n');
+
+        const imageInLangFolder = path.join(__dirname, 'camera_4126.jpg');
+        if (fs.existsSync(imageInLangFolder)) {
+            const result1 = await gptrans.img(imageInLangFolder);
+            console.log('   Result:', result1);
+            console.log('');
+        } else {
+            console.log('   ⚠️  Image not found at:', imageInLangFolder);
+            console.log('   (Create en/camera_4126.jpg to test this case)\n');
+        }
+
+        // // Example 2: Image in root folder (./image.jpg -> es/image.jpg)
+        // console.log('📁 Example 2: Image in root/current folder');
+        // console.log('   Input: ./image.jpg');
+        // console.log('   Expected output: ./es/image.jpg (subfolder)\n');
+
+        // const imageInRoot = path.join(__dirname, 'camera_4126.jpg');
+        // if (fs.existsSync(imageInRoot)) {
+        //     const result2 = await gptrans.img(imageInRoot);
+        //     console.log('   Result:', result2);
+        //     console.log('');
+        // } else {
+        //     console.log('   ⚠️  Image not found at:', imageInRoot);
+        //     console.log('   (Create camera_4126.jpg to test this case)\n');
+        // }
+
+        // // Example 3: Image in non-language folder (images/photo.jpg -> images/es/photo.jpg)
+        // console.log('📁 Example 3: Image in custom folder');
+        // console.log('   Input: images/photo.jpg');
+        // console.log('   Expected output: images/es/photo.jpg (subfolder)\n');
+
+        // const imageInCustomFolder = path.join(__dirname, 'images', 'photo.jpg');
+        // if (fs.existsSync(imageInCustomFolder)) {
+        //     const result3 = await gptrans.img(imageInCustomFolder);
+        //     console.log('   Result:', result3);
+        //     console.log('');
+        // } else {
+        //     console.log('   ⚠️  Image not found at:', imageInCustomFolder);
+        //     console.log('   (Create images/photo.jpg to test this case)\n');
+        // }
+
+        // console.log('═══════════════════════════════════════════════════');
+        // console.log('🎉 Example completed successfully!\n');
+
+    } catch (error) {
+        console.error('❌ Error:', error.message);
+
+        if (error.message.includes('API Key')) {
+            console.error('\n💡 Tip: Make sure you have GEMINI_API_KEY in your .env file');
+            console.error('Get your API key from: https://aistudio.google.com/apikey');
+        }
+
+        if (error.message.includes('reference image')) {
+            console.error('\n💡 Tip: Verify that the image path is correct');
+        }
+    }
+}
+
+main();
+

package/index.js

@@ -3,6 +3,9 @@ import stringHash from 'string-hash';
 import { ModelMix } from 'modelmix';
 import { isoAssoc, isLanguageAvailable } from './isoAssoc.js';
 import dotenv from 'dotenv';
+import { GeminiGenerator } from 'genmix';
+import fs from 'fs';
+import path from 'path';
 
 class GPTrans {
     static #mmixInstances = new Map();
@@ -255,6 +258,97 @@ class GPTrans {
         this.freeze = freeze;
         return this;
     }
+
+    async img(imagePath, options = {}) {
+        const {
+            quality = '1K',
+            numberOfImages = 1,
+            prompt = null
+        } = options;
+
+        // Parse image filename and extension
+        const parsedPath = path.parse(imagePath);
+        const filename = parsedPath.base;
+        const targetLang = this.replaceTarget.TARGET_ISO || 'en';
+        
+        // Check if image is already in a language folder
+        const dirName = path.basename(path.dirname(imagePath));
+        const parentDir = path.dirname(path.dirname(imagePath));
+        
+        // If the image is in a language folder (e.g., en/image.jpg)
+        // create the target at the same level (e.g., es/image.jpg)
+        // Otherwise, create it as a subfolder (e.g., ./image.jpg -> es/image.jpg)
+        let targetDir, targetPath;
+        
+        if (this._isLanguageFolder(dirName)) {
+            // Image is in a language folder: create sibling folder
+            targetDir = path.join(parentDir, targetLang);
+            targetPath = path.join(targetDir, filename);
+        } else {
+            // Image is not in a language folder: create subfolder
+            targetDir = path.join(path.dirname(imagePath), targetLang);
+            targetPath = path.join(targetDir, filename);
+        }
+
+        // Check if translated image already exists
+        if (fs.existsSync(targetPath)) {
+            return targetPath;
+        }
+
+        // Generate translated image and wait for completion
+        await this._generateTranslatedImage(imagePath, targetPath, targetDir, prompt, quality, numberOfImages);
+
+        // Return path of translated image
+        return targetPath;
+    }
+
+    _isLanguageFolder(folderName) {
+        // Check if folder name is a valid language code
+        // Common formats: en, es, pt, en-US, pt-BR, es-AR, etc.
+        const languageCodePattern = /^[a-z]{2}(-[A-Z]{2})?$/;
+        return languageCodePattern.test(folderName);
+    }
+
+    async _generateTranslatedImage(imagePath, targetPath, targetDir, customPrompt, quality, numberOfImages) {
+        try {
+            // Initialize GeminiGenerator
+            const generator = new GeminiGenerator();
+
+            // Generate translation prompt
+            const translationPrompt = customPrompt || 
+                `Translate all text in this image to ${this.replaceTarget.TARGET_DENONYM} ${this.replaceTarget.TARGET_LANG}. Maintain the exact same layout, style, colors, and design. Only change the text content.`;
+
+            // Generate translated image
+            const result = await generator.generate(translationPrompt, {
+                referenceImage: imagePath,
+                quality: quality,
+                numberOfImages: numberOfImages
+            });
+
+            if (result.images && result.images.length > 0) {
+                // Create target directory if it doesn't exist
+                if (!fs.existsSync(targetDir)) {
+                    fs.mkdirSync(targetDir, { recursive: true });
+                }
+
+                // Save translated image
+                const originalName = path.basename(targetPath, path.extname(targetPath));
+                await generator.save({
+                    directory: targetDir,
+                    filename: originalName
+                });
+
+                console.log(`✅ Translated image saved: ${targetPath}`);
+            } else {
+                console.error('No translated image was generated');
+            }
+        } catch (error) {
+            if (error.message.includes('API Key')) {
+                console.error('❌ GEMINI_API_KEY not found in .env file');
+            }
+            throw error;
+        }
+    }
 }
 
 export default GPTrans;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "gptrans",
   "type": "module",
-  "version": "1.6.6",
+  "version": "1.6.8",
   "description": "🚆 GPTrans - The smarter AI-powered way to translate.",
   "keywords": [
     "translate",
@@ -36,6 +36,7 @@
     "deepbase": "^1.4.8",
     "dotenv": "^16.4.7",
     "form-data": "^4.0.4",
+    "genmix": "^1.0.0",
     "modelmix": "^3.9.0",
     "string-hash": "^1.1.3"
   }

package/test-image-translation.js

@@ -0,0 +1,70 @@
+import GPTrans from './index.js';
+import path from 'path';
+import fs from 'fs';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+async function testImageTranslation() {
+    try {
+        console.log('🚀 Starting Image Translation Test\n');
+
+        // Initialize GPTrans with Portuguese as target language
+        const gptrans = new GPTrans({
+            from: 'en-US',
+            target: 'pt-BR',
+            model: 'sonnet45'
+        });
+
+        // Test image path (you'll need to provide an actual image)
+        const testImagePath = path.join(__dirname, 'test-image.jpg');
+
+        // Check if test image exists
+        if (!fs.existsSync(testImagePath)) {
+            console.log('⚠️  Test image not found. Please create a test image at:', testImagePath);
+            console.log('You can use any image with text in it for testing.\n');
+            return;
+        }
+
+        console.log('📸 Test image found:', testImagePath);
+        console.log('🎯 Target language: Portuguese (pt-BR)\n');
+
+        // First call - should return original image and start generation
+        console.log('🔄 First call (should return original and start generation)...');
+        const result1 = await gptrans.translateImage(testImagePath);
+        console.log('Result 1:', result1);
+        console.log('');
+
+        // Wait a moment
+        console.log('⏳ Waiting 5 seconds before second call...\n');
+        await new Promise(resolve => setTimeout(resolve, 5000));
+
+        // Second call - check status
+        console.log('🔄 Second call (checking if translation is ready)...');
+        const result2 = await gptrans.translateImage(testImagePath);
+        console.log('Result 2:', result2);
+        console.log('');
+
+        if (result2.isTranslated) {
+            console.log('✅ Translation completed! Translated image at:', result2.path);
+        } else {
+            console.log('⏳ Translation still generating... Check again later.');
+            console.log('Expected path:', path.join(path.dirname(testImagePath), 'pt-BR', path.basename(testImagePath)));
+        }
+
+        console.log('\n🎉 Test completed!\n');
+
+    } catch (error) {
+        console.error('❌ Error:', error.message);
+
+        if (error.message.includes('API Key') || error.message.includes('GEMINI_API_KEY')) {
+            console.error('\n💡 Tip: Make sure you have GEMINI_API_KEY in your .env file');
+            console.error('You can get a free API key from: https://aistudio.google.com/apikey');
+        }
+    }
+}
+
+// Run the test
+testImageTranslation();
+