rem stringlengths 0 322k | add stringlengths 0 2.05M | context stringlengths 8 228k |
|---|---|---|
return self.dirty | return self._dirty | def value(self): return self.dirty |
import string | def encode(s): import string s = string.join(string.split(s, '&'), '&') s = string.join(string.split(s, '<'), '<') s = string.join(string.split(s, '>'), '>') s = string.join(string.split(s, '"'), '"') return s | |
def split_property(property): | def split_property(property, namespaces): keys = namespaces.keys() for namespace in keys: if string.find(property, namespace)==0: return (namespace, property[len(namespace):]) | def split_property(property): length = len(property) for i in range(length): if not property[-1-i] in namechars: for j in range(-1-i,length): if property[j] in namestart: return (property[:j],property[j:]) return ("",property) |
uri = split_property(property)[0] | uri = split_property(property, self.namespaces)[0] | def register_property(self, property): uri = split_property(property)[0] if not self.namespaces.has_key(uri): self.namespaceCount = self.namespaceCount + 1 prefix = "n%s" % self.namespaceCount self.namespaces[uri] = prefix |
if not self.rdfns in self.namespaces.keys(): self.namespaces[self.rdfns] = 'rdf' | def start(self): if not self.rdfns in self.namespaces.keys(): self.namespaces[self.rdfns] = 'rdf' | |
self.stream.write( "<%s:RDF\n" % self.namespaces[self.rdfns]) | self.stream.write( "<rdf:RDF\n" ) | def start(self): if not self.rdfns in self.namespaces.keys(): self.namespaces[self.rdfns] = 'rdf' |
self.stream.write( "</%s:RDF>\n" % self.namespaces[self.rdfns] ) | self.stream.write( "</rdf:RDF>\n" ) | def end(self): if self.current_subject != None: self.subject_end() self.stream.write( "</%s:RDF>\n" % self.namespaces[self.rdfns] ) |
self.stream.write( " <%s:Description" % self.namespaces[self.rdfns] ) if self.baseURI and subject[0:len(self.baseURI)+1]==self.baseURI+" self.stream.write( " %s:ID=\"%s\">\n" % (self.namespaces[self.rdfns], subject[len(self.baseURI)+1:]) ) | self.stream.write( " <rdf:Description" ) if self.baseURI and string.find(subject, self.baseURI)==0: self.stream.write( " rdf:ID=\"%s\">\n" % subject[len(self.baseURI)+1:]) | def subject_start(self, subject): self.stream.write( " <%s:Description" % self.namespaces[self.rdfns] ) if self.baseURI and subject[0:len(self.baseURI)+1]==self.baseURI+"#": self.stream.write( " %s:ID=\"%s\">\n" % (self.namespaces[self.rdfns], subject[len(self.baseURI)+1:]) ) else: self.stream.write( " %s:about=\"%s\"... |
self.stream.write( " %s:about=\"%s\">\n" % (self.namespaces[self.rdfns], encode(subject)) ) | self.stream.write( " rdf:about=\"%s\">\n" % encode(subject) ) | def subject_start(self, subject): self.stream.write( " <%s:Description" % self.namespaces[self.rdfns] ) if self.baseURI and subject[0:len(self.baseURI)+1]==self.baseURI+"#": self.stream.write( " %s:ID=\"%s\">\n" % (self.namespaces[self.rdfns], subject[len(self.baseURI)+1:]) ) else: self.stream.write( " %s:about=\"%s\"... |
self.stream.write( " </%s:Description>\n" % self.namespaces[self.rdfns] ) | self.stream.write( " </rdf:Description>\n" ) | def subject_end(self): self.current_subject = None self.stream.write( " </%s:Description>\n" % self.namespaces[self.rdfns] ) |
(namespace, localName) = split_property(predicate) | (namespace, localName) = split_property(predicate, self.namespaces) prefix = self.namespaces[namespace] | def property(self, predicate, object): (namespace, localName) = split_property(predicate) |
self.stream.write( " <%s:%s>%s</%s:%s>\n" % (self.namespaces[namespace], localName, encode(un_literal(object)), self.namespaces[namespace], localName) ) | self.stream.write( " <%s:%s>%s</%s:%s>\n" % (prefix, localName, encode(un_literal(object)), prefix, localName) ) | def property(self, predicate, object): (namespace, localName) = split_property(predicate) |
self.stream.write( " <%s:%s %s:resource=\"%s\"/>\n" % (self.namespaces[namespace], localName, self.namespaces[self.rdfns], encode(object)) ) | self.stream.write( " <%s:%s rdf:resource=\"%s\"/>\n" % (prefix, localName, encode(object)) ) | def property(self, predicate, object): (namespace, localName) = split_property(predicate) |
self.getEditor().handleRequest(request, response) | self.getEditor().handle_request(request, response) | def call_editor(self, request, response): request._pathInfo = request.getPathInfo()[len(self.path):] self.getEditor().handleRequest(request, response) |
s = "%0004d-%02d-%2dT%02d_%02d_%02dZ" % ( year, month, day, hh, mm, ss) | s = "%0004d-%02d-%02dT%02d_%02d_%02dZ" % ( year, month, day, hh, mm, ss) | def date_time_string(self, t=None): """.""" import time if t==None: t = time.time() |
for id in self.connections: | for id in self.connections.keys(): | def deregister_all(self, connection): """ Remove the given connection as being to a node with any id. |
def _can_proxy(proxy, node_list): self.proxies[proxy] = set(node_list) print "proxies:", self.proxies self.refresh() | def can_proxy(self, proxy, node_list): """ Informs this node that proxy can act as proxy for nodes in node_list. """ | |
_can_proxy(proxy, node_list) | self._add_proxy(proxy, node_list) | def _can_proxy(proxy, node_list): self.proxies[proxy] = set(node_list) print "proxies:", self.proxies self.refresh() |
def tell(self, to, frm, message_id, message): """ Send the given message directly and/or indirectly. """ result = 0 | def _check(self, to, frm, message_id, message): | def tell(self, to, frm, message_id, message): """ Send the given message directly and/or indirectly. """ result = 0 |
connection.send_pass_on(to, frm, message_id, message) | msg = (to, frm, message_id, message) self._send_pass_on(connection, msg) | def tell(self, to, frm, message_id, message): """ Send the given message directly and/or indirectly. """ result = 0 |
keys = namespaces.keys() for namespace in keys: if string.find(property, namespace)==0: return (namespace, property[len(namespace):]) | def split_property(property, namespaces={}): property = property keys = namespaces.keys() for namespace in keys: if string.find(property, namespace)==0: return (namespace, property[len(namespace):]) length = len(property) for i in range(length): if not property[-1-i] in namechars: for j in range(-1-i,length): if proper... | |
for i in range(length): if not property[-1-i] in namechars: for j in range(-1-i,length): if property[j] in namestart: if j==0: return None return (property[:j], property[j:]) return ("", property) | for i in xrange(1, length): if not property[-i-1] in namechars: j = -i return (property[:j], property[j:]) raise "Could not split property" | def split_property(property, namespaces={}): property = property keys = namespaces.keys() for namespace in keys: if string.find(property, namespace)==0: return (namespace, property[len(namespace):]) length = len(property) for i in range(length): if not property[-1-i] in namechars: for j in range(-1-i,length): if proper... |
uri = split_property(property, self.namespaces)[0] | uri = split_property(property)[0] | def register_property(self, property): uri = split_property(property, self.namespaces)[0] if not self.namespaces.has_key(uri): self.namespaceCount = self.namespaceCount + 1 prefix = "n%s" % self.namespaceCount self.namespaces[uri] = prefix |
(namespace, localName) = split_property(predicate, self.namespaces) | (namespace, localName) = split_property(predicate) | def property(self, predicate, object, literal_object=0): (namespace, localName) = split_property(predicate, self.namespaces) prefix = self.namespaces[namespace] |
vName = "prop%s_value" % property_num | vName = "prop%s_orig" % property_num | def deleteProperty(self, parameters): property_num = parameters['processor'][4:] subject = parameters['uri'] property = parameters['prop%s_name' % property_num] vName = "prop%s_value" % property_num value = parameters[vName] if self.storeNode.getRange(property)==LITERAL: value = literal(value) self.storeNode.local.remo... |
if self.storeNode.getRange(property)==LITERAL: value = literal(value) | def deleteProperty(self, parameters): property_num = parameters['processor'][4:] subject = parameters['uri'] property = parameters['prop%s_name' % property_num] vName = "prop%s_value" % property_num value = parameters[vName] if self.storeNode.getRange(property)==LITERAL: value = literal(value) self.storeNode.local.remo... | |
j = -i return (property[:j], property[j:]) raise "Could not split property" | for j in xrange(-1-i,length): if property[j] in namestart: return (property[:j], property[j:]) return ("", property) | def split_property(property): property = property length = len(property) for i in xrange(1, length): if not property[-i-1] in namechars: j = -i return (property[:j], property[j:]) raise "Could not split property" |
self.qstore.reify(self.generateURI(), subject, property, value) | self.qstore.reify(self.storeNode.getStore().URI+self.generateURI(), subject, property, value) | def reifyProperty(self, params): property_num = params["processor"][0][6:] subject = params["uri"][0] property = params["prop%s_name" % property_num][0] value = params["prop%s_value" % property_num][0] if self.qstore.get(property, self.qstore.RANGE, None)[0][2]==self.qstore.LITERAL: value = "^" + value self.qstore.reif... |
processStatement(statement[0], self.store.get(prop[0], QueryStore.PREDICATE, None)[0][2], self.store.get(prop[0], QueryStore.OBJECT, None)[0][2]) | processStatement(statement[0], self.store.get(statement[0], QueryStore.PREDICATE, None)[0][2], self.store.get(statement[0], QueryStore.OBJECT, None)[0][2]) | def reifiedV(self, subject, processStatement): for statement in self.getByType(QueryStore.STATEMENT, QueryStore.SUBJECT, subject): processStatement(statement[0], self.store.get(prop[0], QueryStore.PREDICATE, None)[0][2], self.store.get(prop[0], QueryStore.OBJECT, None)[0][2]) |
query = Query(self.query, (objectSetBuilder,), lambda s, p, o: (o, SUBCLASSOF, None)) self.query(query, type, SUBCLASSOF, None) | self.visitTransitiveSuperTypes(objectSetBuilder, type) | def getTransitiveSuperTypes(self, type): objectSetBuilder = ObjectSetBuilder() objectSetBuilder.set[type] = 1 query = Query(self.query, (objectSetBuilder,), lambda s, p, o: (o, SUBCLASSOF, None)) self.query(query, type, SUBCLASSOF, None) return objectSetBuilder.set.keys() |
def visitTransitiveSuperTypes(self, callback, type): trans = And(callback, Query(self.visitTransitiveSuperTypes, (callback,), lambda s, p, o: (o,))) self.query(trans, type, SUBCLASSOF, None) | def getTransitiveSuperTypes(self, type): objectSetBuilder = ObjectSetBuilder() objectSetBuilder.set[type] = 1 query = Query(self.query, (objectSetBuilder,), lambda s, p, o: (o, SUBCLASSOF, None)) self.query(query, type, SUBCLASSOF, None) return objectSetBuilder.set.keys() | |
subjectSetBuilder = SubjectSetBuilder() subjectSetBuilder.set[type] = 1 query = Query(self.query, (subjectSetBuilder,), lambda s, p, o: (None, SUBCLASSOF, s)) self.query(query, None, SUBCLASSOF, type) return subjectSetBuilder.set.keys() | objectSetBuilder = ObjectSetBuilder() objectSetBuilder.set[type] = 1 self.visitTransitiveSubTypes(objectSetBuilder, type) return objectSetBuilder.set.keys() def visitTransitiveSubTypes(self, callback, type): trans = And(callback, Query(self.visitTransitiveSubTypes, (callback,), lambda s, p, o: (s,))) self.query(trans,... | def getTransitiveSubTypes(self, type): subjectSetBuilder = SubjectSetBuilder() subjectSetBuilder.set[type] = 1 query = Query(self.query, (subjectSetBuilder,), lambda s, p, o: (None, SUBCLASSOF, s)) self.query(query, None, SUBCLASSOF, type) return subjectSetBuilder.set.keys() |
self.add(statement_uri, TYPE, STATEMENT) self.add(statement_uri, SUBJECT, subject) self.add(statement_uri, PREDICATE, predicate) self.add(statement_uri, OBJECT, object) | self.local.add(statement_uri, TYPE, STATEMENT) self.local.add(statement_uri, SUBJECT, subject) self.local.add(statement_uri, PREDICATE, predicate) self.local.add(statement_uri, OBJECT, object) | def reify(self, statement_uri, subject, predicate, object): self.add(statement_uri, TYPE, STATEMENT) self.add(statement_uri, SUBJECT, subject) self.add(statement_uri, PREDICATE, predicate) self.add(statement_uri, OBJECT, object) |
self.add(subject, predicate, object) | self.local.add(subject, predicate, object) | def dereify(self, statement_uri): subject = self.get(statement, SUBJECT, None)[0][2] predicate = self.get(statement, PREDICATE, None)[0][2] object = self.get(statement, OBJECT, None)[0][2] self.add(subject, predicate, object) #self.removeAll(statement) |
def __mark(self, subject): | def __unmark(self, subject): | def __mark(self, subject): self.remove(subject, RUN, None) |
(uri, rdf, address, port) = process_args() | (self.uri, rdf, address, port) = process_args() | def run(self, **args): "This method blocks until the server is shutdown" if len(args)==0: (uri, rdf, address, port) = process_args() apps = redfoot.get_apps() Boot = None else: # TODO: get defaults from common source instead of keeping # them in sync with process_args defaults uri = args.get('uri', 'TODO: compute') rd... |
uri = args.get('uri', 'TODO: compute') | self.uri = args.get('uri', 'TODO: compute') | def run(self, **args): "This method blocks until the server is shutdown" if len(args)==0: (uri, rdf, address, port) = process_args() apps = redfoot.get_apps() Boot = None else: # TODO: get defaults from common source instead of keeping # them in sync with process_args defaults uri = args.get('uri', 'TODO: compute') rd... |
self.load(rdf, uri, 1) | self.load(rdf, self.uri, 1) | def run(self, **args): "This method blocks until the server is shutdown" if len(args)==0: (uri, rdf, address, port) = process_args() apps = redfoot.get_apps() Boot = None else: # TODO: get defaults from common source instead of keeping # them in sync with process_args defaults uri = args.get('uri', 'TODO: compute') rd... |
uri, app_class = apps[0] | app_uri, app_class = apps[0] | def run(self, **args): "This method blocks until the server is shutdown" if len(args)==0: (uri, rdf, address, port) = process_args() apps = redfoot.get_apps() Boot = None else: # TODO: get defaults from common source instead of keeping # them in sync with process_args defaults uri = args.get('uri', 'TODO: compute') rd... |
def get_module_outfile (self, build_dir, package, module): outfile_path = [build_dir] + list(package) + [module + ".xml"] return apply(os.path.join, outfile_path) | def get_module_outfile (self, build_dir, package, module): outfile_path = [build_dir] + list(package) + [module + ".xml"] return apply(os.path.join, outfile_path) | |
module_files = glob(os.path.join(package_dir, "*.py")) module_files = glob(os.path.join(package_dir, "*.xml")) | module_files = glob(os.path.join(package_dir, "*.py")) + glob(os.path.join(package_dir, "*.xml")) | def find_package_modules (self, package, package_dir): self.check_package(package, package_dir) module_files = glob(os.path.join(package_dir, "*.py")) module_files = glob(os.path.join(package_dir, "*.xml")) modules = [] setup_script = os.path.abspath(self.distribution.script_name) |
def ___byte_compile (self, files): pass | def ___byte_compile (self, files): pass | |
self.stream.write( "<?xml version=\"1.0\"?>\n" ) | self.stream.write( """<?xml version="1.0" encoding="iso-8859-1"?>\n""" ) | def start(self): if not self.rdfns in self.namespaces.keys(): self.namespaces[self.rdfns] = 'rdf' |
s = string.join(string.split(s, "'"), '"') | s = string.join(string.split(s, '>'), '>') s = string.join(string.split(s, '"'), '"') | def encode(s): import string s = string.join(string.split(s, '&'), '&') s = string.join(string.split(s, '<'), '<') s = string.join(string.split(s, "'"), '"') return s |
super(Concurrent, self).remove(s, p, o) | super(Concurrent, self).remove(subject, predicate, object) | def remove(self, subject, predicate, object): if self.__visit_count==0: super(Concurrent, self).remove(s, p, o) else: self.__pending_removes.append((subject, predicate, object)) |
| <A HREF=".">RDF</A> | | <A HREF=".">HOME</A> | def menuBar(self): self.response.write(""" <P CLASS="MENUBAR"><B>VIEW</B> : <A HREF="classList">Resources by Class</A> | <A HREF="fullsubclass">Full Subclass Tree</A> | <A HREF="subclass">Partial Subclass Tree</A> | <A HREF=".">RDF</A> | <A HREF="triples">Triples</A> </P> """) |
sys.stderr.write(" sys.stderr.flush() | def _sessionReaper(self): while 1: sessionKey = self.cubby.peek() if sessionKey==None: self.cubby.wait(1) else: import time now = time.time() session = self.sessions[sessionKey] idle = (now - session.getLastAccessedTime()) if idle > session.getMaxInactiveInterval(): self.cubby.get() # todo... pop del self.sessions[ses... | |
for s in model.store.get(resource, QueryStore.TYPE, None): | for s in self.store.get(resource, QueryStore.TYPE, None): | def isOfType(self, resource, type): for s in model.store.get(resource, QueryStore.TYPE, None): if s[2] == type: return 1 return 0 |
def output(self, stream, URI=None, subject=None, predicate=None, object=None): self.local.output(stream, URI, subject, predicate, object) | def output(self, stream, URI=None, subject=None, predicate=None, object=None, absolute=0): self.local.output(stream, URI, subject, predicate, object, absolute) | def output(self, stream, URI=None, subject=None, predicate=None, object=None): self.local.output(stream, URI, subject, predicate, object) |
types = {} triples = self.storeNode.get(subject, TYPE, None) for triple in triples: types[type] = 1 for t in self.storeNode.getTransitiveSuperTypes(triple[2]): types[t] = 1 for type in types.keys(): def possibleProperty(s, p, o, self=self, subject=subject): property = s if len(self.storeNode.get(property, self.REQUIRE... | properties = {} def possibleProperty(s, p, o, properties=properties): properties[s] = 1 self.storeNode.visitPossiblePropertiesForSubject(possibleProperty, subject) for property in properties.keys(): if len(self.storeNode.get(property, self.REQUIREDPROPERTY, "http://redfoot.sourceforge.net/2000/10/06/builtin self.editP... | def edit(self, parameters): |
viewer.view(args['uri']) | viewer.view(args['uri'][0]) | def do_GET(self): """Serve a GET request.""" |
def subjects(s, p, o, predicate=predicate, object=object, add=add): self.visit(add, s, predicate, object) | def subjects(s, p, o, predicate=predicate, object=object, add=add, store=self): store.visit(add, s, predicate, object) | def subjects(s, p, o, predicate=predicate, object=object, add=add): self.visit(add, s, predicate, object) |
if b.list == [literal("37")]: | if b.set == [literal("37")]: | def my_filter(a): if int(a.value) > 36: return 1 else: return 0 |
objectSetBuilder = ObjectSetBuilder() objectSetBuilder.set[type] = 1 self.visitTransitiveSubTypes(objectSetBuilder, type) return objectSetBuilder.set.keys() | subjectSetBuilder = SubjectSetBuilder() subjectSetBuilder.set[type] = 1 self.visitTransitiveSubTypes(subjectSetBuilder, type) return subjectSetBuilder.set.keys() | def getTransitiveSubTypes(self, type): objectSetBuilder = ObjectSetBuilder() objectSetBuilder.set[type] = 1 self.visitTransitiveSubTypes(objectSetBuilder, type) return objectSetBuilder.set.keys() |
def rangeitem(s, p, o, self=self, qstore=self, callback=callback): for type in qstore.getTransitiveSubTypes(o): qstore.visit(callback, None, TYPE, type) query = Query(rangeitem, (), lambda s, p, o: (s, p, o), (self, self, callback)) self.query(query, property, RANGE, None) | ranges = self.get(property, RANGE, None) for range in ranges: for type in self.getTransitiveSubTypes(range[2]): self.visit(callback, None, TYPE, type) | def rangeitem(s, p, o, self=self, qstore=self, callback=callback): for type in qstore.getTransitiveSubTypes(o): qstore.visit(callback, None, TYPE, type) |
try: parser.ParseFile(file) except: import traceback traceback.print_exc() import sys sys.stderr.write("filename: '%s'" % file) | parser.ParseFile(file) | def parse(adder, file, baseURI): import xml.parsers.expat parser = xml.parsers.expat.ParserCreate(namespace_separator=ns_separator) parser.SetBase(baseURI) parser.returns_unicode = 1 LookForRDFHandler(parser, adder, None) try: parser.ParseFile(file) except: import traceback traceback.print_exc() import sys sys.stder... |
viewer = self.getViewer() viewer.setWriter(response) viewer.handler(path_info, args) self.lock.release() | try: viewer = self.getViewer() viewer.setWriter(response) viewer.handler(path_info, args) finally: self.lock.release() | def handleRequest(self, request, response): args = request.parameters path_info = request.path_info |
self.locals = parent.locals self.globals = parent.globals | def __init__(self, parser, parent, name, atts): HandlerBase.__init__(self, parser, parent) #self.locals = parent.locals #self.globals = parent.globals test = atts['test'] self.element = IfNodeList(test) | |
self.locals = self.parent.locals self.globals = self.parent.globals | def __init__(self, parser, parent, name, atts): HandlerBase.__init__(self, parser, parent) #self.locals = self.parent.locals #self.globals = self.parent.globals item = atts['item'] list = atts['list'] code = __builtin__.compile(list, list, "eval") self.element = ForNodeList(item, code) | |
(os.path.join(webroot[1], sitepath, | (os.path.join(webroot[1], sitepath), | def generatePage(root, cfg, entry): data = {} data['title'] = entry['title'] data['author'] = entry['log'][-1]['author'] path, css = cfg.get('misc', 'css') relpath = '../'*root[len(path):].count('/') data['css'] = os.path.join(relpath, css) path, icon = cfg.get('misc', 'x-icon') relpath = '../'*root[len(path):].count(... |
shutil.copytree(os.path.join(banners_path, banners_dir), os.path.join(tempdir, dirname, banners_dir)) | os.mkdir(os.path.join(tempdir, dirname, banners_dir)) for name in os.listdir(os.path.join(banners_path, banners_dir)): fullname = os.path.join(banners_path, banners_dir, name) if os.path.isfile(fullname): shutil.copy(fullname, os.path.join(tempdir, dirname, banners_dir, name)) | def main(): if len(argv) < 2: print 'PyBliki weblog_directory' return blogroot = os.path.abspath(argv[1]) tempdir = mkdtemp('', 'blog') cfg = BlikiConfig() for root, dirs, files in os.walk(blogroot): cfg.testRoot(root, files) # create directories inside temp dirname = root[len(blogroot)+1:] if len(dirname) > 0: nam... |
blogpath += '<a href="http://%s">%s</a>' % \ (os.path.join(webroot[1], sitepath), sitepath[sidx+1:]) | if len(sitepath[sidx+1:]) > 0: blogpath += '<a href="http://%s">%s</a>' % \ (os.path.join(webroot[1], sitepath), sitepath[sidx+1:]) | def generatePage(root, cfg, entry): data = {} data['title'] = entry['title'] data['author'] = entry['log'][-1]['author'] path, css = cfg.get('misc', 'css') relpath = '../'*root[len(path):].count('/') data['css'] = os.path.join(relpath, css) path, icon = cfg.get('misc', 'x-icon') relpath = '../'*root[len(path):].count(... |
data['css'] = os.path.join(path, css) | relpath = '../'*root[len(path):].count('/') data['css'] = os.path.join(relpath, css) | def generatePage(root, cfg, entry): data = {} data['title'] = entry['title'] data['author'] = entry['log'][-1]['author'] path, css = cfg.get('misc', 'css') data['css'] = os.path.join(path, css) path, icon = cfg.get('misc', 'x-icon') data['icon'] = os.path.join(path, icon) parts = publish_parts(entry['text'], writer_na... |
data['icon'] = os.path.join(path, icon) | relpath = '../'*root[len(path):].count('/') data['icon'] = os.path.join(relpath, icon) | def generatePage(root, cfg, entry): data = {} data['title'] = entry['title'] data['author'] = entry['log'][-1]['author'] path, css = cfg.get('misc', 'css') data['css'] = os.path.join(path, css) path, icon = cfg.get('misc', 'x-icon') data['icon'] = os.path.join(path, icon) parts = publish_parts(entry['text'], writer_na... |
basename = basename + "." + options_file | basename = basename + "." + tmp | def compare(name1,name2,decode): if (decode): print "converting mp3 to wav for comparison..." # XXX shouldn't we use lame1 instead of a hardcoded lame? os.system("lame --quiet --mp3input --decode " + name1) os.system("lame --quiet --mp3input --decode " + name2) name1 = name1 + ".wav" name2 = name2 + ".wav" rcode = 0 d... |
size1 = os.path.getsize(name1) | status = os.access(name1, os.R_OK) if 1 != status: size1=0 else: size1 = os.path.getsize(name1) | def fdiff(name1,name2): cmd = "cmp -l "+name1 + " " + name2 + " | wc -l" # XXX either # use a combination of os.popen + read # or # write owen cmp+wc function # to replace commands.getoutput out = commands.getoutput(cmd) out = split(out,"\n") out=out[-1] if (-1==find(out,"No")): diff = atof(out) size1 = os.path.g... |
cmd = "cmp -l "+name1 + " " + name2 + " | wc --lines" | cmd = "cmp -l "+name1 + " " + name2 + " | wc -l" | def fdiff(name1,name2): cmd = "cmp -l "+name1 + " " + name2 + " | wc --lines" out = commands.getoutput(cmd) out = split(out,"\n") out=out[-1] if (-1==find(out,"No")): diff = atof(out) size1 = os.path.getsize(name1) size2 = os.path.getsize(name2) diff = diff + abs(size1-size2) size = max(size1,size2) else: diff = -1 siz... |
status,output=commands.getstatusoutput("which "+lame1) | status,output=commands.getstatusoutput("which "+lame2) | def compare(name1,name2,decode): if (decode): print "converting mp3 to wav for comparison..." commands.getoutput("lame --mp3input --decode " + name1) commands.getoutput("lame --mp3input --decode " + name2) name1 = name1 + ".wav" name2 = name2 + ".wav" rcode = 0 diff,size=fdiff(name1,name2) if (diff==0): print "output ... |
def __init__(self, name, juice, tacPath, onProcessStartup=None, onProcessTermination=None): | def __init__(self, name, juice, tacPath, onProcessStartup=None, onProcessTermination=None, logPath=None, pidPath=None): | def __init__(self, name, juice, tacPath, onProcessStartup=None, onProcessTermination=None): self.name = name self.juice = juice self.tacPath = tacPath self.onProcessStartup = onProcessStartup self.onProcessTermination = onProcessTermination |
'--logfile=%s.log' % (self.name,)] | '--logfile=%s' % (self.logPath,)] | def _startProcess(self): executable = sys.executable env = os.environ env['PYTHONPATH'] = os.pathsep.join(sys.path) |
args.append('--pidfile=%s.pid' % (self.name,)) | args.append('--pidfile=%s' % (self.pidPath,)) | def _startProcess(self): executable = sys.executable env = os.environ env['PYTHONPATH'] = os.pathsep.join(sys.path) |
self._setStore, self._restartProcess) | self._setStore, self._restartProcess, logdir.child("batch.log").path, rundir.child("batch.pid").path) | def startService(self): service.Service.startService(self) tacPath = util.sibpath(__file__, "batch.tac") proto = BatchProcessingProtocol() self.batchController = ProcessController( "batch", proto, tacPath, self._setStore, self._restartProcess) return self.batchController.getProcess() |
""" | Retrieve an item by its storeID, and return it. Note: most of the failure modes of this method are catastrophic and should not be handled by application code. The only one that application programmers should be concerned with is KeyError. They are listed for educational purposes. @param storeID: an L{int} which ref... | def getItemByID(self, storeID, default=_noItem, autoUpgrade=True): """ """ if not isinstance(storeID, (int, long)): raise TypeError("storeID *must* be an int or long, not %r" % ( type(storeID).__name__,)) if storeID == -1: return self if self.objectCache.has(storeID): return self.objectCache.get(storeID) log.msg(interf... |
def postOptions(self): app.installReactor(self['reactor']) dbdir = self.parent.getStoreDirectory() rundir = os.path.join(dbdir, 'run') | def _fixConfig(self): | def postOptions(self): |
twistd.checkPID(self['pidfile']) S = self.parent.getStore() | def _constructApplication(self): application = service.Application("Axiom Service") service.IService(self.parent.getStore()).setServiceParent(application) return application def postOptions(self): if platform.isWinNT(): self._win32PostOptions() else: self._unixPostOptions() def _checkPID(self): if not platform.isWi... | def postOptions(self): |
twistd.startLogging( self['logfile'], self['syslog'], self['prefix'], self['nodaemon']) | self._startLogging() | def postOptions(self): |
application = service.Application("Axiom Service") service.IService(S).setServiceParent(application) twistd.startApplication(self, application) | self.application = application = self._constructApplication() self._startApplication() | def postOptions(self): |
twistd.removePID(self['pidfile']) | S.close() self._removePID() | def postOptions(self): |
yield ('stop', None, Stop, 'Stop the server running from the given Axiom database') yield ('status', None, Status, 'Report whether a server is running from the given Axiom database') | if not platform.isWinNT(): yield ('stop', None, Stop, 'Stop the server running from the given Axiom database') yield ('status', None, Status, 'Report whether a server is running from the given Axiom database') | def get(self): for plg in plugin.getPlugins(iaxiom.IAxiomaticCommand, plugins): try: yield (plg.name, None, plg, plg.description) except AttributeError: raise RuntimeError("Maldefined plugin: %r" % (plg,)) yield ('start', None, Start, 'Launch the given Axiom database') yield ('stop', None, Stop, 'Stop the server runnin... |
self._transientSchedule(when, Time()) | self._transientSchedule(when, self.now()) | def schedule(self, runnable, when): TimedEvent(store=self.store, time=when, runnable=runnable) self._transientSchedule(when, Time()) |
self._transientSchedule(toWhen, Time()) | self._transientSchedule(toWhen, self.now()) | def reschedule(self, runnable, fromWhen, toWhen): for evt in self.store.query(TimedEvent, AND(TimedEvent.time == fromWhen, TimedEvent.runnable == runnable)): evt.time = toWhen self._transientSchedule(toWhen, Time()) break else: raise ValueError("%r is not scheduled to run at %r" % (runnable, fromWhen)) |
if version == _typeNameToMostRecentClass[typename].schemaVersion: self.typenameToID[typename] = oid self.idToTypename[oid] = typename else: self._prepareOldVersionOf(oid, typename, version) | cls = _typeNameToMostRecentClass.get(typename) if cls is not None: if version == cls.schemaVersion: self.typenameToID[typename] = oid self.idToTypename[oid] = typename else: self._prepareOldVersionOf(oid, typename, version) | def __init__(self, dbdir=None, debug=False, parent=None, idInParent=None): """ Create a store. |
self.cursor = self.parent.connection | self.connection = self.parent.connection | def attachToParent(self): assert self.parent is not None, 'must have a parent to attach' assert self.transaction is None, "can't attach within a transaction" |
del referee; del referent | del referee | def testBadReferenceRaises(self): store = Store() for (i, exc) in enumerate(self.exceptions): MyReferent = self._makeReferentItem(exc, i) referee = Referee(store=store) referent = MyReferent(store=store, ref=referee) referee.deleteFromStore() del referee; del referent |
del referee; del referent | del referee | def testBadReferenceNone(self): store = Store() referee = Referee(store=store, topSecret=0) MyReferent = self._makeReferentItem(None, None) referent = MyReferent(store=store, ref=referee) referee.deleteFromStore() del referee; del referent |
workUnitsPerformed += 1 | def tick(self): now = self.now() self.nextEventAt = None before = self.eventsRun workBeingDone = True workUnitsPerformed = 0 errors = 0 while workBeingDone and workUnitsPerformed < MAX_WORK_PER_TICK: workUnitsPerformed += 1 try: workBeingDone = self.store.transact(self._oneTick, now) except _WackyControlFlow, wcf: self... | |
subCommands = property(lambda self: [ (plg.name, None, plg, plg.description) for plg in plugin.getPlugins(iaxiom.IAxiomaticCommand, plugins) ] + [ ('start', None, Start, 'Launch the given Axiomatic database')]) | def subCommands(): def get(self): for plg in plugin.getPlugins(iaxiom.IAxiomaticCommand, plugins): try: yield (plg.name, None, plg, plg.description) except AttributeError: raise RuntimeError("Maldefined plugin: %r" % (plg,)) yield ('start', None, Start, 'Launch the given Axiomatic database') return get, subCommands = p... | def postOptions(self): self['no_save'] = True twistd.ServerOptions.postOptions(self) self.runApp() |
indexes = set() | def _actualTableCreation(self, tableClass, key): """ In the event that an Item subclass which has never before been added to the schema of our SQLite database, create the table, update the schema, and return the typeID. This is internal to the implementation of getTypeID. It must be run in a transaction. | |
if atr.indexed: indexes.add(((atr.columnName,), (atr.attrname,))) for compound in atr.compoundIndexes: indexes.add((tuple(inatr.columnName for inatr in compound), tuple(inatr.attrname for inatr in compound))) | def _actualTableCreation(self, tableClass, key): """ In the event that an Item subclass which has never before been added to the schema of our SQLite database, create the table, update the schema, and return the typeID. This is internal to the implementation of getTypeID. It must be run in a transaction. | |
indexColumnPrefix = '.'.join(tableClass.getTableName(self).split(".")[1:]) for (indexColumns, indexAttrs) in indexes: csql = ('CREATE INDEX %s ON %s(%s)' % (tableClass.indexNameOf(self, '_'.join(indexAttrs)), indexColumnPrefix, ', '.join(indexColumns))) self.createSQL(csql) | self._createIndexesFor(tableClass) | def _actualTableCreation(self, tableClass, key): """ In the event that an Item subclass which has never before been added to the schema of our SQLite database, create the table, update the schema, and return the typeID. This is internal to the implementation of getTypeID. It must be run in a transaction. |
return '<Store %s@0x%x>' % (self.dbdir, unsignedID(self)) | return '<Store %s@0x%x>' % (d, unsignedID(self)) | def __repr__(self): d = self.dbdir if d is None: d = '(in memory)' else: d = repr(d) return '<Store %s@0x%x>' % (self.dbdir, unsignedID(self)) |
for t in self.store.query(Tag, AND(Tag.object == obj, Tag.name == tagName, Tag.tagger == tagger)): return | def tag(self, obj, tagName, tagger=None): """ """ self.tagCount += 1 # check to see if that tag exists: for t in self.store.query(Tag, AND(Tag.object == obj, Tag.name == tagName, Tag.tagger == tagger)): return Tag(store=self.store, object=obj, name=tagName, catalog=self, created=Time(), tagger=tagger) | |
def __init__(self, doc='', indexed=False, caseSensitive=False): SQLAttribute.__init__(self, doc, indexed) | def __init__(self, caseSensitive=False, **kw): SQLAttribute.__init__(self, **kw) | def __init__(self, doc='', indexed=False, caseSensitive=False): SQLAttribute.__init__(self, doc, indexed) if caseSensitive: self.sqltype = 'TEXT' else: self.sqltype = 'TEXT COLLATE NOCASE' self.caseSensitive = caseSensitive |
yield None, more | yield None, bool(more or items) | def step(self): while True: items = list(self.items()) |
print input, output | def testIntegerAttribute_SQLiteBug(self): # SQLite 3.2.1 has a bug which causes various integers to be stored # incorrect. For example, 2 ** 48 - 1 is stored as -1. This is # fixed in 3.2.7. | |
testIntegerAttribute_SQLiteBug.todo = ( "If this test fails on your system, you should really upgrade SQLite " "to at least 3.2.7. Not doing so will lead to corruption of your " "data.") | if sqlite_version_info < (3, 2, '7'): testIntegerAttribute_SQLiteBug.todo = ( "If this test fails on your system, you should really upgrade SQLite " "to at least 3.2.7. Not doing so will lead to corruption of your " "data.") | def testIntegerAttribute_SQLiteBug(self): # SQLite 3.2.1 has a bug which causes various integers to be stored # incorrect. For example, 2 ** 48 - 1 is stored as -1. This is # fixed in 3.2.7. |
raise NotImplementedError( "%s did not specify a typeName attribute" % (qual(T),)) | T.typeName = normalize(qual(T)) | def __new__(meta, name, bases, dictionary): T = slotmachine.SchemaMetaMachine.__new__(meta, name, bases, dictionary) if T.__name__ == 'Item' and T.__module__ == __name__: return T T.__already_inherited__ += 1 if T.__already_inherited__ >= 2: raise NoInheritance("already inherited from item once: " "in-database inherita... |
raise NotImplementedError( "%s did not specify a schemaVersion attribute" % (qual(T),)) | T.schemaVersion = 1 | def __new__(meta, name, bases, dictionary): T = slotmachine.SchemaMetaMachine.__new__(meta, name, bases, dictionary) if T.__name__ == 'Item' and T.__module__ == __name__: return T T.__already_inherited__ += 1 if T.__already_inherited__ >= 2: raise NoInheritance("already inherited from item once: " "in-database inherita... |
schemaVersion = 1 | def dummyItemSubclass(typeName, schemaVersion, attributes, dummyBases): """ Generate a dummy subclass of Item that will have the given attributes, and the base Item methods, but no methods of its own. This is for use with upgrading. @param typeName: a string, the Axiom TypeName to have attributes for. @param schemaVe... | |
return '<Store %s@%x>' % (self.dbdir, id(self)) | return '<Store %s@0x%x>' % (self.dbdir, unsignedID(self)) | def __repr__(self): d = self.dbdir if d is None: d = '(in memory)' else: d = repr(d) return '<Store %s@%x>' % (self.dbdir, id(self)) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.