import re

MOTS_CLES_VERS_PYTHON = {
    'si': 'if',
    'sinon': 'else',
    'sinonsi': 'elif',
    'tantque': 'while',
    'pour': 'for',
    'dans': 'in',
    'pasdans': 'not in',
    'casser': 'break',
    'continuer': 'continue',
    'passer': 'pass',
    'déf': 'def',
    'retourner': 'return',
    'classe': 'class',
    'soi': 'self',
    'rendement': 'yield',
    'asynchrone': 'async',
    'attendre': 'await',
    'Vrai': 'True',
    'Faux': 'False',
    'Rien': 'None',
    'et': 'and',
    'ou': 'or',
    'non': 'not',
    'est': 'is',
    'importer': 'import',
    'de': 'from',
    'comme': 'as',
    'essayer': 'try',
    'sauf': 'except',
    'enfin': 'finally',
    'lever': 'raise',
    'avec': 'with',
    'affirmer': 'assert',
    'global': 'global',
    'nonlocal': 'nonlocal',
    'supprimer': 'del',
    'lambda': 'lambda',
    'afficher': 'print',
    'saisir': 'input',
    'longueur': 'len',
    'intervalle': 'range',
    'liste': 'list',
    'dictionnaire': 'dict',
    'ensemble': 'set',
    'tuple': 'tuple',
    'entier': 'int',
    'decimal': 'float',
    'chaine': 'str',
    'booleen': 'bool',
    'enumerer': 'enumerate',
    'zipper': 'zip',
    'mapper': 'map',
    'filtrer': 'filter',
    'trier': 'sorted',
    'inverser': 'reversed',
    'somme': 'sum',
    'maximum': 'max',
    'minimum': 'min',
    'absolu': 'abs',
    'arrondir': 'round',
    'aide': 'help',
    'type': 'type',
    'super': 'super',
    'ouvrir': 'open',
    'fermer': 'close',
    'identifiant': 'id',
    'repr': 'repr',
    'appeler': 'callable',
    'executer': 'exec',
    'evaluer': 'eval',
    'octets': 'bytes',
    'objet': 'object',
    'propriete': 'property',
    'statique': 'staticmethod',
    'classique': 'classmethod',
    'ErreurValeur': 'ValueError',
    'ErreurType': 'TypeError',
    'ErreurNom': 'NameError',
    'ErreurIndex': 'IndexError',
    'ErreurCle': 'KeyError',
    'ErreurAttribut': 'AttributeError',
    'ErreurImport': 'ImportError',
    'ErreurMemoire': 'MemoryError',
    'ErreurRecursion': 'RecursionError',
    'ErreurSyntaxe': 'SyntaxError',
    'ErreurDivisionZero': 'ZeroDivisionError',
    'ErreurFichier': 'FileNotFoundError',
    'ErreurPermission': 'PermissionError',
    'ErreurArret': 'StopIteration',
    'entree_standard': 'stdin',
    'sortie_standard': 'stdout',
    'tous': 'all',
    'aucun': 'any',
    'toutca': 'any',
    'entier_long': 'int',
    'complexe': 'complex',
    'tableau': 'bytearray',
    'vrai_faux': 'bool',
    'fige': 'frozenset',
    'tranche': 'slice',
    'type_base': 'type',
    'sous_classe': 'issubclass',
    'instance_de': 'isinstance',
    'imprimer': 'print',
    'longueur_max': 'max',
    'longueur_min': 'min',
    'puissance': 'pow',
    'divmod': 'divmod',
    'hex': 'hex',
    'octal': 'oct',
    'binaire': 'bin',
    'caractere': 'chr',
    'ordinal': 'ord',
    'globals': 'globals',
    'locals': 'locals',
    'entree': 'input',
    'executer_fichier': 'execfile',
    'formater_chaine': 'format',
    'iter': 'iter',
    'prochain': 'next',
    'hash': 'hash',
    'taille': 'sizeof',
    'breakpoint': 'breakpoint',
    'NotImplemented': 'NotImplemented',
    'Ellipsis': 'Ellipsis',
    'ErreurOS': 'OSError',
    'ErreurES': 'IOError',
    'ErreurConnexion': 'ConnectionError',
    'ErreurDebordement': 'OverflowError',
    'ErreurUnicode': 'UnicodeError',
    'ErreurIndentation': 'IndentationError',
    'ErreurTabulation': 'TabError',
    'ErreurSysteme': 'SystemError',
    'ErreurRuntime': 'RuntimeError',
    'ErreurNotImplemented': 'NotImplementedError',
    'ErreurTimeout': 'TimeoutError',
    'ErreurInterruption': 'KeyboardInterrupt',
    'ErreurAssertion': 'AssertionError',
    'Avertissement': 'Warning',
    'AvertissementDepreciation': 'DeprecationWarning',
    'AvertissementRuntime': 'RuntimeWarning',
    'AvertissementSyntaxe': 'SyntaxWarning',
    'AvertissementUtilisateur': 'UserWarning',
    'AvertissementFutur': 'FutureWarning',
    'imprimer_erreur': 'sys.stderr.write',
    'geler': 'frozenset',
    'entree_erreur': 'stderr',
    'afficher_format': 'format',
    'memoire': 'memoryview',
    'aiter': 'aiter',
	'prochain_async': 'anext',
	'ascii': 'ascii',
	'compiler': 'compile',
	'supprimer_attribut': 'delattr',
	'repertoire': 'dir',
	'obtenir_attribut': 'getattr',
	'a_attribut': 'hasattr',
	'index': '__index__',
	'vue_memoire': 'memoryview',
	'definir_attribut': 'setattr',
	'variables': 'vars',
	'importer_module': '__import__',
	'__construire_classe__': 'NATIVE.__build_class__',
	'__importer__': 'NATIVE.__import__',
	'abs': 'NATIVE.abs',
	'aiter': 'NATIVE.aiter',
	'tous': 'NATIVE.all',
	'anext': 'NATIVE.anext',
	'asuivant': 'NATIVE.anext',
	'suivant_async': 'NATIVE.anext',
	'certains': 'NATIVE.any',
	'n_importe_quel': 'NATIVE.any',
	'appendStr': 'NATIVE.appendStr',
	'ajouterStr': 'NATIVE.appendStr',
	'ascii': 'NATIVE.ascii',
	'bin': 'NATIVE.bin',
	'binaire': 'NATIVE.bin',
	'bound': 'NATIVE.bound',
	'lien': 'NATIVE.bound',
	'limite': 'NATIVE.bound',
	'breakpoint': 'NATIVE.breakpoint',
	'point_de_rupture': 'NATIVE.breakpoint',
	'pointderupture': 'NATIVE.breakpoint',
	'callable': 'NATIVE.callable',
	'appelable': 'NATIVE.callable',
	'chr': 'NATIVE.chr',
	'clamp': 'NATIVE.clamp',
	'pince': 'NATIVE.clamp',
	'serrer': 'NATIVE.clamp',
	'compile': 'NATIVE.compile',
	'compiler': 'NATIVE.compile',
	'configIsToday': 'NATIVE.configIsToday',
	'configurationEstAujourdhui': 'NATIVE.configIsToday',
	'typeprofond': 'NATIVE.deeptype',
	'type_profond': 'NATIVE.deeptype',
	'rep': 'NATIVE.dir',
	'div_reste': 'NATIVE.divmod',
	'divreste': 'NATIVE.divmod',
	'erreur_enregistree': 'NATIVE.exceptionLogged',
	'exception_enregistree': 'NATIVE.exceptionLogged',
	'exception_journalisee': 'NATIVE.exceptionLogged',
	'repr_rapide': 'NATIVE.fastRepr',
	'representation_rapide': 'NATIVE.fastRepr',
	'volant_inertie': 'NATIVE.flywheel',
	'regulateur': 'NATIVE.flywheel',
	'accumulateur': 'NATIVE.flywheel',
	'formater': 'NATIVE.format',
    'obtenir_base': 'NATIVE.getBase',
    'obtenir_depot': 'NATIVE.getRepository',
    'dictionnaire_histogramme': 'NATIVE.histogramDict',
    'inverser_dictionnaire': 'NATIVE.invertDict',
    'inverser_dictionnaire_sans_perte': 'NATIVE.invertDictLossless',
    'type_itérateur': 'NATIVE.itype',
    'interpolation_linéaire': 'NATIVE.lerp',
    'lerp': 'NATIVE.lerp',
    'journaliser_bloc': 'NATIVE.logBlock',
    'generateur_boucle': 'NATIVE.loopGen',
    'creer_liste': 'NATIVE.makeList',
    'creer_tuple': 'NATIVE.makeTuple',
    'generateur_nul': 'NATIVE.nullGen',
    'afficher_pile_inverse': 'NATIVE.printReverseStack',
    'afficher_pile': 'NATIVE.printStack',
    'afficher_pile_verbeuse': 'NATIVE.printVerboseStack',
    'profile': 'NATIVE.profiled',
    'collecte_pstat': 'NATIVE.pstatcollect',
    'rapport': 'NATIVE.report',
    'repr_securise': 'NATIVE.safeRepr',
    'nom_type_securise': 'NATIVE.safeTypeName',
    'numero_serie': 'NATIVE.serialNum',
    'nom_type': 'NATIVE.typeName',
    'nom_unique': 'NATIVE.uniqueName',
	'abc.initialisation_interne': 'abc._abc_init',
    'abc._initialisation_interne': 'abc._abc_init',
    'abc.verifier_instance': 'abc._abc_instancecheck',
    'abc._verifier_instance': 'abc._abc_instancecheck',
    'abc.enregistrer': 'abc._abc_register',
    'abc._enregistrer': 'abc._abc_register',
    'abc.verifier_sous_classe': 'abc._abc_subclasscheck',
    'abc._verifier_sous_classe': 'abc._abc_subclasscheck',
    'abc.obtenir_decharge': 'abc._get_dump',
    'abc._obtenir_decharge': 'abc._get_dump',
    'abc.reinitialiser_caches': 'abc._reset_caches',
    'abc._reinitialiser_caches': 'abc._reset_caches',
    'abc.reinitialiser_registre': 'abc._reset_registry',
    'abc._reinitialiser_registre': 'abc._reset_registry',
    'abc.methode_abstraite': 'abc.abstractmethod',
    'abc.obtenir_jeton_cache': 'abc.get_cache_token',
    'abc.actualiser_methodes_abstraites': 'abc.update_abstractmethods',
	'reseau.adresse_vers_infos': 'aiohappyeyeballs.addr_to_addr_infos',
    'reseau.extraire_infos_entrelacees': 'aiohappyeyeballs.pop_addr_infos_interleave',
    'reseau.supprimer_infos_adresse': 'aiohappyeyeballs.remove_addr_infos',
    'reseau.demarrer_connexion': 'aiohappyeyeballs.start_connection',
	'web.nom_fichier_disposition': 'aiohttp.content_disposition_filename',
    'web.obtenir_donnees_utiles': 'aiohttp.get_payload',
    'web.analyser_disposition_contenu': 'aiohttp.parse_content_disposition',
    'web.requete': 'aiohttp.request',
    'web.definir_moteur_zlib': 'aiohttp.set_zlib_backend',
	'type.construire_cloture': 'annotationlib._build_closure',
    'type._construire_cloture': 'annotationlib._build_closure',
    'type.appeler_annoter_interne': 'annotationlib._get_and_call_annotate',
    'type._appeler_annoter_interne': 'annotationlib._get_and_call_annotate',
    'type.obtenir_annotations_doubles': 'annotationlib._get_dunder_annotations',
    'type._obtenir_annotations_doubles': 'annotationlib._get_dunder_annotations',
    'type.reescrire_deballage_etoile': 'annotationlib._rewrite_star_unpack',
    'type._reescrire_deballage_etoile': 'annotationlib._rewrite_star_unpack',
    'type.transformer_en_chaine_unique': 'annotationlib._stringify_single',
    'type._transformer_en_chaine_unique': 'annotationlib._stringify_single',
    'type.modele_vers_ast': 'annotationlib._template_to_ast',
    'type._modele_vers_ast': 'annotationlib._template_to_ast',
    'type.constructeur_modele_ast': 'annotationlib._template_to_ast_constructor',
    'type._constructeur_modele_ast': 'annotationlib._template_to_ast_constructor',
    'type.literal_modele_ast': 'annotationlib._template_to_ast_literal',
    'type._literal_modele_ast': 'annotationlib._template_to_ast_literal',
    'type.annotations_en_chaine': 'annotationlib.annotations_to_string',
    'type.appeler_fonction_annoter': 'annotationlib.call_annotate_function',
    'type.appeler_fonction_evaluer': 'annotationlib.call_evaluate_function',
    'type.obtenir_espace_nom_classe': 'annotationlib.get_annotate_from_class_namespace',
    'type.obtenir_annotations': 'annotationlib.get_annotations',
    'type.repr_type': 'annotationlib.type_repr',
	'antigravite.hachage_geo': 'antigravity.geohash',
	'anyio.lancer': 'anyio.run',
    'anyio.dormir': 'anyio.sleep',
    'anyio.dormir_toujours': 'anyio.sleep_forever',
    'anyio.dormir_jusqua': 'anyio.sleep_until',
    'anyio.creer_groupe_taches': 'anyio.create_task_group',
    'anyio.echouer_apres': 'anyio.fail_after',
    'anyio.continuer_apres': 'anyio.move_on_after',
    'anyio.temps_actuel': 'anyio.current_time',
    'anyio.deadline_actuelle': 'anyio.current_effective_deadline',
	'anyio.connecter_tcp': 'anyio.connect_tcp',
    'anyio.connecter_unix': 'anyio.connect_unix',
    'anyio.creer_ecouteur_tcp': 'anyio.create_tcp_listener',
    'anyio.creer_ecouteur_unix': 'anyio.create_unix_listener',
    'anyio.creer_socket_udp_connecte': 'anyio.create_connected_udp_socket',
    'anyio.creer_socket_udp': 'anyio.create_udp_socket',
    'anyio.fermer_de_force': 'anyio.aclose_forcefully',
    'anyio.notifier_fermeture': 'anyio.notify_closing',
    'anyio.attendre_lisible': 'anyio.wait_readable',
    'anyio.attendre_scriptible': 'anyio.wait_writable',
	'anyio.ouvrir_fichier': 'anyio.open_file',
    'anyio.envelopper_fichier': 'anyio.wrap_file',
    'anyio.ouvrir_processus': 'anyio.open_process',
    'anyio.lancer_processus': 'anyio.run_process',
    'anyio.creer_repertoire_temp': 'anyio.mkdtemp',
    'anyio.creer_fichier_temp': 'anyio.mkstemp',
    'anyio.obtenir_repertoire_temp': 'anyio.gettempdir',
	'anyio.obtenir_tache_actuelle': 'anyio.get_current_task',
    'anyio.obtenir_taches_en_cours': 'anyio.get_running_tasks',
    'anyio.obtenir_tous_les_moteurs': 'anyio.get_all_backends',
    'anyio.obtenir_moteurs_disponibles': 'anyio.get_available_backends',
	'arguments.n_obtenir_texte': 'argparse.ngettext',
    'arguments._copier_elements': 'argparse._copy_items',
    'arguments.copier_elements': 'argparse._copy_items',
    'arguments._obtenir_nom_action': 'argparse._get_action_name',
    'arguments.obtenir_nom_action': 'argparse._get_action_name',
    'arguments._nom_programme': 'argparse._prog_name',
    'arguments.nom_programme': 'argparse._prog_name',
	'ast.analyser': 'ast.parse',
    'ast.desanalyser': 'ast.unparse',
    'ast.parcourir': 'ast.walk',
    'ast.decharger': 'ast.dump',
    'ast.comparer': 'ast.compare',
    'ast.evaluer_litteral': 'ast.literal_eval',
    'ast.obtenir_docstring': 'ast.get_docstring',
    'ast.obtenir_segment_source': 'ast.get_source_segment',
    'ast.corriger_emplacements': 'ast.fix_missing_locations',
    'ast.copier_emplacement': 'ast.copy_location',
    'ast.incrementer_ligne': 'ast.increment_lineno',
    'ast.iterer_noeuds_enfants': 'ast.iter_child_nodes',
    'ast.iterer_champs': 'ast.iter_fields',
	'ast._remplir_espaces': 'ast._pad_whitespace',
    'ast.remplir_espaces': 'ast._pad_whitespace',
    'ast._diviser_lignes_sans_ff': 'ast._splitlines_no_ff',
    'ast.diviser_lignes_sans_ff': 'ast._splitlines_no_ff',
    'ast._obtenir_dims': 'ast._dims_getter',
    'ast.obtenir_dims': 'ast._dims_getter',
    'ast._definir_dims': 'ast._dims_setter',
    'ast.definir_dims': 'ast._dims_setter',
	'asyncio.lancer': 'asyncio.run',
    'asyncio.dormir': 'asyncio.sleep',
    'asyncio.attendre': 'asyncio.wait',
    'asyncio.attendre_pendant': 'asyncio.wait_for',
    'asyncio.delai_limite': 'asyncio.timeout',
    'asyncio.delai_limite_a': 'asyncio.timeout_at',
    'asyncio.rassembler': 'asyncio.gather',
    'asyncio.bouclier': 'asyncio.shield',
    'asyncio.vers_fil': 'asyncio.to_thread',
	'asyncio.creer_tache': 'asyncio.create_task',
    'asyncio.tache_actuelle': 'asyncio.current_task',
    'asyncio.toutes_les_taches': 'asyncio.all_tasks',
    'asyncio.au_fur_et_a_mesure': 'asyncio.as_completed',
    'asyncio.assurer_futur': 'asyncio.ensure_future',
    'asyncio.envelopper_futur': 'asyncio.wrap_future',
    'asyncio.lancer_coroutine_filetée': 'asyncio.run_coroutine_threadsafe',
	'asyncio.obtenir_boucle_actuelle': 'asyncio.get_running_loop',
    'asyncio.obtenir_boucle': 'asyncio.get_event_loop',
    'asyncio.nouvelle_boucle': 'asyncio.new_event_loop',
    'asyncio.definir_boucle': 'asyncio.set_event_loop',
	'asyncio.est_coroutine': 'asyncio.iscoroutine',
    'asyncio.est_fonction_coroutine': 'asyncio.iscoroutinefunction',
    'asyncio.est_futur': 'asyncio.isfuture',
	'asyncio.ouvrir_connexion': 'asyncio.open_connection',
    'asyncio.demarrer_serveur': 'asyncio.start_server',
    'asyncio.creer_sous_processus_exec': 'asyncio.create_subprocess_exec',
    'asyncio.creer_sous_processus_shell': 'asyncio.create_subprocess_shell',
	'asyncio.entrer_dans_tache': 'asyncio._enter_task',
    'asyncio._entrer_dans_tache': 'asyncio._enter_task',
    'asyncio.quitter_tache': 'asyncio._leave_task',
    'asyncio._quitter_tache': 'asyncio._leave_task',
    'asyncio.enregistrer_tache': 'asyncio._register_task',
    'asyncio._enregistrer_tache': 'asyncio._register_task',
    'asyncio.desenregistrer_tache': 'asyncio._unregister_task',
    'asyncio._desenregistrer_tache': 'asyncio._unregister_task',
	'attr.definir': 'attr.define',
    'attrs.definir': 'attrs.define',
    'attr.champ': 'attr.field',
    'attrs.field': 'attrs.field',
    'attr.attribut': 'attr.attrib',
    'attr.mutable': 'attr.mutable',
    'attrs.mutable': 'attrs.mutable',
    'attr.creer_classe': 'attr.make_class',
    'attrs.creer_classe': 'attrs.make_class',
	'attr.en_dict': 'attr.asdict',
    'attrs.en_dict': 'attrs.asdict',
    'attr.en_tuple': 'attr.astuple',
    'attrs.en_tuple': 'attrs.astuple',
    'attr.evoluer': 'attr.evolve',
    'attrs.evoluer': 'attrs.evolve',
    'attr.associer': 'attr.assoc',
    'attrs.associer': 'attrs.assoc',
	'attr.champs': 'attr.fields',
    'attrs.champs': 'attrs.fields',
    'attr.dict_champs': 'attr.fields_dict',
    'attrs.dict_champs': 'attrs.fields_dict',
    'attr.a': 'attr.has',
    'attrs.a': 'attrs.has',
    'attrs.inspecter': 'attrs.inspect',
	'attr.valider': 'attr.validate',
    'attrs.valider': 'attrs.validate',
    'attr.resoudre_types': 'attr.resolve_types',
    'attrs.resoudre_types': 'attrs.resolve_types',
    'attr.comparer_avec': 'attr.cmp_using',
    'attrs.comparer_avec': 'attrs.cmp_using',
	'base64.encoder': 'base64.encode',
    'base64.decoder': 'base64.decode',
    'base64.encoder_octets': 'base64.encodebytes',
    'base64.decoder_octets': 'base64.decodebytes',
    'base64.b64_encoder': 'base64.b64encode',
    'base64.b64_decoder': 'base64.b64decode',
    'base64.b64_url_encoder': 'base64.urlsafe_b64encode',
    'base64.b64_url_decoder': 'base64.urlsafe_b64decode',
    'base64.b32_encoder': 'base64.b32encode',
    'base64.b32_decoder': 'base64.b32decode',
    'base64.b16_encoder': 'base64.b16encode',
    'base64.b16_decoder': 'base64.b16decode',
    'base64.a85_encoder': 'base64.a85encode',
    'base64.a85_decoder': 'base64.a85decode',
	'base64._verification_type_entree': 'base64._input_type_check',
    'base64.verification_type_entree': 'base64._input_type_check',
    'base64._octets_depuis_donnees_decodees': 'base64._bytes_from_decode_data',
    'base64.octets_depuis_donnees_decodees': 'base64._bytes_from_decode_data',
	'bisect.bissection': 'bisect.bisect',
    'bisect.bissection_gauche': 'bisect.bisect_left',
    'bisect.bissection_droite': 'bisect.bisect_right',
    'bisect.insérer_trié': 'bisect.insort',
    'bisect.insérer_trié_gauche': 'bisect.insort_left',
    'bisect.insérer_trié_droite': 'bisect.insort_right',
	'calendrier.est_bissextile': 'calendar.isleap',
    'calendrier.jours_bissextiles': 'calendar.leapdays',
    'calendrier.plage_mois': 'calendar.monthrange',
    'calendrier.jour_semaine': 'calendar.weekday',
    'calendrier.definir_premier_jour_semaine': 'calendar.setfirstweekday',
    'calendrier.formater': 'calendar.format',
	'calendrier._longueur_mois': 'calendar._monthlen',
    'calendrier.longueur_mois': 'calendar._monthlen',
    'calendrier._mois_suivant': 'calendar._nextmonth',
    'calendrier.mois_suivant': 'calendar._nextmonth',
    'calendrier._mois_precedent': 'calendar._prevmonth',
    'calendrier.mois_precedent': 'calendar._prevmonth',
    'calendrier._valider_mois': 'calendar._validate_month',
    'calendrier.valider_mois': 'calendar._validate_month',
	'bz2.compresser': 'bz2.compress',
    'bz2.decompresser': 'bz2.decompress',
    'bz2.ouvrir': 'bz2.open',
    'build.verifier_dependance': 'build.check_dependency',
    'bs4.convertir': 'bs4.cast',
	'profiler.lancer': 'cProfile.run',
    'profiler.lancer_contexte': 'cProfile.runctx',
    'profiler.etiquette': 'cProfile.label',
	'encodage.detecter': 'charset_normalizer.detect',
    'encodage.depuis_octets': 'charset_normalizer.from_bytes',
    'encodage.depuis_chemin': 'charset_normalizer.from_path',
    'encodage.est_binaire': 'charset_normalizer.is_binary',
    'encodage.definir_journalisation': 'charset_normalizer.set_logging_handler',
	'certificats.ou': 'certifi.where',
    'certificats.contenu': 'certifi.contents',
    'bdb.definir_trace': 'bdb.set_trace',
    'bdb.gestionnaire_contexte': 'bdb.contextmanager',
    'bdb.verifier_nom_fonction': 'bdb.checkfuncname',
	'clic.argument': 'click.argument',
	'clic.effacer': 'click.clear',
	'clic.commande': 'click.command',
	'clic.confirmer': 'click.confirm',
	'clic.option_confirmation': 'click.confirmation_option',
	'clic.echo': 'click.echo',
	'clic.echo_page': 'click.echo_via_pager',
	'clic.editer': 'click.edit',
	'clic.formater_nom_fichier': 'click.format_filename',
	'clic.obtenir_dossier_app': 'click.get_app_dir',
	'clic.obtenir_flux_binaire': 'click.get_binary_stream',
	'clic.obtenir_contexte_actuel': 'click.get_current_context',
	'clic.obtenir_flux_texte': 'click.get_text_stream',
	'clic.lire_caractere': 'click.getchar',
	'clic.groupe': 'click.group',
	'clic.option_aide': 'click.help_option',
	'clic.lancer': 'click.launch',
	'clic.creer_decorateur_passage': 'click.make_pass_decorator',
	'clic.ouvrir_fichier': 'click.open_file',
	'clic.option': 'click.option',
	'clic.passer_contexte': 'click.pass_context',
	'clic.passer_objet': 'click.pass_obj',
	'clic.option_mot_de_passe': 'click.password_option',
	'clic.pause': 'click.pause',
	'clic.barre_progression': 'click.progressbar',
	'clic.demander': 'click.prompt',
	'clic.secho': 'click.secho',
	'clic.style': 'click.style',
	'clic.enlever_style': 'click.unstyle',
	'clic.option_version': 'click.version_option',
	'clic.envelopper_texte': 'click.wrap_text',
	'code.compiler_commande': 'code.compile_command',
	'code.interagir': 'code.interact',
	'codecs.fichier_encode': 'codecs.EncodedFile',
	'codecs.ascii_decoder': 'codecs.ascii_decode',
	'codecs.ascii_encoder': 'codecs.ascii_encode',
	'codecs.erreur_remplacement_barre': 'codecs.backslashreplace_errors',
	'codecs.construire_carte_caracteres': 'codecs.charmap_build',
	'codecs.decoder': 'codecs.decode',
	'codecs.encoder': 'codecs.encode',
	'codecs.echappement_decoder': 'codecs.escape_decode',
	'codecs.echappement_encoder': 'codecs.escape_encode',
	'codecs.obtenir_decoder': 'codecs.getdecoder',
	'codecs.obtenir_encoder': 'codecs.getencoder',
	'codecs.obtenir_lecteur': 'codecs.getreader',
	'codecs.obtenir_ecrivain': 'codecs.getwriter',
	'codecs.ignorer_erreurs': 'codecs.ignore_errors',
	'codecs.iterer_decoder': 'codecs.iterdecode',
	'codecs.iterer_encoder': 'codecs.iterencode',
	'codecs.latin1_decoder': 'codecs.latin_1_decode',
	'codecs.latin1_encoder': 'codecs.latin_1_encode',
	'codecs.chercher': 'codecs.lookup',
	'codecs.chercher_erreur': 'codecs.lookup_error',
	'codecs.creer_carte_encodage': 'codecs.make_encoding_map',
	'codecs.ouvrir': 'codecs.open',
	'codecs.enregistrer': 'codecs.register',
	'codecs.enregistrer_erreur': 'codecs.register_error',
	'codecs.erreurs_strictes': 'codecs.strict_errors',
	'codecs.desenregistrer': 'codecs.unregister',
	'codecs.utf8_decoder': 'codecs.utf_8_decode',
	'codecs.utf8_encoder': 'codecs.utf_8_encode',
	'codeop._compiler': 'codeop._compile',
	'codeop.compiler': 'codeop._compile',
	'codeop._peut_etre_compiler': 'codeop._maybe_compile',
	'codeop.peut_etre_compiler': 'codeop._maybe_compile',
	'codeop.compiler_commande': 'codeop.compile_command',
	'collections.compter_elements': 'collections._count_elements',
	'collections._compter_elements': 'collections._count_elements',
	'collections.est_mot_cle': 'collections._iskeyword',
	'collections._est_mot_cle': 'collections._iskeyword',
	'collections.repr_recursif': 'collections._recursive_repr',
	'collections._repr_recursif': 'collections._recursive_repr',
	'collections.tuple_nomme': 'collections.namedtuple',
	'colorama.texte_couleur': 'colorama.colorama_text',
	'colorama.desinit': 'colorama.deinit',
	'colorama.init': 'colorama.init',
	'colorama.reinit': 'colorama.reinit',
	'colorama.reparer_console_windows': 'colorama.just_fix_windows_console',
	'couleurs.hls_vers_rgb': 'colorsys.hls_to_rgb',
	'couleurs.hsv_vers_rgb': 'colorsys.hsv_to_rgb',
	'couleurs.rgb_vers_hls': 'colorsys.rgb_to_hls',
	'couleurs.rgb_vers_hsv': 'colorsys.rgb_to_hsv',
	'tout_compiler.compiler_dossier': 'compileall.compile_dir',
	'tout_compiler.compiler_fichier': 'compileall.compile_file',
	'tout_compiler.compiler_chemin': 'compileall.compile_path',
	'contexte.gestionnaire_async': 'contextlib.asynccontextmanager',
	'contexte.gestionnaire': 'contextlib.contextmanager',
	'contexte.envelopper': 'contextlib.wraps',
	'variables_contexte.copier_contexte': 'contextvars.copy_context',
	'contour.generateur_contour': 'contourpy.contour_generator',
	'contour.calculer_tailles_blocs': 'contourpy.calc_chunk_sizes',
	'contour.convertir_lignes': 'contourpy.convert_lines',
	'contour.convertir_rempli': 'contourpy.convert_filled',
	'copie.copier': 'copy.copy',
	'copie.copie_profonde': 'copy.deepcopy',
	'copie.remplacer': 'copy.replace',
	'copie._copie_profonde_dict': 'copy._deepcopy_dict',
	'copie.copie_profonde_dict': 'copy._deepcopy_dict',
	'copie._copie_profonde_liste': 'copy._deepcopy_list',
	'copie.copie_profonde_liste': 'copy._deepcopy_list',
	'registre_copie.constructeur': 'copyreg.constructor',
	'registre_copie.ajouter_extension': 'copyreg.add_extension',
	'registre_copie.supprimer_extension': 'copyreg.remove_extension',
	'csv.limite_taille_champ': 'csv.field_size_limit',
	'csv.obtenir_dialecte': 'csv.get_dialect',
	'csv.lister_dialectes': 'csv.list_dialects',
	'csv.lecteur': 'csv.reader',
	'csv.enregistrer_dialecte': 'csv.register_dialect',
	'csv.desenregistrer_dialecte': 'csv.unregister_dialect',
	'csv.ecrivain': 'csv.writer',
	'ctypes.TABLEAU': 'ctypes.ARRAY',
	'ctypes.POINTEUR': 'ctypes.POINTER',
	'ctypes.ErreurWin': 'ctypes.WinError',
	'ctypes.ErreurFormat': 'ctypes.FormatError',
	'ctypes.adresse_de': 'ctypes.addressof',
	'ctypes.alignement': 'ctypes.alignment',
	'ctypes.par_ref': 'ctypes.byref',
	'ctypes.tampon_c': 'ctypes.c_buffer',
	'ctypes.convertir': 'ctypes.cast',
	'ctypes.creer_tampon_chaine': 'ctypes.create_string_buffer',
	'ctypes.creer_tampon_unicode': 'ctypes.create_unicode_buffer',
	'ctypes.obtenir_errno': 'ctypes.get_errno',
	'ctypes.obtenir_derniere_erreur': 'ctypes.get_last_error',
	'ctypes.vue_memoire_a': 'ctypes.memoryview_at',
	'ctypes.pointeur': 'ctypes.pointer',
	'ctypes.redimensionner': 'ctypes.resize',
	'ctypes.taille_de': 'ctypes.sizeof',
	'ctypes.chaine_a': 'ctypes.string_at',
	'ctypes.chaine_large_a': 'ctypes.wstring_at',
	'ctypes._charger_bibliotheque': 'ctypes._LoadLibrary',
	'ctypes.charger_bibliotheque': 'ctypes._LoadLibrary',
	'cycleur.cycleur': 'cycler.cycler',
	'cycleur.ajouter': 'cycler.add',
	'cycleur.concatener': 'cycler.concat',
	'cycleur.multiplier': 'cycler.mul',
	'cycleur.reduire': 'cycler.reduce',
	'donnees.en_dict': 'dataclasses.asdict',
	'donnees._en_dict_interne': 'dataclasses._asdict_inner',
	'donnees.en_dict_interne': 'dataclasses._asdict_inner',
	'donnees.en_tuple': 'dataclasses.astuple',
	'donnees.donnee_classe': 'dataclasses.dataclass',
	'donnees.champ': 'dataclasses.field',
	'donnees.champs': 'dataclasses.fields',
	'donnees.est_donnee_classe': 'dataclasses.is_dataclass',
	'donnees.creer_donnee_classe': 'dataclasses.make_dataclass',
	'donnees.remplacer': 'dataclasses.replace',
	'jeux_donnees.charger': 'datasets.load_dataset',
	'jeux_donnees.charger_depuis_disque': 'datasets.load_from_disk',
	'jeux_donnees.concatener': 'datasets.concatenate_datasets',
	'jeux_donnees.entrelacer': 'datasets.interleave_datasets',
	'jeux_donnees.activer_cache': 'datasets.enable_caching',
	'jeux_donnees.desactiver_cache': 'datasets.disable_caching',
	'jeux_donnees.activer_barre_progression': 'datasets.enable_progress_bar',
	'jeux_donnees.desactiver_barre_progression': 'datasets.disable_progress_bar',
	'dbm.ouvrir': 'dbm.open',
	'dbm.quel_db': 'dbm.whichdb',
	'decimal.obtenir_contexte': 'decimal.getcontext',
	'decimal.contexte_local': 'decimal.localcontext',
	'decimal.definir_contexte': 'decimal.setcontext',
	'diff.diff_contexte': 'difflib.context_diff',
	'diff.diff_unifie': 'difflib.unified_diff',
	'diff.obtenir_correspondances_proches': 'difflib.get_close_matches',
	'diff.restaurer': 'difflib.restore',
	'diff._calculer_ratio': 'difflib._calculate_ratio',
	'diff.calculer_ratio': 'difflib._calculate_ratio',
	'dill.verifier': 'dill.check',
	'dill.copier': 'dill.copy',
	'dill.sauvegarder': 'dill.dump',
	'dill.sauvegarder_module': 'dill.dump_module',
	'dill.sauvegarder_session': 'dill.dump_session',
	'dill.charger': 'dill.load',
	'dill.charger_module': 'dill.load_module',
	'dill.charger_session': 'dill.load_session',
	'dis.analyser': 'dis.dis',
	'dis.desassembler': 'dis.disassemble',
	'dis.info_code': 'dis.code_info',
	'dis.instructions': 'dis.get_instructions',
	'dis.montrer_code': 'dis.show_code',
	'dis.effet_pile': 'dis.stack_effect',
	'dis._trouver_importations': 'dis._find_imports',
	'dis.trouver_importations': 'dis._find_imports',
	'dis._desassembler_octets': 'dis._disassemble_bytes',
	'dis.desassembler_octets': 'dis._disassemble_bytes',
	'django.obtenir_version': 'django.get_version',
	'django.configuration': 'django.setup',
	'doctest.tester_module': 'doctest.testmod',
	'doctest.tester_fichier': 'doctest.testfile',
	'doctest.deboguer': 'doctest.debug',
	'doctest.source_test': 'doctest.testsource',
	'doctest._tester': 'doctest._test',
	'doctest.tester': 'doctest._test',
	'doctest._indenter': 'doctest._indent',
	'doctest.indenter': 'doctest._indent',
	'doctest.exemples_vers_script': 'doctest.script_from_examples',
	'email.message_depuis_fichier_binaire': 'email.message_from_binary_file',
	'email.message_depuis_octets': 'email.message_from_bytes',
	'email.message_depuis_fichier': 'email.message_from_file',
	'email.message_depuis_chaine': 'email.message_from_string',
	'encodages.normaliser_encodage': 'encodings.normalize_encoding',
	'encodages.rechercher_fonction': 'encodings.search_function',
	'ensurepip.amorce': 'ensurepip.bootstrap',
	'ensurepip._amorce': 'ensurepip._bootstrap',
	'ensurepip.version': 'ensurepip.version',
	'enum.unique': 'enum.unique',
	'enum.afficher_valeurs_drapeau': 'enum.show_flag_values',
	'enum._est_prive': 'enum._is_private',
	'enum.est_prive': 'enum._is_private',
	'flux.analyser': 'feedparser.parse',
	'flux.enregistrer_gestionnaire_date': 'feedparser.registerDateHandler',
	'comparaison_fichier.comparer': 'filecmp.cmp',
	'comparaison_fichier.comparer_fichiers': 'filecmp.cmpfiles',
	'comparaison_fichier.vider_cache': 'filecmp.clear_cache',
	'entree_fichier.entree': 'fileinput.input',
	'entree_fichier.fermer': 'fileinput.close',
	'entree_fichier.nom_fichier': 'fileinput.filename',
	'entree_fichier.num_ligne': 'fileinput.lineno',
	'entree_fichier.fichier_suivant': 'fileinput.nextfile',
	'flask.avorter': 'flask.abort',
	'flask.apres_cette_requete': 'flask.after_this_request',
	'flask.flasher': 'flask.flash',
	'flask.obtenir_messages_flash': 'flask.get_flashed_messages',
	'flask.jsonnifier': 'flask.jsonify',
	'flask.creer_reponse': 'flask.make_response',
	'flask.rediriger': 'flask.redirect',
	'flask.rendre_modele': 'flask.render_template',
	'flask.rendre_chaine_modele': 'flask.render_template_string',
	'flask.envoyer_fichier': 'flask.send_file',
	'flask.envoyer_depuis_dossier': 'flask.send_from_directory',
	'flask.url_pour': 'flask.url_for',
	'correspondance.filtrer': 'fnmatch.filter',
	'correspondance.fnmatch': 'fnmatch.fnmatch',
	'correspondance.traduire': 'fnmatch.translate',
	'fractions._arrondir_exposant': 'fractions._round_to_exponent',
	'fractions.arrondir_exposant': 'fractions._round_to_exponent',
	'frython.transpileur': 'frython.transpiler',
	'fsspec.systeme_fichiers': 'fsspec.filesystem',
	'fsspec.ouvrir': 'fsspec.open',
	'fsspec.ouvrir_fichiers': 'fsspec.open_files',
	'fsspec.protocoles_disponibles': 'fsspec.available_protocols',
	'fsspec.compressions_disponibles': 'fsspec.available_compressions',
	'fsspec.enregistrer_implementation': 'fsspec.register_implementation',
	'fonctions.cache': 'functools.cache',
	'fonctions.lru_cache': 'functools.lru_cache',
	'fonctions.reduire': 'functools.reduce',
	'fonctions.wraps': 'functools.wraps',
	'fonctions.envelopper': 'functools.wraps',
	'fonctions.mise_a_jour_enveloppe': 'functools.update_wrapper',
	'fonctions.ordre_total': 'functools.total_ordering',
	'fonctions.dispatch_unique': 'functools.singledispatch',
	'fonctions._trouver_impl': 'functools._find_impl',
	'fonctions.trouver_impl': 'functools._find_impl',
	'functorch.grad': 'functorch.grad',
	'functorch.hessienne': 'functorch.hessian',
	'functorch.vmap': 'functorch.vmap',
	'functorch.rendre_fonctionnel': 'functorch.make_functional',
}

METHODES_CHAINE = {
    'majuscule': 'upper',
    'minuscule': 'lower',
    'capitaliser': 'capitalize',
    'titrer': 'title',
    'remplacer': 'replace',
    'diviser': 'split',
    'joindre': 'join',
    'supprimer_espaces': 'strip',
    'supprimer_espaces_gauche': 'lstrip',
    'supprimer_espaces_droite': 'rstrip',
    'commencer_par': 'startswith',
    'finir_par': 'endswith',
    'trouver': 'find',
    'contient': '__contains__',
    'formater': 'format',
    'encoder': 'encode',
    'decoder': 'decode',
    'est_alpha': 'isalpha',
    'est_digit': 'isdigit',
    'est_alphanum': 'isalnum',
    'est_espace': 'isspace',
    'est_majuscule': 'isupper',
    'est_minuscule': 'islower',
    'compter': 'count',
    'indice': 'index',
    'est_numerique': 'isnumeric',
    'est_decimal': 'isdecimal',
    'est_titre': 'istitle',
    'centrer': 'center',
    'aligner_gauche': 'ljust',
    'aligner_droite': 'rjust',
    'remplir_zeros': 'zfill',
    'partitionner': 'partition',
    'expandre_tabs': 'expandtabs',
    'supprimer_prefixe': 'removeprefix',
    'supprimer_suffixe': 'removesuffix',
    'est_ascii': 'isascii',
    'est_identifiant': 'isidentifier',
    'est_imprimable': 'isprintable',
    'traduire': 'translate',
    'maketrans': 'maketrans',
    'rfind': 'rfind',
    'rindex': 'rindex',
    'rpartitionner': 'rpartition',
    'diviser_droite': 'rsplit',
    'diviser_lignes': 'splitlines',
    'formater_map': 'format_map',
    'compter_depuis': 'count',
    'compter_tout': 'count',
    'en_liste': 'split',
}

METHODES_LISTE = {
    'ajouter': 'append',
    'inserer': 'insert',
    'etendre': 'extend',
    'retirer': 'remove',
    'extraire': 'pop',
    'vider': 'clear',
    'copier': 'copy',
    'trier': 'sort',
    'inverser': 'reverse',
    'compter': 'count',
    'indice': 'index',
    'supprimer': 'remove',
    'effacer': 'clear',
    'annexer': 'append',
    'concatener': 'extend',
    'inserer_debut': 'insert',
    'premier': 'pop',
    'dernier': 'pop',
    'existe': '__contains__',
    'longueur': '__len__',
    'multiplier': '__mul__',
    'copie_profonde': 'copy',
    'remplir': 'fill',
    'remplir_avec': 'extend',
}

METHODES_DICT = {
    'cles': 'keys',
    'valeurs': 'values',
    'elements': 'items',
    'obtenir': 'get',
    'mettre_a_jour': 'update',
    'extraire': 'pop',
    'vider': 'clear',
    'copier': 'copy',
    'contient_cle': '__contains__',
    'effacer': 'clear',
    'fusionner': 'update',
    'extraire_defaut': 'setdefault',
    'extraire_dernier': 'popitem',
    'depuis_cles': 'fromkeys',
    'inverser': 'items',
    'longueur': '__len__',
    'contient': '__contains__',
    'obtenir_ou_creer': 'setdefault',
    'a_cle': 'has_key',
}

METHODES_ENSEMBLE = {
    'ajouter': 'add',
    'retirer': 'remove',
    'ecarter': 'discard',
    'union': 'union',
    'intersection': 'intersection',
    'difference': 'difference',
    'vider': 'clear',
    'copier': 'copy',
    'est_sous_ensemble': 'issubset',
    'est_sur_ensemble': 'issuperset',
    'difference_symetrique': 'symmetric_difference',
    'est_disjoint': 'isdisjoint',
    'mettre_a_jour': 'update',
    'geler': 'frozenset',
    'union_sur_place': 'update',
    'intersection_sur_place': 'intersection_update',
    'difference_sur_place': 'difference_update',
    'diff_sym_sur_place': 'symmetric_difference_update',
    'supprimer_si_existe': 'discard',
    'extraire_aleatoire': 'pop',
    'est_vide': '__len__',
}

MODULES_TRADUITS = {
    'mathématiques': 'math',
    'aleatoire': 'random',
    'systeme': 'sys',
    'systeme_exploitation': 'os',
    'temps': 'time',
    'datetime': 'datetime',
    'json': 'json',
    're': 're',
    'collections': 'collections',
    'itertools': 'itertools',
    'functools': 'functools',
    'pathlib': 'pathlib',
    'io': 'io',
    'copie': 'copy',
    'decimal_module': 'decimal',
    'fractions': 'fractions',
    'statistiques': 'statistics',
    'hashlib': 'hashlib',
    'base64': 'base64',
    'urllib': 'urllib',
    'http': 'http',
    'socket': 'socket',
    'threading': 'threading',
    'multiprocessing': 'multiprocessing',
    'subprocess': 'subprocess',
    'unittest': 'unittest',
    'logging': 'logging',
    'argparse': 'argparse',
    'configparser': 'configparser',
    'sqlite3': 'sqlite3',
    'mathematiques': 'math',
    'chemin': 'os.path',
    'date': 'datetime',
    'expression_reguliere': 're',
    'iterateurs': 'itertools',
    'fonctionnel': 'functools',
    'chemin_fichier': 'pathlib',
    'entree_sortie': 'io',
    'copie_profonde': 'deepcopy',
    'hachage': 'hashlib',
    'encodage': 'base64',
    'reseau': 'urllib',
    'fil': 'threading',
    'multiprocessus': 'multiprocessing',
    'sous_processus': 'subprocess',
    'tests': 'unittest',
    'journalisation': 'logging',
    'arguments': 'argparse',
    'configuration': 'configparser',
    'base_donnees': 'sqlite3',
    'csv': 'csv',
    'xml': 'xml',
    'html': 'html',
    'email': 'email',
    'compression': 'zipfile',
    'archive': 'tarfile',
    'chiffrement': 'cryptography',
    'interface': 'tkinter',
    'graphiques': 'matplotlib',
    'donnees': 'pandas',
    'calcul': 'numpy',
    'images': 'PIL',
    'web': 'requests',
    'async_io': 'asyncio',
    'signal': 'signal',
    'plateforme': 'platform',
    'inspection': 'inspect',
    'abstrait': 'abc',
    'types_donnees': 'typing',
    'enum': 'enum',
    'dataclasse': 'dataclasses',
    'contextlib': 'contextlib',
    'warnings': 'warnings',
    'traceback': 'traceback',
    'garbage': 'gc',
    'weakref': 'weakref',
    'struct': 'struct',
    'binaire_io': 'io',
    'uuid': 'uuid',
    'secret': 'secrets',
    'environnement': 'dotenv',
    'test_rapide': 'pytest',
    'tortue': 'turtle',
    'nombres': 'numbers',
    'couleur': 'colorsys',
    'decimal_precision': 'decimal',
	'ast_module': 'ast',
	'debogueur': 'pdb',
	'code_module': 'code',
	'collections_abc': 'collections.abc',
	'concurrent': 'concurrent.futures',
	'cryptographie': 'cryptography',
	'curses': 'curses',
	'difflib': 'difflib',
	'dis': 'dis',
	'doctest': 'doctest',
	'fichier_entree': 'fileinput',
	'fnmatch': 'fnmatch',	
	'formateur': 'formatter',
	'fractions': 'fractions',
	'ftplib': 'ftplib',
	'futur': '__future__',
	'gestionnaire_contexte': 'contextlib',
	'glob': 'glob',
	'grp': 'grp',
	'gzip': 'gzip',
	'heapq': 'heapq',
	'hmac': 'hmac',
	'html_analyse': 'html.parser',
	'http_client': 'http.client',
	'http_serveur': 'http.server',
	'imaplib': 'imaplib',
	'importlib': 'importlib',
	'ipaddress': 'ipaddress',
	'locale': 'locale',
	'lzma': 'lzma',
	'mailbox': 'mailbox',
	'marshal': 'marshal',
	'math': 'math',
	'mimetypes': 'mimetypes',
	'mmap': 'mmap',
	'msvcrt': 'msvcrt',
	'netrc': 'netrc',
	'nis': 'nis',
	'nntplib': 'nntplib',
	'nombres': 'numbers',
	'operateur': 'operator',
	'optparse': 'optparse',
	'os_chemin': 'os.path',
	'pickle': 'pickle',
	'pickletools': 'pickletools',
	'pipes': 'pipes',
	'pkgutil': 'pkgutil',
	'poplib': 'poplib',
	'pprint': 'pprint',
	'profil': 'cProfile',
	'pty': 'pty',
	'pwd': 'pwd',
	'py_compile': 'py_compile',
	'pydoc': 'pydoc',
	'queue': 'queue',
	'quopri': 'quopri',
	'readline': 'readline',
	'reprlib': 'reprlib',
	'rlcompleter': 'rlcompleter',
	'runpy': 'runpy',
	'sched': 'sched',
	'secrets': 'secrets',
	'select': 'select',
	'selectors': 'selectors',
	'shelve': 'shelve',
	'shlex': 'shlex',
	'shutil': 'shutil',
	'smtplib': 'smtplib',
	'sndhdr': 'sndhdr',
	'spwd': 'spwd',
	'sqlite': 'sqlite3',
	'ssl': 'ssl',
	'stat': 'stat',
	'statistiques_module': 'statistics',
	'string_module': 'string',
	'stringprep': 'stringprep',
	'tableau_module': 'array',
	'telnetlib': 'telnetlib',
	'tempfichier': 'tempfile',
	'terminal': 'tty',
	'textwrap': 'textwrap',
	'timeit': 'timeit',
	'tkinter_module': 'tkinter',
	'token': 'token',
	'tokenize': 'tokenize',
	'tomllib': 'tomllib',
	'trace': 'trace',
	'turtle_module': 'turtle',
	'turtledemo': 'turtledemo',
	'types_module': 'types',
	'unicodedata': 'unicodedata',
	'urllib_analyse': 'urllib.parse',
	'urllib_requete': 'urllib.request',
	'urllib_erreur': 'urllib.error',
	'uu': 'uu',
	'venv': 'venv',
	'wave': 'wave',
	'webbrowser': 'webbrowser',
	'winreg': 'winreg',
	'winsound': 'winsound',
	'wsgiref': 'wsgiref',
	'xdrlib': 'xdrlib',
	'xmlrpc': 'xmlrpc',
	'zipapp': 'zipapp',
	'zipimport': 'zipimport',
	'zlib': 'zlib',
	'zoneinfo': 'zoneinfo',
}

PYTHON_VERS_MOTS_CLES = {v: k for k, v in MOTS_CLES_VERS_PYTHON.items()}


class Transpileur:

    def __init__(self, source: str):
        self.source = source
        self.lignes = source.splitlines(keepends=True)

    def transpiler(self) -> str:
        resultat = []
        for ligne in self.lignes:
            resultat.append(self._transpiler_ligne(ligne))
        return ''.join(resultat)

    def _transpiler_ligne(self, ligne: str) -> str:
        stripped = ligne.lstrip()
        indentation = ligne[:len(ligne) - len(stripped)]
        if not stripped or stripped.startswith('#'):
            return ligne
        fin = '\n' if stripped.endswith('\n') else ''
        stripped = stripped.rstrip('\n')
        contenu = self._remplacer_tokens(stripped)
        return indentation + contenu + fin

    def _remplacer_tokens(self, code: str) -> str:
        parties = self._separer_chaines(code)
        resultat = []
        for est_chaine, partie in parties:
            if est_chaine:
                resultat.append(partie)
            else:
                resultat.append(self._remplacer_mots_cles(partie))
        return ''.join(resultat)

    def _separer_chaines(self, code: str):
        parties = []
        i = 0
        n = len(code)
        while i < n:
            char = code[i]
            if char in ('"', "'"):
                est_fstring = (i > 0 and code[i-1].lower() == 'f') or \
                              (i > 1 and code[i-2].lower() == 'f' and code[i-1] in 'rRbB')
                if code[i:i+3] in ('"""', "'''"):
                    delim = code[i:i+3]
                    fin = code.find(delim, i + 3)
                    if fin == -1:
                        contenu = code[i:]
                        i = n
                    else:
                        contenu = code[i:fin+3]
                        i = fin + 3
                else:
                    delim = char
                    j = i + 1
                    while j < n and code[j] != delim:
                        if code[j] == '\\':
                            j += 1
                        j += 1
                    contenu = code[i:j+1]
                    i = j + 1
                if est_fstring:
                    contenu = self._traduire_fstring(contenu)
                parties.append((True, contenu))
            else:
                j = i
                while j < n and code[j] not in ('"', "'"):
                    j += 1
                if j > i:
                    parties.append((False, code[i:j]))
                i = j
        return parties

    def _traduire_fstring(self, fstring: str) -> str:
        resultat = []
        i = 0
        n = len(fstring)
        while i < n:
            if fstring[i] == '{' and i + 1 < n and fstring[i+1] != '{':
                j = i + 1
                profondeur = 1
                while j < n and profondeur > 0:
                    if fstring[j] == '{':
                        profondeur += 1
                    elif fstring[j] == '}':
                        profondeur -= 1
                    j += 1
                expr = fstring[i+1:j-1]
                expr_traduit = self._remplacer_mots_cles(expr)
                resultat.append('{' + expr_traduit + '}')
                i = j
            else:
                resultat.append(fstring[i])
                i += 1
        return ''.join(resultat)

    def _remplacer_mots_cles(self, code: str) -> str:
        methodes_fusionnees = {}
        methodes_fusionnees.update(METHODES_ENSEMBLE)
        methodes_fusionnees.update(METHODES_DICT)
        methodes_fusionnees.update(METHODES_CHAINE)
        methodes_fusionnees.update(METHODES_LISTE)
        for fr, py in methodes_fusionnees.items():
            code = re.sub(r'\.' + re.escape(fr) + r'\b', '.' + py, code)
        for fr, py in MODULES_TRADUITS.items():
            code = re.sub(r'\b' + re.escape(fr) + r'\b', py, code)
        for fr, py in sorted(MOTS_CLES_VERS_PYTHON.items(), key=lambda x: -len(x[0])):
            code = re.sub(r'\b' + re.escape(fr) + r'\b', py, code)
        return code


def transpiler(source: str) -> str:
    t = Transpileur(source)
    return t.transpiler()
