Commit 4aa41ea

import unreal_engine as ue

import time

import sys

import upythread as ut

from threading import Thread

def onfinished(args=""):

ue.log(args)

ue.log('finished with: <' + str(args) + '>')

def onfinishedempty():

ue.log('finished')

def testaction(args=""):

ue.log('starting action with <' + str(args) + '>')

#onfinished()

#pretend you take time to finish

time.sleep(1)

ue.log('wait complete')

ue.run_on_gt(onfinished, args)

ue.run_on_gt(onfinishedempty)

def test(params=None):

ue.log(type(params))

ue.log('starting test')

if not params:

t = Thread(target=testaction)

else:

t = Thread(target=testaction, args=(params,))

t.start()

def yolo():

ue.log('yolo!')

def yolodone():

ue.log('yolo done!')

def test2():

ut.run_on_bt(yolo)

def test3():

ut.run_on_bt(yolo, yolodone)

def progresscallback(progress):

ue.log('at ' + str(progress))

def doLongTask():

ue.log('started my task')

for x in range(1,10):

time.sleep(0.5)

ue.run_on_gt(progresscallback, x)

def testp():

ut.run_on_bt(doLongTask)

import sys

import unreal_engine as ue

class Redirector(object):

def __init__(self):

pass

def write(self, message):

ue.log(message)

def flush(self):

sys.stdout.flush()

def splitlines(self):

sys.stdout.splitlines()

sys.stdout = Redirector()

sys.stderr = Redirector()

import subprocess

import sys

import unreal_engine as ue

import _thread as thread

def PythonHomePath():

for path in sys.path:

if ('UnrealEnginePython' in path and

path.endswith('Binaries/Win64')):

return path

#return sys.path[1]

return "not found"

def PythonHomeScriptsPath():

home = PythonHomePath()

return home + "/Scripts"

_PythonHomePath = PythonHomePath()

def FolderCommand(folder):

#replace backslashes

folder = folder.replace('/','\\')

changefolder = "cd /d \"" + folder + "\" & "

return changefolder

def run(process, path=_PythonHomePath, verbose=True):

#todo: change folder

fullcommand = FolderCommand(path) + process

if verbose:

ue.log("Started cmd <" + fullcommand + ">")

stdoutdata = subprocess.getstatusoutput(fullcommand)

if verbose:

ue.log("cmd Result: ")

ue.log(stdoutdata[1])

return stdoutdata[1] #return the data for dependent functions

def dir(path=_PythonHomePath):

run('dir', path)

def ls(path=_PythonHomePath):

dir(path)

def md(folder, path=_PythonHomePath):

run('md ' + folder, path)

def mkdir(folder, path=_PythonHomePath):

md(folder, path)

import upypip as pip

import sys

import unreal_engine as ue

import json

import upypip

pip = upypip.pip

def parseJson(packagePath):

try:

with open(packagePath) as data_file:

#TODO: catch file not found error

package = json.load(data_file)

ue.log('Resolving upymodule dependencies for ' + package['name'])

pythonModules = package['pythonModules']

#loop over all the modules, check if we have them installed

for module in pythonModules:

version = pythonModules[module]

ue.log(module + " " + version + " installed? " + str(pip.isInstalled(module)))

if not pip.isInstalled(module, version):

ue.log('Dependency not installed, fetching via pip...')

pip.install(module + '==' + version)

dependencyNoun = 'dependencies'

if len(pythonModules) == 1:

dependencyNoun = 'dependency'

ue.log(str(len(pythonModules)) + ' ' + package['name'] + ' upymodule ' + dependencyNoun + ' resolved (if installation in progress, more async output will stream)')

except:

e = sys.exc_info()[0]

ue.log('upymodule.json error: ' + str(e))

import upycmd as cmd

import sys

from threading import Thread

from distutils.version import LooseVersion

class PipInstall:

#global modules class static variable

modules = None

def __init__(self):

return None

#blocking actions, should be run on off-thread

def pipModuleAction(self, command, args, verbose=True):

return cmd.run('pip ' + command + ' ' + args, cmd.PythonHomeScriptsPath(), verbose)

#use this if you need to work on the resulting list to query current dependencies

def listDict(self, verbose=True):

#get the list of all the modules from pip

resultString = self.pipModuleAction('list','--format=columns', verbose)

#convert to lines for parsing

lines = resultString.split("\n")

resultDict = {}

#exclude first two lines, then pair up the results

for i in range(2,len(lines)):

splitEntry = lines[i].split() #split and ignore all whitespace

resultDict[splitEntry[0]] = splitEntry[1]

#save list to cache

PipInstall.modules = resultDict

return resultDict

def isDesiredVersionSufficient(self, desired, current):

return LooseVersion(desired) <= LooseVersion(current)

def isInstalled(self, module, desiredVersion=None):

if PipInstall.modules == None:

PipInstall.modules = self.listDict(False)

if module in PipInstall.modules:

#did we specify a version? ensure we've installed that version at least

if desiredVersion:

#print('current version: ' + str(PipInstall.modules[module]))

#print('desired version: ' + str(desiredVersion))

return self.isDesiredVersionSufficient(desiredVersion, PipInstall.modules[module])

else:

return True

else:

return False

#Threaded actions

def install(self, module):

PipInstall.modules = None #our cache is no longer valid

action = self.pipModuleAction

t = Thread(target=action, args=('install',module,))

t.start()

def uninstall(self, module):

PipInstall.modules = None #our cache is no longer valid

action = self.pipModuleAction

t = Thread(target=action, args=('uninstall -y',module,))

t.start()

def list(self):

action = self.listDict

t = Thread(target=action)

t.start()

pip = PipInstall()

import unreal_engine as ue

from threading import Thread

def backgroundAction(args=None):

#ue.log(args)

action = args[0]

if len(args) >1:

callback = args[1]

#call the blocking action

action()

#return the result if we have a callback

if callback:

ue.run_on_gt(callback)

def run_on_bt(actionfunction, callback=None):

t = Thread(target=backgroundAction, args=([actionfunction, callback],))

t.start()

This fork is meant to encapsulate python + pip + scripts fully in the plugin and to allow dependency plugins to be built on top of the python plugin. Specifically it means adding automatic pip dependency resolution and automatic sys.path additions such that the resulting two plugins can be fully drag and dropped into a new project.

#include "TabManager.h"