def build_stamp(pyxes, include_dirs=()):
""" Cythonize files in `pyxes`, return pyx, C filenames, hashes
Parameters
----------
pyxes : sequence
sequence of filenames of files on which to run Cython
include_dirs : sequence
Any extra include directories in which to find Cython files.
Returns
-------
pyx_defs : dict
dict has key, value pairs of <pyx_filename>, <pyx_info>, where
<pyx_info> is a dict with key, value pairs of "pyx_hash", <pyx file SHA1
hash>; "c_filename", <c filemane>; "c_hash", <c file SHA1 hash>.
"""
pyx_defs = {}
from Cython.Compiler.Main import compile
from Cython.Compiler.CmdLine import parse_command_line
includes = sum([['--include-dir', d] for d in include_dirs], [])
for source in pyxes:
base, ext = splitext(source)
pyx_hash = sha1(open(source, 'rt').read()).hexdigest()
c_filename = base + '.c'
options, sources = parse_command_line(includes + [source])
result = compile(sources, options)
if result.num_errors > 0:
raise RuntimeError('Cython failed to compile ' + source)
c_hash = sha1(open(c_filename, 'rt').read()).hexdigest()
pyx_defs[source] = dict(pyx_hash=pyx_hash,
c_filename=c_filename,
c_hash=c_hash)
return pyx_defs
def build_stamp(pyxes, include_dirs=()):
""" Cythonize files in `pyxes`, return pyx, C filenames, hashes
Parameters
----------
pyxes : sequence
sequence of filenames of files on which to run Cython
include_dirs : sequence
Any extra include directories in which to find Cython files.
Returns
-------
pyx_defs : dict
dict has key, value pairs of <pyx_filename>, <pyx_info>, where
<pyx_info> is a dict with key, value pairs of "pyx_hash", <pyx file
SHA1 hash>; "c_filename", <c filemane>; "c_hash", <c file SHA1 hash>.
"""
pyx_defs = {}
from Cython.Compiler.Main import compile
from Cython.Compiler.CmdLine import parse_command_line
includes = sum([['--include-dir', d] for d in include_dirs], [])
for source in pyxes:
base, ext = splitext(source)
pyx_hash = sha1((open(source, 'rt').read().encode())).hexdigest()
c_filename = base + '.c'
options, sources = parse_command_line(['-3'] + includes + [source])
result = compile(sources, options)
if result.num_errors > 0:
raise RuntimeError('Cython failed to compile ' + source)
c_hash = sha1(open(c_filename, 'rt').read().encode()).hexdigest()
pyx_defs[source] = dict(pyx_hash=pyx_hash,
c_filename=c_filename,
c_hash=c_hash)
return pyx_defs
def cython_ann(line, cell):
from Cython.Compiler.Main import compile as cy_compile
from Cython.Compiler.CmdLine import parse_command_line
from IPython.core import display
import re
with open("demo.pyx","wb") as f:
f.write(cell.strip().encode("utf8"))
options, sources = parse_command_line(["-a", "demo.pyx"])
cy_compile(sources, options)
with open("demo.html") as f:
html = f.read().decode("utf8")
html = u"\n".join([line for line in html.split("\n") if not line.startswith("<p>")])
html = html.replace(u"display: none;", u"")
html= re.sub(u"/\*.+?\*/.", u"", html, flags=re.DOTALL | re.MULTILINE)
javascript = u"""
<script>
$("pre.code").css("background-color", "#ffffff").hide()
.css("border-left", "2px solid #cccccc")
.css("margin-left", "10px");
$("pre.line").attr("onclick", "").click(function(){$(this).next().slideToggle();return 0;})
.css("border-bottom", "1px solid #cccccc");
$("span.error_goto").hide();
</script>
"""
display.display(display.HTML(html))
display.display(display.HTML(javascript))
def parse_pxd_file(path):
"""
Args
====
path: path to pxd file
Returns
=======
root of parse tree
"""
options, sources = parse_command_line(["", path])
path = os.path.abspath(path)
basename = os.path.basename(path)
name, ext = os.path.splitext(basename)
source_desc = FileSourceDescriptor(path, basename)
source = CompilationSource(source_desc, name, os.getcwd())
result = create_default_resultobj(source, options)
context = options.create_context()
pipeline = Pipeline.create_pyx_pipeline(context, options, result)
context.setup_errors(options, result)
root = pipeline[0](source)
return root
def cython(self, pyx):
from Cython.Compiler.CmdLine import parse_command_line
from Cython.Compiler.Main import compile
options, sources = parse_command_line(['-2', pyx])
result = compile(sources, options)
if result.num_errors > 0:
print('Errors converting %s to C' % pyx, file=sys.stderr)
raise Exception('Errors converting %s to C' % pyx)
self.announce('Converted %s to C' % pyx)
def cython(self, pyx):
from Cython.Compiler.CmdLine import parse_command_line
from Cython.Compiler.Main import compile
options, sources = parse_command_line(['-2', pyx])
result = compile(sources, options)
if result.num_errors > 0:
print('Errors converting %s to C' % pyx, file=sys.stderr)
raise Exception('Errors converting %s to C' % pyx)
self.announce('Converted %s to C' % pyx)
def parse_pxd_file(path):
options, sources = parse_command_line(["--cplus", path])
import pkg_resources
# TODO sync with CodeGenerator.py function fixed_include_dirs
data = pkg_resources.resource_filename("autowrap", "data_files/autowrap")
options.include_path = [data]
options.language_level = sys.version_info.major
path = os.path.abspath(path)
basename = os.path.basename(path)
name, ext = os.path.splitext(basename)
source_desc = FileSourceDescriptor(path, basename)
source = CompilationSource(source_desc, name, os.getcwd())
result = create_default_resultobj(source, options)
context = options.create_context()
pipeline = Pipeline.create_pyx_pipeline(context, options, result)
context.setup_errors(options, result)
root = pipeline[0](source) # only parser
def iter_bodies(tree):
try:
for n in tree.body.stats[0].stats:
# cimports at head of file
yield n
except:
pass
if hasattr(tree.body, "stats"):
for s in tree.body.stats:
if isinstance(s, CDefExternNode):
body = s.body
if hasattr(body, "stats"):
for node in body.stats:
yield node
else:
yield body
elif hasattr(tree.body, "body"):
body = tree.body.body
yield body
else:
raise Exception("parse_pxd_file failed: no valied .pxd file !")
lines = open(path).readlines()
def cimport(b, _, __):
print("cimport", b.module_name, "as", b.as_name)
handlers = {
CEnumDefNode: EnumDecl.parseTree,
CppClassNode: CppClassDecl.parseTree,
CTypeDefNode: CTypeDefDecl.parseTree,
CVarDefNode: MethodOrAttributeDecl.parseTree,
CImportStatNode: cimport,
}
result = []
for body in iter_bodies(root):
handler = handlers.get(type(body))
if handler is not None:
# L.info("parsed %s, handler=%s" % (body.__class__, handler.im_self))
try:
result.append(handler(body, lines, path))
except Exception:
raise Exception("failed to parse " + path)
else:
for node in getattr(body, "stats", []):
handler = handlers.get(type(node))
if handler is not None:
result.append(handler(node, lines, path))
return result
def parse_pxd_file(path):
import pdb
import os
from Cython.Compiler.CmdLine import parse_command_line
from Cython.Compiler.Main import create_default_resultobj, CompilationSource
from Cython.Compiler import Pipeline
from Cython.Compiler.Scanning import FileSourceDescriptor
from Cython.Compiler.Nodes import CEnumDefNode, CppClassNode, CTypeDefNode, CVarDefNode, CImportStatNode, CDefExternNode
# from Cython.Compiler.ExprNodes import *
options, sources = parse_command_line(["--cplus", path])
path = os.path.abspath(path)
basename = os.path.basename(path)
name, ext = os.path.splitext(basename)
source_desc = FileSourceDescriptor(path, basename)
source = CompilationSource(source_desc, name, os.getcwd())
result = create_default_resultobj(source, options)
context = options.create_context()
pipeline = Pipeline.create_pyx_pipeline(context, options, result)
context.setup_errors(options, result)
root = pipeline[0](source) # only parser
def iter_bodies(tree):
try:
for n in tree.body.stats[0].stats:
# cimports at head of file
yield n
except:
pass
if hasattr(tree.body, "stats"):
for s in tree.body.stats:
if isinstance(s, CDefExternNode):
body = s.body
if hasattr(body, "stats"):
for node in body.stats:
yield node
else:
yield body
elif hasattr(tree.body, "body"):
body = tree.body.body
yield body
else:
raise Exception("parse_pxd_file failed: no valied .pxd file !")
lines = open(path).readlines()
def cimport(b, _, __):
print "cimport", b.module_name, "as", b.as_name
handlers = { CEnumDefNode : "",
CppClassNode : "",
CTypeDefNode : "",
CVarDefNode : "",
CImportStatNode : "",
}
# from autowrap.PXDParser import EnumDecl.parseTree, CppClassDecl.parseTree, CTypeDefDecl.parseTree, MethodOrAttributeDecl.parseTree
# handlers = { CEnumDefNode : EnumDecl.parseTree,
# CppClassNode : CppClassDecl.parseTree,
# CTypeDefNode : CTypeDefDecl.parseTree,
# CVarDefNode : MethodOrAttributeDecl.parseTree,
# CImportStatNode : cimport,
# }
result = []
for body in iter_bodies(root):
handler = handlers.get(type(body))
if handler is not None:
# L.info("parsed %s, handler=%s" % (body.__class__, handler.im_self))
result.append([ body, lines, path ])
else:
for node in getattr(body, "stats", []):
handler = handlers.get(type(node))
if handler is not None:
result.append([ node, lines, path ])
return result
def parse_pxd_file(path):
options, sources = parse_command_line(["--cplus", path])
import pkg_resources
data = pkg_resources.resource_filename("autowrap", "data_files")
options.include_path = [data]
path = os.path.abspath(path)
basename = os.path.basename(path)
name, ext = os.path.splitext(basename)
source_desc = FileSourceDescriptor(path, basename)
source = CompilationSource(source_desc, name, os.getcwd())
result = create_default_resultobj(source, options)
context = options.create_context()
pipeline = Pipeline.create_pyx_pipeline(context, options, result)
context.setup_errors(options, result)
root = pipeline[0](source) # only parser
def iter_bodies(tree):
try:
for n in tree.body.stats[0].stats:
# cimports at head of file
yield n
except:
pass
if hasattr(tree.body, "stats"):
for s in tree.body.stats:
if isinstance(s, CDefExternNode):
body = s.body
if hasattr(body, "stats"):
for node in body.stats:
yield node
else:
yield body
elif hasattr(tree.body, "body"):
body = tree.body.body
yield body
else:
raise Exception("parse_pxd_file failed: no valied .pxd file !")
lines = open(path).readlines()
def cimport(b, _, __):
print("cimport", b.module_name, "as", b.as_name)
handlers = {CEnumDefNode: EnumDecl.parseTree,
CppClassNode: CppClassDecl.parseTree,
CTypeDefNode: CTypeDefDecl.parseTree,
CVarDefNode: MethodOrAttributeDecl.parseTree,
CImportStatNode: cimport,
}
result = []
for body in iter_bodies(root):
handler = handlers.get(type(body))
if handler is not None:
# L.info("parsed %s, handler=%s" % (body.__class__, handler.im_self))
result.append(handler(body, lines, path))
else:
for node in getattr(body, "stats", []):
handler = handlers.get(type(node))
if handler is not None:
result.append(handler(node, lines, path))
return result
