pythonnet/pythonnet

Ivan Diep

@idiep_gitlab

Does anyone know how to build pythonnet to obtain clr.pyd on Ubuntu? I'm able to build the .whl file, which gives me a clr.cpython-38-x86_64-linux-gnu.so and Python.Runtime.dll, but I'm looking for a clr.pyd. Any help on this would be appreciated.

William Roseberry

@RoseberryPi

I'm running PythonNet from a Blazor project, when I run the project using IIS, pythonnet works as expected. When running the Blazor app using Kestrel PythonNet no longer works. Any ideas why this could be?

zergmk2

@zergmk2

I'm running PythonNet from a Blazor project, when I run the project using IIS, pythonnet works as expected. When running the Blazor app using Kestrel PythonNet no longer works. Any ideas why this could be?

You can check if the environment variable set in IIS and kestrel are different.

I'm trying to run the pythonnet with .net5 under MacOS now, when I run the sample code in github readme file, I found there were many space in the result.

above is the source code

elTRexx

@elTRexx

Hi again.
Well After testing and trying pythonnet a little bit, here I am :

///Kept all my empirical previous testing in comment
class Program
    {
        static string _scriptsPath = @"C:\.....\ConsoleApp_TestPythonNet\Scripts";

        static string[] _pyExts = { ".py" };

        static void Main(string[] args)
        {
            Console.WriteLine("In C#");

            //string before = Environment.GetEnvironmentVariable("PATH", EnvironmentVariableTarget.Process);

            //Console.WriteLine("PATH (process): " + before);

            PythonSetupEnv.AddModulePath(_scriptsPath);
            PythonSetupEnv.UpdateEnvPaths();

            //Console.WriteLine("------------------------------------");

            //string after = Environment.GetEnvironmentVariable("PATH", EnvironmentVariableTarget.Process);

            //Console.WriteLine("PATH (process): " + after);

            //Environment.SetEnvironmentVariable("PYTHONPATH", _scriptsPath, EnvironmentVariableTarget.Process);

            //var bf = before.Split(Path.PathSeparator);

            //var af = after.Split(Path.PathSeparator);

            //string[] res;

            //if (bf.Length > af.Length)
            //    res = bf.Except(af).ToArray();
            //else
            //    res = af.Except(bf).ToArray();

            //Console.WriteLine("------------------------------------");
            //foreach (var p in res)
            //    Console.WriteLine(" - " + p);
            //Console.ReadKey();

            using (Py.GIL())
            {
                //Console.WriteLine("PYTHONPATH (process): " + Environment.GetEnvironmentVariable("PYTHONPATH", EnvironmentVariableTarget.Process));              

                //PythonSetupEnv.AddModulePath(_scriptsPath);

                //PythonSetupEnv.UpdateEnvPaths();

                //PythonEngine.RunSimpleString("import sys;print(sys.path)");

                //Console.ReadKey();

                //Console.WriteLine("PYTHONPATH (process): " + Environment.GetEnvironmentVariable("PYTHONPATH", EnvironmentVariableTarget.Process));

                //PythonEngine.RunSimpleString("import sys;print(sys.path)");

                //Console.ReadKey();                

                //PythonEngine.Exec(FileUtilities.GetStringCodeFromFile(_filepath, _pyExts));

                PythonEngine.Initialize();
                using (PyScope scope = Py.CreateScope())
                {
                    string code = FileUtilities.GetStringCodeFromFile(_scriptsPath+@"\poc.py", _pyExts);

                    var scriptCompiled = PythonEngine.Compile(code);

                    scope.Execute(scriptCompiled);

                    //dynamic pocPy = Py.Import("poc");

                    //dynamic pocPy = scope.Import("poc");

                    //var pocPy = PythonEngine.ImportModule("poc");
                    //scope.Execute(pocPy);

                    dynamic func = scope.Get("PrintInput");
                    dynamic res = func();

                    dynamic inputText = scope.Get("InputText");

                    Console.WriteLine("Inside C# code : "+inputText.ToString());
                }
            }

            Console.ReadKey();
        }
    }
}

For completeness the rest of my code (not important here, if is just utility class to read code from .py file, and setup the Environment Variables (PATH, PYTHONHOME and PYTHONPATH) :

class FileUtilities
    {
        public static string GetStringCodeFromFile(string filepath, string[] ext)
        {
            /// if we have an existing file with a correct extension
            if (!string.IsNullOrEmpty(filepath) && File.Exists(filepath) && ext != null && ext.Length > 0 && ext.Contains(Path.GetExtension(filepath)))
                return File.ReadAllText(filepath);
            return null;
        }
    }

elTRexx

@elTRexx

public class PythonSetupEnv
    {
        private static Dictionary<string, List<string>> _pythonEnvPaths;

        private static string _pythonPath;

        public static Dictionary<string, List<string>> PythonEnvPaths
        {
            get
            {
                if (_pythonEnvPaths == null || _pythonEnvPaths.Count < 3)
                    _pythonEnvPaths = InitEnvPathsDict(_pythonPath);
                return _pythonEnvPaths;
            }
            set => _pythonEnvPaths = value;
        }

        public static string PythonPath { get => _pythonPath; set => _pythonPath = value; }

        private static string KeysToString()
        {
            string result = "";
            foreach (var key in PythonEnvPaths.Keys)
                result += (key + " ");
            return result;
        }

        private static List<string> ParseEnvPaths(string rawPaths, char separator)
        {
            if (rawPaths != null)
                return rawPaths.Split(new char[1] { separator }).ToList();
            else
                return new List<string>();
        }

        /// <summary>
        /// Standard Environment Variable Initialisation, from a given Python directory path, or not
        /// </summary>
        /// <param name="path">The path to the pythyon directory</param>
        /// <returns></returns>
        private static Dictionary<string, List<string>> InitEnvPathsDict(string path = null)
        {
            var alreadyDefinedPATH = ParseEnvPaths(Environment.GetEnvironmentVariable("PATH", EnvironmentVariableTarget.Machine), Path.PathSeparator);
            alreadyDefinedPATH = alreadyDefinedPATH.Union(ParseEnvPaths(Environment.GetEnvironmentVariable("PATH", EnvironmentVariableTarget.Process), Path.PathSeparator)).ToList();
            alreadyDefinedPATH = alreadyDefinedPATH.Union(ParseEnvPaths(Environment.GetEnvironmentVariable("PATH", EnvironmentVariableTarget.User), Path.PathSeparator)).ToList();

            var envDict = new Dictionary<string, List<string>>() {
                { "PATH", alreadyDefinedPATH },
                { "PYTHONHOME", ParseEnvPaths(Environment.GetEnvironmentVariable("PYTHONHOME", EnvironmentVariableTarget.Machine), Path.PathSeparator) },
                { "PYTHONPATH", ParseEnvPaths(Environment.GetEnvironmentVariable("PYTHONPATH", EnvironmentVariableTarget.Machine), Path.PathSeparator) }
            };
            if (path != null && Directory.Exists(path))
            {
                try
                {
                    //PATH
                    AddEnvPath("PATH", path, envDict);
                    //PYTHONHOME
                    AddEnvPath("PYTHONHOME", path, envDict);
                    //PYTHONPATH
                    AddEnvPath("PYTHONPATH", Path.Combine(path, "Lib"), envDict);
                    AddEnvPath("PYTHONPATH", Path.Combine(path, "Lib", "site-packages"), envDict);
                    AddEnvPath("PYTHONPATH", Path.Combine(path, "DLLs"), envDict);
                }
                catch (Exception e) { Console.WriteLine(e.Message); }
            }
            return envDict;
        }

        /// <summary>
        /// Add a custom module | script to look for
        /// </summary>
        /// <param name="path">The path to the script, library / directory</param>
        public static void AddModulePath(string path)
        {
            try
            {
                AddEnvPath("PYTHONPATH", path);
            }
            catch(Exception e) { Console.WriteLine(e.Message); }
        }
        ...... -->

<-- ......
public static void AddEnvPath(string envKey, string envPath, Dictionary<string, List<string>> dict = null)
        {
            if (dict == null)
                dict = @PythonEnvPaths;
            if (!Directory.Exists(envPath))
                throw new DirectoryNotFoundException("Incorect path to this directory : " + envPath);
            if (!dict.ContainsKey(envKey))
                throw new KeyNotFoundException(envKey + " is not a correct environment key. Allowed ones are : " + KeysToString());
            if (!dict[envKey].Contains(envPath)) dict[envKey].Add(envPath);

        }

        public static void UpdateEnvPaths()
        {
            string envPath = null;

            foreach (var env in PythonEnvPaths)
            {
                //foreach (var path in env.Value.FindAll(x => Directory.Exists(x)))
                foreach (var path in env.Value)
                {
                    envPath = envPath + Path.PathSeparator.ToString() + path;
                }

                //trim first path separator
                if (!string.IsNullOrEmpty(envPath))
                    envPath = envPath.Substring(1);

                Environment.SetEnvironmentVariable(env.Key, envPath, EnvironmentVariableTarget.Process);
                envPath = null; 
            }
        }
    }

elTRexx

@elTRexx

#poc.py
print("Inside Python poc.py")

InputText = "Python Text"

def PrintInput():
    print("inside poc.py PrintInput function : " + InputText)

#PrintInput()

So As you can see I tried

to loop up my script using PYTHONPATH environment variable setup before (that worked)
executing that script using dynamic pocPy = Py.Import("poc")
calling a python func from C# usign pocPy.PrintInput() (that worked)

But now when I want to "play" with my python variables / function from C# usign dynamic pocPy = Py.Import("poc") doesn't help me.
After looking on this I found some code example leading me to my current state :

PythonEngine.Initialize();
using (PyScope scope = Py.CreateScope())
{

                    string code = FileUtilities.GetStringCodeFromFile(_scriptsPath+@"\poc.py", _pyExts);

                    var scriptCompiled = PythonEngine.Compile(code);

                    scope.Execute(scriptCompiled);

                    dynamic func = scope.Get("PrintInput");
                    dynamic res = func();

                    dynamic inputText = scope.Get("InputText");

                    Console.WriteLine("Inside C# code : "+inputText.ToString());
}

So yeah that work, but I don't get back the more "elegant" way I was using before with environment variables to just "import" a script .
Doesn't it be possible to play with "scope" variable like I did finally, but using Py.Import() (or something similar involving scope I suppose) ?

Amaury Levé

@Evangelink

Hi there,
Sorry for the stupid question but I am pretty new to your tool and I can't find any help (looked at SO and issues) about converting a numpy array into a c# collection. This thread seems to be the closestpythonnet/pythonnet#623

LuckyGuySam

@LuckGuySam

Hi, I try to use C# call python with pythonnet. I need to switch the python visual env, but after PythonEngine.Initialize() I can't change my visual env. How can I do? Can I initialize a lot of python visual env and switch when I need ?

Andy Salerno

@andysalerno:matrix.org

Where communities thrive

People

Repo info

Activity