def __init__(self, experiment, dev=None):
try:
import clr
clr.AddReference("System.Reflection")
from System.Reflection import Assembly
directory=os.getcwd()
print(directory)
pluginfolder = os.dirname(__file__)
Assembly.UnsafeLoadFrom(directory+'\share\opensesame_plugins\Pulse_EVT2\HidSharp.dll')
Assembly.UnsafeLoadFrom(directory+'\share\opensesame_plugins\Pulse_EVT2\HidSharp.DeviceHelpers.dll')
Assembly.UnsafeLoadFrom(directory+'\share\opensesame_plugins\Pulse_EVT2\EventExchanger.dll')
except Exception as e:
print(e.Message)
print(e.Source)
try:
self._EVT2 = clr.ID.EventExchanger()
print(self._EVT2.Attached())
self._nEVT2 = self._EVT2.Attached().count('/')+1
except Exception as e:
raise osexception('EVT2 Error')
# print(self._EVT2.Attached())
self.experiment = experiment
# If a device has not been specified, autodetect
if dev in (None, "", "autodetect"):
try:
if self._nEVT2 == 1:
print("Starting the only attached EVT")
self._EVT2.Start()
else:
print(("Starting device %s" % self._EVT2.Attached().partition('/')[0]))
self._EVT2.Start(self._EVT2.Attached().partition('/')[0])
except Exception as e:
print(e.Message)
raise osexception(
"libEVT2 does not know how to auto-detect the EVT on your platform. Please specify a device.")
else:
try:
self._EVT2.Start(str(dev))
except Exception as e:
raise osexception(
"Failed to open device port '%s' in libEVT2: '%s'" \
% (dev, e))
if self._EVT2 is None:
raise osexception(
"libEVT2 failed to auto-detect a unique instance of the EVT. Please specify a device.")
debug.msg("using device %s" % dev)
def test_explicit_assembly_load():
"""Test explicit assembly loading using standard CLR tools."""
from System.Reflection import Assembly
import System, sys
assembly = Assembly.LoadWithPartialName('System.Data')
assert assembly is not None
import System.Data
assert 'System.Data' in sys.modules
assembly = Assembly.LoadWithPartialName('SpamSpamSpamSpamEggsAndSpam')
assert assembly is None
def testExplicitAssemblyLoad(self):
"""Test explicit assembly loading using standard CLR tools."""
from System.Reflection import Assembly
import System, sys
assembly = Assembly.LoadWithPartialName('System.Data')
self.assertTrue(assembly != None)
import System.Data
self.assertTrue('System.Data' in sys.modules)
assembly = Assembly.LoadWithPartialName('SpamSpamSpamSpamEggsAndSpam')
self.assertTrue(assembly == None)
def test_type(self):
from System.Reflection import Assembly
from System.Reflection.Emit import AssemblyBuilder
mscorlib = Assembly.Load("mscorlib")
self.assertTrue("Assembly" in repr(mscorlib))
self.assertGreaterEqual(len(dir(Assembly)), 75)
self.assertGreaterEqual(len(dir(AssemblyBuilder)), 89)
def __imports__(self):
""" DotNetDevice loads the DLL; importing in the
class definition tries to load a lot of DLLs
on import
of ssmdevices, which would 1) break platforms
that do not support the DLL, and 2) waste
memory, and 3)
"""
if hasattr(self.__class__, '__dll__') and not hasattr(self, 'dll'):
self.dll = self.__class__.__dll__
return
if self.dll_name is None:
raise Exception('Need file name of a dll binary')
if self.library is None:
raise Exception(
'Need the python module that shares the library path')
try:
import clr
except ImportError as err:
if str(err) == 'No module named clr':
warnings.warn(
'could not import pythonnet support via clr module; no support for .NET drivers'
)
return None
else:
raise err
import os
clr.setPreload(False)
# CPython and .NET libraries: Are they friends?
clr.AddReference('System.Reflection')
from System.Reflection import Assembly
import System
# if libname is None:
libname = os.path.splitext(os.path.basename(self.dll_name))[0]
if hasattr(self.library, '__loader__'):
""" If the python module is packaged as a .egg file,
then use some introspection and the module's
__loader__ to load the contents of the dll
"""
# relpath = module.__name__.replace('.', os.path.sep)
self.dll_name = os.path.join(self.library.__path__[0],
self.dll_name)
contents = self.library.__loader__.get_data(self.dll_name)
else:
path = os.path.join(self.library.__path__[0], self.dll_name)
with open(path, 'rb') as f:
contents = f.read()
name = System.Array[System.Byte](contents)
self._dlls[self.dll_name] = Assembly.Load(name)
self.dll = __import__(libname)
try:
self.__class__.__dll__ = self.dll
except AttributeError: # Race condition =/
pass
def run(self, py_file):
self.py_file = py_file
#use the current executing version of IPY to launch the debug process
ipy = Assembly.GetEntryAssembly().Location
cmd_line = "\"%s\" -D \"%s\"" % (ipy, py_file)
self.process = self.debugger.CreateProcess(ipy, cmd_line)
self.process.OnCreateAppDomain += self.OnCreateAppDomain
self.process.OnProcessExit += self.OnProcessExit
self.process.OnUpdateModuleSymbols += self.OnUpdateModuleSymbols
self.process.OnBreakpoint += self.OnBreakpoint
self.process.OnStepComplete += self.OnStepComplete
self.process.OnClassLoad += self.OnClassLoad
self.terminate_event = AutoResetEvent(False)
self.break_event = AutoResetEvent(False)
self.initial_breakpoint = None
self.breakpoints = []
self.source_files = dict()
handles = Array.CreateInstance(WaitHandle, 2)
handles[0] = self.terminate_event
handles[1] = self.break_event
while True:
if hasattr(self, 'active_thread'): delattr(self, 'active_thread')
if hasattr(self, 'active_appdomain'):
delattr(self, 'active_appdomain')
self.process.Continue(False)
i = WaitHandle.WaitAny(handles)
if i == 0:
break
self._input()
def __init__(self, **kwargs):
super(NewFocus6700, self).__init__()
# Load usb ddl Newport
try:
# dllpath = 'C:\\ProgramData\\Anaconda3\\DLLs\\'
# dllpath = 'C:\\Users\\Greg\\Anaconda3\\DLLs\\'
dllpath = 'C:\\ProgramData\\Anaconda3\\DLLs\\'
Assembly.LoadFile(dllpath + 'UsbDllWrap.dll')
clr.AddReference(r'UsbDllWrap')
import Newport
self._dev = Newport.USBComm.USB()
except Exception as err:
print(err)
self._dev = None
# Laser state
self._open = False
self._DeviceKey = kwargs.get('key', None)
self._idLaser = kwargs.get('id', 4106)
# Laser properties
self._lbd = '0'
self._cc = 0
self._scan_lim = []
self._scan_speed = 0
self._scan = 0
self._beep = 0
self._output = 0
self._is_scaning = False
# self._is_changing_lbd = False
self._no_error = '0,"NO ERROR"'
self._haserr = False
# Miscs
self._buff = StringBuilder(64)
self._err_msg = ''
def test_type():
mscorlib = Assembly.Load("mscorlib")
Assert("Assembly" in repr(mscorlib))
if not is_net40:
AreEqual(len(dir(Assembly)), 65)
AreEqual(len(dir(AssemblyBuilder)), 78)
else:
AreEqual(len(dir(Assembly)), 71)
AreEqual(len(dir(AssemblyBuilder)), 84)
def CustomizeRemoteRuntimeStartInfo(self, processInfo):
fileName = Assembly.GetEntryAssembly().Location
assert (fileName.endswith("ipy.exe"))
processInfo.FileName = fileName
# Pass along any command-line arguments
if len(sys.argv) > 1:
args = ""
for arg in sys.argv[1:]:
args += arg + " "
processInfo.Arguments += " " + args
def DynamoDocSetup():
# MIGHT BE USEFUL, KEEPING HERE FOR REFERENCE
from System.Reflection import Assembly
dynamo = Assembly.Load('DynamoCore')
if dynamo:
print(dynamo)
print("This is in Dynamo")
else:
print("This is not Dynamo")
# standard modules
import clr
import math
import os
import re
import sys
import System
import traceback
# RevitServices for Dynamo
clr.AddReference("RevitServices")
import RevitServices
from RevitServices.Persistence import DocumentManager
from RevitServices.Transactions import TransactionManager
# Revit/Dynamo Nodes
clr.AddReference("RevitNodes")
import Revit
clr.ImportExtensions(Revit.Elements)
clr.ImportExtensions(Revit.GeometryConversion)
# Dynamo Geometry nodes
clr.AddReference("ProtoGeometry")
from Autodesk.DesignScript.Geometry import *
# Revit API
clr.AddReference('RevitAPI')
clr.AddReference('RevitAPIUI')
import Autodesk
from Autodesk.Revit.UI import *
from Autodesk.Revit import DB
import Autodesk.Revit.UI.Selection
doc = DocumentManager.Instance.CurrentDBDocument
uiapp = DocumentManager.Instance.CurrentUIApplication
app = uiapp.Application
uidoc = DocumentManager.Instance.CurrentUIApplication.ActiveUIDocument
user = str(System.Environment.UserName)
tol = 0.001
# transaction variables
tStart = TransactionManager.Instance.EnsureInTransaction(doc)
tEnd = TransactionManager.Instance.TransactionTaskDone()
"""
def InitialiseFWGlobals():
global FWCodeDir
global FWProjectsDir
global FWShortVersion
global FWLongVersion
try:
rKey = GetFWRegKey()
except Exception as e:
logging.exception("Couldn't find FieldWorks registry entry")
raise
FWCodeDir = rKey.GetValue(FWREG_CODEDIR)
FWProjectsDir = rKey.GetValue(FWREG_PROJECTSDIR)
# On developer's machines we also check the build directories
# for FieldWorks.exe
if not os.access(os.path.join(FWCodeDir, "FieldWorks.exe"), os.F_OK):
if os.access(
os.path.join(FWCodeDir, r"..\Output\Release\FieldWorks.exe"),
os.F_OK):
FWCodeDir = os.path.join(FWCodeDir, r"..\Output\Release")
elif os.access(
os.path.join(FWCodeDir, r"..\Output\Debug\FieldWorks.exe"),
os.F_OK):
FWCodeDir = os.path.join(FWCodeDir, r"..\Output\Debug")
else:
# This can happen if there is a ghost registry entry for
# an uninstalled FLEx
msg = "FieldWorks.exe not found in %s" \
% FWCodeDir
logger.error(msg)
raise Exception(msg)
# Add the FW code directory to the search path for importing FW libs.
sys.path.append(FWCodeDir)
logger.info("sys.path = %s" % "\n\t".join(sys.path))
# These can't be imported until the path is set:
clr.AddReference("FwUtils")
from SIL.FieldWorks.Common.FwUtils import VersionInfoProvider
# Get the full version information out of FW itself
vip = VersionInfoProvider(Assembly.GetAssembly(VersionInfoProvider), False)
FWShortVersion = System.Version(vip.ShortNumericAppVersion) # e.g. 8.1.3
FWLongVersion = vip.ApplicationVersion
logger.info("Found FieldWorks installation")
logger.info("FWCodeDir = %s" % FWCodeDir)
logger.info("FWProjectsDir = %s" % FWProjectsDir)
logger.info("FWShortVersion = %s" % FWShortVersion)
logger.info("FWLongVersion = %s" % FWLongVersion)
def load_assembly_attributes(self):
assembly = Assembly.ReflectionOnlyLoadFrom(self.assembly_path)
assembly_name = AssemblyName(assembly.FullName)
assembly_uri = u'file:///' + self.assembly_path.replace(os.path.sep, u'/')
p = Properties()
p.full_name = assembly.FullName
p.version = str(assembly_name.Version)
p.codebase_uri = assembly_uri
p.runtime_version = assembly.ImageRuntimeVersion
self.assembly_properties = p
def test_type(self):
from System.Reflection import Assembly
from System.Reflection.Emit import AssemblyBuilder
mscorlib = Assembly.Load("mscorlib")
self.assertTrue("Assembly" in repr(mscorlib))
if is_mono: # Mono has another member
self.assertEqual(len(dir(Assembly)), 76)
else:
self.assertEqual(len(dir(Assembly)), 75)
if is_mono: # Mono has another member
self.assertEqual(len(dir(AssemblyBuilder)), 90)
else:
self.assertEqual(len(dir(AssemblyBuilder)), 89)
def load_pypylib():
from rpython.translator.cli.rte import get_pypy_dll
dll = get_pypy_dll()
try:
import clr
from System.Reflection import Assembly
except ImportError:
pass
else:
ass = Assembly.LoadFrom(dll)
assert ass is not None
clr.AddReference(pypylib)
load_assembly(pypylib)
def __init__(self, experiment, dev=None):
try:
import clr
clr.AddReference("System.Reflection")
from System.Reflection import Assembly
directory = os.getcwd()
print directory
pluginfolder = os.dirname(__file__)
Assembly.UnsafeLoadFrom(
directory +
'\share\opensesame_plugins\Pulse_EVT2\HidSharp.dll')
Assembly.UnsafeLoadFrom(
directory +
'\share\opensesame_plugins\Pulse_EVT2\HidSharp.DeviceHelpers.dll'
)
Assembly.UnsafeLoadFrom(
directory +
'\share\opensesame_plugins\Pulse_EVT2\EventExchanger.dll')
except Exception, e:
print e.Message
print e.Source
def test_type():
mscorlib = Assembly.Load("mscorlib")
Assert("Assembly" in repr(mscorlib))
if not is_net40:
AreEqual(len(dir(Assembly)), 65)
AreEqual(len(dir(AssemblyBuilder)), 78)
else:
if is_posix: # Mono has another member
AreEqual(len(dir(Assembly)), 76)
else:
AreEqual(len(dir(Assembly)), 75)
if is_posix: # Mono has another member
AreEqual(len(dir(AssemblyBuilder)), 90)
else:
AreEqual(len(dir(AssemblyBuilder)), 89)
def InitializePath(self):
searchPath = []
currentDir = Directory.GetCurrentDirectory()
searchPath.append(currentDir)
filePathDir = Path.GetDirectoryName(Path.Combine(currentDir, self.fileName))
searchPath.append(filePathDir)
entryDir = Path.GetDirectoryName(Assembly.GetEntryAssembly().Location)
searchPath.append(entryDir)
siteDir = Path.Combine(entryDir, "Lib")
searchPath.append(siteDir)
dllsDir = Path.Combine(entryDir, "DLLs")
if Directory.Exists(dllsDir):
searchPath.append(dllsDir)
self.engine.SetSearchPaths(Array[str](searchPath))
def InitializePath(self):
searchPath = []
currentDir = Directory.GetCurrentDirectory()
searchPath.append(currentDir)
filePathDir = Path.GetDirectoryName(Path.Combine(currentDir, self.fileName))
searchPath.append(filePathDir)
entryDir = Path.GetDirectoryName(Assembly.GetEntryAssembly().Location)
searchPath.append(entryDir)
siteDir = Path.Combine(entryDir, "Lib")
searchPath.append(siteDir)
devStdLibDir = Path.Combine(entryDir, '../../External.LCA_RESTRICTED/Languages/IronPython/27/Lib')
searchPath.append(devStdLibDir)
dllsDir = Path.Combine(entryDir, "DLLs")
if Directory.Exists(dllsDir):
searchPath.append(dllsDir)
self.engine.SetSearchPaths(Array[str](searchPath))
def __init__(self, fileName):
scriptEnv = Python.CreateRuntime()
self.fileName = fileName
self.engine = scriptEnv.GetEngine("python")
self.context = HostingHelpers.GetLanguageContext(self.engine)
scriptEnv.LoadAssembly(Type.GetType("System.String").Assembly) #mscorlib.dll
scriptEnv.LoadAssembly(UriBuilder().GetType().Assembly) #System.dll
self.InitializePath()
executable = Assembly.GetEntryAssembly().Location
prefix = Path.GetDirectoryName(executable)
self.context.SystemState.executable = executable
self.context.SystemState.exec_prefix = self.context.SystemState.prefix = prefix
import imp
mod = imp.new_module('__main__')
mod.__file__ = fileName
mod.__builtins__ = sys.modules['__builtin__']
self.context.SystemState.modules['__main__'] = mod
self.mainScope = scriptEnv.CreateScope(mod.__dict__)
import logging
import os
import sys
from settings import PACKAGE_ROOT
#------------------------------------------------------------------------------
# prepare environment for loading latino (Python.net interpreter should be used)
# see: http://pythonnet.sourceforge.net/
#------------------------------------------------------------------------------
dllPath = os.path.join(PACKAGE_ROOT, 'bin')
sys.path.append(dllPath)
try:
import clr
import System
import LemmaSharp
from LemmaSharpInterfaces import *
from System.Reflection import Assembly
Assembly.LoadFile(os.path.join(dllPath, 'LemmaSharpPrebuilt.dll'))
except Exception:
logging.warning(
"DotNet assemblies could not be loaded! Probable reasons: missing dlls or wrong interpreter (see http://pythonnet.sourceforge.net). "
"Other functionality of ClowdFlows (besides .Net assemblies) should be OK!"
)
pass
def load_asm_file(asm_file):
return Assembly.LoadFrom(asm_file)
# from System.IO import Stream, StreamReader, MemoryStream, BinaryWriter, FileStream, File
# from System.IO.Compression import ZipArchive, ZipArchiveMode
## Download a dll to memory from the remote endpoint, load it up in memroy
with WebClient() as wc:
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12
dll = wc.DownloadData("http://127.0.0.1:8000/tmpB1B9.dll")
## This is how we get .Net and Python typres from an object
print(".Net Type: ", clr.GetClrType(type(dll)) )
print("Python Type: ", type(dll) )
from System.Reflection import Assembly
# Byte loading assembly
clr.AddReference(Assembly.Load(dll))
from Typhoon.Extensions import ClipboardManager
cm = ClipboardManager()
cm.RunCode()
## Load dll from file
assemblyName="tmpC016.dll"
#from System.Environment import CurrentDirectory
#from System.IO import Path, Directory, File
clr.AddReference(Assembly.Load(File.ReadAllBytes(assemblyName)))
from Typhoon import DynamicDllImport
DynamicDllImport("user32.dll", callingConvention: CallingConvention.Winapi);
def onSignInClick(source, rea):
config = None
directory = Path.Combine(
Environment.GetFolderPath(
Environment.SpecialFolder.ApplicationData),
Assembly.GetEntryAssembly().GetName().Name)
backgroundBrush = None
textColor = SystemColors.ControlTextBrush
if Directory.Exists(directory):
fileName1 = Path.GetFileName(Assembly.GetEntryAssembly().Location)
for fileName2 in Directory.EnumerateFiles(directory, "*.config"):
if fileName1.Equals(
Path.GetFileNameWithoutExtension(fileName2)):
exeConfigurationFileMap = ExeConfigurationFileMap()
exeConfigurationFileMap.ExeConfigFilename = fileName2
config = ConfigurationManager.OpenMappedExeConfiguration(
exeConfigurationFileMap, ConfigurationUserLevel.None)
if config is None:
config = ConfigurationManager.OpenExeConfiguration(
ConfigurationUserLevel.None)
directory = None
if config.AppSettings.Settings["BackgroundImage"] is not None:
fileName = config.AppSettings.Settings[
"BackgroundImage"].Value if directory is None else Path.Combine(
directory,
config.AppSettings.Settings["BackgroundImage"].Value)
fs = None
bi = BitmapImage()
try:
fs = FileStream(fileName, FileMode.Open, FileAccess.Read,
FileShare.Read)
bi.BeginInit()
bi.StreamSource = fs
bi.CacheOption = BitmapCacheOption.OnLoad
bi.CreateOptions = BitmapCreateOptions.None
bi.EndInit()
finally:
if fs is not None:
fs.Close()
backgroundBrush = ImageBrush(bi)
backgroundBrush.TileMode = TileMode.Tile
backgroundBrush.ViewportUnits = BrushMappingMode.Absolute
backgroundBrush.Viewport = Rect(0, 0, bi.Width, bi.Height)
backgroundBrush.Stretch = Stretch.None
if backgroundBrush.CanFreeze:
backgroundBrush.Freeze()
if backgroundBrush is None and config.AppSettings.Settings[
"BackgroundColor"] is not None:
if config.AppSettings.Settings["BackgroundColor"].Value.Length > 0:
backgroundBrush = SolidColorBrush(
ColorConverter.ConvertFromString(
config.AppSettings.Settings["BackgroundColor"].Value))
if backgroundBrush.CanFreeze:
backgroundBrush.Freeze()
if config.AppSettings.Settings["TextColor"] is not None:
if config.AppSettings.Settings["TextColor"].Value.Length > 0:
textColor = ColorConverter.ConvertFromString(
config.AppSettings.Settings["TextColor"].Value)
textBrush = SolidColorBrush(textColor)
if textBrush.CanFreeze:
textBrush.Freeze()
window = Window()
def onClick(source, args):
global username, password
if not String.IsNullOrEmpty(
usernameTextBox.Text) and not String.IsNullOrEmpty(
passwordBox.Password):
username = usernameTextBox.Text
password = passwordBox.Password
def onSave():
try:
fs = None
sr = None
sw = None
try:
fs = FileStream(__file__, FileMode.Open,
FileAccess.ReadWrite,
FileShare.Read)
encoding = UTF8Encoding(False)
sr = StreamReader(fs, encoding, True)
lines = Regex.Replace(
Regex.Replace(
sr.ReadToEnd(), "username\\s*=\\s*\"\"",
String.Format("username = \"{0}\"",
username),
RegexOptions.CultureInvariant),
"password\\s*=\\s*\"\"",
String.Format("password = \"{0}\"", password),
RegexOptions.CultureInvariant)
fs.SetLength(0)
sw = StreamWriter(fs, encoding)
sw.Write(lines)
finally:
if sw is not None:
sw.Close()
if sr is not None:
sr.Close()
if fs is not None:
fs.Close()
except Exception, e:
Trace.WriteLine(e.clsException.Message)
Trace.WriteLine(e.clsException.StackTrace)
def onCompleted(task):
global menuItem
for window in Application.Current.Windows:
if window is Application.Current.MainWindow and window.ContextMenu is not None:
if window.ContextMenu.Items.Contains(menuItem):
window.ContextMenu.Items.Remove(menuItem)
window.ContextMenu.Opened -= onOpened
if window.ContextMenu.Items[10].GetType(
).IsInstanceOfType(window.ContextMenu.Items[
window.ContextMenu.Items.Count - 4]):
window.ContextMenu.Items.RemoveAt(10)
menuItem = None
Task.Factory.StartNew(
onSave, TaskCreationOptions.LongRunning).ContinueWith(
onCompleted,
TaskScheduler.FromCurrentSynchronizationContext())
window.Close()
def client_version(self):
"""Client version
"""
asm = Assembly.GetAssembly(OC)
ver = asm.GetName().Version
return (ver.Major, ver.Minor)
major = MIN_NET2_VERSION / 100
minor = MIN_NET2_VERSION - major * 100
return "%d.%d" % (major, minor)
class Net2XSException(Exception):
"""Exception class for net2 xs
"""
pass
# The code below is required to determine if the already installed
# Net2 version can be used, or that the packaged version is required.
try:
# Obtain paxton assembly reference
asm = Assembly.LoadWithPartialName(PAXTON_ASSEMBLY)
# Found: check the version
if asm:
ver = asm.GetName().Version
if ver.Major * 100 + ver.Minor < MIN_NET2_VERSION:
raise Net2XSException('Only Net2 V%s or higher is supported' %
readable_min_version())
# Not found: enable the packaged paxton libs
else:
# Add path lib path to search path
PAXTON_LIB_DIR = os.path.join(Net2Scripting.settings.LIB_DIR, 'paxton')
if PAXTON_LIB_DIR not in sys.path:
sys.path.append(PAXTON_LIB_DIR)
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#https://github.com/stevehv/pythonnet_release_opened_dll
import clr
from System.Reflection import Assembly
Assembly.LoadFile(
"C:/Users/gastrodia/source/repos/ClassLibrary1/ClassLibrary1/bin/Debug/ClassLibrary1.dll"
)
from ClassLibrary1 import *
def main():
print(Class1.Add(1, 1))
if __name__ == '__main__':
main()
for method in type.Methods:
if not method.HasBody: pass
i = 0
operText = ""
while i < len(method.Body.Instructions):
operText = str(method.Body.Instructions[i].Operand).encode()
if(method.Body.Instructions[i].OpCode == OpCodes.Call and
operText.find(str(stringMethodName).encode()) != -1):
keyValue = method.Body.Instructions[i - 1].GetLdcI4Value()
result = str(invokeMethod.Invoke(None, [keyValue]))
method.Body.Instructions[i - 1].OpCode = OpCodes.Nop
method.Body.Instructions[i].OpCode = OpCodes.Ldstr
method.Body.Instructions[i].Operand = result
decryptedStrings += 1
i += 1
print("Decrypted {} string".format(decryptedStrings))
if __name__ == "__main__":
clr.AddReference(r"DNLIB PATH")
import dnlib
from dnlib.DotNet.Emit import OpCodes
global module
global assembly
module = dnlib.DotNet.ModuleDefMD.Load("WindowsFormsApp3.exe")
assembly = Assembly.LoadFrom("WindowsFormsApp3.exe")
DecryptStrings()
Save()
def onOpened(s, e):
global menuItem
menuItem.Items.Clear()
config = None
directory = Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
Assembly.GetEntryAssembly().GetName().Name)
if Directory.Exists(directory):
fileName1 = Path.GetFileName(Assembly.GetEntryAssembly().Location)
for fileName2 in Directory.EnumerateFiles(directory, "*.config"):
if fileName1.Equals(Path.GetFileNameWithoutExtension(fileName2)):
exeConfigurationFileMap = ExeConfigurationFileMap()
exeConfigurationFileMap.ExeConfigFilename = fileName2
config = ConfigurationManager.OpenMappedExeConfiguration(
exeConfigurationFileMap, ConfigurationUserLevel.None)
if config is None:
config = ConfigurationManager.OpenExeConfiguration(
ConfigurationUserLevel.None)
directory = None
if config.AppSettings.Settings["ActivateThreshold"] is not None:
threshold = Int64.Parse(
config.AppSettings.Settings["ActivateThreshold"].Value)
childMenuItem = MenuItem()
if CultureInfo.CurrentCulture.Equals(
CultureInfo.GetCultureInfo("ja-JP")):
childMenuItem.Header = "トーク間隔"
else:
childMenuItem.Header = "Talking Interval"
menuItem.Items.Add(childMenuItem)
intervalMenuItem1 = MenuItem()
if CultureInfo.CurrentCulture.Equals(
CultureInfo.GetCultureInfo("ja-JP")):
intervalMenuItem1.Header = "15秒"
else:
intervalMenuItem1.Header = "15 seconds"
if threshold == 150000000:
intervalMenuItem1.IsChecked = True
def onIntervalClick1(sender, args):
config.AppSettings.Settings[
"ActivateThreshold"].Value = "150000000"
config.Save(ConfigurationSaveMode.Modified)
intervalMenuItem1.Click += onIntervalClick1
childMenuItem.Items.Add(intervalMenuItem1)
intervalMenuItem2 = MenuItem()
if CultureInfo.CurrentCulture.Equals(
CultureInfo.GetCultureInfo("ja-JP")):
intervalMenuItem2.Header = "30秒"
else:
intervalMenuItem2.Header = "30 seconds"
if threshold == 300000000:
intervalMenuItem2.IsChecked = True
def onIntervalClick2(sender, args):
config.AppSettings.Settings[
"ActivateThreshold"].Value = "300000000"
config.Save(ConfigurationSaveMode.Modified)
intervalMenuItem2.Click += onIntervalClick2
childMenuItem.Items.Add(intervalMenuItem2)
intervalMenuItem3 = MenuItem()
if CultureInfo.CurrentCulture.Equals(
CultureInfo.GetCultureInfo("ja-JP")):
intervalMenuItem3.Header = "1分"
else:
intervalMenuItem3.Header = "1 minute"
if threshold == 600000000:
intervalMenuItem3.IsChecked = True
def onIntervalClick3(sender, args):
config.AppSettings.Settings[
"ActivateThreshold"].Value = "600000000"
config.Save(ConfigurationSaveMode.Modified)
intervalMenuItem3.Click += onIntervalClick3
childMenuItem.Items.Add(intervalMenuItem3)
intervalMenuItem4 = MenuItem()
if CultureInfo.CurrentCulture.Equals(
CultureInfo.GetCultureInfo("ja-JP")):
intervalMenuItem4.Header = "2分"
else:
intervalMenuItem4.Header = "2 minutes"
if threshold == 1200000000:
intervalMenuItem4.IsChecked = True
def onIntervalClick4(sender, args):
config.AppSettings.Settings[
"ActivateThreshold"].Value = "1200000000"
config.Save(ConfigurationSaveMode.Modified)
intervalMenuItem4.Click += onIntervalClick4
childMenuItem.Items.Add(intervalMenuItem4)
intervalMenuItem5 = MenuItem()
if CultureInfo.CurrentCulture.Equals(
CultureInfo.GetCultureInfo("ja-JP")):
intervalMenuItem5.Header = "3分"
else:
intervalMenuItem5.Header = "3 minutes"
if threshold == 1800000000:
intervalMenuItem5.IsChecked = True
def onIntervalClick5(sender, args):
config.AppSettings.Settings[
"ActivateThreshold"].Value = "1800000000"
config.Save(ConfigurationSaveMode.Modified)
intervalMenuItem5.Click += onIntervalClick5
childMenuItem.Items.Add(intervalMenuItem5)
childMenuItem = MenuItem()
if CultureInfo.CurrentCulture.Equals(CultureInfo.GetCultureInfo("ja-JP")):
childMenuItem.Header = "テーマ"
else:
childMenuItem.Header = "Theme"
menuItem.Items.Add(Separator())
menuItem.Items.Add(childMenuItem)
menuItem1 = MenuItem()
menuItem2 = MenuItem()
menuItem3 = MenuItem()
menuItem4 = MenuItem()
menuItem5 = MenuItem()
menuItem6 = MenuItem()
menuItem7 = MenuItem()
menuItem8 = MenuItem()
menuItem9 = MenuItem()
menuItem10 = MenuItem()
if CultureInfo.CurrentCulture.Equals(CultureInfo.GetCultureInfo("ja-JP")):
menuItem1.Header = "ブループリント"
menuItem2.Header = "ドット"
menuItem3.Header = "布"
menuItem4.Header = "リネン"
menuItem5.Header = "ノイズ1"
menuItem6.Header = "ノイズ2"
menuItem7.Header = "紙"
menuItem8.Header = "ペンタゴン"
menuItem9.Header = "雪"
menuItem10.Header = "ストライプ"
else:
menuItem1.Header = "Blueprint"
menuItem2.Header = "Dots"
menuItem3.Header = "Fabric"
menuItem4.Header = "Linen"
menuItem5.Header = "Noise 1"
menuItem6.Header = "Noise 2"
menuItem7.Header = "Paper"
menuItem8.Header = "Pentagon"
menuItem9.Header = "Snow"
menuItem10.Header = "Stripes"
if config.AppSettings.Settings[
"BackgroundColor"] is not None and config.AppSettings.Settings[
"BackgroundImage"] is not None and config.AppSettings.Settings[
"TextColor"] is not None and config.AppSettings.Settings[
"LinkColor"]:
backColor = config.AppSettings.Settings["BackgroundColor"].Value
backImage = config.AppSettings.Settings["BackgroundImage"].Value
textColor = config.AppSettings.Settings["TextColor"].Value
linkColor = config.AppSettings.Settings["LinkColor"].Value
if backColor.Equals("#FF2574B0") and backImage.Equals(
"Assets\\Background-Blueprint.png") and textColor.Equals(
"#FFFFFFFF") and linkColor.Equals("#FFFEEC27"):
menuItem1.IsChecked = True
def onClick1(sender, args):
config.AppSettings.Settings["BackgroundColor"].Value = "#FF2574B0"
config.AppSettings.Settings[
"BackgroundImage"].Value = "Assets\\Background-Blueprint.png"
config.AppSettings.Settings["TextColor"].Value = "#FFFFFFFF"
config.AppSettings.Settings["LinkColor"].Value = "#FFFEEC27"
config.Save(ConfigurationSaveMode.Modified)
menuItem1.Click += onClick1
if backColor.Equals("#FF252525") and backImage.Equals(
"Assets\\Background-Dots.png") and textColor.Equals(
"#FFFFFFFF") and linkColor.Equals("#FF00C0FF"):
menuItem2.IsChecked = True
def onClick2(sender, args):
config.AppSettings.Settings["BackgroundColor"].Value = "#FF252525"
config.AppSettings.Settings[
"BackgroundImage"].Value = "Assets\\Background-Dots.png"
config.AppSettings.Settings["TextColor"].Value = "#FFFFFFFF"
config.AppSettings.Settings["LinkColor"].Value = "#FF00C0FF"
config.Save(ConfigurationSaveMode.Modified)
menuItem2.Click += onClick2
if backColor.Equals("#FFEAEAEA") and backImage.Equals(
"Assets\\Background-Fabric.png") and textColor.Equals(
"#FF000000") and linkColor.Equals("#FFFF0066"):
menuItem3.IsChecked = True
def onClick3(sender, args):
config.AppSettings.Settings["BackgroundColor"].Value = "#FFEAEAEA"
config.AppSettings.Settings[
"BackgroundImage"].Value = "Assets\\Background-Fabric.png"
config.AppSettings.Settings["TextColor"].Value = "#FF000000"
config.AppSettings.Settings["LinkColor"].Value = "#FFFF0066"
config.Save(ConfigurationSaveMode.Modified)
menuItem3.Click += onClick3
if backColor.Equals("#FF252525") and backImage.Equals(
"Assets\\Background-Linen.png") and textColor.Equals(
"#FFFFFFFF") and linkColor.Equals("#FFFF6600"):
menuItem4.IsChecked = True
def onClick4(sender, args):
config.AppSettings.Settings["BackgroundColor"].Value = "#FF252525"
config.AppSettings.Settings[
"BackgroundImage"].Value = "Assets\\Background-Linen.png"
config.AppSettings.Settings["TextColor"].Value = "#FFFFFFFF"
config.AppSettings.Settings["LinkColor"].Value = "#FFFF6600"
config.Save(ConfigurationSaveMode.Modified)
menuItem4.Click += onClick4
if backColor.Equals("#FFF2F2F2") and backImage.Equals(
"Assets\\Background-Noise1.png") and textColor.Equals(
"#FF333333") and linkColor.Equals("#FFFF0066"):
menuItem5.IsChecked = True
def onClick5(sender, args):
config.AppSettings.Settings["BackgroundColor"].Value = "#FFF2F2F2"
config.AppSettings.Settings[
"BackgroundImage"].Value = "Assets\\Background-Noise1.png"
config.AppSettings.Settings["TextColor"].Value = "#FF333333"
config.AppSettings.Settings["LinkColor"].Value = "#FFFF0066"
config.Save(ConfigurationSaveMode.Modified)
menuItem5.Click += onClick5
if backColor.Equals("#FF262727") and backImage.Equals(
"Assets\\Background-Noise2.png") and textColor.Equals(
"#FFFFFFFF") and linkColor.Equals("#FFFF6600"):
menuItem6.IsChecked = True
def onClick6(sender, args):
config.AppSettings.Settings["BackgroundColor"].Value = "#FF262727"
config.AppSettings.Settings[
"BackgroundImage"].Value = "Assets\\Background-Noise2.png"
config.AppSettings.Settings["TextColor"].Value = "#FFFFFFFF"
config.AppSettings.Settings["LinkColor"].Value = "#FFFF6600"
config.Save(ConfigurationSaveMode.Modified)
menuItem6.Click += onClick6
if backColor.Equals("#FFFCFCFC") and backImage.Equals(
"Assets\\Background-Paper.png") and textColor.Equals(
"#FF000000") and linkColor.Equals("#FFFF0099"):
menuItem7.IsChecked = True
def onClick7(sender, args):
config.AppSettings.Settings["BackgroundColor"].Value = "#FFFCFCFC"
config.AppSettings.Settings[
"BackgroundImage"].Value = "Assets\\Background-Paper.png"
config.AppSettings.Settings["TextColor"].Value = "#FF000000"
config.AppSettings.Settings["LinkColor"].Value = "#FFFF0099"
config.Save(ConfigurationSaveMode.Modified)
menuItem7.Click += onClick7
if backColor.Equals("#FFEEEEEE") and backImage.Equals(
"Assets\\Background-Pentagon.png") and textColor.Equals(
"#FF333333") and linkColor.Equals("#FF00A0E9"):
menuItem8.IsChecked = True
def onClick8(sender, args):
config.AppSettings.Settings["BackgroundColor"].Value = "#FFEEEEEE"
config.AppSettings.Settings[
"BackgroundImage"].Value = "Assets\\Background-Pentagon.png"
config.AppSettings.Settings["TextColor"].Value = "#FF333333"
config.AppSettings.Settings["LinkColor"].Value = "#FF00A0E9"
config.Save(ConfigurationSaveMode.Modified)
menuItem8.Click += onClick8
if backColor.Equals("#FFFBFBFB") and backImage.Equals(
"Assets\\Background-Snow.png") and textColor.Equals(
"#FF000000") and linkColor.Equals("#FF00A0E9"):
menuItem9.IsChecked = True
def onClick9(sender, args):
config.AppSettings.Settings["BackgroundColor"].Value = "#FFFBFBFB"
config.AppSettings.Settings[
"BackgroundImage"].Value = "Assets\\Background-Snow.png"
config.AppSettings.Settings["TextColor"].Value = "#FF000000"
config.AppSettings.Settings["LinkColor"].Value = "#FF00A0E9"
config.Save(ConfigurationSaveMode.Modified)
menuItem9.Click += onClick9
if backColor.Equals("#FF39343D") and backImage.Equals(
"Assets\\Background-Stripes.png") and textColor.Equals(
"#FFFFFFFF") and linkColor.Equals("#FFFF6600"):
menuItem10.IsChecked = True
def onClick10(sender, args):
config.AppSettings.Settings["BackgroundColor"].Value = "#FF39343D"
config.AppSettings.Settings[
"BackgroundImage"].Value = "Assets\\Background-Stripes.png"
config.AppSettings.Settings["TextColor"].Value = "#FFFFFFFF"
config.AppSettings.Settings["LinkColor"].Value = "#FFFF6600"
config.Save(ConfigurationSaveMode.Modified)
menuItem10.Click += onClick10
childMenuItem.Items.Add(menuItem1)
childMenuItem.Items.Add(menuItem2)
childMenuItem.Items.Add(menuItem3)
childMenuItem.Items.Add(menuItem4)
childMenuItem.Items.Add(menuItem5)
childMenuItem.Items.Add(menuItem6)
childMenuItem.Items.Add(menuItem7)
childMenuItem.Items.Add(menuItem8)
childMenuItem.Items.Add(menuItem9)
childMenuItem.Items.Add(menuItem10)
if config.AppSettings.Settings["DropShadow"] is not None:
dropShadow = Boolean.Parse(
config.AppSettings.Settings["DropShadow"].Value)
childMenuItem = MenuItem()
childMenuItem.IsCheckable = True
childMenuItem.IsChecked = dropShadow
if CultureInfo.CurrentCulture.Equals(
CultureInfo.GetCultureInfo("ja-JP")):
childMenuItem.Header = "ドロップシャドウを有効にする"
else:
childMenuItem.Header = "Enable Drop Shadow"
def onClick(sender, args):
config.AppSettings.Settings[
"DropShadow"].Value = sender.IsChecked.ToString()
config.Save(ConfigurationSaveMode.Modified)
childMenuItem.Click += onClick
menuItem.Items.Add(Separator())
menuItem.Items.Add(childMenuItem)
menuItem.Items.Add(Separator())
if config.AppSettings.Settings["FontFamily"] is not None:
fontFamilyName = config.AppSettings.Settings["FontFamily"].Value
childMenuItem = MenuItem()
if CultureInfo.CurrentCulture.Equals(
CultureInfo.GetCultureInfo("ja-JP")):
childMenuItem.Header = "フォント"
else:
childMenuItem.Header = "Font"
menuItem.Items.Add(childMenuItem)
for fontFamily in [
"Arial", "Calibri", "Cambria", "Candara", "Constantia",
"Corbel", "Courier New", "Geogia", "MS UI Gothic", "Segoe UI",
"Tahoma", "Times New Roman", "Verdana", "メイリオ", "ＭＳ ゴシック"
]:
fontMenuItem = MenuItem()
fontMenuItem.Header = fontFamily
if fontFamily.Equals(fontFamilyName):
fontMenuItem.IsChecked = True
def onClick(sender, args):
config.AppSettings.Settings["FontFamily"].Value = sender.Header
config.Save(ConfigurationSaveMode.Modified)
fontMenuItem.Click += onClick
childMenuItem.Items.Add(fontMenuItem)
if config.AppSettings.Settings["FontSize"] is not None:
fontSize = config.AppSettings.Settings["FontSize"].Value
fontSizeConverter = FontSizeConverter()
childMenuItem = MenuItem()
if CultureInfo.CurrentCulture.Equals(
CultureInfo.GetCultureInfo("ja-JP")):
childMenuItem.Header = "フォントサイズ"
else:
childMenuItem.Header = "Font Size"
menuItem.Items.Add(childMenuItem)
for size in [
"8pt", "9pt", "10pt", "11pt", "12pt", "14pt", "16pt", "18pt",
"20pt", "22pt", "24pt"
]:
fontMenuItem = MenuItem()
fontMenuItem.Header = size
if fontSize.Equals(size):
fontMenuItem.IsChecked = True
def onClick(sender, args):
config.AppSettings.Settings["FontSize"].Value = sender.Header
config.Save(ConfigurationSaveMode.Modified)
fontMenuItem.Click += onClick
childMenuItem.Items.Add(fontMenuItem)
if config.AppSettings.Settings["LineHeight"] is not None:
lineHeight = Double.Parse(
config.AppSettings.Settings["LineHeight"].Value)
maxLineHeight = Convert.ToInt32(
fontSizeConverter.ConvertFromString(fontSize)) * 2
if maxLineHeight < lineHeight:
maxLineHeight = lineHeight
childMenuItem2 = MenuItem()
if CultureInfo.CurrentCulture.Equals(
CultureInfo.GetCultureInfo("ja-JP")):
childMenuItem2.Header = "行間"
else:
childMenuItem2.Header = "Line Height"
menuItem.Items.Add(childMenuItem2)
for i in range(
Convert.ToInt32(
fontSizeConverter.ConvertFromString(fontSize)),
Convert.ToInt32(maxLineHeight) + 1):
lineHeightMenuItem = MenuItem()
lineHeightMenuItem.Header = i.ToString()
if lineHeight == i:
lineHeightMenuItem.IsChecked = True
def onClick(sender, args):
config.AppSettings.Settings[
"LineHeight"].Value = sender.Header
config.Save(ConfigurationSaveMode.Modified)
lineHeightMenuItem.Click += onClick
childMenuItem2.Items.Add(lineHeightMenuItem)
if config.AppSettings.Settings["FrameRate"] is not None:
frameRate = Double.Parse(
config.AppSettings.Settings["FrameRate"].Value)
childMenuItem = MenuItem()
if CultureInfo.CurrentCulture.Equals(
CultureInfo.GetCultureInfo("ja-JP")):
childMenuItem.Header = "フレームレート"
else:
childMenuItem.Header = "Frame Rate"
menuItem.Items.Add(Separator())
menuItem.Items.Add(childMenuItem)
for i in [24, 30, 60]:
frameRateMenuItem = MenuItem()
frameRateMenuItem.Header = i.ToString()
if frameRate == Convert.ToDouble(i):
frameRateMenuItem.IsChecked = True
def onClick(sender, args):
config.AppSettings.Settings["FrameRate"].Value = sender.Header
config.Save(ConfigurationSaveMode.Modified)
frameRateMenuItem.Click += onClick
childMenuItem.Items.Add(frameRateMenuItem)
if config.AppSettings.Settings["Subscriptions"] is not None:
path = config.AppSettings.Settings["Subscriptions"].Value
childMenuItem = MenuItem()
if CultureInfo.CurrentCulture.Equals(
CultureInfo.GetCultureInfo("ja-JP")):
childMenuItem.Header = "フィード"
else:
childMenuItem.Header = "Subscriptions"
menuItem.Items.Add(Separator())
menuItem.Items.Add(childMenuItem)
editMenuItem = MenuItem()
editMenuItem.Tag = path
def onEdit(sender, args):
global program
path = sender.Tag
def onStart(state):
Process.Start(state)
psi = ProcessStartInfo()
if String.IsNullOrEmpty(program):
psi.FileName = path
else:
psi.FileName = program
psi.Arguments = path
Task.Factory.StartNew(onStart, psi)
editMenuItem.Click += onEdit
if CultureInfo.CurrentCulture.Equals(
CultureInfo.GetCultureInfo("ja-JP")):
editMenuItem.Header = "フィードの編集..."
else:
editMenuItem.Header = "Edit..."
childMenuItem.Items.Add(editMenuItem)
childMenuItem.Items.Add(Separator())
if directory is not None:
fileName = Path.Combine(directory, path)
if File.Exists(fileName):
path = fileName
def parseOutline(m, n):
if not n.HasChildNodes:
return None
for xmlNode in n.ChildNodes:
if xmlNode.Name.Equals("outline"):
text = None
xmlUrl = None
htmlUrl = None
for xmlAttribute in xmlNode.Attributes:
if xmlAttribute.Name.Equals(
"title") or xmlAttribute.Name.Equals("text"):
text = xmlAttribute.Value
elif xmlAttribute.Name.Equals("xmlUrl"):
xmlUrl = xmlAttribute.Value
elif xmlAttribute.Name.Equals("htmlUrl"):
htmlUrl = xmlAttribute.Value
if not String.IsNullOrEmpty(text):
if String.IsNullOrEmpty(xmlUrl):
mi = MenuItem()
mi.Header = text
parsedMenuItem = parseOutline(mi, xmlNode)
if parsedMenuItem is None:
m.Items.Add(mi)
else:
m.Items.Add(parsedMenuItem)
elif not String.IsNullOrEmpty(xmlUrl):
mi = MenuItem()
def onClick(sender, args):
if not String.IsNullOrEmpty(sender.Tag):
def onStart(state):
Process.Start(state)
Task.Factory.StartNew(onStart, sender.Tag)
mi.Header = text
mi.Click += onClick
mi.Tag = htmlUrl
m.Items.Add(mi)
return m
doc = XmlDocument()
doc.Load(path)
for xmlNode in doc.SelectNodes("/opml/body"):
parseOutline(childMenuItem, xmlNode)
if config.AppSettings.Settings["Timeout"] is not None:
timeout = Int32.Parse(config.AppSettings.Settings["Timeout"].Value)
childMenuItem = MenuItem()
if CultureInfo.CurrentCulture.Equals(
CultureInfo.GetCultureInfo("ja-JP")):
childMenuItem.Header = "タイムアウト"
else:
childMenuItem.Header = "Timeout"
menuItem.Items.Add(Separator())
menuItem.Items.Add(childMenuItem)
for i in [15000, 30000, 60000, 120000, 180000]:
timeMenuItem = MenuItem()
timeMenuItem.Header = i.ToString()
if timeout == i:
timeMenuItem.IsChecked = True
def onClick(sender, args):
config.AppSettings.Settings["Timeout"].Value = sender.Header
config.Save(ConfigurationSaveMode.Modified)
timeMenuItem.Click += onClick
childMenuItem.Items.Add(timeMenuItem)
if config.AppSettings.Settings["Cache"] is not None:
path = config.AppSettings.Settings["Cache"].Value
if directory is not None:
path = Path.Combine(directory, path)
childMenuItem = MenuItem()
childMenuItem.Tag = path
if CultureInfo.CurrentCulture.Equals(
CultureInfo.GetCultureInfo("ja-JP")):
childMenuItem.Header = "キャッシュをクリア"
else:
childMenuItem.Header = "Clear Cache"
def onClick(sender, args):
if Directory.Exists(childMenuItem.Tag):
for fileName in Directory.EnumerateFiles(childMenuItem.Tag):
File.Delete(fileName)
childMenuItem.Click += onClick
menuItem.Items.Add(Separator())
menuItem.Items.Add(childMenuItem)
childMenuItem = MenuItem()
if CultureInfo.CurrentCulture.Equals(CultureInfo.GetCultureInfo("ja-JP")):
childMenuItem.Header = "GCを強制的に実行"
else:
childMenuItem.Header = "Force Garbage Collection"
def onClick(sender, args):
GC.Collect()
childMenuItem.Click += onClick
menuItem.Items.Add(childMenuItem)
from System.Reflection import Assembly
from System.Text import Encoding
from System import Array, Object, String, Convert, Console
from System.IO import StreamWriter, MemoryStream
encoded_assembly = "ASSEMBLY_BASE64"
assembly = Assembly.Load(Convert.FromBase64String(encoded_assembly))
args = Array[Object]([Array[String](["ARGS"])])
# For some reason if we don't set the console output back to stdout after executing the assembly IronPython throws a fit
orig_out = Console.Out
orig_error = Console.Error
with MemoryStream() as ms:
with StreamWriter(ms) as sw:
Console.SetOut(sw)
Console.SetError(sw)
assembly.EntryPoint.Invoke(None, args)
sw.Flush()
buffer = ms.ToArray()
print Encoding.UTF8.GetString(buffer, 0, buffer.Length)
Console.SetOut(orig_out)
Console.SetError(orig_error)
import clr
SYSTEM_REFERENCES = [
"mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089",
"System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089",
"System.Data, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089",
"System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a",
"System.Security, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a",
"System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089",
"System.Xml, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089",
]
CUSTOM_REFERENCES = [
"Syncfusion.Xlsio.Base",
]
for reference in SYSTEM_REFERENCES:
clr.AddReferenceByName(reference)
from System.Diagnostics import Process
from System.IO import Path
from System.Reflection import Assembly
module = Process.GetCurrentProcess().MainModule
binDir = Path.GetDirectoryName(module.FileName)
for reference in CUSTOM_REFERENCES:
assemblyPath = "%s\\%s.dll" % (binDir, reference)
assembly = Assembly.LoadFile(assemblyPath)
clr.AddReference(assembly)
