def _load_template(self, name):
pkg_name, class_name = split_view_name(name)
# Try to obtain the template class from a template file
try:
source_file = self._find_template(pkg_name, class_name)
except TemplateNotFoundError:
source_file = None
if source_file is not None:
full_name = f"{pkg_name}.{class_name}"
# Read the template's source
f = open(source_file, "r")
try:
source = f.read()
finally:
f.close()
# Compile the template's source
compiler = self.Compiler(pkg_name, class_name, self, source)
# Update the template dependency graph
dependencies = set()
self.__dependencies[name] = dependencies
for dependency in list(compiler.classes.keys()):
dependencies.add(dependency)
dependency_derivatives = self.__derivatives.get(dependency)
if dependency_derivatives is None:
dependency_derivatives = set()
self.__derivatives[dependency] = dependency_derivatives
dependency_derivatives.add(name)
cls = compiler.get_template_class()
# If no template file for the requested template is found, try to import
# the template class from a regular python module
# Note that by convention, foo.Bar becomes foo.bar.Bar
else:
full_name = f"{pkg_name}.{class_name.lower()}.{class_name}"
try:
cls = import_object(full_name)
except ImportError:
raise TemplateNotFoundError(name)
self.__dependencies[name] = None
set_full_name(cls, full_name)
cls.source_file = source_file
return cls
def import_type(full_name):
schema = _schemas.get(full_name)
if schema:
return schema
# Transform foobar.Spam into foobar.spam.Spam
parts = full_name.split(".")
if len(parts) < 2 or parts[-2] != parts[-1].lower():
parts.insert(-1, parts[-1].lower())
expanded_name = ".".join(parts)
schema = _schemas.get(expanded_name)
if schema:
return schema
return import_object(full_name)
def create_view(self):
if self.view_class is None:
raise ValueError("No view specified for block %s" % self)
view = templates.new(self.view_class)
self.init_view(view)
if self.controller:
controller_class = import_object(self.controller)
controller = controller_class()
controller.block = self
controller.view = view
controller()
for key, value in controller.output.iteritems():
setattr(view, key, value)
return view
def _resolve_matching_member_reference(compound_name):
pos = compound_name.rfind(".")
type_full_name = compound_name[:pos]
member_name = compound_name[pos + 1:]
cls = import_object(type_full_name)
return cls[member_name]
def model(self):
return import_object(
self.controller.context["publishable"].subscription_form)
def resolve_controller(self):
if self.controller and self.controller.python_name:
return import_object(self.controller.python_name)
def model(self):
return import_object(self.controller.block.subscriber_model)