ether-code 0.1.0

package/generators/python-generator.js

@@ -0,0 +1,913 @@
+const fs = require('fs')
+
+class PythonGenerator {
+  constructor(i18nPath = null) {
+    this.i18n = null
+    this.indent = 0
+    this.output = ''
+    this.keywordMap = {}
+    this.builtinMap = {}
+    
+    if (i18nPath) {
+      this.loadI18n(i18nPath)
+    }
+  }
+
+  loadI18n(filePath) {
+    const content = fs.readFileSync(filePath, 'utf-8')
+    this.i18n = JSON.parse(content)
+    this.buildMaps()
+  }
+
+  buildMaps() {
+    this.keywordMap = {}
+    this.builtinMap = {}
+    
+    if (!this.i18n) return
+
+    const addToMap = (map, section) => {
+      if (!section) return
+      for (const [key, translations] of Object.entries(section)) {
+        if (translations && translations.fr && translations.python) {
+          map[translations.fr.toLowerCase()] = translations.python
+        }
+      }
+    }
+
+    for (const sectionName of Object.keys(this.i18n)) {
+      addToMap(this.keywordMap, this.i18n[sectionName])
+    }
+  }
+
+  translate(word) {
+    if (!word) return ''
+    const lower = word.toLowerCase()
+    return this.keywordMap[lower] || this.translateGeneric(word)
+  }
+
+  translateGeneric(word) {
+    const translations = {
+      'si': 'if',
+      'sinon': 'else',
+      'sinon si': 'elif',
+      'pour': 'for',
+      'dans': 'in',
+      'tant que': 'while',
+      'définir': 'def',
+      'fonction': 'def',
+      'classe': 'class',
+      'retourner': 'return',
+      'produire': 'yield',
+      'passer': 'pass',
+      'sortir': 'break',
+      'continuer': 'continue',
+      'essayer': 'try',
+      'sauf': 'except',
+      'finalement': 'finally',
+      'lever': 'raise',
+      'affirmer': 'assert',
+      'avec': 'with',
+      'comme': 'as',
+      'importer': 'import',
+      'depuis': 'from',
+      'global': 'global',
+      'non local': 'nonlocal',
+      'lambda': 'lambda',
+      'et': 'and',
+      'ou': 'or',
+      'non': 'not',
+      'est': 'is',
+      'vrai': 'True',
+      'faux': 'False',
+      'aucun': 'None',
+      'soi': 'self',
+      'cls': 'cls',
+      'asynchrone': 'asynchrone',
+      'attendre': 'await',
+      'afficher': 'print',
+      'saisir': 'input',
+      'longueur': 'len',
+      'type': 'type',
+      'plage': 'range',
+      'enumerer': 'enumerate',
+      'zipper': 'zip',
+      'mapper': 'map',
+      'filtrer': 'filter',
+      'trier': 'sorted',
+      'inverser': 'reversed',
+      'tout': 'all',
+      'quelconque': 'any',
+      'minimum': 'min',
+      'maximum': 'max',
+      'somme': 'sum',
+      'absolu': 'abs',
+      'arrondir': 'round',
+      'entier': 'int',
+      'flottant': 'float',
+      'chaîne': 'str',
+      'booléen': 'bool',
+      'liste': 'list',
+      'tuple': 'tuple',
+      'ensemble': 'set',
+      'dictionnaire': 'dict',
+      'octets': 'bytes',
+      'ouvrir': 'open',
+      'fermer': 'close',
+      'lire': 'read',
+      'écrire': 'write',
+      'ligne': 'readline',
+      'lignes': 'readlines',
+      'ajouter': 'append',
+      'etendre': 'extend',
+      'insérer': 'insert',
+      'retirer': 'remove',
+      'extraire': 'pop',
+      'vider': 'clear',
+      'copier': 'copy',
+      'compter': 'count',
+      'indice': 'index',
+      'trier liste': 'sort',
+      'inverser liste': 'reverse',
+      'majuscules': 'upper',
+      'minuscules': 'lower',
+      'titre': 'title',
+      'capitaliser': 'capitalize',
+      'supprimer espaces': 'strip',
+      'supprimer gauche': 'lstrip',
+      'supprimer droite': 'rstrip',
+      'diviser': 'split',
+      'joindre': 'join',
+      'remplacer': 'replace',
+      'trouver': 'find',
+      'commence par': 'startswith',
+      'finit par': 'endswith',
+      'est numerique': 'isdigit',
+      'est alpha': 'isalpha',
+      'est alphanumerique': 'isalnum',
+      'est espace': 'isspace',
+      'formater': 'format',
+      'clés': 'keys',
+      'valeurs': 'values',
+      'éléments': 'items',
+      'obtenir': 'get',
+      'définir défaut': 'setdefault',
+      'mettre a jour': 'update',
+      'union': 'union',
+      'intersection': 'intersection',
+      'difference': 'difference',
+      'sous ensemble': 'issubset',
+      'sur ensemble': 'issuperset',
+      'exception': 'Exception',
+      'erreur valeur': 'ValueError',
+      'erreur type': 'TypeError',
+      'erreur clé': 'KeyError',
+      'erreur index': 'IndexError',
+      'erreur attribut': 'AttributeError',
+      'erreur fichier': 'FileNotFoundError',
+      'erreur zero': 'ZeroDivisionError',
+      'decorateur': '@',
+      'propriété': 'property',
+      'méthode statique': 'staticmethod',
+      'méthode classe': 'classmethod',
+      'super': 'super',
+      'init': '__init__',
+      'constructeur': '__init__',
+      'representer': '__repr__',
+      'chaîne dunder': '__str__',
+      'iterateur': '__iter__',
+      'suivant': '__next__',
+      'longueur dunder': '__len__',
+      'obtenir item': '__getitem__',
+      'définir item': '__setitem__',
+      'supprimer item': '__delitem__',
+      'contient': '__contains__',
+      'appeler': '__call__',
+      'entrer': '__enter__',
+      'sortir dunder': '__exit__'
+    }
+
+    const lower = word.toLowerCase()
+    return translations[lower] || word
+  }
+
+  generate(ast) {
+    this.output = ''
+    this.indent = 0
+
+    if (Array.isArray(ast)) {
+      for (const node of ast) {
+        const result = this.generateNode(node)
+        if (result !== undefined && result !== '' && this.output === '') {
+          return result
+        }
+      }
+    } else if (ast && ast.type) {
+      const result = this.generateNode(ast)
+      if (result !== undefined && result !== '' && this.output === '') {
+        return result
+      }
+    } else if (ast && ast.body) {
+      for (const node of ast.body) {
+        const result = this.generateNode(node)
+        if (result !== undefined && result !== '' && this.output === '') {
+          return result
+        }
+      }
+    }
+
+    return this.output.trim()
+  }
+
+  generateNode(node) {
+    if (!node) return ''
+
+    switch (node.type) {
+      case 'Module':
+        return this.generateModule(node)
+      case 'ImportStatement':
+        return this.generateImport(node)
+      case 'FromImportStatement':
+        return this.generateFromImport(node)
+      case 'FunctionDef':
+      case 'FunctionDeclaration':
+        return this.generateFunction(node)
+      case 'AsyncFunctionDef':
+        return this.generateAsyncFunction(node)
+      case 'ClassDef':
+      case 'ClassDeclaration':
+        return this.generateClass(node)
+      case 'IfStatement':
+        return this.generateIf(node)
+      case 'ForStatement':
+        return this.generateFor(node)
+      case 'WhileStatement':
+        return this.generateWhile(node)
+      case 'TryStatement':
+        return this.generateTry(node)
+      case 'WithStatement':
+        return this.generateWith(node)
+      case 'ReturnStatement':
+        return this.generateReturn(node)
+      case 'YieldStatement':
+        return this.generateYield(node)
+      case 'RaiseStatement':
+        return this.generateRaise(node)
+      case 'AssertStatement':
+        return this.generateAssert(node)
+      case 'PassStatement':
+        this.writeLine('pass')
+        return
+      case 'BreakStatement':
+        this.writeLine('break')
+        return
+      case 'ContinueStatement':
+        this.writeLine('continue')
+        return
+      case 'ExpressionStatement':
+        return this.generateExpressionStatement(node)
+      case 'AssignmentStatement':
+      case 'AssignmentExpression':
+        return this.generateAssignment(node)
+      case 'AugmentedAssignment':
+        return this.generateAugmentedAssignment(node)
+      case 'Decorator':
+        return this.generateDecorator(node)
+      case 'CallExpression':
+        return this.generateCall(node)
+      case 'BinaryExpression':
+        return this.generateBinary(node)
+      case 'UnaryExpression':
+        return this.generateUnary(node)
+      case 'CompareExpression':
+        return this.generateCompare(node)
+      case 'BoolOp':
+        return this.generateBoolOp(node)
+      case 'IfExpression':
+      case 'ConditionalExpression':
+        return this.generateIfExpr(node)
+      case 'ListExpression':
+      case 'ArrayExpression':
+        return this.generateList(node)
+      case 'DictExpression':
+      case 'ObjectExpression':
+        return this.generateDict(node)
+      case 'SetExpression':
+        return this.generateSet(node)
+      case 'TupleExpression':
+        return this.generateTuple(node)
+      case 'ListComprehension':
+        return this.generateListComp(node)
+      case 'DictComprehension':
+        return this.generateDictComp(node)
+      case 'SetComprehension':
+        return this.generateSetComp(node)
+      case 'GeneratorExpression':
+        return this.generateGenExpr(node)
+      case 'LambdaExpression':
+        return this.generateLambda(node)
+      case 'Subscript':
+      case 'MemberExpression':
+        return this.generateSubscript(node)
+      case 'Attribute':
+        return this.generateAttribute(node)
+      case 'Slice':
+        return this.generateSlice(node)
+      case 'FString':
+      case 'TemplateLiteral':
+        return this.generateFString(node)
+      case 'Identifier':
+        return this.translate(node.name)
+      case 'Literal':
+        return this.generateLiteral(node)
+      default:
+        return ''
+    }
+  }
+
+  generateModule(node) {
+    for (const stmt of node.body || []) {
+      this.generateNode(stmt)
+    }
+  }
+
+  generateImport(node) {
+    const names = (node.names || [node.name]).map(n => {
+      if (typeof n === 'string') return this.translate(n)
+      let result = this.translate(n.name)
+      if (n.alias) result += ' as ' + n.alias
+      return result
+    })
+    this.writeLine('import ' + names.join(', '))
+  }
+
+  generateFromImport(node) {
+    const module = this.translate(node.module)
+    const names = (node.names || []).map(n => {
+      if (typeof n === 'string') return this.translate(n)
+      let result = this.translate(n.name)
+      if (n.alias) result += ' as ' + n.alias
+      return result
+    })
+    this.writeLine(`from ${module} import ${names.join(', ')}`)
+  }
+
+  generateFunction(node) {
+    if (node.decorators) {
+      for (const dec of node.decorators) {
+        this.generateDecorator(dec)
+      }
+    }
+
+    const name = this.translate(node.name || node.id?.name || '')
+    const params = this.generateParams(node.params || node.args || [])
+    const returnType = node.returnType ? ' -> ' + this.translate(node.returnType) : ''
+
+    this.writeLine(`def ${name}(${params})${returnType}:`)
+    this.indent++
+    
+    if (node.docstring) {
+      this.writeLine(`"""${node.docstring}"""`)
+    }
+    
+    const body = node.body?.body || node.body || []
+    if (body.length === 0) {
+      this.writeLine('pass')
+    } else {
+      for (const stmt of body) {
+        this.generateNode(stmt)
+      }
+    }
+    
+    this.indent--
+    this.writeLine('')
+  }
+
+  generateAsyncFunction(node) {
+    if (node.decorators) {
+      for (const dec of node.decorators) {
+        this.generateDecorator(dec)
+      }
+    }
+
+    const name = this.translate(node.name || '')
+    const params = this.generateParams(node.params || [])
+
+    this.writeLine(`async def ${name}(${params}):`)
+    this.indent++
+    
+    const body = node.body?.body || node.body || []
+    if (body.length === 0) {
+      this.writeLine('pass')
+    } else {
+      for (const stmt of body) {
+        this.generateNode(stmt)
+      }
+    }
+    
+    this.indent--
+    this.writeLine('')
+  }
+
+  generateParams(params) {
+    return params.map(p => {
+      let param = ''
+      
+      if (p.kind === 'vararg' || p.vararg) {
+        param = '*'
+      } else if (p.kind === 'kwarg' || p.kwarg) {
+        param = '**'
+      }
+      
+      param += this.translate(p.name || p.arg || p)
+      
+      if (p.annotation || p.type) {
+        param += ': ' + this.translate(p.annotation || p.type)
+      }
+      
+      if (p.default !== undefined) {
+        param += ' = ' + this.generateNode(p.default)
+      }
+      
+      return param
+    }).join(', ')
+  }
+
+  generateClass(node) {
+    if (node.decorators) {
+      for (const dec of node.decorators) {
+        this.generateDecorator(dec)
+      }
+    }
+
+    const name = node.name || node.id?.name || ''
+    const bases = (node.bases || node.extends || []).map(b => 
+      typeof b === 'string' ? b : this.generateNode(b)
+    )
+    const basesStr = bases.length > 0 ? `(${bases.join(', ')})` : ''
+
+    this.writeLine(`class ${name}${basesStr}:`)
+    this.indent++
+    
+    if (node.docstring) {
+      this.writeLine(`"""${node.docstring}"""`)
+    }
+    
+    const body = node.body?.body || node.body || []
+    if (body.length === 0) {
+      this.writeLine('pass')
+    } else {
+      for (const member of body) {
+        this.generateNode(member)
+      }
+    }
+    
+    this.indent--
+    this.writeLine('')
+  }
+
+  generateDecorator(node) {
+    let name = ''
+    if (typeof node === 'string') {
+      name = node
+    } else if (typeof node.name === 'string') {
+      name = this.translate(node.name)
+    } else if (node.name?.name) {
+      name = this.translate(node.name.name)
+    } else {
+      name = this.generateNode(node)
+    }
+    const args = node.arguments ? 
+      '(' + node.arguments.map(a => this.generateNode(a)).join(', ') + ')' : ''
+    this.writeLine(`@${name}${args}`)
+  }
+
+  generateIf(node) {
+    const test = this.generateNode(node.test)
+    this.writeLine(`if ${test}:`)
+    this.indent++
+    
+    const consequent = node.consequent?.body || node.consequent || node.body || []
+    for (const stmt of (Array.isArray(consequent) ? consequent : [consequent])) {
+      this.generateNode(stmt)
+    }
+    
+    this.indent--
+
+    if (node.alternate || node.orelse) {
+      const alt = node.alternate || node.orelse
+      if (alt.type === 'IfStatement' || (Array.isArray(alt) && alt[0]?.type === 'IfStatement')) {
+        const elif = Array.isArray(alt) ? alt[0] : alt
+        this.output = this.output.trimEnd() + '\n'
+        const elifTest = this.generateNode(elif.test)
+        this.writeLine(`elif ${elifTest}:`)
+        this.indent++
+        const elifBody = elif.consequent?.body || elif.consequent || elif.body || []
+        for (const stmt of (Array.isArray(elifBody) ? elifBody : [elifBody])) {
+          this.generateNode(stmt)
+        }
+        this.indent--
+        if (elif.alternate || elif.orelse) {
+          const nextAlt = elif.alternate || elif.orelse
+          if (nextAlt.type === 'IfStatement') {
+            this.generateIf({ ...nextAlt, isElif: true })
+          } else {
+            this.writeLine('else:')
+            this.indent++
+            const nextBody = Array.isArray(nextAlt) ? nextAlt : [nextAlt]
+            for (const stmt of nextBody) {
+              this.generateNode(stmt)
+            }
+            this.indent--
+          }
+        }
+      } else {
+        this.writeLine('else:')
+        this.indent++
+        const altBody = Array.isArray(alt) ? alt : [alt]
+        for (const stmt of altBody) {
+          this.generateNode(stmt)
+        }
+        this.indent--
+      }
+    }
+  }
+
+  generateFor(node) {
+    const target = this.generateNode(node.target || node.left)
+    const iter = this.generateNode(node.iter || node.right)
+    
+    this.writeLine(`for ${target} in ${iter}:`)
+    this.indent++
+    
+    const body = node.body?.body || node.body || []
+    for (const stmt of (Array.isArray(body) ? body : [body])) {
+      this.generateNode(stmt)
+    }
+    
+    this.indent--
+
+    if (node.orelse && node.orelse.length > 0) {
+      this.writeLine('else:')
+      this.indent++
+      for (const stmt of node.orelse) {
+        this.generateNode(stmt)
+      }
+      this.indent--
+    }
+  }
+
+  generateWhile(node) {
+    const test = this.generateNode(node.test)
+    
+    this.writeLine(`while ${test}:`)
+    this.indent++
+    
+    const body = node.body?.body || node.body || []
+    for (const stmt of (Array.isArray(body) ? body : [body])) {
+      this.generateNode(stmt)
+    }
+    
+    this.indent--
+  }
+
+  generateTry(node) {
+    this.writeLine('try:')
+    this.indent++
+    
+    const tryBody = node.body?.body || node.body || node.block?.body || node.block || []
+    for (const stmt of (Array.isArray(tryBody) ? tryBody : [tryBody])) {
+      this.generateNode(stmt)
+    }
+    
+    this.indent--
+
+    for (const handler of node.handlers || (node.handler ? [node.handler] : [])) {
+      let exceptLine = 'except'
+      if (handler.type) {
+        exceptLine += ' ' + this.translate(handler.type)
+        if (handler.name || handler.param) {
+          exceptLine += ' as ' + (handler.name || this.generateNode(handler.param))
+        }
+      }
+      this.writeLine(exceptLine + ':')
+      this.indent++
+      
+      const handlerBody = handler.body?.body || handler.body || []
+      for (const stmt of (Array.isArray(handlerBody) ? handlerBody : [handlerBody])) {
+        this.generateNode(stmt)
+      }
+      
+      this.indent--
+    }
+
+    if (node.orelse && node.orelse.length > 0) {
+      this.writeLine('else:')
+      this.indent++
+      for (const stmt of node.orelse) {
+        this.generateNode(stmt)
+      }
+      this.indent--
+    }
+
+    if (node.finalbody || node.finalizer) {
+      this.writeLine('finally:')
+      this.indent++
+      const finalBody = node.finalbody || node.finalizer?.body || node.finalizer || []
+      for (const stmt of (Array.isArray(finalBody) ? finalBody : [finalBody])) {
+        this.generateNode(stmt)
+      }
+      this.indent--
+    }
+  }
+
+  generateWith(node) {
+    const items = (node.items || [node]).map(item => {
+      let result = this.generateNode(item.context_expr || item.expression)
+      if (item.optional_vars || item.alias) {
+        result += ' as ' + this.generateNode(item.optional_vars || item.alias)
+      }
+      return result
+    })
+
+    this.writeLine(`with ${items.join(', ')}:`)
+    this.indent++
+    
+    const body = node.body?.body || node.body || []
+    for (const stmt of (Array.isArray(body) ? body : [body])) {
+      this.generateNode(stmt)
+    }
+    
+    this.indent--
+  }
+
+  generateReturn(node) {
+    if (node.value || node.argument) {
+      const value = this.generateNode(node.value || node.argument)
+      this.writeLine(`return ${value}`)
+    } else {
+      this.writeLine('return')
+    }
+  }
+
+  generateYield(node) {
+    if (node.value) {
+      const value = this.generateNode(node.value)
+      if (node.from) {
+        this.writeLine(`yield from ${value}`)
+      } else {
+        this.writeLine(`yield ${value}`)
+      }
+    } else {
+      this.writeLine('yield')
+    }
+  }
+
+  generateRaise(node) {
+    if (node.exc || node.argument) {
+      const exc = this.generateNode(node.exc || node.argument)
+      if (node.cause) {
+        this.writeLine(`raise ${exc} from ${this.generateNode(node.cause)}`)
+      } else {
+        this.writeLine(`raise ${exc}`)
+      }
+    } else {
+      this.writeLine('raise')
+    }
+  }
+
+  generateAssert(node) {
+    const test = this.generateNode(node.test)
+    if (node.msg) {
+      this.writeLine(`assert ${test}, ${this.generateNode(node.msg)}`)
+    } else {
+      this.writeLine(`assert ${test}`)
+    }
+  }
+
+  generateExpressionStatement(node) {
+    const expr = this.generateNode(node.expression)
+    this.writeLine(expr)
+  }
+
+  generateAssignment(node) {
+    const targets = (node.targets || [node.left]).map(t => this.generateNode(t))
+    const value = this.generateNode(node.value || node.right)
+    this.writeLine(`${targets.join(' = ')} = ${value}`)
+  }
+
+  generateAugmentedAssignment(node) {
+    const target = this.generateNode(node.target)
+    const value = this.generateNode(node.value)
+    const op = node.op || node.operator
+    this.writeLine(`${target} ${op}= ${value}`)
+  }
+
+  generateCall(node) {
+    const func = this.generateNode(node.func || node.callee)
+    const args = (node.args || node.arguments || []).map(a => this.generateNode(a))
+    const kwargs = (node.keywords || []).map(kw => 
+      `${kw.arg}=${this.generateNode(kw.value)}`
+    )
+    const allArgs = [...args, ...kwargs].join(', ')
+    return `${func}(${allArgs})`
+  }
+
+  generateBinary(node) {
+    const left = this.generateNode(node.left)
+    const right = this.generateNode(node.right)
+    const op = this.translateOperator(node.op || node.operator)
+    return `${left} ${op} ${right}`
+  }
+
+  generateUnary(node) {
+    const operand = this.generateNode(node.operand || node.argument)
+    const op = this.translateOperator(node.op || node.operator)
+    if (op === 'not') {
+      return `not ${operand}`
+    }
+    return `${op}${operand}`
+  }
+
+  generateCompare(node) {
+    let result = this.generateNode(node.left)
+    const ops = node.ops || [node.operator]
+    const comparators = node.comparators || [node.right]
+    
+    for (let i = 0; i < ops.length; i++) {
+      result += ' ' + this.translateOperator(ops[i]) + ' ' + this.generateNode(comparators[i])
+    }
+    
+    return result
+  }
+
+  generateBoolOp(node) {
+    const op = node.op === 'And' || node.op === 'et' ? ' and ' : ' or '
+    return node.values.map(v => this.generateNode(v)).join(op)
+  }
+
+  generateIfExpr(node) {
+    const body = this.generateNode(node.body || node.consequent)
+    const test = this.generateNode(node.test)
+    const orelse = this.generateNode(node.orelse || node.alternate)
+    return `${body} if ${test} else ${orelse}`
+  }
+
+  generateList(node) {
+    const elements = (node.elts || node.elements || []).map(e => this.generateNode(e))
+    return `[${elements.join(', ')}]`
+  }
+
+  generateDict(node) {
+    const pairs = []
+    const keys = node.keys || []
+    const values = node.values || []
+    
+    if (node.properties) {
+      for (const prop of node.properties) {
+        const key = this.generateNode(prop.key)
+        const value = this.generateNode(prop.value)
+        pairs.push(`${key}: ${value}`)
+      }
+    } else {
+      for (let i = 0; i < keys.length; i++) {
+        const key = this.generateNode(keys[i])
+        const value = this.generateNode(values[i])
+        pairs.push(`${key}: ${value}`)
+      }
+    }
+    
+    return `{${pairs.join(', ')}}`
+  }
+
+  generateSet(node) {
+    const elements = (node.elts || node.elements || []).map(e => this.generateNode(e))
+    return `{${elements.join(', ')}}`
+  }
+
+  generateTuple(node) {
+    const elements = (node.elts || node.elements || []).map(e => this.generateNode(e))
+    if (elements.length === 1) {
+      return `(${elements[0]},)`
+    }
+    return `(${elements.join(', ')})`
+  }
+
+  generateListComp(node) {
+    const elt = this.generateNode(node.elt || node.element)
+    const generators = (node.generators || []).map(g => this.generateComprehensionGen(g))
+    return `[${elt} ${generators.join(' ')}]`
+  }
+
+  generateDictComp(node) {
+    const key = this.generateNode(node.key)
+    const value = this.generateNode(node.value)
+    const generators = (node.generators || []).map(g => this.generateComprehensionGen(g))
+    return `{${key}: ${value} ${generators.join(' ')}}`
+  }
+
+  generateSetComp(node) {
+    const elt = this.generateNode(node.elt || node.element)
+    const generators = (node.generators || []).map(g => this.generateComprehensionGen(g))
+    return `{${elt} ${generators.join(' ')}}`
+  }
+
+  generateGenExpr(node) {
+    const elt = this.generateNode(node.elt || node.element)
+    const generators = (node.generators || []).map(g => this.generateComprehensionGen(g))
+    return `(${elt} ${generators.join(' ')})`
+  }
+
+  generateComprehensionGen(gen) {
+    const target = this.generateNode(gen.target)
+    const iter = this.generateNode(gen.iter)
+    let result = `for ${target} in ${iter}`
+    
+    for (const if_ of gen.ifs || []) {
+      result += ` if ${this.generateNode(if_)}`
+    }
+    
+    return result
+  }
+
+  generateLambda(node) {
+    const args = this.generateParams(node.args?.args || node.params || [])
+    const body = this.generateNode(node.body)
+    return `lambda ${args}: ${body}`
+  }
+
+  generateSubscript(node) {
+    const value = this.generateNode(node.value || node.object)
+    const slice = this.generateNode(node.slice || node.property)
+    
+    if (node.computed === false) {
+      return `${value}.${slice}`
+    }
+    
+    return `${value}[${slice}]`
+  }
+
+  generateAttribute(node) {
+    const value = this.generateNode(node.value)
+    const attr = this.translate(node.attr)
+    return `${value}.${attr}`
+  }
+
+  generateSlice(node) {
+    const lower = node.lower ? this.generateNode(node.lower) : ''
+    const upper = node.upper ? this.generateNode(node.upper) : ''
+    const step = node.step ? ':' + this.generateNode(node.step) : ''
+    return `${lower}:${upper}${step}`
+  }
+
+  generateFString(node) {
+    let result = 'f"'
+    for (const part of node.values || node.parts || []) {
+      if (part.type === 'Literal' || typeof part === 'string') {
+        result += typeof part === 'string' ? part : part.value
+      } else {
+        result += '{' + this.generateNode(part.value || part) + '}'
+      }
+    }
+    result += '"'
+    return result
+  }
+
+  generateLiteral(node) {
+    if (node.value === null || node.value === undefined) return 'None'
+    if (node.value === true) return 'True'
+    if (node.value === false) return 'False'
+    if (typeof node.value === 'string') {
+      return `"${node.value.replace(/"/g, '\\"')}"`
+    }
+    return String(node.value)
+  }
+
+  translateOperator(op) {
+    const operators = {
+      'et': 'and',
+      'ou': 'or',
+      'non': 'not',
+      'est': 'is',
+      'dans': 'in',
+      'pas dans': 'not in',
+      'est pas': 'is not',
+      'egal': '==',
+      'different': '!=',
+      'puissance': '**',
+      'div entiere': '//'
+    }
+    return operators[op] || op
+  }
+
+  writeLine(text) {
+    this.output += this.getIndent() + text + '\n'
+  }
+
+  getIndent() {
+    return '    '.repeat(this.indent)
+  }
+}
+
+module.exports = {
+  PythonGenerator
+}