Contenu

# Importer des modules Python

Les scripts Python de LibreOffice se déclinent en trois versions distinctes, ils peuvent être personnels, partagés ou intégrés dans des documents. Ils sont stockés à différents endroits décrits dans Python Scripts Organization and Location. Afin d'importer des modules Python, leurs emplacements doivent être connus depuis Python au moment de l'exécution.

Ce mécanisme est illustré pour les modules basés sur le système de fichiers et les modules basés sur les documents. La gestion des exceptions est omise par souci de clarté. Les termes bibliothèque ou répertoire, scripts ou modules sont utilisés de manière interchangeable. Une macro Python fait référence à une fonction dans un module.

Notez que <User Profile>/Scripts/python/pythonpath répertoire local est toujours exploré lors de l'exécution d'une macro Python de <User Profile>/Scripts/python.

## Import du module système de fichiers

Les bibliothèques LibreOffice Basic contiennent des classes, des routines et des variables, les modules Python contiennent des classes, des fonctions et des variables. Les éléments communs des fonctionnalités Python ou UNO réutilisables doivent être stockés dans Mes macros et boîtes de dialogue dans (User Profile)/Scripts/python/pythonpath. Les bibliothèques Python aident à organiser les modules afin d'éviter les collisions de noms de modules. Importez uno.py dans les modules partagés.

### Modules utilisateur ou partagés

Les scripts Python personnels et partagés peuvent être importés une fois que leurs répertoires sont inclus dans le chemin d'exécution Python. Reportez-vous à la page Obtenir des informations de session pour plus de détails sur la classe de session omise.

            # -*- coding: utf-8 -*-
            from __future__ import unicode_literals
            import sys

            user_lib = Session().UserPythonScripts  # emplacement des scripts utilisateur
            if not user_lib in sys.path:
                sys.path.insert(0, user_lib)  # Ajouter au chemin de recherche
            import screen_io as ui  # le module 'screen_io.py' module réside dans le répertoire user_lib
            # Votre code suit ici

Cet exemple Python expose une variable XSCRIPTCONTEXT locale à un module importé :

            # -*- coding: utf-8 -*-
            from __future__ import unicode_literals
            import uno, sys

            share_lib = Session.SharedPythonScripts()  # Emplacement des scripts partagés
            if not share_lib in sys.path:
                sys.path.insert(0, share_lib)  # Ajouter au chemin de recherche
            from IDE_utils import ScriptContext  # IDE_utils.py' se trouve avec les scripts Python partagés.
            XSCRIPTCONTEXT = ScriptContext(uno.getComponentContext)
            # Votre code suit ici

### Modules d'installation pour applications

Contrairement aux scripts personnels et partagés, les scripts d'installation de LibreOffice peuvent être importés à tout moment. À côté des modules LibreOffice Python uno & unohelper, les autres scripts présents dans le répertoire <installation_path>/program peuvent être importés directement, comme le module msgbox.

Avec le shell Python :

>>> import msgbox, uno

>>> myBox = msgbox.MsgBox(uno.getComponentContext())

>>> myBox.addButton("okay")

>>> myBox.renderFromButtonSize()

>>> myBox.numberOflines = 2

>>> print(myBox.show("A small message",0,"Dialog title"))

## Importation de modules de documents

L'import d'un module Python intégré au document est illustrée ci-dessous. La gestion des erreurs n'est pas détaillée. Le chemin d'exécution Python est mis à jour à l'ouverture du document et avant sa fermeture. Voir Event-Driven Macros pour savoir comment associer des macros Python pour documenter des événements.

            # -*- coding: utf-8 -*-
            from __future__ import unicode_literals

            import sys, uno

            def OnDocPostOpenLoadPython():
                """ Prepare l'import des modules Python pendant que le doc. charge """
                PythonLibraries.loadLibrary('lib/subdir')  # Ajoute le dossier au chemin de recherche
                PythonLibraries.loadLibrary('my_gui', 'screen_io')  #Ajoute le répertoire  & importe screen_io

            def OnDocQueryCloseUnloadPython():
                """ Nettoie PYTHON_PATH quand doc.fermé """
                PythonLibraries.unloadLibrary('my_gui')  # Python runtime path cleanup
                # Note: les modules importés restent chargés dans cet exemple

            class PythonLibraries():
                """ chargeur de bibliothèque Python et importation de modules

                adapté depuis'Bibliothèque de fonctions' parHubert Lambert
                à https://forum.openoffice.org/fr/forum/viewtopic.php?p=286213 """
                def isImportedModule(module_name: str) -> bool:
                    """ Check run time module list """
                    return (module_name in sys.modules.keys())
                def isLoadedLibrary(lib_name: str) -> bool:
                    """ Vérifie le contenu de PYTHON_PATH """
                    return (lib_name in sys.path)
                def loadLibrary(lib_name: str, module_name=None):
                    """ ajoute le répertoire à  PYTHON_PATH, importe le module nommé"""
                    doc = XSCRIPTCONTEXT.getDocument()
                    url = uno.fileUrlToSystemPath(
                        '{}/{}'.format(doc.URL,'Scripts/python/'+lib_name)
                    if not url in sys.path:
                        sys.path.insert(0, url)
                    if module_name and not module_name in sys.modules.keys():
                        return zipimport.zipimporter(url).load_module(module_name)
                def unloadLibrary(lib_name: str):
                    """supprime le répertoire de PYTHON_PATH """
                    sys.path.remove(lib_name)

            g_exportedScripts = (OnDocPostOpenLoadPython, OnDocQueryCloseUnloadPython)

Rubriques connexes

Obtenir les informations de la session

Programmer avec des Scripts Python

Organisation et emplacement des Scripts Python

Voir Creating a Python Listener pour des exemples de macros événementielles.