class MainPage(Element): loader = XMLFile(templatepath.child('mainpage.html')) extraContent = XMLFile(csspath.child('lcars.css')) @renderer def css_spec(self, _request, tag): LOG.debug('In css_spec renderer') l_path = csspath.child('Simple.css') tag.fillSlots(css_filespec=l_path) return tag
def alarms(self, request, tag): """ dynamically render the alarms """ if not self.display_alarms: return '' else: alarm_snippet = XMLFile( FilePath("TrackerDash/snippets/green_alarm.xml")) return alarm_snippet.load()
class Workspace(Element): """ WARNING: The names of the @athena.expose methods seem to have to match the js file name. They are called from browser when elements are attached to the workspace. """ loader = XMLFile(templatepath.child('workspaceElement.html')) #----------------- # Calls from browser JS to load an element (fragment) """ # NOTE! Tne name of the def MUST be the same as the widget name as used in workspace.js attachWidget's first argument. """ def inject_404(self): LOG.info("404 called from browser") # f = FourOfour() # f.setFragmentParent(self) # return f @renderer def login(self, _p_params): l_element = web_login.LoginElement(self) l_element.setFragmentParent(self) return l_element @renderer def rootMenu(self, _p_params): l_element = web_rootMenu.RootMenuElement(self) l_element.setFragmentParent(self) return l_element
class ClassIndexPage(Element): filename = 'classIndex.html' loader = XMLFile(templatefile('summary.html')) def __init__(self, system): self.system = system @renderer def title(self, request, tag): return tag.clear()("Class Hierarchy") @renderer def stuff(self, request, tag): t = tag anchors = set() for b, o in findRootClasses(self.system): if isinstance(o, model.Class): t(subclassesFrom(self.system, o, anchors)) else: item = tags.li(b) if o: ul = tags.ul() for sc in sorted(o, key=_lckey): ul(subclassesFrom(self.system, sc, anchors)) item(ul) t(item) return t @renderer def heading(self, request, tag): return tag.clear()("Class Hierarchy")
class UndocumentedSummaryPage(Element): filename = 'undoccedSummary.html' loader = XMLFile(templatefile('summary.html')) def __init__(self, system): self.system = system @renderer def title(self, request, tag): return tag.clear()("Summary of Undocumented Objects") @renderer def heading(self, request, tag): return tag.clear()("Summary of Undocumented Objects") @renderer def stuff(self, request, tag): undoccedpublic = [ o for o in self.system.orderedallobjects if o.isVisible and not hasdocstring(o) ] undoccedpublic.sort(key=lambda o: o.fullName()) for o in undoccedpublic: tag(tags.li(o.kind, " - ", taglink(o))) return tag
class MainTemplate(Element): loader = XMLFile(FilePath('templates/main.xml')) def __init__(self, title, user, body=None): Element.__init__(self) self.titleText = title self.user = user self.bodyElement = body @renderer def body(self, req, tag): if self.bodyElement == None: return tag('No content on this page sorry...') return self.bodyElement @renderer def titleTag(self, req, tag): return tag(self.titleText) @renderer def userSpot(self, req, tag): if self.user != None and self.user.loggedIn: return UserInfoTemplate(self.user) return RawXML( '<ul class="nav navbar-nav navbar-right"><li><a href="/login">Login</a></li><li><a href="/register">Register</a></li></ul>' )
def __init__(self, template, data, snapshot, maxDepth = 0): Element.__init__(self) self.loader = XMLFile(FilePath(template)) self.chart_data = data self.snapshot_id = snapshot if maxDepth > 0: self.chart_options['maxDepth'] = maxDepth
class NameIndexPage(Element): filename = 'nameIndex.html' loader = XMLFile(templatefile('nameIndex.html')) def __init__(self, system): self.system = system self.initials = {} for ob in self.system.orderedallobjects: if ob.isVisible: self.initials.setdefault(ob.name[0].upper(), []).append(ob) @renderer def title(self, request, tag): return tag.clear()("Index Of Names") @renderer def heading(self, request, tag): return tag.clear()("Index Of Names") @renderer def index(self, request, tag): r = [] for i in sorted(self.initials): r.append(LetterElement(TagLoader(tag), self.initials, i)) return r
def test_filename(self) -> None: """ An L{XMLFile} with a filename returns a useful repr(). """ fname = "/tmp/fake.xml" # deprecated self.assertEqual(f"<XMLFile of {fname!r}>", repr(XMLFile(fname))) # type: ignore[arg-type]
class WidgetsElement(Element): loader = XMLFile(FilePath('MusicLister.xml')) @renderer def widgets(self, request, tag): for widget in self.widgetData: yield tag.clone().fillSlots(href=widget['href'], content=widget['content'])
class DisclaimerElement(Element): loader = XMLFile( FilePath( os.path.join(_get_startup_folder(), '_login_disclaimer_banner.html'))) def __init__(self, banner): super(DisclaimerElement, self).__init__() self._set_loader(banner) self._banner_filename = banner or "_login_disclaimer_banner.html" def _set_loader(self, banner): if banner: current_path = os.path.dirname(os.path.abspath(__file__)) banner_file_path = os.path.join(current_path, "..", "..", "..", banner) self.loader = XMLFile(FilePath(banner_file_path)) def render(self, request): try: return super(DisclaimerElement, self).render(request) except SAXParseException: return [ "Invalid XML template format for %s." % self._banner_filename ] except IOError: return [ "Disclaimer banner file %s could not be read or does not exit." % self._banner_filename ]
class DiffElement(Element): def __init__(self, root, ob, origob, editA, editB): self.root = root self.ob = ob self.origob = origob self.editA = editA self.editB = editB @renderer def title(self, request, tag): return tag("Viewing differences between revisions ", str(self.editA.rev), " and ", str(self.editB.rev), " of ", u"\N{LEFT DOUBLE QUOTATION MARK}" + self.origob.fullName() + u"\N{RIGHT DOUBLE QUOTATION MARK}") @renderer def diff(self, request, tag): fd = FileDiff(self.ob.parentMod) fd.apply_edit(self.root.editsbyob[self.ob][0], self.editA) fd.reset() fd.apply_edit(self.editA, self.editB) return tags.pre(fd.diff()) loader = XMLFile(util.templatefile('diff.html'))
def test_file(self) -> None: """ An L{XMLFile} with a file object returns a useful repr(). """ fobj = StringIO("not xml") # deprecated self.assertEqual(f"<XMLFile of {fobj!r}>", repr(XMLFile(fobj))) # type: ignore[arg-type]
class IndexPage(Element): filename = 'index.html' loader = XMLFile(templatefile('index.html')) def __init__(self, system): self.system = system @renderer def project_link(self, request, tag): if self.system.options.projecturl: return tags.a(href=self.system.options.projecturl)( self.system.projectname) else: return self.system.projectname @renderer def project(self, request, tag): return self.system.projectname @renderer def recentChanges(self, request, tag): return () @renderer def problemObjects(self, request, tag): return () @renderer def onlyIfOneRoot(self, request, tag): if len(self.system.rootobjects) != 1: return [] else: root, = self.system.rootobjects return tag.clear()("Start at ", taglink(root), ", the root ", root.kind.lower(), ".") @renderer def onlyIfMultipleRoots(self, request, tag): if len(self.system.rootobjects) == 1: return [] else: return tag @renderer def roots(self, request, tag): r = [] for o in self.system.rootobjects: r.append(tag.clone().fillSlots(root=taglink(o))) return r @renderer def rootkind(self, request, tag): rootkinds = {} for o in self.system.rootobjects: rootkinds[o.kind.lower() + 's'] = 1 return tag.clear()('/'.join(sorted(rootkinds))) @renderer def buildtime(self, request, tag): return self.system.buildtime.strftime("%Y-%m-%d %H:%M:%S")
class ChildTable(Element): loader = XMLFile(util.templatefilepath('table.html')) last_id = 0 def __init__(self, docgetter, ob, children): self.docgetter = docgetter self.system = ob.system self.children = children ChildTable.last_id += 1 self._id = ChildTable.last_id self.ob = ob @renderer def id(self, request, tag): return 'id'+str(self._id) @renderer def rows(self, request, tag): return [ TableRow( TagLoader(tag), self.docgetter, self.ob, child) for child in self.children]
class AttributeChild(Element): loader = XMLFile(util.templatefilepath('attribute-child.html')) def __init__(self, docgetter, ob): self.docgetter = docgetter self.ob = ob @renderer def class_(self, request, tag): class_ = self.ob.css_class if self.ob.parent is not self.ob: class_ = 'base' + class_ return class_ @renderer def functionAnchor(self, request, tag): return self.ob.fullName() @renderer def shortFunctionAnchor(self, request, tag): return self.ob.name @renderer def attribute(self, request, tag): return self.ob.name @renderer def functionBody(self, request, tag): return self.docgetter.get(self.ob)
class MxitResponse(Element): loader = XMLFile(FilePath(MXIT_RESOURCES.path('templates/response.xml'))) def __init__(self, message, loader=None): self.header, self.items = ResponseParser.parse( message['content'] or u'') super(MxitResponse, self).__init__(loader or self.loader) @renderer def render_header(self, request, tag): return tag(self.header) @renderer def render_body(self, request, tag): if not self.items: return '' return tag @renderer def render_item(self, request, tag): for index, text in self.items: yield tag.clone().fillSlots(index=str(index), text=text) def flatten(self): return flattenString(None, self)
class FunctionChild(Element): loader = XMLFile(util.templatefilepath('function-child.html')) def __init__(self, docgetter, ob, functionExtras): self.docgetter = docgetter self.ob = ob self._functionExtras = functionExtras @renderer def class_(self, request, tag): class_ = self.ob.css_class if self.ob.parent is not self.ob: class_ = 'base' + class_ return class_ @renderer def functionAnchor(self, request, tag): return self.ob.fullName() @renderer def shortFunctionAnchor(self, request, tag): return self.ob.name @renderer def decorator(self, request, tag): return list(format_decorators(self.ob)) @renderer def functionDef(self, request, tag): def_stmt = 'async def' if self.ob.is_async else 'def' name = self.ob.name if name.endswith('.setter') or name.endswith('.deleter'): name = name[:name.rindex('.')] return [ tags.span(def_stmt, class_='py-keyword'), ' ', tags.span(name, class_='py-defname'), signature(self.ob), ':' ] @renderer def sourceLink(self, request, tag): if self.ob.sourceHref: return tag.fillSlots(sourceHref=self.ob.sourceHref) else: return () @renderer def functionExtras(self, request, tag): return self._functionExtras @renderer def functionBody(self, request, tag): return self.docgetter.get(self.ob) @renderer def functionDeprecated(self, request, tag): if hasattr(self.ob, "_deprecated_info"): return (tags.div(self.ob._deprecated_info, role="alert", class_="deprecationNotice alert alert-warning"),) else: return ()
class AccountRecoveryPage(Element): loader = XMLFile( FilePath( os.path.join(get_public_static_folder(), 'account_recovery.html'))) def __init__(self): super(AccountRecoveryPage, self).__init__()
def test_filename(self): """ An L{XMLFile} with a filename returns a useful repr(). """ fname = "/tmp/fake.xml" self.assertEqual("<XMLFile of {!r}>".format(fname), repr(XMLFile(fname)))
class UploadResultsElement(status.UploadResultsRendererMixin): loader = XMLFile(FilePath(__file__).sibling("upload-results.xhtml")) def __init__(self, upload_results): super(UploadResultsElement, self).__init__() self._upload_results = upload_results def upload_results(self): return defer.succeed(self._upload_results) @renderer def done(self, req, tag): d = self.upload_results() d.addCallback(lambda res: "done!") return d @renderer def uri(self, req, tag): d = self.upload_results() d.addCallback(lambda res: res.get_uri()) return d @renderer def download_link(self, req, tag): d = self.upload_results() d.addCallback( lambda res: tags.a("/uri/" + res.get_uri(), href="/uri/" + urllib.quote(res.get_uri()))) return d
def setLoader(self, templateDir="", templateFile=""): if not templateDir: templateDir = self.templateDir if not templateFile: templateFile = self.templateFile template = FilePath("%s/%s" % (templateDir, templateFile)) self.loader = XMLFile(template.path)
class ConfigElement(Element): loader = XMLFile(os.path.join(htmldir, "index.html")) @staticmethod def gatherArgs(opts): meta = {} with open(cosmosConfigFile(opts['home'])) as f: config = f.read() gr = '/usr/src/app/lib/git-revision.txt' if os.path.exists(gr): with open(gr) as f: meta['package_git'] = f.read().strip() else: with os.popen('git rev-parse --short HEAD') as f: sha = f.read().strip() with os.popen('git diff --quiet || echo -dirty') as f: meta['package_git'] = sha + f.read().strip() pj = '/usr/src/app/package.json' pjson = {} if os.path.exists(pj): with open(pj) as f: pjson = json.load(f) else: pjpath = None # Walk upwards from the current directory. pj = os.path.abspath('package.json') while pj != pjpath: pjpath = pj if os.path.exists(pjpath): with open(pjpath) as f: pjson = json.load(f) break pj = os.path.join(os.path.dirname(pjpath), '../package.json') pj = os.path.abspath(pj) meta['package_version'] = pjson.get('version', 'unknown') meta['package_name'] = pjson.get('name', 'cosmic-swingset') repo = pjson.get('repository', 'https://github.com/Agoric/cosmic-swingset') cleanRev = meta['package_git'].replace('-dirty', '') link = repo + '/commit/' + cleanRev meta['package_repo'] = link return [config, meta] def __init__(self, config, meta): self._config = config self._meta = meta @renderer def config(self, request, tag): tag.fillSlots(cosmos_config=self._config) return tag @renderer def meta(self, request, tag): tag.fillSlots(**self._meta) return tag
class BackupAccountPage(Element): loader = XMLFile( FilePath( os.path.join(get_protected_static_folder(), 'backup_account.html'))) def __init__(self): super(BackupAccountPage, self).__init__()
def loaderFactory(self) -> ITemplateLoader: """ @return: an L{XMLString} constructed with a filename that points to a file containing C{self.templateString}. """ fp = FilePath(self.mktemp()) fp.setContent(self.templateString.encode("utf8")) return XMLFile(fp.path) # type: ignore[arg-type]
def __init__(self, templateName): super(PageElement, self).__init__() self.loader = XMLFile( getModule(__name__).filePath.sibling( u"{name}.xhtml".format(name=templateName) ) )
def loaderFactory(self): """ @return: an L{XMLString} constructed with a filename that points to a file containing C{self.templateString}. """ fp = FilePath(self.mktemp()) fp.setContent(self.templateString.encode('utf8')) return XMLFile(fp.path)
def loaderFactory(self): """ @return: an L{XMLString} constructed with a L{FilePath} pointing to a file that contains C{self.templateString}. """ fp = FilePath(self.mktemp()) fp.setContent(self.templateString.encode("utf8")) return XMLFile(fp)
def __init__(self, template, data, labels, snapshot, processes, field): Element.__init__(self) self.loader = XMLFile(FilePath(template)) self.chart_data = data self.labels = labels self.snapshot_id = snapshot self.process_ids = processes self.field = field
class Template(Element): loader = XMLFile(self.infonode_template) @renderer def description(self, request, tag): html = verifier.getDescription() if not IRenderable.providedBy(html): html = Verbatim(html) return tag(html)
class WidgetsElement(Element): loader = XMLFile(FilePath("subviews-1.xml")) widgetData = ["gadget", "contraption", "gizmo", "doohickey"] @renderer def widgets(self, request, tag): for widget in self.widgetData: yield WidgetElement(TagLoader(tag), widget)
def content(self, request, tag): """ get the content for the configuration page """ log_content = XMLFile(FilePath("TrackerDash/snippets/logs.xml")) return log_content.load()
def content(self, request, tag): """ get the content for the configuration page """ footer_snippet = XMLFile(FilePath("TrackerDash/snippets/new_dash.xml")) return footer_snippet.load()
def footer(self, request, tag): """ dynamically render the footer """ footer_snippet = XMLFile(FilePath("TrackerDash/snippets/footer.xml")) return footer_snippet.load()