def test_compiled_code():
if System.Environment.GetEnvironmentVariable('DLR_SaveAssemblies'):
# The SaveAssemblies option is not compatible with saving code to disk
print '... skipping test if DLR_SaveAssemblies is set...'
return
import clr
pyil = os.path.join(testpath.temporary_dir, 'test.pyil')
# make sure we can compile
clr.CompileModules(pyil,
os.path.join(testpath.public_testdir, 'test_class.py'))
# make sure we can compile multiple files
clr.CompileModules(pyil,
os.path.join(testpath.public_testdir, 'test_class.py'),
os.path.join(testpath.public_testdir, 'test_slice.py'))
clr.AddReferenceToFileAndPath(pyil)
import nt
# and make sure we can run some reasonable sophisticated code...
System.IO.File.Move(os.path.join(testpath.public_testdir, 'test_class.py'),
'old_test_class.py')
try:
import test_class
Assert(test_class.test_oldstyle_getattr.__doc__ != '')
finally:
System.IO.File.Move(
'old_test_class.py',
os.path.join(testpath.public_testdir, 'test_class.py'))
def test_overwrite():
write_to_file(path_combine(testpath.temporary_dir, "overwrite.py"), "def foo(): return 'bar'")
dllFile = path_combine(testpath.temporary_dir, "overwrite.dll")
clr.CompileModules(dllFile, path_combine(testpath.temporary_dir, "overwrite.py"))
write_to_file(path_combine(testpath.temporary_dir, "overwrite1.py"), "def foo(): return 'boo'")
clr.CompileModules(dllFile, path_combine(testpath.temporary_dir, "overwrite1.py"))
clr.AddReferenceToFileAndPath(dllFile)
import overwrite1
AreEqual(overwrite1.foo(), 'boo')
def test_overwrite(self):
import clr
self.write_to_file(os.path.join(self.temporary_dir, "overwrite.py"), "def foo(): return 'bar'")
dllFile = os.path.join(self.temporary_dir, "overwrite.dll")
clr.CompileModules(dllFile, os.path.join(self.temporary_dir, "overwrite.py"))
self.write_to_file(os.path.join(self.temporary_dir, "overwrite1.py"), "def foo(): return 'boo'")
clr.CompileModules(dllFile, os.path.join(self.temporary_dir, "overwrite1.py"))
clr.AddReferenceToFileAndPath(dllFile)
import overwrite1
self.assertEqual(overwrite1.foo(), 'boo')
def test_load_order_modfile():
fileName = path_combine(testpath.temporary_dir, "loadOrderMod.py")
dllName = path_combine(testpath.temporary_dir, "loadOrderMod.dll")
write_to_file(fileName, "def f(): return 'hello'")
clr.CompileModules(dllName, fileName)
write_to_file(fileName, "def f(): return 'bonjour'")
clr.AddReferenceToFileAndPath(dllName)
import loadOrderMod
AreEqual(loadOrderMod.f(), 'hello')
def test_load_order_modfile(self):
import clr
fileName = os.path.join(self.temporary_dir,"loadOrderMod.py")
dllName = os.path.join(self.temporary_dir,"loadOrderMod.dll")
self.write_to_file(fileName, "def f(): return 'hello'")
clr.CompileModules(dllName, fileName)
self.write_to_file(fileName, "def f(): return 'bonjour'")
clr.AddReferenceToFileAndPath(dllName)
import loadOrderMod
self.assertEqual(loadOrderMod.f(), 'hello')
def compileCode(name, *codeArr):
inputFiles = []
counter = 0
for code in codeArr:
inputFile = path_combine(testpath.temporary_dir, name + ("" if counter == 0 else str(counter)) + ".py")
write_to_file(inputFile, code)
inputFiles.append(inputFile)
counter+=1
dllFile = path_combine(testpath.temporary_dir, name + ".dll")
clr.CompileModules(dllFile, mainModule=inputFiles[0], *inputFiles)
delete_files(*inputFiles)
clr.AddReferenceToFileAndPath(dllFile)
def compileDLL_ipy(outname,files):
compileOptions={
# "mainModule":"aaa" ,
"assemblyFileVersion":"0.0.0.0",
"copyright":"By wangzht",
"productName":"For Potevio",
"productVersion":"0.0.0.1"
}
# import System
import clr
# files = ["LibSRC/backupmail.py","LibSRC/CSVProc.py","LibSRC/Odbc2ADLib.py","LibSRC/Shell.py","LibSRC/XLSCombine.py","LibSRC/Exdecision.py"]
clr.CompileModules( outname ,*files ,**compileOptions);
def compilePackage(packageName, codeDict):
packagePath = path_combine(testpath.temporary_dir, packageName)
ensure_directory_present(packagePath)
fileList = []
for fileName, code in codeDict.iteritems():
filePath = path_combine(packagePath, fileName)
ensure_directory_present(Path.GetDirectoryName(filePath))
write_to_file(filePath, code)
fileList.append(filePath)
dllFile = path_combine(testpath.temporary_dir, packageName + ".dll")
clr.CompileModules(dllFile, mainModule=fileList[0], *fileList)
delete_files(*fileList)
clr.AddReferenceToFileAndPath(dllFile)
def compileCode(self, name, *codeArr):
import clr
inputFiles = []
counter = 0
for code in codeArr:
inputFile = os.path.join(self.temporary_dir, name + ("" if counter == 0 else str(counter)) + ".py")
self.write_to_file(inputFile, code)
inputFiles.append(inputFile)
counter+=1
dllFile = os.path.join(self.temporary_dir, name + ".dll")
clr.CompileModules(dllFile, mainModule=inputFiles[0], *inputFiles)
self.delete_files(*inputFiles)
clr.AddReferenceToFileAndPath(dllFile)
def test_gh1357(self):
filename = os.path.join(self.temporary_dir, 'gh1357.py')
dll = os.path.join(self.temporary_dir, "test.dll")
with open(filename, 'w') as f:
f.write('{(1,): None}')
import clr
try:
clr.CompileModules(dll, filename)
except:
Fail('Failed to compile the specified file')
finally:
os.unlink(filename)
os.unlink(dll)
def compilePackage(self, packageName, codeDict):
import clr
packagePath = os.path.join(self.temporary_dir, packageName)
self.ensure_directory_present(packagePath)
fileList = []
for fileName, code in codeDict.items():
filePath = os.path.join(packagePath, fileName)
self.ensure_directory_present(os.path.dirname(filePath))
self.write_to_file(filePath, code)
fileList.append(filePath)
dllFile = os.path.join(self.temporary_dir, packageName + ".dll")
clr.CompileModules(dllFile, mainModule=fileList[0], *fileList)
self.delete_files(*fileList)
clr.AddReferenceToFileAndPath(dllFile)
def main():
if len(sys.argv) != 2:
print "Usage: ipy run_compiled.py <testfile.py>"
sys.exit(-1)
testName = sys.argv[1]
print "Compiling ", testName ,"..."
clr.CompileModules("compiledTest.dll", testName)
File.Move(testName, testName+".bak")
try:
print "Running test from compiled binary..."
clr.AddReference("compiledTest")
__import__(Path.GetFileNameWithoutExtension(testName))
finally:
File.Move(testName+".bak" , testName)
def Main(args):
files = []
config = Config()
config.ParseArgs(args)
if not config.Validate():
print __doc__
sys.exit(0)
print config
print "Compiling..."
clr.CompileModules(config.output + ".dll", mainModule = config.main_name, *config.files)
if config.target != System.Reflection.Emit.PEFileKinds.Dll:
GenerateExe(config)
print "Saved to %s" % (config.output, )
from System import IO as IO
import os
def walk(folder):
for file in IO.Directory.GetFiles(folder):
yield file
for folder in IO.Directory.GetDirectories(folder):
for file in walk(folder):
yield file
folder = os.path.dirname(os.path.abspath(__file__))
#pygments_files = list(walk(IO.Combine(folder, 'pygments')))
#pygments_dependencies = list(walk(Combine(folder,'pygments_dependencies')))
all_files = [f for f in walk(folder) if f[-2:] == 'py']
#print all_files
#pygments_files + pygments_dependencies
#all_files.append(IO.Path.Combine(folder, 'devhawk_formatter.py'))
import clr
clr.CompileModules(folder + ".dll", *all_files)
from System import IO
import sys
import clr
def walk(dir):
for file in IO.Directory.GetFiles(dir):
yield file
for dir in IO.Directory.GetDirectories(dir):
for file in walk(dir):
yield file
if __name__ == "__main__":
all_files = list(walk(sys.argv[1]))
exceptions = [
"shotgun_api3\lib\httplib2\cacerts.txt",
"shotgun_api3\lib\simplejson\_speedups.c",
"site-packages\README.txt",
]
files = [
e for e in all_files if e[len(sys.argv[1]) + 1:] not in exceptions
]
print "Compiling:\n %s" % "\n ".join(
[e[len(sys.argv[1]) + 1:] for e in files])
clr.CompileModules(sys.argv[2], *files)
print "Created %s" % sys.argv[2]
def main(badger_file, editable, install, rhino_version, skip_compatibility_check):
if not skip_compatibility_check:
# Asserts rhino version is installed and compatible with IronPython used.
rhino_to_ipy_version = {
'6': ['2.7.8'],
'7': ['2.7.8', '2.7.9']
}
ipy_version_actual = '{}.{}.{}'.format(sys.version_info.major, sys.version_info.minor, sys.version_info.micro)
ipy_version_allowed = rhino_to_ipy_version[rhino_version]
# Checks that IronPython is being used
assert platform.python_implementation() == 'IronPython', "You need to use IronPython to badger your components. Currently using {}".format(platform.python_implementation())
assert ipy_version_actual in ipy_version_allowed, \
"IronPython version does not match for Rhino {rhino_version}. Must be {version_target} but was {version_actual}".format(
rhino_version=rhino_version,
version_target=' or '.join(ipy_version_allowed),
version_actual=ipy_version_actual
)
assert os.path.exists(
os.path.join(os.path.expandvars("${PROGRAMFILES}"),
"Rhino {v}".format(v=rhino_version),
"Plug-ins", "Grasshopper", "Grasshopper.dll")), \
"Could not find Grasshopper.dll. Is Rhino {v} installed?".format(v=rhino_version)
assert os.path.exists(
os.path.join(os.path.expandvars("${PROGRAMFILES}"),
"Rhino {v}".format(v=rhino_version),
"System", "RhinoCommon.dll")), \
"Could not find RhinoCommon.dll. Is Rhino {v} installed?".format(v=rhino_version)
parameter_compiler.setup(rhino_version)
try:
# temporary create the helloworld dll adding the honey-badger.json to it
with open(badger_file, mode='r') as bf:
badger_file_contents = bf.read()
badger_config = json.loads(badger_file_contents)
badger_dir = os.path.abspath(os.path.dirname(badger_file))
build_dir = os.path.join(badger_dir, '_build')
if not os.path.exists(build_dir):
os.makedirs(build_dir)
badger_config = check_badger_config(badger_config, badger_dir)
template = string.Template(TEMPLATE)
guid = badger_config["id"].replace('-', '_')
hb_main_py = 'honey_badger_{guid}.py'.format(guid=guid)
with open(os.path.join(build_dir, hb_main_py), 'w') as hb_main:
json_badger_config = json.dumps(badger_config, indent=4)
assert not "'''" in json_badger_config, "Tripple single quotes not allowed in badger-file!"
json_badger_config = json_badger_config.replace("\\", "\\\\") # make sure we escape backslashes
hb_main.write(template.substitute(badger_config=json_badger_config, guid=guid))
# copy hblib.py to build dir
src_hblib_py = os.path.join(os.path.dirname(os.path.normpath(os.path.abspath(__file__))), 'hblib.py')
dst_hblib_py = os.path.join(build_dir, "hblib_{guid}.py".format(guid=guid))
# print("Copying hblib.py from {src} to {dst}".format(src=src_hblib_py, dst=dst_hblib_py))
shutil.copy(src_hblib_py, dst_hblib_py)
# compile to .ghpy file
ghpy_path = os.path.join(build_dir, "{}.ghpy".format(badger_config['name']))
clr.CompileModules(ghpy_path,
os.path.join(build_dir, hb_main_py),
dst_hblib_py,
*[os.path.join(badger_dir, f) for f in badger_config['include-files']])
gha_path = os.path.join(build_dir, "{}.gha".format(badger_config['name']))
if "parameters" in badger_config:
parameter_compiler.compile_parameters(
badger_config, badger_dir, os.path.join(build_dir, gha_path))
if install:
destination = os.path.join(os.path.expandvars("${APPDATA}"), "Grasshopper", "Libraries")
print('installing {ghpy_name} to {destination}'.format(
ghpy_name=os.path.basename(ghpy_path), destination=destination))
shutil.copy(ghpy_path, destination)
if "parameters" in badger_config:
print("installing {gha_name} to {destination}".format(
gha_name=os.path.basename(gha_path), destination=destination))
shutil.copy(gha_path, destination)
hbrt_path = os.path.join(os.path.dirname(os.path.normpath(os.path.abspath(__file__))),
"honey-badger-runtime", "bin", "honey-badger-runtime.dll")
print("installing {hbrt_name} to {destination}".format(
hbrt_name=os.path.basename(hbrt_path), destination=destination))
shutil.copy(hbrt_path, destination)
# copy additional files (from "include-install")
for file_name in badger_config["include-install"]:
if os.path.isabs(file_name):
file_path = file_name
else:
# relative paths are relative to the folder containing the badger-file
file_path = os.path.join(badger_dir, file_name)
assert os.path.exists(file_path), "Could not locate file: {}".format(file_path)
print("copying {file_path} to {destination}".format(**locals()))
shutil.copy(file_path, destination)
print('done.')
except:
print traceback.print_exc()
# Taken from https://github.com/devhawk/pygments.wlwriter
from System import IO
def walk(folder):
for file in IO.Directory.GetFiles(folder, '*.py'):
yield file
for folder in IO.Directory.GetDirectories(folder):
for file in walk(folder): yield file
folder = IO.Path.GetDirectoryName(__file__)
pygments_files = list(walk(IO.Path.Combine(folder, 'pygments')))
pygments_dependencies = list(walk(IO.Path.Combine(folder, 'dependencies')))
#pygments_dependencies = list(walk(IO.Path.Combine(folder, '..\..\packages\IronPython.StdLib.2.7.5\content\Lib' )))
all_files = pygments_files + pygments_dependencies
import clr
clr.CompileModules(IO.Path.Combine(folder, "..\..\intermediate\pygments.dll"), *all_files)
pass
else:
File.Copy(filename, new_filename)
try:
# make build dir if needed
if not path.exists(build_dir):
os.mkdir(build_dir)
# get list of files to put in dll
filenames = os.listdir("BioIronPython")
for i in range(0, len(filenames)):
filenames[i] = "BioIronPython\\" + filenames[i]
# build dll
clr.CompileModules(build_dir + "\\Bio.IronPython.dll", *filenames)
# copy demo file
deploy_file("BioMenu.py")
deploy_file("..\\..\\..\\Build\\Binaries\\Debug\\Bio.dll")
deploy_file("..\\..\\..\\Build\\Binaries\\Debug\\Bio.WebServiceHandlers.dll")
# copy test file
deploy_file("Data\\Small_Size.gbk")
# run the demo
import BioMenu
except:
print "An error occurred: " + `sys.exc_info()` + "\n"
from System import IO
def walk(folder):
for file in IO.Directory.GetFiles(folder):
yield file
for folder in IO.Directory.GetDirectories(folder):
for file in walk(folder): yield file
folder = IO.Path.GetDirectoryName(__file__)
pygments_files = list(walk(IO.Path.Combine(folder, 'pygments')))
pygments_dependencies = list(walk(IO.Path.Combine(folder, 'pygments_dependencies')))
all_files = pygments_files + pygments_dependencies
all_files.append(IO.Path.Combine(folder, 'devhawk_formatter.py'))
import clr
clr.CompileModules(IO.Path.Combine(folder, "..\external\pygments.dll"), *all_files)
import clr
clr.CompileModules("lineComponent.pygha", "makeLine.py")
# -*- coding: UTF-8 -*-
import clr
clr.AddReference("System.Windows.Forms")
import System
def walk(folder):
for file in System.IO.Directory.GetFiles(folder, '*.py'):
yield file
for folder in System.IO.Directory.GetDirectories(folder):
for file in walk(folder):
yield file
folder = System.IO.Path.GetDirectoryName(__file__) + "\\PythonScript\\"
#pygments_files = list(walk(IO.Path.Combine(folder, 'pygments')))
#pygments_dependencies = list(walk(IO.Path.Combine(folder, 'pygments_dependencies')))
#all_files = pygments_files + pygments_dependencies
#all_files.append(IO.Path.Combine(folder, 'devhawk_formatter.py'))
all_files = list(walk(folder))
#all_files.remove(__file__);
#for i in all_files:
# System.Windows.Forms.MessageBox.Show(i);
clr.CompileModules(
System.IO.Path.Combine(folder, "..\\reference\\PythonScript.dll"),
*all_files)
import clr
import os
DIR = "Builds/makes/"
s = float('123.56')
i = int(s)
for filename in os.listdir('.'):
print(filename)
if not os.path.isfile(filename):
continue
splits = os.path.splitext(filename)
if splits[1] == ".py":
name = splits[0]
print(name)
if name == 'make_dll':
continue
clr.CompileModules(DIR + name + ".dll", filename)
print('Make dll completed,start to make encrypt dll ..')
cmd = "co.exe projectfile=E:\\workspace\\git\\PA.Scripts\\scripts.obproj"
os.system(cmd)
import os
import clr
basedir = 'C:\\Program Files (x86)\\IronPython 2.7\\'
all_files = []
for dir, blah, files in os.walk(basedir + 'Lib'):
if dir.startswith('Lib\\site-packages'):
print('skipping', dir)
continue
for file in files:
if file.endswith('.py'):
if file in ['platform.py']:
continue
all_files.append(dir + '\\' + file)
clr.CompileModules('z:\\Documents\\ipy-issues\\issues\\LibPy.dll', *all_files)
def Main(args):
files = []
main = None # The main file to start the execution (passed to the PythonCompiler)
main_name = None # File which will drive the name of the assembly if "output" not provided
output = None # Output assembly name
target = System.Reflection.Emit.PEFileKinds.Dll
platform = System.Reflection.PortableExecutableKinds.ILOnly
machine = System.Reflection.ImageFileMachine.I386
for arg in args:
if arg.startswith("/main:"):
main_name = main = arg[6:]
target = System.Reflection.Emit.PEFileKinds.ConsoleApplication
elif arg.startswith("/out:"):
output = arg[5:]
elif arg.startswith("/target:"):
tgt = arg[8:]
if tgt == "exe":
target = System.Reflection.Emit.PEFileKinds.ConsoleApplication
elif tgt == "winexe":
target = System.Reflection.Emit.PEFileKinds.WindowApplication
else:
target = System.Reflection.Emit.PEFileKinds.Dll
elif arg.startswith("/platform:"):
pform = arg[10:]
if pform == "x86":
platform = System.Reflection.PortableExecutableKinds.ILOnly | System.Reflection.PortableExecutableKinds.Required32Bit
machine = System.Reflection.ImageFileMachine.I386
elif pform == "x64":
platform = System.Reflection.PortableExecutableKinds.ILOnly | System.Reflection.PortableExecutableKinds.PE32Plus
machine = System.Reflection.ImageFileMachine.AMD64
else:
platform = System.Reflection.PortableExecutableKinds.ILOnly
machine = System.Reflection.ImageFileMachine.I386
elif arg in ["/?", "-?", "/h", "-h"]:
print __doc__
sys.exit(0)
else:
files.append(arg)
if not files and not main_name:
print __doc__
sys.exit(0)
if target != System.Reflection.Emit.PEFileKinds.Dll and main_name == None:
print __doc__
sys.exit(0)
print "EXEs require /main:<filename> to be specified"
if not output and main_name:
output = System.IO.Path.GetFileNameWithoutExtension(main_name)
elif not output and files:
output = System.IO.Path.GetFileNameWithoutExtension(files[0])
print "Input Files:"
for file in files:
print "\t%s" % file
print "Output:\n\t%s" % output
print "Target:\n\t%s" % target
print 'Platform:\n\t%s' % platform
print 'Machine:\n\t%s' % machine
print 'Compiling...'
clr.CompileModules(output + '.dll', mainModule=main_name, *files)
if target != System.Reflection.Emit.PEFileKinds.Dll:
GenerateExe(output, target, platform, machine, main_name)
print 'Saved to %s' % (output, )
def Main(args):
config = Config()
config.ParseArgs(args)
if not config.Validate(config):
print __doc__
sys.exit(0)
if config.verbose:
res = ''
print 'Compiling with config:\n'
if 'StdLib' in config.output:
res = "Input Files - see:{}\n" \
.format(config.output + '.txt')
else:
res += "Input Files - see below 'Setting up compile' output\n"
res += "Output:\n\t%s\n" % config.output
res += "Target:\n\t%s\n" % config.target
res += "Platform:\n\t%s\n" % config.platform
res += "Machine:\n\t%s\n" % config.machine
if config.target == System.Reflection.Emit.PEFileKinds.WindowApplication:
res += "Threading:\n"
if config.mta:
res += "\tMTA\n"
else:
res += "\tSTA\n"
print res
#hdunn 4/3/2018 -try clr.CompileMods
msg = ''
pre = ''
if config.verbose:
print "Setting up full compile: "
pre = '\nSending internal to clr.ComplierModules:\n'
msg = msg + '\tconifg.ouput is: {}\n'.format(config.output)
msg = msg + '\tconfig.main_name is: {}\n'.format(config.main_name)
if config.files and config.verbose:
#hdunn 4/6/2018 output ----------
if 'StdLib' in config.output:
cfiles = list(config.files)
cfiles.sort()
with open( config.output + '.txt', 'w') as tw:
tw.writelines(('\n').join(cfiles))
else:
msg = msg + ('\tconfig.files:\n\t' + '{} \n\t'*len(config.files)) \
.format(*config.files)
print 'config.files len: ' + str(len(config.files))
if config.dlls and config.verbose and not 'StdLib' in config.output:
msg = msg + ('\n\n\tproject config.dlls (no re-compile):\n\t' + \
'{} \n\t'*len(config.dlls)).format(*config.dlls)
print 'config.dlls len: ' + str(len(config.dlls))
elif config.verbose and not config.files and not config.dlls:
msg = msg + '\nconfig.files and config.dlls are empty:'
print str(pre + msg)
#hdunn 4/6/2018 Try ----------
try:
print 'Compiling dlls ...'
print ' main name - ' + str(config.main_name)
clr.CompileModules(config.output + ".dll",
mainModule = config.main_name,
*config.files)
except Exception as ex:
pre = ('FATAL ERROR - Internal clr.ComplierModules:' + \
'\n - possible bad file in config.files:' + \
'\n - This Error will cause additional Errors:' + \
'\n - Err like:\n {} - acces denied or does not exist.') \
.format(config.output + '.exe')
print(str(ex)[:255] + ' ...' + '\n' + pre + msg)
if config.target != System.Reflection.Emit.PEFileKinds.Dll:
# read bytes while using dll in compile
# 4.11.2018 Copyright 2018 - hdunn. Apache 2.0 licensed. Modified from original.
System.IO.File.Copy(config.output + ".dll",
config.output + ".IPDLL",
True)
# ------------------------------------------
#config.dlls.append(config.output + '.dll')
if config.verbose: print 'Gen Start'
GenerateExe(config)
from System import IO
from System.IO.Path import Combine
def walk(folder):
for file in IO.Directory.GetFiles(folder):
yield file
for folder in IO.Directory.GetDirectories(folder):
for file in walk(folder): yield file
folder = IO.Path.GetDirectoryName(__file__)
all_files = list(walk(Combine(folder, 'moduleName')))
import clr
clr.CompileModules(Combine(folder, "myDll.dll"), *all_files)
import sys
import os.path as op
import clr
from pyrevit import USER_SYS_TEMP
from pyrevit import script
from pyrevit.framework import IO
# compile
try:
source = script.get_bundle_file('ipycompiletest.py')
dest = op.join(USER_SYS_TEMP, 'compiledipytest.dll')
clr.CompileModules(dest, source)
except IO.IOException as ioerr:
print('DLL file already exists...')
except Exception as cerr:
print('Compilation failed: {}'.format(cerr))
# import test
sys.path.append(USER_SYS_TEMP)
clr.AddReferenceToFileAndPath(dest)
import ipycompiletest
ipycompiletest.compile_test('Compiled function works.')
ipycompiletest.CompiledType('Compiled type works.')
import clr
clr.CompileModules("Githopper.1.3.1.p2.7.5.0.ghpy", "Githopper.py")
import os
import clr
def get_complete_file_list(root_directory):
walk_result = os.walk(root_directory)
return [os.path.join(dp, f) for dp, dn, fns in walk_result for f in fns]
base_directory = os.path.dirname(__file__)
jinja2_src_directory = os.path.join(base_directory,
'nJinja/jinja2_package/jinja2')
dependencies_src_directory = os.path.join(
base_directory, 'nJinja/jinja2_package/dependencies')
all_files = get_complete_file_list(
jinja2_src_directory) + get_complete_file_list(dependencies_src_directory)
jinja2_bin_path = os.path.join(os.path.dirname(__file__),
'nJinja/jinja2_package/jinja2.dll')
clr.CompileModules(jinja2_bin_path, *all_files)
import clr
clr.AddReference('pygments')
code = '''import os
def get_all_files(folder):
files = []
for (dirpath, dirnames, filenames) in os.walk(folder):
for file in filenames:
files.append(os.path.join(dirpath, file))
return files
pygments_files = get_all_files(
os.path.join(os.getcwd(), 'pygments'))
import clr
clr.CompileModules("pygments.dll", *pygments_files)'''
from pygments import highlight
from pygments.lexers import get_all_lexers, get_lexer_by_name
from pygments.styles import get_all_styles, get_style_by_name
from devhawk_formatter import DevHawkHtmlFormatter
def get_lexers():
return get_all_lexers()
def get_styles():
return get_all_styles()
def generate_html(code, lexer_name, style_name):
