def main():
""" Generate tests """
template = mako.template.Template(
textwrap.dedent("""
/* [config]
* expect_result: fail
* glsl_version: 1.20
* [end config]
*/
#version 120
void main() {
gl_Position = vec4(0);
outerProduct(${type}(0), ${type}(0));
}
"""))
try:
os.makedirs('spec/glsl-1.20/compiler/built-in-functions')
except OSError:
pass
for type_ in [
'int', 'float', 'bool', 'bvec2', 'bvec3', 'bvec4', 'mat2',
'mat2x2', 'mat2x3', 'mat2x4', 'mat3', 'mat3x2', 'mat3x3', 'mat3x4',
'mat4', 'mat4x2', 'mat4x3', 'mat4x4'
]:
name = ('spec/glsl-1.20/compiler/built-in-functions/'
'outerProduct-{0}.vert'.format(type_))
print(name)
with open(name, 'w+') as f:
f.write(template.render_unicode(type=type_))
def gen_frag_grad_test(parameter, filename):
""" Generate fragment shader gradient tests """
template = mako.template.Template(
textwrap.dedent("""
/* [config]
* expect_result: pass
* glsl_version: 1.10
* require_extensions: ${extensions}
* [end config]
*/
#extension GL_ARB_shader_texture_lod: require
uniform sampler${param.dimensions} s;
varying ${param.coord} coord;
varying ${param.grad} dPdx;
varying ${param.grad} dPdy;
void main()
{
gl_FragColor = ${param.mode}GradARB(s, coord, dPdx, dPdy);
}
"""))
with open(filename, 'w+') as f:
f.write(
template.render_unicode(param=parameter,
extensions=get_extensions(parameter.mode)))
def build_latex_pdf(output_filename="cscutcher_cv_latex.pdf"):
"""Build latex style pdf."""
resume = nx6_cv.resume.get_resume()
output_stream = Path(output_filename).open('wb')
with tempfile.TemporaryDirectory(prefix="nx6_cv_latex_") as tmpdir:
tmpdir = Path(tmpdir)
# Copy latex sources
for path in pkg_resources.resource_listdir(__name__, "latex"):
(tmpdir / path).open('wb').write(
pkg_resources.resource_string(
__name__, os.path.join("latex", path)))
template_raw = (tmpdir / 'cv.tex.mako').open().read()
# Stop mako nuking '//' in tex
template_raw = re.sub(
r"\\$",
r"\\\\" + "\n",
template_raw,
flags=re.MULTILINE)
# Render and write template
template = mako.template.Template(template_raw)
tex = template.render_unicode(cv=resume)
(tmpdir / 'cv.tex').open('w').write(tex)
# Add gitrevision tex
(tmpdir / 'gitrevision.tex').open('w').write("NOTSET")
sh.make("-C", str(tmpdir.resolve()))
output_stream.write((tmpdir / 'cv.pdf').open('rb').read())
def gen_frag_grad_test(parameter, filename):
""" Generate fragment shader gradient tests """
template = mako.template.Template(textwrap.dedent("""
/* [config]
* expect_result: pass
* glsl_version: 1.10
* require_extensions: ${extensions}
* [end config]
*/
#extension GL_ARB_shader_texture_lod: require
uniform sampler${param.dimensions} s;
varying ${param.coord} coord;
varying ${param.grad} dPdx;
varying ${param.grad} dPdy;
void main()
{
gl_FragColor = ${param.mode}GradARB(s, coord, dPdx, dPdy);
}
"""))
with open(filename, 'w+') as f:
f.write(template.render_unicode(
param=parameter,
extensions=get_extensions(parameter.mode)))
def main():
""" Generate tests """
template = mako.template.Template(textwrap.dedent("""
/* [config]
* expect_result: fail
* glsl_version: 1.20
* [end config]
*/
#version 120
void main() {
gl_Position = vec4(0);
outerProduct(${type}(0), ${type}(0));
}
"""))
try:
os.makedirs('spec/glsl-1.20/compiler/built-in-functions')
except OSError:
pass
for type_ in ['int', 'float', 'bool', 'bvec2', 'bvec3', 'bvec4', 'mat2',
'mat2x2', 'mat2x3', 'mat2x4', 'mat3', 'mat3x2', 'mat3x3',
'mat3x4', 'mat4', 'mat4x2', 'mat4x3', 'mat4x4']:
name = ('spec/glsl-1.20/compiler/built-in-functions/'
'outerProduct-{0}.vert'.format(type_))
print(name)
with open(name, 'w+') as f:
f.write(template.render_unicode(type=type_))
def print_html_report(projects, filename=None):
# I want atomicity: don't destroy old .html file if an exception happens
# during rendering.
html = template.render_unicode(projects=list(projects),
nice_date=nice_date,
pluralize=pluralize)
if filename and filename != '-':
with open(filename, 'w') as f:
f.write(html)
else:
print(html)
def WriteLexer(config, name):
"""Converts a Pygments lexer into a Java lexer.
Args:
config: an OutputConfiguration object.
name: the short name of the lexer (e.g. "Css" or "Python"),
usable as an index into ALL_LEXERS.
"""
try:
lexer_cls = lexers.ALL[name]
except KeyError:
raise RuntimeError('Unknown lexer "%s"' % name)
class_name = _JavaLexerName(name)
outfile = config.OutputFile(class_name)
states = ExtractStates(lexer_cls)
filenames = ConvertFilenames(lexer_cls.filenames)
template = mako.template.Template(
resources.GetResource(os.path.join(_TEMPLATES_DIR, 'lexer.mako')))
outfile.write(template.render_unicode(
states=states, lexer_name=class_name, origin=lexer_cls,
package=config.package, filenames=filenames).encode('utf-8'))
def main():
""" Generate tests """
try:
os.makedirs('spec/glsl-1.20/execution')
except OSError:
pass
name = ('spec/glsl-1.20/execution/'
'{shader}-outerProduct-{type}{mat}{vec}.shader_test')
template = mako.template.Template(filename=
os.path.join(os.path.dirname(__file__),
'gen_outerproduct_template.mako'))
for c, r in itertools.product(xrange(2, 5), repeat=2):
vecs = [
Parameters(c, r, 'vec', 'mat{0}x{1}'.format(r, c)),
Parameters(c, r, 'ivec', 'mat{0}x{1}'.format(r, c))
]
if r == c:
vecs.extend([
Parameters(c, r, 'vec', 'mat{0}'.format(r)),
Parameters(c, r, 'ivec', 'mat{0}'.format(r))
])
for shader in ['vs', 'fs']:
for type in ['const', 'uniform']:
for params in vecs:
_name = name.format(
shader=shader,
type='const-' if type == 'const' else '',
mat=params.matrix,
vec='-ivec' if params.vec_type == 'ivec' else '')
print(_name)
with open(_name, 'w+') as f:
f.write(template.render_unicode(params=params,
type=type,
shader=shader))
def gen_frag_lod_test(parameter, filename):
""" Generate fragment shader LOD tests """
template = mako.template.Template(textwrap.dedent("""
/* [config]
* expect_result: pass
* glsl_version: 1.10
* require_extensions: GL_ARB_shader_texture_lod
* [end config]
*/
#extension GL_ARB_shader_texture_lod: require
uniform sampler${param.dimensions} s;
varying ${param.coord} coord;
varying float lod;
void main()
{
gl_FragColor = ${param.mode}Lod(s, coord, lod);
}
"""))
with open(filename, 'w+') as f:
f.write(template.render_unicode(param=parameter))
def gen_frag_lod_test(parameter, filename):
""" Generate fragment shader LOD tests """
template = mako.template.Template(
textwrap.dedent("""
/* [config]
* expect_result: pass
* glsl_version: 1.10
* require_extensions: GL_ARB_shader_texture_lod
* [end config]
*/
#extension GL_ARB_shader_texture_lod: require
uniform sampler${param.dimensions} s;
varying ${param.coord} coord;
varying float lod;
void main()
{
gl_FragColor = ${param.mode}Lod(s, coord, lod);
}
"""))
with open(filename, 'w+') as f:
f.write(template.render_unicode(param=parameter))
def main():
# Define command line arguments
parser = argparse.ArgumentParser()
parser.add_argument("csvfile", help="CSV file containing hosts")
parser.add_argument("templates", help="template file or directory")
parser.add_argument("output", help="output file or directory")
parser.add_argument("-d", "--dnsdir", metavar="DNSDIR", default="\000",
help="directory with the old DNS files")
parser.add_argument("-v", "--var", metavar="VARFILE",
help="yaml file with variables")
# Parse arguments
args = parser.parse_args()
# Configure logging
logging.basicConfig(level=logging.INFO, format='%(levelname)s: %(message)s')
# Parse CSV file
try:
hosts = parse_csv(args.csvfile)
except IOError as exc:
logging.fatal("unable to open '{}': {}".format(args.csvfile, exc.strerror))
return sys.exit(1)
except csv.Error:
logging.fatal("unable to parse csv file")
return sys.exit(2)
except CsvIntegrityError as exc:
logging.fatal("error in csv file: {}".format(exc))
return sys.exit(3)
# Create in-memory database from the list of network entities
db = tinydb.TinyDB(storage=tinydb.storages.MemoryStorage)
db.insert_multiple(hosts)
# Parse variables file (if given)
if args.var:
try:
with open(args.var, "r") as f:
var = yaml.load(f)
except IOError as exc:
logging.fatal("unable to open '{}': {}".format(args.var, exc.strerror))
return sys.exit(4)
except yaml.error.YAMLError as exc:
logging.fatal("yaml error: {}".format(exc))
return sys.exit(5)
else:
var = {}
# Iterate over each input/output path pair
# There is also a hack with iterating over files in DNS directory in parallel
for infile, outfile, dnsfile in find_templates(args.templates, args.output, args.dnsdir):
# Strip '.mako' extension if present
if outfile.endswith(".mako"):
outfile = outfile[:-len(".mako")]
if dnsfile.endswith(".mako"):
dnsfile = dnsfile[:-len(".mako")]
# Create template
try:
template = mako.template.Template(filename=infile)
except IOError as exc:
logging.error("unable to open '{}': {}".format(infile, exc.strerror))
continue
except mako.exceptions.MakoException as exc:
logging.error("template error while reading '{}': {}".format(infile, exc))
continue
# Render template
try:
output = template.render_unicode(var=var, db=db, host=tinydb.Query(),
view=ViewSet(), FILE_NAME=os.path.basename(outfile),
get_dns_version=lambda: DNS_HACK_ANCHOR + DNS_HACK_COMMENT)
except Exception:
tb = mako.exceptions.text_error_template().render().strip()
logging.error("unhandled exception while rendering template '{}':\n{}"
.format(infile, tb))
continue
# Apply DNS version hack if needed
if DNS_HACK_ANCHOR in output:
output = apply_dns_version_hack(output, dnsfile)
# Make parent directories if they do not exist
dirname = os.path.dirname(outfile)
if dirname:
try:
os.makedirs(dirname, exist_ok=True)
except OSError as exc:
logging.error("could not create directory '{}': {}".format(dirname, exc.strerror))
continue
# Write rendered template
try:
with open(outfile, "w", encoding="utf8") as f:
f.write(output)
except IOError as exc:
logging.error("could not write to file '{}': {}".format(outfile, exc.strerror))
continue
# All done
return sys.exit(0)
def render(self, content):
template = mako.template.Template(content)
content = template.render_unicode()
return content
