rem stringlengths 0 322k | add stringlengths 0 2.05M | context stringlengths 8 228k |
|---|---|---|
print 'HERE' | def _make_node(self, singular, plural, variables, plural_expr, vars_referenced): """Generates a useful node from the data provided.""" # no variables referenced? no need to escape for old style # gettext invocations if not vars_referenced and not self.environment.newstyle_gettext: singular = singular.replace('%%', '%'... | |
pass | def test_call(self): env = Environment() env.globals['foo'] = lambda a, b, c, e, g: a + b + c + e + g tmpl = env.from_string("{{ foo('a', c='d', e='f', *['b'], **{'g': 'h'}) }}") assert tmpl.render() == 'abdfh' def test_slicing(self): tmpl = env.from_string('{{ [1, 2, 3][:] }}|{{ [1, 2, 3][::-1] }}') assert tmpl.rende... | def assert_error(code, expected): try: Template(code) except TemplateSyntaxError, e: assert str(e) == expected, 'unexpected error message' else: assert False, 'that was suposed to be an error' |
for child in node.iter_child_nodes(exclude=('body', 'args')): self.visit(child) | self.visit(node.call) | def visit_CallBlock(self, node): for child in node.iter_child_nodes(exclude=('body', 'args')): self.visit(child) |
-> 43 | -> 43.0 | def do_round(value, precision=0, method='common'): """Round the number to a given precision. The first parameter specifies the precision (default is ``0``), the second the rounding method: - ``'common'`` rounds either up or down - ``'ceil'`` always rounds up - ``'floor'`` always rounds down If you don't specify a met... |
global rectime, recnumber, recirule, recgpnum, debug pmatch=gpstress_re.search(aline) if pmatch: check_element_rec (rectime, recnumber, recirule, recgpnum, 'stresses', 0.0, aline) if debug: print " stress rec" return 1 ppmatch = gpstrain_re.search(aline) if ppmatch: check_element_rec (rectime, recnumber, recirule, ... | global rectime, recnumber, recirule, recgpnum, debug pmatch=gpstress_re.search(aline) if pmatch: check_element_rec (rectime, recnumber, recirule, recgpnum, 'stresses', 0.0, aline) if debug: print " stress rec" return 1 ppmatch = gpstrain_re.search(aline) if ppmatch: check_element_rec (rectime, recnumber, recirule, ... | def match_gpsubrec (aline): global rectime, recnumber, recirule, recgpnum, debug pmatch=gpstress_re.search(aline) if pmatch: check_element_rec (rectime, recnumber, recirule, recgpnum, 'stresses', 0.0, aline) if debug: print " stress rec" return 1 ppmatch = gpstrain_re.search(aline) if ppmatch: check_element_rec (re... |
check_element_rec (rectime, recnumber, recirule, recgpnum, 'state', 0.0, aline) if debug: print " state rec" return 1 ppmatch = gpflow_re.search(aline) if ppmatch: check_element_rec (rectime, recnumber, recirule, recgpnum, 'flow', 0.0, aline) if debug: print " flow rec" return 1 return 0 def match_singlegprec... | check_beam_rec (rectime, recnumber, 'forces', 0.0, line) if debug: print " local forces rec" continue return line | def match_gpsubrec (aline): global rectime, recnumber, recirule, recgpnum, debug pmatch=gpstress_re.search(aline) if pmatch: check_element_rec (rectime, recnumber, recirule, recgpnum, 'stresses', 0.0, aline) if debug: print " stress rec" return 1 ppmatch = gpstrain_re.search(aline) if ppmatch: check_element_rec (re... |
if debug: print "Opening oofem output file:", oofemoutfilename[:-1] infile = open(oofemoutfilename[:-1]) | if debug: print "Opening oofem output file:", oofemoutfilename.rstrip('\r\n') infile = open(oofemoutfilename.rstrip('\r\n')) | def main(): global userrec, recval, infile, infilename, mode, tolerance try: # options expecting value followed by ':', see also Unix getopt opts, args = getopt.getopt (sys.argv[1:],'cf:') except getopt.GetoptError, err: print str(err) usage() exit(1) # flag whether -f compulsory option provided infileflag = False #pr... |
self.record_fail("%d messages queued" % count) | if count == 1: self.record_fail("%d message queued" % count) else: self.record_fail("%d messages queued" % count) | def run_test(self): try: pipe = subprocess.Popen([os.path.join(self.path, "exiqgrep"), "-xc"], stdout=subprocess.PIPE).stdout for line in pipe: matches = self.r.match(line) if matches: count = int(matches.group("count")) total = int(matches.group("total")) if count > self.max_length: self.record_fail("%d messages queue... |
self.record_success("%d messages queued" % count) | if count == 1: self.record_success("%d message queued" % count) else: self.record_success("%d messages queued" % count) | def run_test(self): try: pipe = subprocess.Popen([os.path.join(self.path, "exiqgrep"), "-xc"], stdout=subprocess.PIPE).stdout for line in pipe: matches = self.r.match(line) if matches: count = int(matches.group("count")) total = int(matches.group("total")) if count > self.max_length: self.record_fail("%d messages queue... |
raise ioe | raise | def copyfile(srcpath, dstpath, copy_mode_from_dst=True, run_restorecon=True): """Copy srcpath to dstpath. Abort operation if e.g. not enough space is available. Attempt to atomically replace dstpath if it exists.""" if issamefile(srcpath, dstpath, catch_stat_exceptions=OSError): return dstpath = os.path.realpath(ds... |
exc_name = e.get_dbus_name() if not exc_name.startswith(AUTH_EXC_PREFIX): raise e action_id = exc_name[len(AUTH_EXC_PREFIX):] if authfail_callback is not None: authfail_callback(action_id=action_id) if authfail_exception is not None: try: raise authfail_exception(action_id=action_id) except: raise authfail_exceptio... | def handle_authfail(e): assert isinstance(e, dbus.DBusException) | |
packet_string = "Content-Length:" + str(len(json_str)) + "\r\n" + json_str | packet_string = "Content-Length:" + str(len(json_str)) + "\r\n\r\n" + json_str | def run(self): while True: try: self.cv.acquire() if len(self.packetQueue) > 0: packet = self.packetQueue.pop() json_str = json.dumps(packet.packet) packet_string = "Content-Length:" + str(len(json_str)) + "\r\n" + json_str self.conn.send(packet_string) |
length = 0 | prev = curr = "" while prev != '\r' and curr != '\n': prev = curr try: curr = self.socket.recv(1) except socket.error: break | def waitHandshake(self): shake = '' print 'Waiting for Crossfire handshake...' try: shake = self.socket.recv(len(HANDSHAKE_STRING)) print shake except socket.error, msg: print msg if shake == HANDSHAKE_STRING: print 'Received Crossfire handshake.' |
self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) try: self.socket.bind((self.host, self.port)) except socket.error: print socket.error quit() self.socket.listen(1) self.conn, addr = self.socket.accept() | self.socket = socket.create_connection((self.host, self.port)) | def start(self): self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) try: self.socket.bind((self.host, self.port)) except socket.error: print socket.error quit() |
self.reader = PacketReader(self.conn, self.socketCondition) self.writer = PacketWriter(self.conn, self.socketCondition) | self.reader = PacketReader(self.socket, self.socketCondition) self.writer = PacketWriter(self.socket, self.socketCondition) self.socket.settimeout(10) self.socket.send(HANDSHAKE_STRING) | def start(self): self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) try: self.socket.bind((self.host, self.port)) except socket.error: print socket.error quit() |
self.conn.close() | def stop(self): try: self.conn.close() self.socket.close() self.socketCondition.acquire() self.reader.join(10) self.writer.join(10) except (AttributeError, KeyboardInterrupt): pass | |
shake = self.conn.recv(len(HANDSHAKE_STRING)) except socket.error: print socket.error | shake = self.socket.recv(len(HANDSHAKE_STRING)) print shake except socket.error, msg: print msg | def waitHandshake(self): print 'Waiting for Crossfire handshake...' try: shake = self.conn.recv(len(HANDSHAKE_STRING)) except socket.error: print socket.error if shake == HANDSHAKE_STRING: print 'Received Crossfire handshake.' self.conn.settimeout(3) self.conn.send(HANDSHAKE_STRING) |
self.conn.settimeout(3) self.conn.send(HANDSHAKE_STRING) | def waitHandshake(self): print 'Waiting for Crossfire handshake...' try: shake = self.conn.recv(len(HANDSHAKE_STRING)) except socket.error: print socket.error if shake == HANDSHAKE_STRING: print 'Received Crossfire handshake.' self.conn.settimeout(3) self.conn.send(HANDSHAKE_STRING) | |
server = None | client = None | def run(self): while True: try: line = raw_input(COMMAND_PROMPT) #line = sys.stdin.readline() if line: line = line.strip() space = line.find(' ') argstr = None if space == -1: command = line else: command = line[:space].strip() argstr = line[space:].strip() if command in Commands: if command == "entercontext": self.cur... |
print 'Starting Crossfire server on ' + host + ':' + port server = CrossfireServer(host, int(port)) | print 'Starting Crossfire client on ' + host + ':' + port client = CrossfireClient(host, int(port)) | def main(): global server global commandLine |
server.start() | client.start() | def main(): global server global commandLine |
server.sendPacket(command) | client.sendPacket(command) | def main(): global server global commandLine |
packet = server.getPacket() | packet = client.getPacket() | def main(): global server global commandLine |
server.restart() | client.restart() | def main(): global server global commandLine |
print 'Usage: $> python crossfire_server.py [<host>] <port>' | print 'Usage: $> python crossfire_test_client.py [<host>] <port>' | def main(): global server global commandLine |
print "\nStopping Server..." | print "\nShutting down..." | def quit(): global server global commandLine |
def __init__(self, type): | def __init__(self): | def __init__(self, type): gst.Bin.__init__(self) self.colorspace = gst.element_factory_make( "ffmpegcolorspace", "videoconvert_colorspace" ) self.add(self.colorspace) |
"sink", self.videoscale.sink_pads().next() | "sink", self.colorspace.sink_pads().next() | def __init__(self, type): gst.Bin.__init__(self) self.colorspace = gst.element_factory_make( "ffmpegcolorspace", "videoconvert_colorspace" ) self.add(self.colorspace) |
self.encoding = encoding_ui.EncodingUI(ui) | def __init__(self, preview_area, ui): self.player = None self.preview = Preview(preview_area) | |
def show_encoding(self): self.encoding.show_window() | def __init__(self, preview_area, ui): self.player = None self.preview = Preview(preview_area) | |
pass | self.emit("error", "Please, add an encoder.") break | def play(self): |
self.about.set_copyright("Copyright 2010 Holoscopio Tecnologia") | self.about.set_copyright("Copyright (c) 2010 Holoscópio Tecnologia") | def create_about(self): self.about.set_name("SLTV") self.about.set_copyright("Copyright 2010 Holoscopio Tecnologia") self.about.set_version("0.1") self.about.set_website("https://wiki.softwarelivre.org/TV/ProjetoSLTV") self.about.set_wrap_license(True) self.about.set_license( "This program is free software; you can red... |
src_pad = gst.GhostPad( "src", self.find_unlinked_pad(gst.PAD_SRC) ) | src_pad = gst.GhostPad("src", self.csp.src_pads().next()) | def __init__(self, colorspace, width, height): gst.Bin.__init__(self) self.caps = self.make_caps(colorspace, width, height) self.videomixer = gst.element_factory_make("videomixer", "videomixer") self.add(self.videomixer) self.inside_videoscale = gst.element_factory_make( "videoscale", "inside_videoscale" ) self.add(sel... |
"sink_1", self.inside_videoscale.get_static_pad("sink") | "sink_1", self.inside_videoscale.sink_pads().next() | def __init__(self, colorspace, width, height): gst.Bin.__init__(self) self.caps = self.make_caps(colorspace, width, height) self.videomixer = gst.element_factory_make("videomixer", "videomixer") self.add(self.videomixer) self.inside_videoscale = gst.element_factory_make( "videoscale", "inside_videoscale" ) self.add(sel... |
"sink_2", self.outside_videoscale.get_static_pad("sink") | "sink_2", self.outside_videoscale.sink_pads().next() | def __init__(self, colorspace, width, height): gst.Bin.__init__(self) self.caps = self.make_caps(colorspace, width, height) self.videomixer = gst.element_factory_make("videomixer", "videomixer") self.add(self.videomixer) self.inside_videoscale = gst.element_factory_make( "videoscale", "inside_videoscale" ) self.add(sel... |
"sink", self.audioresample.sink_pads().next() | "sink", self.audiorate.sink_pads().next() | def __init__(self): gst.Bin.__init__(self) |
"audio/x-raw-int, rate=%d; audio/x-raw-float, rate=%d" %( value, value | "audio/x-raw-int, rate=%d" %( value | def do_set_property(self, property, value): if property.name == "audiorate": caps = gst.caps_from_string( "audio/x-raw-int, rate=%d; audio/x-raw-float, rate=%d" %( value, value ) ) self.capsfilter.set_property("caps", caps) self.audiorate_property = value else: Log.warning('audioresample unknown property %s' % property... |
converter = output.converter.factory_class() | converter = output.create_converter() | def play(self, overlay_text, video_effect_name, audio_effect_name): |
encoder = output.encoding.factory_class(type) | encoder = output.create_encoding(type) | def play(self, overlay_text, video_effect_name, audio_effect_name): |
previewsink.set_property("sync", "false") previewsink.set_property("force-aspect-ratio", "true") self.emit("prepare-xwindow-id", previewsink) | if previewsink.get_parent() == self.sink: previewsink.set_property("sync", "false") previewsink.set_property("force-aspect-ratio", "true") self.emit("prepare-xwindow-id", previewsink) | def on_sync_message(self, sltv, bus, message): if message.structure is None: return message_name = message.structure.get_name() if message_name == "prepare-xwindow-id": previewsink = message.src previewsink.set_property("sync", "false") previewsink.set_property("force-aspect-ratio", "true") self.emit("prepare-xwindow-i... |
A_videoscale, A_videorate, A_csp, A_capsfilter | A_videoscale, A_videorate, A_csp, A_alpha, A_capsfilter | def _create_A_input(self): A_videoscale = gst.element_factory_make( "videoscale", None ) self.add(A_videoscale) A_videorate = gst.element_factory_make( "videorate", None ) self.add(A_videorate) A_capsfilter = gst.element_factory_make( "capsfilter", None ) self.add(A_capsfilter) self.A_capsfilter.append(A_capsfilter) A_... |
B_videoscale, B_videorate, B_csp, B_capsfilter | B_videoscale, B_videorate, B_csp, B_alpha, B_capsfilter | def _create_B_input(self): B_videoscale = gst.element_factory_make( "videoscale", None ) self.add(B_videoscale) B_videorate = gst.element_factory_make( "videorate", None ) self.add(B_videorate) B_capsfilter = gst.element_factory_make( "capsfilter", None ) self.add(B_capsfilter) self.B_capsfilter.append(B_capsfilter) B_... |
self.mount_point_entry.set_text(self.config["mount_point"]) | self.mount_point_entry.set_text(self.config["mount"]) | def update_config(self): self.server_entry.set_text(self.config["ip"]) self.user_entry.set_text(self.config["username"]) self.password_entry.set_text(self.config["password"]) self.port_spinbutton.set_value(float(self.config["port"])) self.mount_point_entry.set_text(self.config["mount_point"]) |
bla = "" | (model, iter) = self.sources_treeview.get_selection().get_selected() model.remove(iter) | def on_remove_source(self, button): bla = "" |
sltv.connect("pipeline-ready", self._on_pipeline_ready) | self.sltv.connect("pipeline-ready", self._on_pipeline_ready) def source_destroy(self): self.sltv.disconnect_by_func(self._on_pipeline_ready) | def __init__(self, sltv, name, a_group, b_group): self.sltv = sltv |
source = sltv.source.Source(name, self.factory) source.set_config(self.factory.get_ui().get_config()) self.sources.add_source(name, source) | if not self.sources.config.has_item("Sources", name): source = sltv.source.Source(name, self.factory) source.set_config(self.factory.get_ui().get_config()) self.sources.add_source(name, source) | def save(self): name = self.name_entry.get_text() if name == None or name == "": return False source = sltv.source.Source(name, self.factory) source.set_config(self.factory.get_ui().get_config()) self.sources.add_source(name, source) |
return self.config[section][item_name] | if self.has_item(section, item_name): return self.config[section][item_name] else: return None | def get_item(self, section, item_name): return self.config[section][item_name] |
print "oggmux" oggmux = gst.element_factory_make("oggmux", "oggmux") self.add(oggmux) | self.oggmux = gst.element_factory_make("oggmux", "oggmux") self.add(self.oggmux) | def __init__(self, type): Encoder.__init__(self, type) print "oggmux" oggmux = gst.element_factory_make("oggmux", "oggmux") self.add(oggmux) if type & INPUT_TYPE_AUDIO: audioconvert = gst.element_factory_make( "audioconvert", "audioconvert" ) self.add(audioconvert) vorbisenc = gst.element_factory_make("vorbisenc", "vor... |
audioconvert, vorbisenc, queue_audio, oggmux | audioconvert, vorbisenc, queue_audio, self.oggmux | def __init__(self, type): Encoder.__init__(self, type) print "oggmux" oggmux = gst.element_factory_make("oggmux", "oggmux") self.add(oggmux) if type & INPUT_TYPE_AUDIO: audioconvert = gst.element_factory_make( "audioconvert", "audioconvert" ) self.add(audioconvert) vorbisenc = gst.element_factory_make("vorbisenc", "vor... |
theoraenc = gst.element_factory_make("theoraenc", "theoraenc") self.add(theoraenc) | self.theoraenc = gst.element_factory_make("theoraenc", "theoraenc") self.add(self.theoraenc) | def __init__(self, type): Encoder.__init__(self, type) print "oggmux" oggmux = gst.element_factory_make("oggmux", "oggmux") self.add(oggmux) if type & INPUT_TYPE_AUDIO: audioconvert = gst.element_factory_make( "audioconvert", "audioconvert" ) self.add(audioconvert) vorbisenc = gst.element_factory_make("vorbisenc", "vor... |
gst.element_link_many(theoraenc, queue_video, oggmux) self.video_pad.set_target(theoraenc.sink_pads().next()) self.source_pad.set_target(oggmux.src_pads().next()) | gst.element_link_many(self.theoraenc, queue_video, self.oggmux) self.video_pad.set_target(self.theoraenc.sink_pads().next()) self.source_pad.set_target(self.oggmux.src_pads().next()) | def __init__(self, type): Encoder.__init__(self, type) print "oggmux" oggmux = gst.element_factory_make("oggmux", "oggmux") self.add(oggmux) if type & INPUT_TYPE_AUDIO: audioconvert = gst.element_factory_make( "audioconvert", "audioconvert" ) self.add(audioconvert) vorbisenc = gst.element_factory_make("vorbisenc", "vor... |
return config[section][item_name] | return self.config[section][item_name] | def get_item(self, section, item_name): return config[section][item_name] |
gst.DEBUG_BIN_TO_DOT_FILE_WITH_TS(self.player, gst.DEBUG_GRAPH_SHOW_MEDIA_TYPE, "debug") | def play(self): | |
self.colorspace, self.videoscale, self.capsfilter | self.colorspace, self.videorate, self.videoscale, self.capsfilter | def __init__(self, type): gst.Bin.__init__(self) self.colorspace = gst.element_factory_make( "ffmpegcolorspace", "videoconvert_colorspace" ) self.add(self.colorspace) |
media_item.set_config(self.factory.get_ui().get_config()) | media_item.set_config(self.factory.get_ui().get_config().copy()) | def save(self): if self.media_item == None: name = self.name_entry.get_text() if name == None or name == "": return False if not self.media_list.get_item(name): media_item = sltv.mediaitem.MediaItem(name, self.factory) media_item.set_config(self.factory.get_ui().get_config()) if self.audio_config: audio = sltv.mediaite... |
self.audio_factory.get_ui().get_config() | self.audio_factory.get_ui().get_config().copy() | def save(self): if self.media_item == None: name = self.name_entry.get_text() if name == None or name == "": return False if not self.media_list.get_item(name): media_item = sltv.mediaitem.MediaItem(name, self.factory) media_item.set_config(self.factory.get_ui().get_config()) if self.audio_config: audio = sltv.mediaite... |
self.media_item.set_config(self.factory.get_ui().get_config()) | self.media_item.set_config( self.factory.get_ui().get_config().copy() ) | def save(self): if self.media_item == None: name = self.name_entry.get_text() if name == None or name == "": return False if not self.media_list.get_item(name): media_item = sltv.mediaitem.MediaItem(name, self.factory) media_item.set_config(self.factory.get_ui().get_config()) if self.audio_config: audio = sltv.mediaite... |
self.effects = effects.EffectsUI(self, self.sltv) self.overlay = overlay.OverlayUI(self, self.sltv) self.volume = volume.VolumeUI(self, self.sltv) | self.effects = effects.EffectsUI(self.ui, self.sltv) self.overlay = overlay.OverlayUI(self.ui, self.sltv) self.volume = volume.VolumeUI(self.ui, self.sltv) | def __init__(self, ui, sltv): self.ui = ui self.sltv = sltv self.interface = gtk.Builder() self.interface.add_from_file(UI_DIR + "/settings.ui") self.widget = self.interface.get_object("vbox") self.content = self.interface.get_object("content_viewport") |
return self.file_chooser.get_filename() | return self.entry.get_text() | def get_filename(self): return self.file_chooser.get_filename() |
if self.playing(): | if self.playing() and self.volume: | def set_volume(self, value): if self.playing(): self.volume.set_property("volume", value) |
self.play() def play(self): if not self.sltv.playing(): | def on_play_press(self, event): if not self.sltv.playing(): self.stop_button.set_active(False) | |
self.add(self.video_queue, self.colorspc) | self.add(self.colorspc) | def __init__(self): Input.__init__(self, CAPABILITIES) self.dv_src = gst.element_factory_make("dv1394src", "video_src") self.add(self.dv_src) self.capsfilter = gst.element_factory_make( "capsfilter", "dv_capsfilter" ) self.add(self.capsfilter) self.tee = gst.element_factory_make("tee", "dv_tee") self.add(self.tee) self... |
if item_name in self.config[section].keys(): return True else: return False | if self.has_section(section): if item_name in self.config[section].keys(): return True else: return False return False | def has_item(self, section, item_name): if item_name in self.config[section].keys(): return True else: return False |
def __init__(self, colorspace): | def __init__(self): | def __init__(self, colorspace): gst.Bin.__init__(self) |
self.colorspace = colorspace | def __init__(self, colorspace): gst.Bin.__init__(self) | |
self.caps = self.make_caps(colorspace, self.width, self.height) | self.caps = self.make_caps(self.width, self.height) | def __init__(self, colorspace): gst.Bin.__init__(self) |
self.inside_capsfilter, self.inside_csp | self.inside_csp, self.inside_capsfilter | def __init__(self, colorspace): gst.Bin.__init__(self) |
self.outside_capsfilter, self.outside_csp | self.outside_csp, self.outside_capsfilter | def __init__(self, colorspace): gst.Bin.__init__(self) |
self.inside_csp.get_static_pad("src").link(videomixer_sink_1) | self.inside_capsfilter.get_static_pad("src").link(videomixer_sink_1) | def __init__(self, colorspace): gst.Bin.__init__(self) |
self.outside_csp.get_static_pad("src").link(videomixer_sink_2) | self.outside_capsfilter.get_static_pad("src").link(videomixer_sink_2) | def __init__(self, colorspace): gst.Bin.__init__(self) |
self.caps = self.make_caps(self.colospace, self.width, self.height) | self.caps = self.make_caps(self.width, self.height) | def do_set_property(self, property, value): if property.name == "width": self.width = value elif property.name == "height": self.height = value else: Log.warning('PictureInPicture unknown property %s' % property.name) self.caps = self.make_caps(self.colospace, self.width, self.height) self.inside_capsfilter.set_propert... |
self.player, self.queue_audio, self.convert, | self.player, self.volume, self.convert, | def change_effect(self, effect_name, effect_type): |
def blah(method): | def blah(method): def wrapper(client, *args, **kwargs): gen = method(client, *args, **kwargs) promise = gen.next() client.set_callback(promise, lambda t, result: \ callback_wrapper(client, gen, t, result)) PROMISES[gen] = promise return wrapper | |
promise = gen.next() client.set_callback(promise, lambda t, result: \ | waiting_for[0] = gen.next() client.set_callback(waiting_for[0], lambda t, result: \ | def wrapper(client, *args, **kwargs): gen = method(client, *args, **kwargs) promise = gen.next() client.set_callback(promise, lambda t, result: \ callback_wrapper(client, gen, t, result)) PROMISES[gen] = promise |
PROMISES[gen] = promise | def wrapper(client, *args, **kwargs): gen = method(client, *args, **kwargs) promise = gen.next() client.set_callback(promise, lambda t, result: \ callback_wrapper(client, gen, t, result)) PROMISES[gen] = promise | |
def callback_wrapper(client, gen, t, result): promise = gen.send(result) client.set_callback(promise, lambda t, result: \ callback_wrapper(client, gen, t, result)) PROMISES[gen] = promise | def callback_wrapper(client, gen, t, result): promise = gen.send(result) client.set_callback(promise, lambda t, result: \ callback_wrapper(client, gen, t, result)) PROMISES[gen] = promise | |
yield client.basic_publish(exchange='', routing_key=q, | client.basic_publish(exchange='', routing_key=q, | def worker(client, q, msg_cnt, body, prefetch_cnt, inc, avg): result = (yield client.queue_declare(queue=q)) fill = max(msg_cnt - result['message_count'], 0) while fill > 0: fill -= BURST_SIZE for i in xrange(BURST_SIZE): promise = client.basic_publish(exchange='', routing_key=q, body=body, headers=headers) yield prom... |
t1 = t0 + 1.0 while True: td = t1 - time.time() if td > 0: client.wait(PROMISES.values(), timeout=td) else: break global counter, average, average_count | client.loop(timeout=1.0) | def avg(td): global average, average_count average += td average_count += 1 |
auto_delete = False | def exchange_declare(conn, exchange, type='direct', durable=False, auto_delete=False, arguments={}): # Exchanges don't support 'x-expires', so we support only durable exchanges. auto_delete = False t = conn.promises.new(_exchange_declare) t.x_frames = spec.encode_exchange_declare(exchange, type, False, durable, auto_d... | |
if not git_dir.endswith((".git", ".git/")): git_dir = git_dir + "/.git/" os.putenv("GIT_DIR", git_dir) | def __get_root_dir (self, uri): if uri != self.uri: directory = os.path.dirname (uri) while directory and not os.path.isdir (os.path.join (directory, ".git")): directory = os.path.dirname (directory) else: directory = uri | |
cwd = os.getcwd () | cwd = self.__get_root_dir(uri) | def blame (self, uri, rev = None, files = None, mc = False): self._check_uri (uri) |
cmd = ['git', 'show', '-m' '--pretty=format:'] | cmd = ['git', 'show', '-m', '--pretty=format:'] | def show (self, uri, rev = None): self._check_uri (uri) |
cmd = ['git', 'show', '--pretty=format:'] | cmd = ['git', 'show', '-m' '--pretty=format:'] | def show (self, uri, rev = None): self._check_uri (uri) |
for tempFile in self.tempFiles: os.remove(tempFile) | def tearDown(self): unittest.TestCase.tearDown(self) system("rm -rf %s" % self.tempDir) for tempFile in self.tempFiles: os.remove(tempFile) | |
command = "sonLib_cigarsTest %s %s" % (tempFile, keepProbs) | command = "sonLib_cigarTest %s %s" % (tempFile, keepProbs) | def testCigarReadWrite(self): """Tests the C code for reading and writing cigars against the python parser for cigars. """ tempFile = getTempFile() self.tempFiles.append(tempFile) for test in xrange(0, self.testNo): pairwiseAlignmentNumber = random.choice(xrange(10)) l = [ getRandomPairwiseAlignment() for i in xrange(p... |
HTTPSConnection.putrequest(self, method, rest, skip_host, skip_accept_encoding) | if sys.version_info < (2,4): HTTPSConnection.putrequest(self, method, rest, skip_host) else: HTTPSConnection.putrequest(self, method, rest, skip_host, skip_accept_encoding) | def putrequest(self, method, url, skip_host=0, skip_accept_encoding=0): #putrequest is called before connect, so can interpret url and get #real host/port to be used to make CONNECT request to proxy proto, netloc, path, query, fragment = urlsplit(url) if not proto: raise ValueError, "unknown URL type: %s" % url #get h... |
fp = open(os.path.expandvars("$GIP_LOCATION/templates/%s" % template)) | cp = config() template_dirs = cp_getList(cp, 'gip', 'local_template_dirs', []) template_dirs.append(os.path.expandvars('$GIP_LOCATION/templatestest')) tried = [] fp = '' for template_dir in template_dirs: try: template_dir = os.path.expandvars(template_dir) fp = open("%s/%s" % (template_dir, template)) break except IO... | def getTemplate(template, name): """ Return a template from a file. @param template: Name of the template file in $GIP_LOCATION/templates. @param name: Entry in the template file; for now, this is the first entry of the DN. @return: Template string @raise e: ValueError if it is unable to find the template in the file.... |
print results | def printResults(self, results): print results xml = '<?xml version="1.0" encoding="UTF-8"?>\n' xml += '<GIPValidator>\n' for result in results: xml += " <ResourceGroup type='%s'>\n" % result['type'] xml += " <Name>%s</Name>\n" % result['site'] xml += " <Timestamp>%s</Timestamp>\n" % result['timestamp'... | |
'Notification'), 'Notification', {(None, 'ConsumerURL'): \ | 'Notification'), 'Notification', {("http://glite.org/ce/" \ "monitorapij/types", 'ConsumerURL'): \ | def generate(self, messages, producer="OSG CE Sensor"): self.encoding = 'UTF-8' output = cStringIO.StringIO() gen = XMLGenerator(output, self.encoding) gen.startDocument() gen.startPrefixMapping('soapenv', 'http://schemas.xmlsoap.org/soap/envelope/') gen.startElementNS(('http://schemas.xmlsoap.org/soap/envelope/', 'Env... |
for entry in self.entries: | bdii_base = "mds-vo-name=%s,mds-vo-name=local,o=grid" % self.site fd = query_bdii(self.endpoint, query="", base=bdii_base) local_entries = read_ldap(fd, multi=True) for entry in local_entries: | def test_sponsors(self): r = re.compile("(\w+):([0-9]+)") for entry in self.entries: if 'GlueSite' not in entry.objectClass: continue try: m = r.findall(entry.glue['SiteSponsor']) if m == None: msg="Invalid site sponsor: %s" % entry.glue['SiteSponsor'] self.appendMessage(MSG_CRITICAL, msg) return tot = 0 num_sponsors =... |
m = r.findall(entry.glue['SiteSponsor']) if m == None: | try: sponsors = entry.glue['SiteSponsor'] except: | def test_sponsors(self): r = re.compile("(\w+):([0-9]+)") for entry in self.entries: if 'GlueSite' not in entry.objectClass: continue try: m = r.findall(entry.glue['SiteSponsor']) if m == None: msg="Invalid site sponsor: %s" % entry.glue['SiteSponsor'] self.appendMessage(MSG_CRITICAL, msg) return tot = 0 num_sponsors =... |
for e in m: | for s in sponsors: try: amount = int(s.split(":")[1]) except: msg="Invalid site sponsor percentage: %s" % entry.glue['SiteSponsor'] self.appendMessage(MSG_CRITICAL, msg) return | def test_sponsors(self): r = re.compile("(\w+):([0-9]+)") for entry in self.entries: if 'GlueSite' not in entry.objectClass: continue try: m = r.findall(entry.glue['SiteSponsor']) if m == None: msg="Invalid site sponsor: %s" % entry.glue['SiteSponsor'] self.appendMessage(MSG_CRITICAL, msg) return tot = 0 num_sponsors =... |
tot += int(e[1]) | tot += amount | def test_sponsors(self): r = re.compile("(\w+):([0-9]+)") for entry in self.entries: if 'GlueSite' not in entry.objectClass: continue try: m = r.findall(entry.glue['SiteSponsor']) if m == None: msg="Invalid site sponsor: %s" % entry.glue['SiteSponsor'] self.appendMessage(MSG_CRITICAL, msg) return tot = 0 num_sponsors =... |
if queue not in queue_exclude: queues.append(queue) | def getQueueList(cp): """ Returns a list of all the queue names that are supported. @param cp: Site configuration @returns: List of strings containing the queue names. """ queues = [] try: queue_exclude = [i.strip() for i in cp.get("pbs", "queue_exclude").\ split(',')] except: queue_exclude = [] rvf_info = parseRvf('p... | |
if cp_getBoolean(cp, "condor", "count_flocked", False): | if cp_getBoolean(cp, "condor", "count_flocked", True): | def addIntInfo(my_info_dict, classad_dict, my_key, classad_key): """ Add some integer info contained in classad_dict[classad_key] to my_info_dict[my_key]; protect against any thrown exceptions. If classad_dict[classad_key] cannot be converted to a number, default to 0. """ if my_key not in my_info_dict or classad_key n... |
xml += '<GIPValidator>\n' | xml += '</GIPValidator>\n' | def printResults(self, results): xml = '<?xml version="1.0" encoding="UTF-8"?>\n' xml += '<GIPValidator>\n' for result in results: xml += " <ResourceGroup type='%s'>\n" % result['type'] xml += " <Name>%s</Name>\n" % result['site'] xml += " <Timestamp>%s</Timestamp>\n" % result['timestamp'] xml += " ... |
info = jinfo.get(vo, {"running": 0, "idle": 0, "held": 0}) | info = jinfo.get(vo.lower(), {"running": 0, "idle": 0, "held": 0}) | def print_VOViewLocal(cp): """ Print the GLUE VOView entity; shows the VO's view of the condor batch system. Config options used: * ce.name. The human-readable name of the ce. * condor.status. The status of condor; defaults to "Production" * osg_dirs.app. The $OSG_APP directory; defaults to "/Unknown" * osg_dirs.da... |
def __init__(self): | def __init__(self, url=""): | def __init__(self): cp = config() self.xml_file = getTempFilename() self.xsl_file = os.path.expandvars(cp_get(cp, "gip", "pretty_gip_xsl", "$GIP_LOCATION/templates/pretty_gip_info.xsl")) self.html_file = os.path.expandvars(cp_get(cp, "gip", "pretty_gip_html", "$VDT_LOCATION/apache/htdocs/pretty_gip_info.html")) self.do... |
runCommand("rm -rf %s" % self.xml_file) | def transform(self): writeXML(self.doc, self.xml_file, pretty=False) transform_cmd = "xsltproc -o %s %s %s" runCommand(transform_cmd % (self.html_file,self.xsl_file,self.xml_file)) runCommand("rm -rf %s" % self.xml_file) | |
path = os.path.expandvars("$GIP_LOCATION/bin/gip_info") fd = os.popen(path) | url_re = re.compile('http://([A-Za-z0-9-\.]+)/(.+)') m = url_re.match(self.url) if m: fd = getUrlFd(self.url) else: path = os.path.expandvars("$GIP_LOCATION/bin/gip_info") fd = os.popen(path) | def getEntries(self): path = os.path.expandvars("$GIP_LOCATION/bin/gip_info") fd = os.popen(path) self.entries = read_ldap(fd, multi=True) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.