rem stringlengths 0 322k | add stringlengths 0 2.05M | context stringlengths 8 228k |
|---|---|---|
print 'smart sort', self._objectlist, attribute, order | def _on_configuration_changed(self, *k): order_descending = self._order_button.get_active() if order_descending: order = gtk.SORT_DESCENDING else: order = gtk.SORT_ASCENDING attribute = self._proxy.read() | |
print 'broken sort', self._objectlist, attribute, order | def _on_configuration_changed(self, *k): order_descending = self._order_button.get_active() if order_descending: order = gtk.SORT_DESCENDING else: order = gtk.SORT_ASCENDING attribute = self._proxy.read() | |
setattr(self, obj.get_name(), obj) | setattr(self, gtk.Buildable.get_name(obj), obj) | def _load_builder(self): builder = gtk.Builder() if self.builder_path: if not os.path.exists(self.builder_path): raise LookupError(self.__class__, self.builder_path) builder.add_from_file(self.builder_path) elif self.builder_file: |
"""an open dialog | """An open dialog. | def open_filechooser( title, parent=None, patterns=None, folder=None, filter=None, _before_run=None, action=None): """an open dialog :param parent: window or None :param patterns: file match patterns :param folder: initial folder :param filter: file filter use of filter and patterns at the same time is invalid """ as... |
use of filter and patterns at the same time is invalid | Use of filter and patterns at the same time is invalid. | def open_filechooser( title, parent=None, patterns=None, folder=None, filter=None, _before_run=None, action=None): """an open dialog :param parent: window or None :param patterns: file match patterns :param folder: initial folder :param filter: file filter use of filter and patterns at the same time is invalid """ as... |
setattr(self, gtk.Buildable.get_name(obj), obj) | try: obj_name = gtk.Buildable.get_name(obj) except TypeError: pass else: setattr(self, obj_name, obj) | def _load_builder(self): builder = gtk.Builder() if self.builder_path: if not os.path.exists(self.builder_path): raise LookupError(self.__class__, self.builder_path) builder.add_from_file(self.builder_path) elif self.builder_file: |
toplevel.unparent() | toplevel.get_parent().remove(toplevel) | def get_builder_toplevel(self, builder): """Get the toplevel widget from a gtk.Builder file. |
def on_model_set(self): | def model_set(self): | def on_model_set(self): if self.model: self.firstname_entry.set_text(self.model.name) self.lastname_entry.set_text(self.model.surname) self.email_entry.set_text(self.model.email) else: self.reset() |
gobject.threads_init() | def __init__(self, work_callback=None, loop_callback=None, daemon=True): self.counter = 0 gobject.threads_init() #the glib mainloop doesn't love us else self.daemon = daemon | |
"""Start the task | """Start the task. | def start(self, *args, **kwargs): """Start the task |
The diference between this task and AsyncTask | The difference between this task and AsyncTask | def _loop_callback(self, vargs): counter, ret = vargs if counter != self.counter: return |
pl = ProxyStringList() | pl = StringList() | def test_proxy_stringlist_create(): pl = ProxyStringList() assert not pl.view.get_headers_visible() |
act.connect('activate', lambda a, (s, selected): \ | act.connect('activate', lambda a, (s, ip): \ | def __on_button_press(self, tree, event): self.last_pos = (event.x, event.y) |
return NET_LAYER, mpkt.get_field('eth.type') | mpkt.l2_proto = IL_TYPE_ETH mpkt.l2_len = 14 mpkt.l2_src, \ mpkt.l2_dst, \ mpkt.l3_proto = mpkt.get_fields('eth', ('src', 'dst', 'type')) if mpkt.l3_proto == LL_TYPE_ARP: mpkt.l3_src, \ mpkt.l3_dst = mpkt.get_fields('arp', ('psrc', 'pdst')) return NET_LAYER, mpkt.l3_proto | def eth_decoder(mpkt): return NET_LAYER, mpkt.get_field('eth.type') |
(mpkt.l3_dst, mpkt.l4_dst, | (mpkt.l3_src, mpkt.l4_src, | def report(self, mpkt, manager): #if self.status not in (LOGON_COMPLETED_OK, LOGON_COMPLETED_FAILURE): # return |
pkt.set_field('ip.dst', self.dip) pkt.set_field('tcp.dport', self.dport) pkt.set_field('tcp.flags', TH_SYN) | def __thread_main(self): try: log.debug('Entered in __thread_main') | |
pkt.set_field('ip.src', random_ip()) elif sip != '0.0.0.0': pkt.set_field('ip.src', self.sip) | sip = random_ip() elif self.sip != '0.0.0.0': sip = self.sip | def __thread_main(self): try: log.debug('Entered in __thread_main') |
pkt.set_field('tcp.sport', randint(1, 65535)) | sport = randint(1, 65535) | def __thread_main(self): try: log.debug('Entered in __thread_main') |
pkt.set_field('tcp.sport', self.sport) | sport = self.sport pkt.set_fields('ip', { 'dst' : self.dip, 'src' : sip}) pkt.set_fields('tcp', { 'sport' : sport, 'dport' : self.dport, 'flags' : TH_SYN, 'seq' : randint(0, 2L**32-1)}) | def __thread_main(self): try: log.debug('Entered in __thread_main') |
'inj::l4proto' : [PM_TYPE_INT, 'Used to track down L4 protocol for ' 'injection'], 'inj::flags' : [PM_TYPE_INT, 'Used for injection'], 'inj::payload' : [PM_TYPE_STR, 'Data for injection'], 'inj::data' : [PM_TYPE_INSTANCE, 'General objects'], | def __init__(self): self._output = None # It seems that specifying {} * n doesn't create a new object # but instead only create a new pointer to the same object. # Here we need separated dict so we should declare them all self._decoders = ({}, {}, {}, {}, {}, {}, {}, {}) self._injectors = ({}, {}, {}, {}, {}, {}, {}, {... | |
ret = NL_TYPE_TCP | ret = APP_LAYER_TCP | def __run_dissectors(self, mpkt): if mpkt.flags & MPKT_DONT_DISSECT: return |
ret = NL_TYPE_UDP | ret = APP_LAYER_UDP | def __run_dissectors(self, mpkt): if mpkt.flags & MPKT_DONT_DISSECT: return |
self._conn_manager.parse(mpkt) if mpkt.flags & MPKT_FORWARDABLE and \ not mpkt.flags & MPKT_FORWARDED: manager.run_hook_point('pm::pre-forward', mpkt) self._context.forward(mpkt) | if not mpkt.flags & MPKT_FORWARDED: self._conn_manager.parse(mpkt) if mpkt.flags & MPKT_FORWARDABLE: manager.run_hook_point('pm::pre-forward', mpkt) self._context.forward(mpkt) | def feed(self, mpkt, *args): """ General purpose procedure. Will be used the main_decoder created in the constructor. So if you need to have another main_dissector you could change it with the correct property. |
http_type = HTTP_REQUEST def __init__(self, sess): | def __init__(self, sess, manager): | def form_extract(data, type=FORM_USERNAME): if not g_fields: return None for pattern in unquote(data).split('&'): try: k, v = pattern.split('=', 1) if g_fields[k] == type: return v except: pass |
if self.content_length > 0 or self.chunked: if data[end_ptr:]: ret = self._parse_body(data[end_ptr:], end_ptr) if ret[0]: self.analyze_headers(mpkt) self._parse_post(mpkt) if self.http_type == HTTP_REQUEST: mpkt.set_cfield(HTTP_NAME + '.request', self.body) else: mpkt.set_cfield(HTTP_NAME + '.response', self.body) r... | finished = self._check_finished() if not finished: remaining = data[end_ptr:] if not remaining: return False, end_ptr ret = self._parse_body(remaining, end_ptr) if ret[0] == True: self.analyze_headers(mpkt) self._parse_post(mpkt) if self.http_type == HTTP_REQUEST: mpkt.set_cfield(HTTP_NAME + '.request', self.body)... | def feed(self, mpkt, data): """ @return a tuple (bool, int) with bool = True if the response/request parsing is complete. The int is the last data count. """ if not self.headers_complete: end_ptr = self._parse_headers(mpkt, data) |
return True, end_ptr | self.manager.run_hook_point('http', mpkt) return finished, end_ptr | def feed(self, mpkt, data): """ @return a tuple (bool, int) with bool = True if the response/request parsing is complete. The int is the last data count. """ if not self.headers_complete: end_ptr = self._parse_headers(mpkt, data) |
return 3 | return 2 | def _parse_headers(self, mpkt, payload): idx = payload.find(HTTP_TRAILER) |
key, value = line.split(' ', 1) | try: key, value = line.split(' ', 1) except: key, value = line.split(':', 1) key += ':' | def _parse_headers(self, mpkt, payload): idx = payload.find(HTTP_TRAILER) |
elif key == 'authorization': | elif key == 'authorization' or \ key == 'www-authenticate': | def _parse_headers(self, mpkt, payload): idx = payload.find(HTTP_TRAILER) |
elif key == 'www-authenticate': if value[0:5] == 'NTLM ': | elif value[0:5] == 'NTLM ': | def _parse_headers(self, mpkt, payload): idx = payload.find(HTTP_TRAILER) |
mpkt.set_cfield('password', ', '.join(values)) | mpkt.set_cfield('password', password) self.report(mpkt, 'DIGEST', user, password) | def _parse_digest(self, mpkt, val): values = [] found = False user = '' |
def _parse_basic(self, val): | def _parse_basic(self, mpkt, val): | def _parse_basic(self, val): val = b64decode(val) ret = val.split(':', 1) |
mpkt.set_cfield('user', ret[0]) | mpkt.set_cfield('username', ret[0]) | def _parse_basic(self, val): val = b64decode(val) ret = val.split(':', 1) |
if not idx: | if idx == 0: idx = payload.find('\r\n', 2) if idx < 0: | def _parse_body(self, payload, end_ptr=0): if self.chunked: idx = 0 clen, cbody = self.chunks[-1] |
self.body = '\r\n'.join(map(lambda x: x[1], self.chunks)) | def _parse_body(self, payload, end_ptr=0): if self.chunked: idx = 0 clen, cbody = self.chunks[-1] | |
http_type = HTTP_RESPONSE | def __init__(self, sess, manager): HTTPRequest.__init__(self, sess, manager) self.http_type = HTTP_RESPONSE | def _parse_body(self, payload, end_ptr=0): if self.chunked: idx = 0 clen, cbody = self.chunks[-1] |
def __init__(self): self.request = HTTPRequest(self) self.response = HTTPResponse(self) | def __init__(self, manager): self.manager = manager self.request = HTTPRequest(self, manager) self.response = HTTPResponse(self, manager) | def __init__(self): self.request = HTTPRequest(self) self.response = HTTPResponse(self) |
if ret: self.request = HTTPRequest(self) | if ret == True: self.request = HTTPRequest(self, self.manager) | def feed_request(self, hlfstream, mpkt): while hlfstream.count > self.req_last_len: ret, idx = self.request.feed(mpkt, hlfstream.data[self.req_last_len:]) |
if ret is True: self.response = HTTPResponse(self) | if ret == True: self.response = HTTPResponse(self, self.manager) | def feed_response(self, hlfstream, mpkt): while hlfstream.count > self.res_last_len: ret, idx = self.response.feed(mpkt, hlfstream.data[self.res_last_len:]) |
conf = AuditManager().get_configuration(HTTP_NAME) | self.manager = AuditManager() conf = self.manager.get_configuration(HTTP_NAME) | def start(self, reader): self.sessions = {} |
gflieds = dict(map(lambda x: (x, 0), ufields.split(',')) + \ map(lambda x: (x, 1), pfields.split(','))) | g_fields = dict( map(lambda x: (x, FORM_USERNAME), ufields.split(',')) + \ map(lambda x: (x, FORM_PASSWORD), pfields.split(',')) ) | def start(self, reader): self.sessions = {} |
conf = AuditManager().get_configuration(HTTP_NAME) | conf = self.manager.get_configuration(HTTP_NAME) | def stop(self): conf = AuditManager().get_configuration(HTTP_NAME) |
AuditManager().remove_dissector(APP_LAYER_TCP, port, self._http_decoder) | self.manager.remove_dissector(APP_LAYER_TCP, port, self._http_decoder) | def stop(self): conf = AuditManager().get_configuration(HTTP_NAME) |
if self.reassemble: | self.manager.register_hook_point('http') if not self.reassemble: | def register_decoders(self): if self.reassemble: for port in HTTP_PORTS: AuditManager().add_dissector(APP_LAYER_TCP, port, self._http_decoder) |
AuditManager().add_dissector(APP_LAYER_TCP, port, self._http_decoder) | self.manager.add_dissector(APP_LAYER_TCP, port, self._http_decoder) | def register_decoders(self): if self.reassemble: for port in HTTP_PORTS: AuditManager().add_dissector(APP_LAYER_TCP, port, self._http_decoder) |
payload = mpkt.get_field('raw.load') | payload = mpkt.data | def _http_decoder(self, mpkt): payload = mpkt.get_field('raw.load') |
obj = HTTPRequest(None) | obj = HTTPRequest(None, self.manager) | def _http_decoder(self, mpkt): payload = mpkt.get_field('raw.load') |
except: | except Exception, exc: | def _http_decoder(self, mpkt): payload = mpkt.get_field('raw.load') |
if stream.dport in HTTP_PORTS: | if stream.dport in HTTP_PORTS or \ stream.sport in HTTP_PORTS: | def _tcp_callback(self, stream, mpkt): if stream.dport in HTTP_PORTS: stream.listeners.append(self._process_http) |
if hash(stream) not in self.sessions: sess = HTTPSession() self.sessions[hash(stream)] = sess | if stream not in self.sessions: sess = HTTPSession(self.manager) self.sessions[stream] = sess | def _process_http(self, stream, mpkt, rcv): if hash(stream) not in self.sessions: sess = HTTPSession() self.sessions[hash(stream)] = sess else: sess = self.sessions[hash(stream)] |
sess = self.sessions[hash(stream)] | sess = self.sessions[stream] | def _process_http(self, stream, mpkt, rcv): if hash(stream) not in self.sessions: sess = HTTPSession() self.sessions[hash(stream)] = sess else: sess = self.sessions[hash(stream)] |
del self.sessions[hash(stream)] return INJ_COLLECT_DATA | del self.sessions[stream] return REAS_COLLECT_DATA | def _process_http(self, stream, mpkt, rcv): if hash(stream) not in self.sessions: sess = HTTPSession() self.sessions[hash(stream)] = sess else: sess = self.sessions[hash(stream)] |
__plugins_deps__ = [('HTTPDissector', ['TCPDecoder'], [], [])] | __plugins_deps__ = [('HTTPDissector', ['TCPDecoder'], ['=HTTPDissector-1.0'], [])] | def _process_http(self, stream, mpkt, rcv): if hash(stream) not in self.sessions: sess = HTTPSession() self.sessions[hash(stream)] = sess else: sess = self.sessions[hash(stream)] |
sess.mitm_attacks.remove(AUDIT_NAME) | self.session.mitm_attacks.remove(AUDIT_NAME) | def stop(self): if self.state == self.NOT_RUNNING or not self.internal: return False |
self._hooks = {} | self._hooks = { 'pm::received' : [], 'pm::handled' : [], 'pm::decoded' : [], 'pm::filter' : [], 'pm::pre-forward' : [], 'pm::dispatcher' : [], } | def __init__(self): self._output = None # It seems that specifying {} * n doesn't create a new object # but instead only create a new pointer to the same object. # Here we need separated dict so we should declare them all self._decoders = ({}, {}, {}, {}, {}, {}, {}, {}) self._injectors = ({}, {}, {}, {}, {}, {}, {}, {... |
while level and type: | ret = None while level is not None and type is not None: | def run_decoder(self, level, type, metapkt): while level and type: decoder, pre, post = self.get_decoder(level, type) |
AuditManager().run_decoder(LINK_LAYER, self.datalink, mpkt) if self._context: self._context.set_forwardable(mpkt) if mpkt.flags & MPKT_FORWARDABLE and \ not mpkt.flags & MPKT_FORWARDED: self._context.forward(mpkt) flags = mpkt.cfields.get('inj::flags', None) l4proto = mpkt.cfields.get('inj::l4proto', None) im... | manager = AuditManager() manager.run_hook_point('pm::received', mpkt) if not self._context: manager.run_decoder(LINK_LAYER, self.datalink, mpkt) return level = LINK_LAYER type = self.datalink mpkt.context = self._context while level is not None and type is not None: decoder, pre, post = manager.get_decoder(level... | def feed(self, mpkt, *args): """ General purpose procedure. Will be used the main_decoder created in the constructor. So if you need to have another main_dissector you could change it with the correct property. |
_('Neither get_target could be used to autopopulate' 'target. Please load at least an appropriate plugin and ' 'make an ARP scan, or add targets MAC by hand.')) | _('Neither get_target can be used to autopopulate the targ' 'ets. Please load at least an appropriate plugin (like ' 'Profiler) and make an ARP scan, or add targets MAC by ' 'hand.')) | def add_host_entry(target, targets_idx): entry = None |
mpkt.l4_src, | mpkt.l4_src, \ | def udp(mpkt): mpkt.l4_len = UDP_LENGTH mpkt.l4_src, mpkt.l4_dst = mpkt.get_fields('udp', ('sport', 'dport')) |
(typ, mpkt.l3_src, mpkt.l4_src, mpkt.l3_dst, mpkt.l4_dst, | (typ, src[0], src[1], dst[0], dst[1], | def report(self, mpkt, typ, username, password): self.manager.user_msg( 'HTTP %s : %s:%d <-> %s:%d USERNAME: %s PASSWORD: %s' % \ (typ, mpkt.l3_src, mpkt.l4_src, mpkt.l3_dst, mpkt.l4_dst, username, password), 6, HTTP_NAME) |
mac = mpkt.l3_dst | mac = mpkt.l2_dst | def get_or_create(self, mpkt, clientside=False): if len(self.profiles) >= self.maxnum: self.cleanup() |
match = re.match(".*Request from.*", line, re.DOTALL) | match = re.match(".*Request from.*cmdaddr None.*", line, re.DOTALL) | def makestats(filename, days): day = None pack = None lang = None packages = {"None": 0, "tor-browser-bundle": 0, "tor-im-browser-bundle": 0, "tor-browser-bundle_en": 0, "tor-im-browser-bundle_en": 0, "tor-browser-bundle_de": 0, "tor-im-browser-bundle_de": 0, "tor-browser-bundle_ar": 0, "tor-im-browser-bundle_ar": 0, "... |
if not os.path.isdir(subdir) or not subdir.startswith("_"): | if not os.path.isdir(subdir) or not dirname.startswith("_"): | def buildPackages(self): for (pack, (regex_single, regex_split)) in self.packageRegex.items(): for dirname in os.listdir(self.distDir): subdir = os.path.join(self.distDir, dirname) # Ignore non-dir directory members and non-gettor dirs if not os.path.isdir(subdir) or not subdir.startswith("_"): continue for filename in... |
now = datetime.datetime.now() | now = datetime.now() | def dumpMessage(conf, message): """Dump a message to our dumpfile""" dumpFile = conf.getDumpFile() # Be nice: Create dir if it's not there dumpDir = os.path.dirname(dumpFile) if not os.access(dumpDir, os.W_OK): if not createDir(dumpDir): log.error("Could not create dump dir") return False try: fd = open(dumpFile, 'a') ... |
return RequestVal(self.toAddress, \ self.replytoAddress, \ self.replyLocale, \ self.returnPackage, \ self.splitDelivery, \ self.signature, \ | return RequestVal(self.toAddress, self.replytoAddress, self.replyLocale, self.returnPackage, self.splitDelivery, self.signature, | def parseMail(self): if self.parsedMessage.is_multipart(): for part in self.parsedMessage.walk(): if part.get_content_maintype() == "text": # We found a text part, parse it self.parseTextPart(part.get_payload(decode=1)) else: self.parseTextPart(self.parsedMessage.get_payload(decode=1)) |
if remainder == 1: return str(position) + 'st' elif remainder == 2: return str(position) + 'nd' elif remainder == 3: return str(position) + 'rd' | if remainder == 1 and position != 11: return str(position) + 'st' elif remainder == 2 and position != 12: return str(position) + 'nd' elif remainder == 3 and position != 13: return str(position) + 'rd' | def position(position): remainder = position % 10 if remainder == 1: return str(position) + 'st' elif remainder == 2: return str(position) + 'nd' elif remainder == 3: return str(position) + 'rd' return str(position) + 'th' |
if arch == 64: | if arch == "64": | def load_library(libname, print_path=True): # lib gets loaded from # 32bit python: pymunk/libchipmunk.so, libchipmunk.dylib or chipmunk.dll # 64 bit python pymunk/libchipmunk64.so, libchipmunk.dylib or chipmunk64.dll s = platform.system() arch = str(ctypes.sizeof(ctypes.c_voidp) * 8) path = os.path.dirname(os.path.ab... |
print body.position | def create_poly(self, points, mass = 5.0, pos = (0,0)): moment = pm.moment_for_poly(mass,points, Vec2d(0,0)) #moment = 1000 body = pm.Body(mass, moment) body.position = Vec2d(pos) shape = pm.Poly(body, points, Vec2d(0,0)) shape.friction = 0.5 shape.collision_type = COLLTYPE_DEFAULT self.space.add(body, shape) return ... | |
return Vec2d(1, 0) | return Vec2d(0, 1) | def unit(): """A unit vector pointing up""" return Vec2d(1, 0) |
compiler_preargs += ['-arch i386', '-arch x86_64'] | compiler_preargs += ['-arch', 'i386', '-arch', 'x86_64'] | def compile_chipmunk(self): print("compiling chipmunk...") compiler = cc.new_compiler(compiler=self.compiler) |
compiler.set_executable('linker_so', ['cc', '-dynamiclib']) | compiler.set_executable('linker_so', ['cc', '-dynamiclib', '-arch', 'i386', '-arch', 'x86_64']) | def compile_chipmunk(self): print("compiling chipmunk...") compiler = cc.new_compiler(compiler=self.compiler) |
def add_collision_handler(self, a, b, begin, pre_solve, post_solve, separate, *args, **kwargs): | def add_collision_handler(self, a, b, begin=None, pre_solve=None, post_solve=None, separate=None, *args, **kwargs): | def add_collision_handler(self, a, b, begin, pre_solve, post_solve, separate, *args, **kwargs): """Add a collision handler for given collision type pair. Whenever a shapes with collision_type a and collision_type b collide, these callbacks will be used to process the collision. None can be provided for callbacks you d... |
def set_default_collision_handler(self, begin, pre_solve, post_solve, separate, *args, **kwargs): | def set_default_collision_handler(self, begin=None, pre_solve=None, post_solve=None, separate=None, *args, **kwargs): | def set_default_collision_handler(self, begin, pre_solve, post_solve, separate, *args, **kwargs): """Register a default collision handler to be used when no specific collision handler is found. If you do nothing, the space will be given a default handler that accepts all collisions in begin() and pre_solve() and does n... |
doc="""Information on the contact points between the objects.""") | doc="""Information on the contact points between the objects. Return [`Contact`]""") | def _get_contacts(self): if self._contacts is None: self._contacts = [] for i in range(self._arbitercontents.numContacts): self.contacts.append(Contact(self._arbitercontents.contacts[i])) return self._contacts |
return bool(self._arbiter.contents.firstColl) | return bool(cp._cpArbiterIsFirstContact(self._arbiter)) | def _get_is_first_contact(self): return bool(self._arbiter.contents.firstColl) |
long_description = """pymunk is wrapper for the 2d rigid body physics library Chipmunk""" | long_description = """pymunk is a easy-to-use pythonic 2d physics library that can be used whenever you need 2d rigid body physics from Python. It is build on top of the very nice 2d physics library Chipmunk, http://code.google.com/p/chipmunk-physics/""" | def run(self): self.compile_chipmunk() |
image = ATImage('image') | image = ATImage('image').__of__(self.folder) | def testCreateScaleWithPdata(self): data = self.getImage() + '\x00' * (1 << 16) from Products.ATContentTypes.content.image import ATImage image = ATImage('image') image.setImage(data) field = image.getField('image') field.swallowResizeExceptions = False from OFS.Image import Pdata self.failUnless(isinstance(image.getIm... |
control = can_do_verify_ypin(hCard) | control = can_do_verify_pin(hCard) | def verifypin(hCard, control=None): if None==control: control = can_do_verify_ypin(hCard) if (None == control): raise error, "Not a pinpad" hresult, response = SCardControl(hcard, control, []) if hresult!=SCARD_S_SUCCESS: raise error, 'SCardControl failed: ' + SCardGetErrorMessage(hresult) return hresult, response |
cmd_verify = can_do_verif_ypin(hcard) | cmd_verify = can_do_verify_pin(hcard) | def verifypin(hCard, control=None): if None==control: control = can_do_verify_ypin(hCard) if (None == control): raise error, "Not a pinpad" hresult, response = SCardControl(hcard, control, []) if hresult!=SCARD_S_SUCCESS: raise error, 'SCardControl failed: ' + SCardGetErrorMessage(hresult) return hresult, response |
control = can_do_verif_ypin(hCard) | control = can_do_verify_ypin(hCard) | def verifypin(hCard, control=None): if None==control: control = can_do_verif_ypin(hCard) if (None == control): raise error, "Not a pinpad" hresult, response = SCardControl(hcard, control, []) if hresult!=SCARD_S_SUCCESS: raise error, 'SCardControl failed: ' + SCardGetErrorMessage(hresult) return hresult, response |
print tag, control | def getFeatureRequest(cardConnection): """ Get the list of Part10 features supported by the reader. cardConnection: CardConnection object return: a list of list [[tag1, value1], [tag2, value2]] """ response = cardConnection.control(CM_IOCTL_GET_FEATURE_REQUEST, []) features = [] while (len(response) > 0): tag = respo... | |
except BaseSCardException as exc: | except BaseSCardException,exc: | def __str__(self): return repr('Failure to remove reader: ' + self.readername + ' from group: ' + self.groupname + ' ' + smartcard.scard.SCardGetErrorMessage(self.hresult)) |
i = iterations | refresh = True | def mainloop(screen, interval): # Sleep time of each iteration in seconds scan = 1.0 / 100.0 # Query socket and redraw the screen in the given interval iterations = interval / scan update = True i = iterations while True: screen.sync_size() if i == iterations: if update: screen.update_data() screen.update_bars() scr... |
i = 0 | refresh = False | def mainloop(screen, interval): # Sleep time of each iteration in seconds scan = 1.0 / 100.0 # Query socket and redraw the screen in the given interval iterations = interval / scan update = True i = iterations while True: screen.sync_size() if i == iterations: if update: screen.update_data() screen.update_bars() scr... |
curses.curs_set(1) | try: curses.curs_set(1) except CursesError: pass | def start(self): curses.curs_set(1) self.draw_output() self.draw_input() |
curses.curs_set(0) | try: curses.curs_set(0) except CursesError: pass | def stop(self): curses.curs_set(0) |
curses.curs_set(0) | def curses_init(): screen = curses.initscr() curses.noecho() curses.nonl() curses.curs_set(0) curses.raw() try: curses.start_color() curses.use_default_colors() except: pass return screen | |
help='update interval in seconds (1-30s, default: 1s)', default=1) | help='update interval in seconds (1-30, default: 1)', default=1) | def mainloop(screen, socket, interval, mode): # Initialize curses screen screen.keypad(1) screen.nodelay(1) screen.idlok(1) screen.move(0, 0) # Initialize the scrollable content pad ymax, xmax = screen.getmaxyx() pad = curses.newpad(MAXLINES_CONTENT+2, SCREEN_XMAX) padpos = 0 # Prepare status bars sb_conn = StatusBar... |
self.screen.refresh() | self.screen.noutrefresh() | def refresh(self): self.screen.refresh() |
def run_cli(pad): | def run_cli(screen): | def run_cli(pad): pass # TODO |
data.update_lines() | if 0 < m < 5: data.update_lines() | def mainloop(screen, socket, interval, mode): # Prepare status bars sb_conn = StatusBar() sb_pipe = StatusBar() # Sleep time of each iteration in seconds scan = 1.0 / 100.0 # Query socket and redraw the screen in the given interval iterations = interval / scan m = mode # numeric mode mode = SCREEN... |
screen.clear_stat() | if 0 < m < 5: screen.clear_stat() | def mainloop(screen, socket, interval, mode): # Prepare status bars sb_conn = StatusBar() sb_pipe = StatusBar() # Sleep time of each iteration in seconds scan = 1.0 / 100.0 # Query socket and redraw the screen in the given interval iterations = interval / scan m = mode # numeric mode mode = SCREEN... |
draw_help(pad) | draw_help(help) | def mainloop(screen, socket, interval, mode): # Prepare status bars sb_conn = StatusBar() sb_pipe = StatusBar() # Sleep time of each iteration in seconds scan = 1.0 / 100.0 # Query socket and redraw the screen in the given interval iterations = interval / scan m = mode # numeric mode mode = SCREEN... |
run_cli(pad) | run_cli(screen) | def mainloop(screen, socket, interval, mode): # Prepare status bars sb_conn = StatusBar() sb_pipe = StatusBar() # Sleep time of each iteration in seconds scan = 1.0 / 100.0 # Query socket and redraw the screen in the given interval iterations = interval / scan m = mode # numeric mode mode = SCREEN... |
elif c == curses.KEY_UP: if screen.cpos > screen.cmin: screen.cpos -= 1 if screen.cpos == screen.cmin and screen.vmin > 0: screen.vmin -= 1 i, update = 0, False continue elif c == curses.KEY_DOWN: maxvmin = len(data.lines) - screen.cmax - 2 if screen.cpos < screen.cmax: screen.cpos += 1 if screen.cpos == screen.cmax an... | if 0 < m < 5: if c == curses.KEY_UP: if screen.cpos > screen.cmin: screen.cpos -= 1 if screen.cpos == screen.cmin and screen.vmin > 0: screen.vmin -= 1 i, update = 0, False continue if c == curses.KEY_DOWN: maxvmin = len(data.lines) - screen.cmax - 2 if screen.cpos < screen.cmax: screen.cpos += 1 if screen.cpos == scre... | def mainloop(screen, socket, interval, mode): # Prepare status bars sb_conn = StatusBar() sb_pipe = StatusBar() # Sleep time of each iteration in seconds scan = 1.0 / 100.0 # Query socket and redraw the screen in the given interval iterations = interval / scan m = mode # numeric mode mode = SCREEN... |
return min(self.span, len(self.lines)) | return min(self.span, len(self.lines) - 1) | def cmax(self): return min(self.span, len(self.lines)) |
maxvmin = len(screen.lines) - screen.cmax - 2 | nlines = len(screen.lines) | def mainloop(screen, interval): # Sleep time of each iteration in seconds scan = 1.0 / 100.0 # Query socket and redraw the screen in the given interval iterations = interval / scan i = 0 update = True # Toggle data update (query socket, parse, ...) refresh = True # Toggle resize and repaint of the whole scr... |
screen.vmin = maxvmin | if nlines > screen.span: screen.vmin = nlines - screen.cmax - 2 else: screen.vmin = screen.vmax - screen.cpos - 1 | def mainloop(screen, interval): # Sleep time of each iteration in seconds scan = 1.0 / 100.0 # Query socket and redraw the screen in the given interval iterations = interval / scan i = 0 update = True # Toggle data update (query socket, parse, ...) refresh = True # Toggle resize and repaint of the whole scr... |
self.obuf.append('- %s %s\n' % (time.ctime(), '-' * 50)) | self.obuf.append('- %s %s' % (time.ctime(), '-' * 50)) self.obuf.append('') | def execute(self): |
assert 'we will inform you as soon as' in response.data | assert 'Welcome to Flask-Gae-Skeleton!' in response.data | def test_landing_index(self): "Should have an index for the landing page with a welcome message" response = self.client.get('/') assert 'we will inform you as soon as' in response.data |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.