def get_contents(meta_path): """ Get the contents of the [meta.yaml|conda.yaml] file. If jinja is installed, then the template.render function is called before standard conda macro processors """ try: import jinja2 except ImportError: print("There was an error importing jinja2.", file=sys.stderr) print("Please run `conda install jinja2` to enable jinja template support", file=sys.stderr) with open(meta_path) as fd: return fd.read() from conda_build.jinja_context import context_processor path, filename = os.path.split(meta_path) loaders = [jinja2.PackageLoader("conda_build"), jinja2.FileSystemLoader(path)] env = jinja2.Environment(loader=jinja2.ChoiceLoader(loaders)) env.globals.update(ns_cfg()) env.globals.update(context_processor()) template = env.get_or_select_template(filename) contents = template.render(environment=env) return contents
def get_contents(meta_path): ''' Get the contents of the [meta.yaml|conda.yaml] file. If jinja is installed, then the template.render function is called before standard conda macro processors ''' try: import jinja2 except ImportError: print("There was an error importing jinja2.") print("Please run `conda install jinja2` to enable jinja template support") with open(meta_path, encoding='utf-8') as fd: return fd.read() from conda_build.jinja_context import context_processor path, filename = os.path.split(meta_path) loaders = [jinja2.PackageLoader('conda_build'), jinja2.FileSystemLoader(path) ] env = jinja2.Environment(loader=jinja2.ChoiceLoader(loaders)) env.globals.update(context_processor()) env.globals.update(ns_cfg()) template = env.get_or_select_template(filename) contents = template.render(environment=env) return contents
def _get_contents(self, permit_undefined_jinja): ''' Get the contents of our [meta.yaml|conda.yaml] file. If jinja is installed, then the template.render function is called before standard conda macro processors. permit_undefined_jinja: If True, *any* use of undefined jinja variables will evaluate to an emtpy string, without emitting an error. ''' try: import jinja2 except ImportError: print("There was an error importing jinja2.", file=sys.stderr) print("Please run `conda install jinja2` to enable jinja template support", file=sys.stderr) # noqa with open(self.meta_path) as fd: return fd.read() from conda_build.jinja_context import context_processor, UndefinedNeverFail, FilteredLoader path, filename = os.path.split(self.meta_path) loaders = [ # search relative to '<conda_root>/Lib/site-packages/conda_build/templates' jinja2.PackageLoader('conda_build'), # search relative to RECIPE_DIR jinja2.FileSystemLoader(path) ] # search relative to current conda environment directory conda_env_path = os.environ.get('CONDA_DEFAULT_ENV') # path to current conda environment if conda_env_path and os.path.isdir(conda_env_path): conda_env_path = os.path.abspath(conda_env_path) conda_env_path = conda_env_path.replace('\\', '/') # need unix-style path env_loader = jinja2.FileSystemLoader(conda_env_path) loaders.append(jinja2.PrefixLoader({'$CONDA_DEFAULT_ENV': env_loader})) undefined_type = jinja2.StrictUndefined if permit_undefined_jinja: # The UndefinedNeverFail class keeps a global list of all undefined names # Clear any leftover names from the last parse. UndefinedNeverFail.all_undefined_names = [] undefined_type = UndefinedNeverFail loader = FilteredLoader(jinja2.ChoiceLoader(loaders)) env = jinja2.Environment(loader=loader, undefined=undefined_type) env.globals.update(ns_cfg()) env.globals.update(context_processor(self, path)) try: template = env.get_or_select_template(filename) rendered = template.render(environment=env) if permit_undefined_jinja: self.undefined_jinja_vars = UndefinedNeverFail.all_undefined_names else: self.undefined_jinja_vars = [] return rendered except jinja2.TemplateError as ex: sys.exit("Error: Failed to render jinja template in {}:\n{}" .format(self.meta_path, ex.message))
def get_contents(meta_path): ''' Get the contents of the [meta.yaml|conda.yaml] file. If jinja is installed, then the template.render function is called before standard conda macro processors ''' try: import jinja2 except ImportError: print("There was an error importing jinja2.", file=sys.stderr) print( "Please run `conda install jinja2` to enable jinja template support", file=sys.stderr) with open(meta_path) as fd: return fd.read() from conda_build.jinja_context import context_processor path, filename = os.path.split(meta_path) loaders = [ # search relative to '<conda_root>/Lib/site-packages/conda_build/templates' jinja2.PackageLoader('conda_build'), # search relative to RECIPE_DIR jinja2.FileSystemLoader(path) ] # search relative to current conda environment directory conda_env_path = os.environ.get( 'CONDA_DEFAULT_ENV') # path to current conda environment if conda_env_path and os.path.isdir(conda_env_path): conda_env_path = os.path.abspath(conda_env_path) conda_env_path = conda_env_path.replace('\\', '/') # need unix-style path env_loader = jinja2.FileSystemLoader(conda_env_path) loaders.append(jinja2.PrefixLoader({'$CONDA_DEFAULT_ENV': env_loader})) env = jinja2.Environment(loader=jinja2.ChoiceLoader(loaders), undefined=jinja2.StrictUndefined) env.globals.update(ns_cfg()) env.globals.update(context_processor()) template = env.get_or_select_template(filename) try: return template.render(environment=env) except jinja2.TemplateError as ex: sys.exit("Error: Failed to parse jinja template in {}:\n{}".format( meta_path, ex.message))
def get_contents(meta_path): ''' Get the contents of the [meta.yaml|conda.yaml] file. If jinja is installed, then the template.render function is called before standard conda macro processors ''' try: import jinja2 except ImportError: print("There was an error importing jinja2.", file=sys.stderr) print("Please run `conda install jinja2` to enable jinja template support", file=sys.stderr) with open(meta_path) as fd: return fd.read() from conda_build.jinja_context import context_processor path, filename = os.path.split(meta_path) loaders = [# search relative to '<conda_root>/Lib/site-packages/conda_build/templates' jinja2.PackageLoader('conda_build'), # search relative to RECIPE_DIR jinja2.FileSystemLoader(path) ] # search relative to current conda environment directory conda_env_path = os.environ.get('CONDA_DEFAULT_ENV') # path to current conda environment if conda_env_path and os.path.isdir(conda_env_path): conda_env_path = os.path.abspath(conda_env_path) conda_env_path = conda_env_path.replace('\\', '/') # need unix-style path env_loader = jinja2.FileSystemLoader(conda_env_path) loaders.append(jinja2.PrefixLoader({'$CONDA_DEFAULT_ENV': env_loader})) env = jinja2.Environment(loader=jinja2.ChoiceLoader(loaders), undefined=jinja2.StrictUndefined) env.globals.update(ns_cfg()) env.globals.update(context_processor()) template = env.get_or_select_template(filename) try: return template.render(environment=env) except jinja2.TemplateError as ex: sys.exit("Error: Failed to parse jinja template in {}:\n{}".format(meta_path, ex.message))
def _get_contents(self, permit_undefined_jinja, config): ''' Get the contents of our [meta.yaml|conda.yaml] file. If jinja is installed, then the template.render function is called before standard conda macro processors. permit_undefined_jinja: If True, *any* use of undefined jinja variables will evaluate to an emtpy string, without emitting an error. ''' try: import jinja2 except ImportError: print("There was an error importing jinja2.", file=sys.stderr) print( "Please run `conda install jinja2` to enable jinja template support", file=sys.stderr) # noqa with open(self.meta_path) as fd: return fd.read() from conda_build.jinja_context import context_processor, UndefinedNeverFail, FilteredLoader path, filename = os.path.split(self.meta_path) loaders = [ # search relative to '<conda_root>/Lib/site-packages/conda_build/templates' jinja2.PackageLoader('conda_build'), # search relative to RECIPE_DIR jinja2.FileSystemLoader(path) ] # search relative to current conda environment directory conda_env_path = os.environ.get( 'CONDA_DEFAULT_ENV') # path to current conda environment if conda_env_path and os.path.isdir(conda_env_path): conda_env_path = os.path.abspath(conda_env_path) conda_env_path = conda_env_path.replace( '\\', '/') # need unix-style path env_loader = jinja2.FileSystemLoader(conda_env_path) loaders.append( jinja2.PrefixLoader({'$CONDA_DEFAULT_ENV': env_loader})) undefined_type = jinja2.StrictUndefined if permit_undefined_jinja: # The UndefinedNeverFail class keeps a global list of all undefined names # Clear any leftover names from the last parse. UndefinedNeverFail.all_undefined_names = [] undefined_type = UndefinedNeverFail loader = FilteredLoader(jinja2.ChoiceLoader(loaders), config=config) env = jinja2.Environment(loader=loader, undefined=undefined_type) env.globals.update(ns_cfg(config)) env.globals.update( context_processor(self, path, config=config, permit_undefined_jinja=permit_undefined_jinja)) try: template = env.get_or_select_template(filename) rendered = template.render(environment=env) if permit_undefined_jinja: self.undefined_jinja_vars = UndefinedNeverFail.all_undefined_names else: self.undefined_jinja_vars = [] return rendered except jinja2.TemplateError as ex: if "'None' has not attribute" in str(ex): ex = "Failed to run jinja context function" sys.exit( "Error: Failed to render jinja template in {}:\n{}".format( self.meta_path, str(ex)))
def get_contents(meta_path, permit_undefined_jinja): ''' Get the contents of the [meta.yaml|conda.yaml] file. If jinja is installed, then the template.render function is called before standard conda macro processors. permit_undefined_jinja: If True, *any* use of undefined jinja variables will evaluate to an emtpy string, without emitting an error. ''' try: import jinja2 except ImportError: print("There was an error importing jinja2.", file=sys.stderr) print("Please run `conda install jinja2` to enable jinja template support", file=sys.stderr) with open(meta_path) as fd: return fd.read() from conda_build.jinja_context import context_processor path, filename = os.path.split(meta_path) loaders = [# search relative to '<conda_root>/Lib/site-packages/conda_build/templates' jinja2.PackageLoader('conda_build'), # search relative to RECIPE_DIR jinja2.FileSystemLoader(path) ] # search relative to current conda environment directory conda_env_path = os.environ.get('CONDA_DEFAULT_ENV') # path to current conda environment if conda_env_path and os.path.isdir(conda_env_path): conda_env_path = os.path.abspath(conda_env_path) conda_env_path = conda_env_path.replace('\\', '/') # need unix-style path env_loader = jinja2.FileSystemLoader(conda_env_path) loaders.append(jinja2.PrefixLoader({'$CONDA_DEFAULT_ENV': env_loader})) undefined_type = jinja2.StrictUndefined if permit_undefined_jinja: class UndefinedNeverFail(jinja2.Undefined): """ A class for Undefined jinja variables. This is even less strict than the default jinja2.Undefined class, because we permits things like {{ MY_UNDEFINED_VAR[:2] }} and {{ float(MY_UNDEFINED_VAR) }}. This can mask lots of errors in jinja templates, so it should only be used for a first-pass parse, when you plan on running a 'strict' second pass later. """ __add__ = __radd__ = __mul__ = __rmul__ = __div__ = __rdiv__ = \ __truediv__ = __rtruediv__ = __floordiv__ = __rfloordiv__ = \ __mod__ = __rmod__ = __pos__ = __neg__ = __call__ = \ __getitem__ = __lt__ = __le__ = __gt__ = __ge__ = __int__ = \ __complex__ = __pow__ = __rpow__ = \ lambda *args, **kwargs: '' __int__ = lambda _: 0 __float__ = lambda _: 0.0 undefined_type = UndefinedNeverFail env = jinja2.Environment(loader=jinja2.ChoiceLoader(loaders), undefined=undefined_type) env.globals.update(ns_cfg()) env.globals.update(context_processor()) try: template = env.get_or_select_template(filename) return template.render(environment=env) except jinja2.TemplateError as ex: sys.exit("Error: Failed to render jinja template in {}:\n{}".format(meta_path, ex.message))
def _get_contents(self, permit_undefined_jinja): ''' Get the contents of our [meta.yaml|conda.yaml] file. If jinja is installed, then the template.render function is called before standard conda macro processors. permit_undefined_jinja: If True, *any* use of undefined jinja variables will evaluate to an emtpy string, without emitting an error. ''' try: import jinja2 except ImportError: print("There was an error importing jinja2.", file=sys.stderr) print( "Please run `conda install jinja2` to enable jinja template support", file=sys.stderr) with open(self.meta_path) as fd: return fd.read() from conda_build.jinja_context import context_processor path, filename = os.path.split(self.meta_path) loaders = [ # search relative to '<conda_root>/Lib/site-packages/conda_build/templates' jinja2.PackageLoader('conda_build'), # search relative to RECIPE_DIR jinja2.FileSystemLoader(path) ] # search relative to current conda environment directory conda_env_path = os.environ.get( 'CONDA_DEFAULT_ENV') # path to current conda environment if conda_env_path and os.path.isdir(conda_env_path): conda_env_path = os.path.abspath(conda_env_path) conda_env_path = conda_env_path.replace( '\\', '/') # need unix-style path env_loader = jinja2.FileSystemLoader(conda_env_path) loaders.append( jinja2.PrefixLoader({'$CONDA_DEFAULT_ENV': env_loader})) undefined_type = jinja2.StrictUndefined if permit_undefined_jinja: class UndefinedNeverFail(jinja2.Undefined): """ A class for Undefined jinja variables. This is even less strict than the default jinja2.Undefined class, because it permits things like {{ MY_UNDEFINED_VAR[:2] }} and {{ MY_UNDEFINED_VAR|int }}. This can mask lots of errors in jinja templates, so it should only be used for a first-pass parse, when you plan on running a 'strict' second pass later. """ __add__ = __radd__ = __mul__ = __rmul__ = __div__ = __rdiv__ = \ __truediv__ = __rtruediv__ = __floordiv__ = __rfloordiv__ = \ __mod__ = __rmod__ = __pos__ = __neg__ = __call__ = \ __getitem__ = __lt__ = __le__ = __gt__ = __ge__ = \ __complex__ = __pow__ = __rpow__ = \ lambda *args, **kwargs: UndefinedNeverFail() __str__ = __repr__ = \ lambda *args, **kwargs: u'' __int__ = lambda _: 0 __float__ = lambda _: 0.0 def __getattr__(self, k): try: return object.__getattr__(self, k) except AttributeError: return UndefinedNeverFail() def __setattr__(self, k, v): pass undefined_type = UndefinedNeverFail env = jinja2.Environment(loader=jinja2.ChoiceLoader(loaders), undefined=undefined_type) env.globals.update(ns_cfg()) env.globals.update(context_processor(self, path)) try: template = env.get_or_select_template(filename) return template.render(environment=env) except jinja2.TemplateError as ex: sys.exit( "Error: Failed to render jinja template in {}:\n{}".format( self.meta_path, ex.message))