public IEnumerator StandalonePublish()
{
// Restart the server, making sure there is no Shotgun client
PythonRunner.StopServer(false);
// Make sure the Shotgun client has stopped
double initTime = EditorApplication.timeSinceStartup;
while (Bootstrap.IsClientAlive())
{
if (EditorApplication.timeSinceStartup - initTime > shutdownTimeout)
{
Assert.That(false, Is.True);
}
System.Threading.Thread.Sleep(100);
}
// Bootstrap Shotgun with our test client
Bootstrap.SpawnClient(clientPath);
// Give some time for the client to connect
yield return(PythonRunner.WaitForConnection(Constants.clientName, connectionTimeout));
// Wait until the client is fully bootstrapped
initTime = EditorApplication.timeSinceStartup;
while (!PythonRunner.CallServiceOnClient(Constants.clientName, "bootstrapped"))
{
if (EditorApplication.timeSinceStartup - initTime > bootstrapTimeout)
{
break;
}
yield return(null);
}
// Fake a recording by copying a video file in the right location
string videoFilePath = Path.GetFullPath($"{testsPath}/standalone_publish.mp4");
var destinationPath = Path.Combine(System.IO.Path.GetTempPath(), Application.productName);
destinationPath += ".mp4";
System.IO.File.Copy(videoFilePath, destinationPath, true);
Service.Call("standalone_publish");
// Wait until the client has finished publishing
initTime = EditorApplication.timeSinceStartup;
while (!PythonRunner.CallServiceOnClient(Constants.clientName, "published"))
{
if (EditorApplication.timeSinceStartup - initTime > publishTimeout)
{
break;
}
yield return(null);
}
// Upon success, the Python script creates a game object named
// after the product name
GameObject go = GameObject.Find(Application.productName);
Assert.IsNotNull(go);
}
public static void InitializeWorker()
{
// The client here spawned could also be launched from the command line.
PythonRunner.SpawnClient(CLIENT_PATH,
wantLogging: true);
EditorCoroutineUtility.StartCoroutineOwnerless(WaitForWorkerAndInitialize());
}
public void TestIsPythonLibraryLoaded()
{
PythonRunner.EnsureInitialized();
var result = PythonRunner.IsPythonLibraryLoaded();
Assert.That(result, Is.True);
}
public void TestScriptAssembliesInSysPath()
{
PythonRunner.EnsureInitialized();
using (Py.GIL())
{
dynamic sysmod = Py.Import("sys");
dynamic syspath = sysmod.path;
bool found = false;
foreach (string path in syspath)
{
if (path == Path.GetFullPath("Library/ScriptAssemblies").Replace("\\", "/"))
{
found = true;
break;
}
}
Assert.True(found);
// Next, try to load PythonRunner from python
dynamic clrmod = Py.Import("clr");
clrmod.AddReference("Unity.Scripting.Python.Editor");
dynamic pythonRunnerMod = Py.Import("UnityEditor.Scripting.Python");
string version = pythonRunnerMod.PythonRunner.PythonVersion;
Assert.That(version, Is.EqualTo(PythonRunner.PythonVersion));
}
}
private void BkWorkerOnDoWork(object sender, DoWorkEventArgs doWorkEventArgs)
{
string firstFileData = PythonRunner.RunWithArgument(sourcePath);
string secondFileData = PythonRunner.RunWithArgument(targetPath);
doWorkEventArgs.Result = new Tuple <string, string>(firstFileData, secondFileData);
}
// ReSharper disable AssignNullToNotNullAttribute
public MainViewModel()
{
// Initialize some defaults.
_startDate = MinStartDate;
_endDate = MaxEndDate;
_numClusters = DefaultClusters;
_needsTreeRefresh = true;
_needsChartRedraw = true;
PythonRunner = new PythonRunner(ConfigurationManager.AppSettings["pythonPath"], 20000);
DbPath = Path.GetFullPath(ConfigurationManager.AppSettings["dbFile"]);
string chartScript = Path.Combine(
Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location),
ConfigurationManager.AppSettings["scripts"],
"chart.py");
string kMeansScript = Path.Combine(
Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location),
ConfigurationManager.AppSettings["scripts"],
"kmeans.py");
// Initialize 'child' VMs.
StockListVm = new StockListViewModel(this);
TreeViewVm = new TreeViewViewModel(this, kMeansScript);
ChartVm = new ChartViewModel(this, chartScript);
// 'Invalidate' chart and tree when stock selection changes.
StockListVm.Stocks.ToList().ForEach(si => si.SelectionChanged += (sender, args) =>
{
NeedsChartRedraw = true;
NeedsTreeRefresh = true;
OnPropertyChanged(nameof(StockListVm.CollectionView));
});
}
static void PrintHelloWorldFromPython()
{
PythonRunner.RunString(@"
import UnityEngine;
UnityEngine.Debug.Log('hello console')
");
}
public async Task <Result> HandleAsync(AddDocumentToSourceStoreCommand command,
CancellationToken cancellationToken)
{
Console.WriteLine($"[AddDocumentToSourceStoreCommandHandler] received command {command}");
await UpdateFileStatus(command, OperationStatus.NotInitialized);
var result = PythonRunner.Run(
_scriptsConfiguration.UploadSource,
$"{command.UserId} {command.FileId} Repository {command.File.FileName} {command.File.Content}"
);
Console.WriteLine(result);
if (result.TrimEnd().Split("\n").Last() == "-1")
{
Console.WriteLine($"[AddDocumentToSourceStoreCommandHandler] Upload failed for file {command.FileId}");
await UpdateFileStatus(command, OperationStatus.Failed);
return(Result.Fail($"Upload failed for file {command.FileId}"));
}
Console.WriteLine($"[AddDocumentToSourceStoreCommandHandler] upload successful");
await UpdateFileStatus(command, OperationStatus.Complete);
return(Guid.NewGuid().ToSuccessfulResult());
}
public void SuicideProbability()
{
//this test is correct with default suicide_result if he still has only 2 posts
Client cl = new User("durov");
string id = cl.Link;
// calling script to process data and make prediction
PythonRunner.RunScript(AppSettings.PythonScriptPath, AppSettings.PythonPath);
Thread.Sleep(10000);
//get prediction
double res = cl.SuicideProbability(DateTime.MinValue, DateTime.MaxValue, id);
//disabling script
IPEndPoint ipe = new IPEndPoint(AppSettings.LocalIP, AppSettings.ClientPort);
Socket socket = new Socket(ipe.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
socket.Connect(ipe);
Byte[] bytesSent = Encoding.UTF32.GetBytes("~exit~::");
socket.Send(bytesSent, bytesSent.Length, 0);
//+ Check correctness with your eyes
Console.WriteLine(res);
Assert.IsTrue(res < 0.999 && res >= 0.00);
}
public void TestUndoRedirectStdout()
{
// open python console
PythonConsoleWindow.ShowWindow();
var prevContents = PythonConsoleWindow.s_window.m_outputContents;
PythonConsoleWindow.s_window.m_outputContents = "";
var msg = "hello world";
var pythonCmd = string.Format("print ('{0}')", msg);
PythonRunner.RunString(pythonCmd);
var output = PythonConsoleWindow.s_window.m_outputContents;
Assert.That(output, Is.EqualTo(msg + "\n"));
PythonRunner.UndoRedirectStdout();
PythonConsoleWindow.s_window.m_outputContents = "";
// stdout should no longer be redirected
PythonRunner.RunString(pythonCmd);
output = PythonConsoleWindow.s_window.m_outputContents;
Assert.That(output, Is.Null.Or.Empty);
PythonConsoleWindow.s_window.m_outputContents = prevContents;
PythonConsoleWindow.s_window.Close();
// redo stdout redirection
PythonRunner.RedirectStdout();
}
public Controller(string dbPath, string _pyPath, string _pyScriptsPath)
{
_persistance = new Persistance();
this.dbPath = dbPath;
this.pythonPath = _pyPath;
this.pythonScriptsPath = _pyScriptsPath;
this.pyRunnes = new PythonRunner(this.pythonPath);
/*
* //string dbpath = @"C:\Users\Enrico\Desktop\ordiniMI2018.sqlite";
* string sdb = ConfigurationManager.AppSettings["dbServer"];
*
* switch (sdb)
* {
* case "SQLiteConn":
* connectionString = ConfigurationManager.ConnectionStrings["SQLiteConn"].ConnectionString;
* connectionString = connectionString.Replace("DBFILE", dbPath);
* _persistance.SetFactory(ConfigurationManager.ConnectionStrings["SQLiteConn"].ProviderName);
* break;
* case "LocalDbConn":
* connectionString = ConfigurationManager.ConnectionStrings["LocalSqlServConn"].ConnectionString;
* _persistance.SetFactory(ConfigurationManager.ConnectionStrings["LocalSqlServConn"].ProviderName);
* break;
* case "RemoteSqlServConn":
* connectionString = ConfigurationManager.ConnectionStrings["RemoteSQLConn"].ConnectionString;
* _persistance.SetFactory(ConfigurationManager.ConnectionStrings["RemoteSQLConn"].ProviderName);
* break;
*
* }
* _persistance.connectionString = connectionString;
*/
}
public override void OnInspectorGUI()
{
if (GUILayout.Button("Launch Python Script", GUILayout.Height(35)))
{
string path = Application.dataPath + "/Plugins/LeapMotion/Core/Scripts/Python_Scripts/test.py";
PythonRunner.RunFile(path);
}
}
static void OnHierarchyChanged()
{
// This is the simplest way to call Python code.
PythonRunner.RunString(@"
import PySideExample
PySideExample.update_camera_list()
");
}
public Controller()
{
this.dbPath = ConfigurationManager.AppSettings["dbordiniFile"];
this.pythonPath = ConfigurationManager.AppSettings["pythonPath"];
this.pythonScriptPath = ConfigurationManager.AppSettings["pyScripts"];
this.pyRunner = new PythonRunner(this.pythonPath, 20000);
P = new Persistence(dbPath);
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
PythonRunner.RunScript(AppSettings.PythonScriptPath, AppSettings.PythonPath);
}
public Controller(string _pyPath, string _pyScriptsPath)
{
this.pythonPath = _pyPath;
this.pythonScriptsPath = _pyScriptsPath;
P = new Persistence();
GAP = new GAPclass();
pyRunner = new PythonRunner(pythonPath, 20000);
}
public void Setup()
{
PythonRunner.EnsureInitialized();
using (Py.GIL())
{
dynamic module = PythonEngine.ImportModule("unity_python.common.spawn_process");
spawn = module.spawn_process_in_environment;
}
}
void CamCapture()
{
// ScreenCapture.CaptureScreenshot(Application.dataPath + "/Screenshots/" + fileCount + ".png");
// fileCount++;
string path = Application.dataPath + "/Plugins/LeapMotion/Core/Scripts/Python_Scripts/test.py";
PythonRunner.RunFile(path);
}
public UserEntryController(IUserEntryRepo userEntry, UserManager <User> userManager, IUserSettingsRepo userSettingsRepo,
PythonRunner pythonRunner, IConfiguration configuration, IImageEntryRepo imageEntryRepo, IUserRepo userRepo)
{
_userEntryRepo = userEntry;
_userManager = userManager;
_userSettingsRepo = userSettingsRepo;
_pythonRunner = pythonRunner;
_configuration = configuration;
_imageEntryRepo = imageEntryRepo;
_userRepo = userRepo;
}
/// <summary>
/// Calls a service on the Shotgun client.
/// </summary>
/// <param name="serviceName">The name of the service</param>
/// <param name="args">Arguments to pass to the service</param>
public static void Call(string serviceName, params object[] args)
{
// Do our best to get a valid client
if (!Client.EnsureConnection())
{
return;
}
// Then call the service
_ = PythonRunner.CallAsyncServiceOnClient(Constants.clientName, serviceName, args);
}
public MainViewModel()
{
GoCommand = new MyCommand(p => Go(), CanGo);
StopCommand = new MyCommand(p => Stop(), CanStop);
IncreaseFontSizeCommand = new MyCommand(p => IncreaseFontSize(), CanIncreaseFontSize);
DecreaseFontSizeCommand = new MyCommand(p => DecreaseFontSize(), CanDecreaseFontSize);
runner = new PythonRunner();
runner.Output += Runner_OutputReceived;
runner.Error += Runner_ErrorReceived;
runner.ExecutionStateChanged += Runner_ExecutionStateChanged;
ProgramInteraction.Input += ProgramInteraction_Input;
}
// Helper for TestProjectAssemblyReferencesAdded.
// Tries to import System and run a command with PythonRunner.RunString().
// Called once before and after domain reload.
private void TestImportSystemHelper()
{
var importSystem = "import System;System.IO.File.Exists('test.txt')";
PythonRunner.RunString(importSystem);
// System has an extra m, so this should throw an exception
var importSystemInvalid = "import Systemm;System.IO.File.Exists('test.txt')";
Assert.Throws <PythonException>(() =>
{
PythonRunner.RunString(importSystemInvalid);
});
}
public AdminService(FantasyCriticService fantasyCriticService, IFantasyCriticRepo fantasyCriticRepo, IMasterGameRepo masterGameRepo,
InterLeagueService interLeagueService, IOpenCriticService openCriticService, IClock clock, ILogger <OpenCriticService> logger, IRDSManager rdsManager,
RoyaleService royaleService, PythonRunner pythonRunner)
{
_fantasyCriticService = fantasyCriticService;
_fantasyCriticRepo = fantasyCriticRepo;
_masterGameRepo = masterGameRepo;
_interLeagueService = interLeagueService;
_openCriticService = openCriticService;
_clock = clock;
_logger = logger;
_rdsManager = rdsManager;
_royaleService = royaleService;
_pythonRunner = pythonRunner;
}
public async Task <KeyValuePair <bool, List <Mark> > > GetSecondMiddlePrediction(string groupCourseId)
{
var result = await Task.Run <bool>(() => PythonRunner.Run(OperationNames.PredictForSecondMiddle, groupCourseId));
if (!result)
{
return(new KeyValuePair <bool, List <Mark> >(false, null));
}
var secondMiddle = (await lessonRepository.GetByGroupCourse(groupCourseId)).FirstOrDefault(l => l.LessonType == LessonType.SecondMiddle);
var predictedMiddleMarks = await markRepository.GetPredictedMarksByLesson(secondMiddle.Id, (int)secondMiddle.LessonType);
return(new KeyValuePair <bool, List <Mark> >(true, predictedMiddleMarks));
}
private double getAnalysisResult(AnalyzeDocumentCommand command)
{
var scriptResult = PythonRunner.Run(
_scriptsConfiguration.PerformAnalysis,
command.FileId.ToString()
);
Console.WriteLine(scriptResult);
var last = scriptResult.TrimEnd().Split("\n").Last();
if (double.TryParse(last, out var result))
{
return(result);
}
throw new NotSupportedException(scriptResult);
}
void DisplayResultSameThread(PythonRunner runner, PythonRunResult result)
{
if (result.hasError)
{
StdoutDisp.Text = "\n" + result.errorString;
}
else
{
string tableStr = "";
foreach (KeyValuePair <string, object> de in result.returnedValues)
{
tableStr += de.Key + "=" + de.Value + "(" + de.Value.GetType() + ")\n";
}
StdoutDisp.Text = runner.stdout + "\n" + tableStr;
}
}
void DisplayResult(PythonRunner runner, PythonRunResult result)
{
if (result.hasError)
{
Application.Current.Dispatcher.Invoke(new Action(() => { StdoutDisp.Text = "\n" + result.errorString; }));
}
else
{
string tableStr = "";
foreach (KeyValuePair <string, object> de in result.returnedValues)
{
tableStr += de.Key + "=" + de.Value + "(" + de.Value.GetType() + ")\n";
}
Application.Current.Dispatcher.Invoke(new Action(() => { StdoutDisp.Text = runner.stdout + "\n" + tableStr; }));
}
}
public async Task <JudgeResult> RunSubmissionAsync()
{
LanguageTypes.Base.Runner runner;
switch (Submission.Program.Language)
{
case Language.C:
runner = new CRunner(Contest, Problem, Submission, Box, Provider);
break;
case Language.Cpp:
runner = new CppRunner(Contest, Problem, Submission, Box, Provider);
break;
case Language.Java:
runner = new JavaRunner(Contest, Problem, Submission, Box, Provider);
break;
case Language.Python:
runner = new PythonRunner(Contest, Problem, Submission, Box, Provider);
break;
case Language.Golang:
runner = new GolangRunner(Contest, Problem, Submission, Box, Provider);
break;
case Language.Rust:
runner = new RustRunner(Contest, Problem, Submission, Box, Provider);
break;
case Language.CSharp:
runner = new CSharpRunner(Contest, Problem, Submission, Box, Provider);
break;
case Language.Haskell:
runner = new HaskellRunner(Contest, Problem, Submission, Box, Provider);
break;
case Language.LabArchive:
return(Problem.Type switch
{
ProblemType.Ordinary => JudgeResult.UnknownLanguageFailure,
ProblemType.TestKitLab => await
new TestKitRunner(Contest, Problem, Submission, Box, Provider).RunSubmissionAsync(),
_ => throw new ArgumentOutOfRangeException()
});
public void TestCanInstallPythonCheck()
{
// In order to have this function return true, python would need to not be installed
// or loaded. However, this would require restarting Unity which is out of scope for this test.
// Instead test all the cases where the function should return false.
// With 0 versionStatus correct package is already installed, nothing to do
Assert.That(PythonRunner.CanInstallPythonCheck(versionStatus: 0, localPackage: false), Is.False);
Assert.That(PythonRunner.CanInstallPythonCheck(versionStatus: 0, localPackage: true), Is.False);
// With versionStatus < 0, needsDowngrade, but don't do so immediately
Assert.That(PythonRunner.CanInstallPythonCheck(versionStatus: -1, localPackage: false), Is.False);
Assert.That(PythonRunner.CanInstallPythonCheck(versionStatus: -1, localPackage: true), Is.False);
// With versionStatus > 0, needs upgrade but don't do so immediately
Assert.That(PythonRunner.CanInstallPythonCheck(versionStatus: 1, localPackage: false), Is.False);
Assert.That(PythonRunner.CanInstallPythonCheck(versionStatus: 1, localPackage: true), Is.False);
}
static void CreateOrReinitialize()
{
// You can manually add the sample directory to your sys.path in
// the Python Settings under site-packages. Or you can do it
// programmatically like so.
string dir = __DIR__();
PythonRunner.EnsureInitialized();
using (Py.GIL())
{
dynamic sys = PythonEngine.ImportModule("sys");
if ((int)sys.path.count(dir) == 0)
{
sys.path.append(dir);
}
}
// Now that we've set up the path correctly, we can import the
// Python side of this example as a module:
PythonRunner.RunString(@"
import PySideExample
PySideExample.create_or_reinitialize()
");
// We can't register events in Python directly, so register them
// here in C#:
EditorApplication.hierarchyChanged += OnHierarchyChanged;
EditorApplication.update += OnUpdate;
//
// A domain reload happens when you change C# code or when you
// launch into play mode (unless you selected the option not to
// reload then).
//
// When it happens, your C# state is entirely reinitialized. The
// Python state, however, remains as it was.
//
// To store information about what happened in the previous domain,
// Unity provides the SessionState. Alternately we could have
// stored the data in a variable in Python.
//
SessionState.SetBool(kStateName, true);
}