class RobotsTxt(rend.Page): """A page combining some built-in robots.txt material with etc/robots.txt if it exists. """ builtin = utils.fixIndentation( """ Disallow: /login Disallow: /seffe """, "") def _getContent(self): content = self.builtin try: with open(os.path.join(base.getConfig("webDir"), "robots.txt")) as f: content = content + "\n" + f.read() except IOError: pass return content def renderHTTP(self, ctx): request = inevow.IRequest(ctx) request.setHeader("content-type", "text/plain") return self._getContent() def locateChild(self, segments): return None
def addNormalizedPara(self, stuff): """adds stuff to the document, making sure it's not glued to any previous material and removing whitespace as necessary for docstrings. """ self.makeSpace() self.content.append( utils.fixIndentation(stuff, "", governingLine=2) + "\n")
def getCode(self): """returns the body code indented with two spaces. """ if self.code is base.NotGiven: return "" else: return utils.fixIndentation(self.code, " ", governingLine=1)
def getBodyCode(self): """returns the body code un-indented. """ collectedCode = [] for frag in self.codeFrags: collectedCode.append( utils.fixIndentation(frag, "", governingLine=1)) return "\n".join(collectedCode)
def addDefinition(self, defHead, defBody): """adds a definition list-style item . defBody is re-indented with two spaces, defHead is assumed to only contain a single line. """ self.content.append(defHead + "\n") self.content.append( utils.fixIndentation(defBody, " ", governingLine=2) + "\n")
def deco(f): f.adqlUDF_name = name f.adqlUDF_signature = f.adqlUDF_name + signature.strip() f.adqlUDF_doc = utils.fixIndentation(doc, "", 1).strip() f.adqlUDF_returntype = returntype f.adqlUDF_unit = unit f.adqlUDF_ucd = ucd UFUNC_REGISTRY[f.adqlUDF_name.upper()] = f return f
def onElementComplete(self): self._onElementCompleteNext(CustomPageFunction) vars = globals().copy() vars["service"] = self.parent exec("def %s(ctx, data):\n%s" % (self.name, utils.fixIndentation(self.content_, newIndent=" ", governingLine=1).rstrip())) in vars self.func = vars[self.name]
def feed(self, ctx, instance, literal): if ctx.restricted: raise common.RestrictedElement("codeItems") attrdef.UnicodeAttribute.feed(self, ctx, instance, literal) src = utils.fixIndentation(getattr(instance, self.name_), " ", governingLine=1) src = "def makeRows():\n" + src + "\n" instance.iterRowsFromCode = utils.compileFunction( src, "makeRows", useGlobals={"context": ctx})
def _compileRenderer(source, queryMeta): """returns a function object from source. Source must be the function body of a renderer. The variable data contains the entire row, and the thing must return a string or at least stan (it can use T.tag). """ code = ("def format(data):\n"+ utils.fixIndentation(source, " ")+"\n") return rmkfuncs.makeProc("format", code, "", None, queryMeta=queryMeta, source=source, T=T)
def _documentParameters(content, pars): content.makeSpace() for par in sorted(pars, key=lambda p: p.key): if par.late: doc = ["Late p"] else: doc = ["P"] doc.append("arameter *%s*\n" % par.key) if par.content_: doc.append(" defaults to ``%s``;\n" % par.content_) if par.description: doc.append(utils.fixIndentation(par.description, " ")) else: doc.append(" UNDOCUMENTED") content.addRaw(''.join(doc) + "\n") content.makeSpace()
def _getModuleFunctionDocs(module): """returns documentation for all functions marked with @document in the namespace module. """ res = [] for name in dir(module): if name.startswith("_"): # ignore all private attributes, whatever else happens continue ob = getattr(module, name) if hasattr(ob, "buildDocsForThis"): if ob.func_doc is None: # silently ignore if no docstring continue res.append("*%s%s*" % (name, inspect.formatargspec(*inspect.getargspec(ob)))) res.append(utils.fixIndentation(ob.func_doc, " ", 1)) res.append("") return "\n".join(res)
def makeDoc(self, content): """adds documentation of macFunc to the RSTFragment content. """ # macros have args in {}, of course there's no self, and null-arg # macros have not {}... args, varargs, varkw, defaults = inspect.getargspec(self.macFunc) args = inspect.formatargspec(args[1:], varargs, varkw, defaults).replace("(", "{").replace( ")", "}").replace("{}", "").replace(", ", "}{") content.addRaw("::\n\n \\%s%s\n\n" % (self.name, args)) content.addRaw( utils.fixIndentation(self.macFunc.func_doc or "undocumented", "", 1).replace("\\", "\\\\")) content.addNormalizedPara( "Available in " + ", ".join(sorted("`Element %s`_" % c.name_ for c in self.inObjects)))
def _doAddMeta(self): content = self.attrs.pop("content_", "") if not self.attrs: # content only, parse this as a meta stream parseMetaStream(self.container, content) else: try: content = utils.fixIndentation(content, "", 1).rstrip() except common.Error, ex: raise utils.logOldExc( common.StructureError("Bad text in meta value" " (%s)" % ex)) if not "name" in self.attrs: raise common.StructureError("meta elements must have a" " name attribute") metaKey = self.attrs.pop("name") self.container.addMeta(metaKey, content, **self.attrs) # meta elements can have children; add these, properly fudging # their keys for key, content, kwargs in self.children: fullKey = "%s.%s" % (metaKey, key) self.container.addMeta(fullKey, content, **kwargs)
def validate(self): if self.procDef and self.procDef.type and self.requiredType: if self.procDef.type!=self.requiredType: raise base.StructureError("The procDef %s has type %s, but" " here %s procDefs are required."%(self.procDef.id, self.procDef.type, self.requiredType)) if self.procDef: if self.procDef.deprecated: if self.getSourcePosition()!="<internally built>": # for now, don't warn about these; they typically # originate when copying/adapting cores and will just # confuse operators procId = "unnamed procApp" if self.name: procId = "procApp %s"%self.name base.ui.notifyWarning("%s, %s: %s"%( self.getSourcePosition(), procId, utils.fixIndentation(self.procDef.deprecated, ""))) self._validateNext(ProcApp) self._ensureParsBound()
def __init__(self, script): # I need to memorize the script as I may need to recompile # it if there's special arguments (yikes!) self.code = ("def scriptFun(table, **kwargs):\n" + utils.fixIndentation(script.getSource(), " ") + "\n") ScriptRunner.__init__(self, script)