python_scripting.h File Reference

#include <Python.h>
#include <wx/string.h>
#include <wx/arrstr.h>

Go to the source code of this file.

Classes
class	PyLOCK

Functions
bool	pcbnewInitPythonScripting (const char *aStockScriptingPath, const char *aUserScriptingPath)
	Initialize the Python engine inside pcbnew. More...
void	pcbnewFinishPythonScripting ()
void	pcbnewGetUnloadableScriptNames (wxString &aNames)
	Collect the list of python scripts which could not be loaded. More...
void	pcbnewGetScriptsSearchPaths (wxString &aNames)
	Collect the list of paths where python scripts are searched. More...
void	pcbnewGetWizardsBackTrace (wxString &aNames)
	Return the backtrace of errors (if any) when wizard python scripts are loaded. More...
void	pcbnewUpdatePythonEnvVar (const wxString &aVar, const wxString &aValue)
	Set an environment variable in the current Python interpreter. More...
bool	IsWxPythonLoaded ()
wxString	PyStringToWx (PyObject *str)
wxArrayString	PyArrayStringToWx (PyObject *arr)
wxString	PyErrStringWithTraceback ()
wxString	PyScriptingPath (bool aUserPath=false)
	Find the Python scripting path. More...
wxString	PyPluginsPath (bool aUserPath=false)

Function Documentation

IsWxPythonLoaded()

bool IsWxPythonLoaded

(

)

Definition at line 77 of file python_scripting.cpp.

{
    return wxPythonLoaded;
}

References wxPythonLoaded.

Referenced by PCB::IFACE::OnKifaceEnd(), PCB_EDIT_FRAME::ReCreateHToolbar(), and PCB_EDIT_FRAME::setupUIConditions().

pcbnewFinishPythonScripting()

void pcbnewFinishPythonScripting

(

)

Definition at line 365 of file python_scripting.cpp.

{
#ifdef KICAD_SCRIPTING_WXPYTHON
    PyEval_RestoreThread( g_PythonMainTState );
#endif
    Py_Finalize();
}

References g_PythonMainTState.

Referenced by PCB::IFACE::OnKifaceEnd().

pcbnewGetScriptsSearchPaths()

void pcbnewGetScriptsSearchPaths

(

wxString &

aNames

)

Collect the list of paths where python scripts are searched.

Parameters

aNames

is a wxString which will contain the paths (separated by ' ')

Definition at line 331 of file python_scripting.cpp.

{
    pcbnewRunPythonMethodWithReturnedString( "pcbnew.GetWizardsSearchPaths", aNames );
}

References pcbnewRunPythonMethodWithReturnedString().

pcbnewGetUnloadableScriptNames()

void pcbnewGetUnloadableScriptNames

(

wxString &

aNames

)

Collect the list of python scripts which could not be loaded.

Parameters

aNames

is a wxString which will contain the filenames (separated by ' ')

Definition at line 325 of file python_scripting.cpp.

{
    pcbnewRunPythonMethodWithReturnedString( "pcbnew.GetUnLoadableWizards", aNames );
}

References pcbnewRunPythonMethodWithReturnedString().

pcbnewGetWizardsBackTrace()

void pcbnewGetWizardsBackTrace

(

wxString &

aNames

)

Return the backtrace of errors (if any) when wizard python scripts are loaded.

Parameters

aNames

is a wxString which will contain the trace

Definition at line 337 of file python_scripting.cpp.

{
    pcbnewRunPythonMethodWithReturnedString( "pcbnew.GetWizardsBackTrace", aTrace );

    // Filter message before displaying them
    // a trace starts by "Traceback" and is followed by 2 useless lines
    // for our purpose
    wxArrayString traces;
    wxStringSplit( aTrace, traces, '\n' );

    // Build the filtered message (remove useless lines)
    aTrace.Clear();

    for( unsigned ii = 0; ii < traces.Count(); ++ii )
    {
        if( traces[ii].Contains( "Traceback" ) )
        {
            ii += 2; // Skip this line and next lines which are related to pcbnew.py module

            if( !aTrace.IsEmpty() ) // Add separator for the next trace block
                aTrace << "\n**********************************\n";
        }
        else
            aTrace += traces[ii] + "\n";
    }
}

References pcbnewRunPythonMethodWithReturnedString(), and wxStringSplit().

pcbnewInitPythonScripting()

bool pcbnewInitPythonScripting	(	const char *	aStockScriptingPath,
		const char *	aUserScriptingPath
	)

Initialize the Python engine inside pcbnew.

Initialize the Python engine inside pcbnew.

This initializes all the wxPython interface and returns the python thread control structure

Definition at line 162 of file python_scripting.cpp.

{
    int  retv;
    char cmd[1024];

    swigAddBuiltin();           // add builtin functions
    swigAddModules();           // add our own modules
    swigSwitchPythonBuiltin();  // switch the python builtin modules to our new list

#ifdef _MSC_VER
    // Under vcpkg/msvc, we need to explicitly set the python home
    // or else it'll start consuming system python registry keys and the like instead
    // We are going to follow the "unix" layout for the msvc/vcpkg distributions so exes in /root/bin
    // And the python lib in /root/lib/python3(/Lib,/DLLs)
    wxFileName pyHome;

    pyHome.Assign( Pgm().GetExecutablePath() );

    pyHome.Normalize();

    // MUST be called before Py_Initialize so it will to create valid default lib paths
    if( !wxGetEnv( wxT( "KICAD_RUN_FROM_BUILD_DIR" ), nullptr ) )
    {
        Py_SetPythonHome( pyHome.GetFullPath().c_str() );
    }
#endif

    Py_Initialize();
    PySys_SetArgv( Pgm().App().argc, Pgm().App().argv );

#ifdef KICAD_SCRIPTING_WXPYTHON

#if PY_VERSION_HEX < 0x03070000  // PyEval_InitThreads() is called by Py_Initialize() starting with version 3.7
    PyEval_InitThreads();
#endif      // if PY_VERSION_HEX < 0x03070000

#ifndef KICAD_SCRIPTING_WXPYTHON_PHOENIX
#ifndef __WINDOWS__   // import wxversion.py currently not working under winbuilder, and not useful.
    // Make sure that that the correct version of wxPython is loaded. In systems where there
    // are different versions of wxPython installed this can lead to select wrong wxPython
    // version being selected.
    snprintf( cmd, sizeof( cmd ), "import wxversion;  wxversion.select( '%s' )", WXPYTHON_VERSION );

    retv = PyRun_SimpleString( cmd );

    if( retv != 0 )
    {
        wxLogError( "Python error %d occurred running command:\n\n`%s`", retv, cmd );
        return false;
    }
#endif      // ifndef __WINDOWS__

    // Load the wxPython core API.  Imports the wx._core_ module and sets a
    // local pointer to a function table located there.  The pointer is used
    // internally by the rest of the API functions.
    if( !wxPyCoreAPI_IMPORT() )
    {
        wxLogError( "***** Error importing the wxPython API! *****" );
        PyErr_Print();
        Py_Finalize();
        return false;
    }
#endif      // ifndef KICAD_SCRIPTING_WXPYTHON_PHOENIX

#if defined( DEBUG )
    RedirectStdio();
#endif

    wxPythonLoaded = true;

    // Save the current Python thread state and release the
    // Global Interpreter Lock.
    g_PythonMainTState = PyEval_SaveThread();

#endif  // ifdef KICAD_SCRIPTING_WXPYTHON

    // Load pcbnew inside Python and load all the user plugins and package-based plugins
    {
        PyLOCK lock;

        // Load os so that we can modify the environment variables through python
        snprintf( cmd, sizeof( cmd ), "import sys, os, traceback\n"
                  "sys.path.append(\".\")\n"
                  "import pcbnew\n"
                  "pcbnew.LoadPlugins(\"%s\", \"%s\")",
                  aStockScriptingPath, aUserScriptingPath );
        retv = PyRun_SimpleString( cmd );

        if( retv != 0 )
            wxLogError( "Python error %d occurred running command:\n\n`%s`", retv, cmd );
    }

    return true;
}

References g_PythonMainTState, Pgm(), swigAddBuiltin(), swigAddModules(), swigSwitchPythonBuiltin(), and wxPythonLoaded.

pcbnewUpdatePythonEnvVar()

void pcbnewUpdatePythonEnvVar	(	const wxString &	aVar,
		const wxString &	aValue
	)

Set an environment variable in the current Python interpreter.

Parameters

aVar	is the variable to set
aValue	is the value to give it

Definition at line 394 of file python_scripting.cpp.

{
    char cmd[1024];

    // Ensure the interpreter is initalized before we try to interact with it
    if( !Py_IsInitialized() )
        return;

    wxLogTrace( traceEnvVars, "pcbnewUpdatePythonEnvVar: Updating Python variable %s = %s",
                aVar, aValue );

    wxString escapedVar = PyEscapeString( aVar );
    wxString escapedVal = PyEscapeString( aValue );

    snprintf( cmd, sizeof( cmd ),
              "# coding=utf-8\n"      // The values could potentially be UTF8
              "os.environ[\"%s\"]=\"%s\"\n",
              TO_UTF8( escapedVar ),
              TO_UTF8( escapedVal ) );

    PyLOCK lock;

    int retv = PyRun_SimpleString( cmd );

    if( retv != 0 )
        wxLogError( "Python error %d occurred running command:\n\n`%s`", retv, cmd );
}

References PyEscapeString(), TO_UTF8, and traceEnvVars.

Referenced by PCB_EDIT_FRAME::PythonSyncEnvironmentVariables(), and PCB_EDIT_FRAME::PythonSyncProjectName().

PyArrayStringToWx()

wxArrayString PyArrayStringToWx

(

PyObject *

arr

)

Definition at line 572 of file python_scripting.cpp.

{
    wxArrayString   ret;

    if( !aArrayString )
        return ret;

    int list_size = PyList_Size( aArrayString );

    for( int n = 0; n < list_size; n++ )
    {
        PyObject* element = PyList_GetItem( aArrayString, n );

        if( element )
        {
#if PY_MAJOR_VERSION >= 3
            const char* str_res = NULL;
            PyObject* temp_bytes = PyUnicode_AsEncodedString( element, "UTF-8", "strict" );

            if( temp_bytes != NULL )
            {
                str_res = PyBytes_AS_STRING( temp_bytes );
                ret.Add( FROM_UTF8( str_res ), 1 );
                Py_DECREF( temp_bytes );
            }
            else
            {
                wxLogMessage( "cannot encode unicode python string" );
            }
#else
            ret.Add( FROM_UTF8( PyString_AsString( element ) ), 1 );
#endif
        }
    }

    return ret;
}

References FROM_UTF8(), and NULL.

Referenced by PYTHON_FOOTPRINT_WIZARD::CallRetArrayStrMethod(), and PyErrStringWithTraceback().

PyErrStringWithTraceback()

wxString PyErrStringWithTraceback

(

)

Definition at line 611 of file python_scripting.cpp.

{
    wxString err;

    if( !PyErr_Occurred() )
        return err;

    PyObject*   type;
    PyObject*   value;
    PyObject*   traceback;

    PyErr_Fetch( &type, &value, &traceback );

    PyErr_NormalizeException( &type, &value, &traceback );

    if( traceback == NULL )
    {
        traceback = Py_None;
        Py_INCREF( traceback );
    }

#if PY_MAJOR_VERSION >= 3
    PyException_SetTraceback( value, traceback );

    PyObject* tracebackModuleString = PyUnicode_FromString( "traceback" );
#else
    PyObject* tracebackModuleString = PyString_FromString( "traceback" );
#endif
    PyObject* tracebackModule = PyImport_Import( tracebackModuleString );
    Py_DECREF( tracebackModuleString );

    PyObject* formatException = PyObject_GetAttrString( tracebackModule,
                                                        "format_exception" );
    Py_DECREF( tracebackModule );

    PyObject* args = Py_BuildValue( "(O,O,O)", type, value, traceback );
    PyObject* result = PyObject_CallObject( formatException, args );
    Py_XDECREF( formatException );
    Py_XDECREF( args );
    Py_XDECREF( type );
    Py_XDECREF( value );
    Py_XDECREF( traceback );

    wxArrayString res = PyArrayStringToWx( result );

    for( unsigned i = 0; i<res.Count(); i++ )
    {
        err += res[i] + wxT( "\n" );
    }

    PyErr_Clear();

    return err;
}

References NULL, and PyArrayStringToWx().

Referenced by PYTHON_ACTION_PLUGIN::CallMethod(), PYTHON_FOOTPRINT_WIZARD::CallMethod(), and pcbnewRunPythonMethodWithReturnedString().

PyPluginsPath()

wxString PyPluginsPath

(

bool

aUserPath = false

)

Definition at line 697 of file python_scripting.cpp.

{
    // Note we are using unix path separator, because window separator sometimes
    // creates issues when passing a command string to a python method by PyRun_SimpleString
    return PyScriptingPath( aUserPath ) + '/' + "plugins";
}

References PyScriptingPath().

Referenced by PCB_EDIT_FRAME::PythonPluginsShowFolder().

PyScriptingPath()

wxString PyScriptingPath

(

bool

aUserPath = false

)

Find the Python scripting path.

Definition at line 670 of file python_scripting.cpp.

{
    wxString path;

    //@todo This should this be a user configurable variable eg KISCRIPT?
    if( aUserPath )
    {
        path = PATHS::GetUserScriptingPath();
    }
    else
    {
        path = PATHS::GetStockScriptingPath();
    }

    wxFileName scriptPath( path );
    scriptPath.MakeAbsolute();

    // Convert '\' to '/' in path, because later python script read \n or \r
    // as escaped sequence, and create issues, when calling it by PyRun_SimpleString() method.
    // It can happen on Windows.
    path = scriptPath.GetFullPath();
    path.Replace( '\\', '/' );

    return path;
}

References PATHS::GetStockScriptingPath(), PATHS::GetUserScriptingPath(), and path.

Referenced by PyPluginsPath(), and PythonPluginsReloadBase().

PyStringToWx()

wxString PyStringToWx

(

PyObject *

str

)

Definition at line 542 of file python_scripting.cpp.

{
    wxString    ret;

    if( !aString )
        return ret;

#if PY_MAJOR_VERSION >= 3
    const char* str_res = NULL;
    PyObject* temp_bytes = PyUnicode_AsEncodedString( aString, "UTF-8", "strict" );

    if( temp_bytes != NULL )
    {
        str_res = PyBytes_AS_STRING( temp_bytes );
        ret = FROM_UTF8( str_res );
        Py_DECREF( temp_bytes );
    }
    else
    {
        wxLogMessage( "cannot encode unicode python string" );
    }
#else
    const char* str_res = PyString_AsString( aString );
    ret = FROM_UTF8( str_res );
#endif

    return ret;
}

References FROM_UTF8(), and NULL.

Referenced by PYTHON_ACTION_PLUGIN::CallRetStrMethod(), PYTHON_FOOTPRINT_WIZARD::CallRetStrMethod(), and PYTHON_FOOTPRINT_WIZARD::GetParameterPageName().