Initialize() public static method

Initialize Method
Initialize the Python runtime. It is safe to call this method more than once, though initialization will only happen on the first call. It is *not* necessary to hold the Python global interpreter lock (GIL) to call this method.
public static Initialize ( ) : void
return void
Exemplo n.º 1
0
        public static GILState GIL()
        {
            if (!PythonEngine.IsInitialized)
            {
                PythonEngine.Initialize();
            }

            return(new GILState());
        }
Exemplo n.º 2
0
        public static int Main(string[] args)
        {
            string [] cmd = Environment.GetCommandLineArgs();
            PythonEngine.Initialize();

            int i = Runtime.Py_Main(cmd.Length, cmd);

            PythonEngine.Shutdown();

            return(i);
        }
Exemplo n.º 3
0
        public static int Main(string[] args)
        {
            // reference the static assemblyLoader to stop it being optimized away
            AssemblyLoader a = assemblyLoader;

            string[] cmd = Environment.GetCommandLineArgs();
            PythonEngine.Initialize();

            int i = Runtime.Py_Main(cmd.Length, cmd);

            PythonEngine.Shutdown();

            return(i);
        }
Exemplo n.º 4
0
        public static int Main(string[] args)
        {
            // Only net40 is capable to safely inject python.runtime.dll into resources.
#if NET40
            // reference the static assemblyLoader to stop it being optimized away
            AssemblyLoader a = assemblyLoader;
#endif
            string[] cmd = Environment.GetCommandLineArgs();
            PythonEngine.Initialize();

            int i = Runtime.Py_Main(cmd.Length, cmd);
            PythonEngine.Shutdown();

            return(i);
        }
Exemplo n.º 5
0
        private object ExecutePythonScriptCode(string code)
        {
            Python.Included.Installer.SetupPython().Wait();

            if (!PythonEngine.IsInitialized)
            {
                PythonEngine.Initialize();
                PythonEngine.BeginAllowThreads();
            }

            using (Py.GIL())
            {
                var result = Scope.Eval(code);
                return(CPythonEvaluator.OutputMarshaler.Marshal(result));
            }
        }
Exemplo n.º 6
0
 public void Dispose()
 {
     if (Scope != null)
     {
         if (!PythonEngine.IsInitialized)
         {
             PythonEngine.Initialize();
             PythonEngine.BeginAllowThreads();
         }
         try
         {
             using (Py.GIL())
             {
                 Scope.Dispose();
             }
         }
         catch {}
     }
 }
Exemplo n.º 7
0
        public DSCPythonCodeCompletionProviderCore()
        {
            VariableTypes = new Dictionary <string, Type>();
            ImportedTypes = new Dictionary <string, Type>();
            ClrModules    = new HashSet <string>();
            BadStatements = new Dictionary <string, int>();
            Guid pythonScopeGUID = Guid.NewGuid();

            uniquePythonScopeName += pythonScopeGUID.ToString();

            // Special case for python variables defined as null
            ImportedTypes["None"] = null;

            BasicVariableTypes = new List <Tuple <Regex, Type> >();

            BasicVariableTypes.Add(Tuple.Create(STRING_VARIABLE, typeof(PyString)));
            BasicVariableTypes.Add(Tuple.Create(DOUBLE_VARIABLE, typeof(PyFloat)));
            BasicVariableTypes.Add(Tuple.Create(INT_VARIABLE, typeof(PyInt)));
            BasicVariableTypes.Add(Tuple.Create(LIST_VARIABLE, typeof(PyList)));
            BasicVariableTypes.Add(Tuple.Create(DICT_VARIABLE, typeof(PyDict)));

            if (!PythonEngine.IsInitialized)
            {
                PythonEngine.Initialize();
                PythonEngine.BeginAllowThreads();
            }

            try
            {
                using (Py.GIL())
                {
                    if (GlobalScope == null)
                    {
                        GlobalScope = CreateGlobalScope();
                    }

                    if (Scope == null)
                    {
                        Scope = CreateUniquePythonScope();
                    }

                    var assemblies = AppDomain.CurrentDomain.GetAssemblies();

                    // Determine if the Revit API is available in the given context
                    if (assemblies.Any(x => x.GetName().Name == "RevitAPI"))
                    {
                        // Try to load Revit Type for autocomplete
                        try
                        {
                            var revitImports =
                                "import clr\nclr.AddReference('RevitAPI')\nclr.AddReference('RevitAPIUI')\nfrom Autodesk.Revit.DB import *\nimport Autodesk\n";

                            Scope.Exec(revitImports);

                            ClrModules.Add("RevitAPI");
                            ClrModules.Add("RevitAPIUI");
                        }
                        catch
                        {
                            Log("Failed to load Revit types for autocomplete. Python autocomplete will not see Autodesk namespace types.");
                        }
                    }

                    // Determine if the ProtoGeometry is available in the given context
                    if (assemblies.Any(x => x.GetName().Name == "ProtoGeometry"))
                    {
                        // Try to load ProtoGeometry Type for autocomplete
                        try
                        {
                            var libGImports =
                                "import clr\nclr.AddReference('ProtoGeometry')\nfrom Autodesk.DesignScript.Geometry import *\n";

                            Scope.Exec(libGImports);
                            ClrModules.Add("ProtoGeometry");
                        }
                        catch (Exception e)
                        {
                            Log(e.ToString());
                            Log("Failed to load ProtoGeometry types for autocomplete. Python autocomplete will not see Autodesk namespace types.");
                        }
                    }

                    // PythonNet evaluates basic types as Python native types:
                    // Ex: a = ""
                    // type(a) will have the value {class str} and not the clr System.String
                    //
                    // Populate the basic types after python is initialized
                    // These instance types will correspond to Python basic types (no clr)
                    // ex. PyString("") => Python's {class str}
                    // PyInt(0) => Python's {class int}
                    basicPyObjects = new Dictionary <Type, PyObject>();
                    basicPyObjects[typeof(PyString)] = new PyString("");
                    basicPyObjects[typeof(PyFloat)]  = new PyFloat(0);
                    basicPyObjects[typeof(PyInt)]    = new PyInt(0);
                    basicPyObjects[typeof(PyList)]   = new PyList();
                    basicPyObjects[typeof(PyDict)]   = new PyDict();
                }
            }
            catch {}
        }
Exemplo n.º 8
0
        /// <summary>
        /// Generate completion data for the specified text, while import the given types into the
        /// scope and discovering variable assignments.
        /// </summary>
        /// <param name="code">The code to parse</param>
        /// <param name="expand">Determines if the entire namespace should be used</param>
        /// <returns>Return a list of IExternalCodeCompletionData </returns>
        public override IExternalCodeCompletionData[] GetCompletionData(string code, bool expand = false)
        {
            IEnumerable <PythonCodeCompletionDataCore> items = new List <PythonCodeCompletionDataCore>();

            if (!PythonEngine.IsInitialized)
            {
                PythonEngine.Initialize();
                PythonEngine.BeginAllowThreads();
            }

            try
            {
                using (Py.GIL())
                {
                    if (code.Contains("\"\"\""))
                    {
                        code = StripDocStrings(code);
                    }

                    UpdateImportedTypes(code);
                    UpdateVariableTypes(code);  // Possibly use hindley-milner in the future

                    // If expand param is true use the entire namespace from the line of code
                    // Else just return the last name of the namespace
                    string name = expand ? GetLastNameSpace(code) : GetLastName(code);
                    if (!String.IsNullOrEmpty(name))
                    {
                        try
                        {
                            // Attempt to get type using naming
                            Type type = expand ? TryGetTypeFromFullName(name) : TryGetType(name);
                            // CLR type
                            if (type != null)
                            {
                                items = EnumerateMembers(type, name).Select(x => new PythonCodeCompletionDataCore(x.Item1, x.Item2, x.Item3, x.Item4, this));
                            }
                            // Variable assignment types
                            else if (VariableTypes.TryGetValue(name, out type))
                            {
                                if (basicPyObjects.TryGetValue(type, out PyObject basicObj))
                                {
                                    items = EnumerateMembers(basicObj, name).Select(x => new PythonCodeCompletionDataCore(x.Item1, x.Item2, x.Item3, x.Item4, this));
                                }
                                else
                                {
                                    items = EnumerateMembers(type, name).Select(x => new PythonCodeCompletionDataCore(x.Item1, x.Item2, x.Item3, x.Item4, this));
                                }
                            }
                            else
                            {
                                // Try to find the corresponding PyObject from the python environment
                                // Most types should be successfully retrieved at this stage
                                var pyObj = LookupObject(name);
                                if (pyObj != null)
                                {
                                    items = EnumerateMembers(pyObj, name).Select(x => new PythonCodeCompletionDataCore(x.Item1, x.Item2, x.Item3, x.Item4, this));
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            Log(ex.ToString());
                        }
                    }
                }
            }
            catch {}

            // If unable to find matching results and expand was set to false,
            // try again using the full namespace (set expand to true)
            if (!items.Any() && !expand)
            {
                return(GetCompletionData(code, true));
            }

            return(items.ToArray());
        }