rem stringlengths 0 322k | add stringlengths 0 2.05M | context stringlengths 8 228k |
|---|---|---|
if format in ('markdown', 'tex') : | if format in ('markdown', 'latex') : | def text_export(request, key, format, download, whichcomments, withcolor, adminkey=None): text, admin = get_text_and_admin(key, adminkey) text_version = text.get_latest_version() original_content = text_version.content original_format = text_version.format # BD : html or markdown for now ... download_response = downl... |
res = ['<table class="diff"><tbody>'] | res = ['<table class="diff"><col class="diff-marker"/><col class="diff-content"/><col class="diff-separator"/<col class="diff-marker"/><col class="diff-content"/><tbody>'] | def get_uniffied_inner_diff_table(title1, title2, author1, author2, text1, text2): """ Return the inner of the html table for text1 vs text2 diff """ gen = unified_diff(text1.split('\n'), text2.split('\n'), n=3) index = 0 res = ['<table class="diff"><tbody>'] res.append('<tr><td></td><td class="diff-title">%s</td><td><... |
res.append('<tr><td class="diff-marker">-</td><td class="diff-deletedline">%s</td><td class="diff-separator"></td><td class="diff-marker">+</td><td class="diff-addedline">%s</td></tr>' % (minus, plus)) | res.append('<tr><td class="diff-marker">-</td><td class="diff-deletedline"><div>%s</div></td><td class="diff-separator"></td><td class="diff-marker">+</td><td class="diff-addedline"><div>%s</div></td></tr>' % (minus, plus)) | def get_uniffied_inner_diff_table(title1, title2, author1, author2, text1, text2): """ Return the inner of the html table for text1 vs text2 diff """ gen = unified_diff(text1.split('\n'), text2.split('\n'), n=3) index = 0 res = ['<table class="diff"><tbody>'] res.append('<tr><td></td><td class="diff-title">%s</td><td><... |
allowed_methods = ('POST', ) | allowed_methods = ('GET', 'POST') | def read(self, request): order_by = '-id' texts = get_texts_with_perm(request, 'can_view_text').order_by(order_by) return texts |
def create(self, request): | def create(self, request, key): | def create(self, request): """ Delete text identified by `key`. """ try: key = request.POST.get('key') text_delete(request, key=key) except UnauthorizedException: return rc.FORBIDDEN except KeyError: return rc.BAD_REQUEST return rc.DELETED |
key = request.POST.get('key') | def create(self, request): """ Delete text identified by `key`. """ try: key = request.POST.get('key') text_delete(request, key=key) except UnauthorizedException: return rc.FORBIDDEN except KeyError: return rc.BAD_REQUEST return rc.DELETED | |
from django.contrib.auth import authenticate | class AnonymousTextFeedHandler(AnonymousBaseHandler): allowed_methods = ('GET',) type = "Text methods" title = "Text feed" desc = "Returns text RSS feed." args = None @staticmethod def endpoint(): return URL_PREFIX + '/text/{key}/feed/?' def read(self, request, key): return text_feed(request, key=key) class TextFeed... | def create(self, request, key): res = text_edit(request, key=key) text = get_text_by_keys_or_404(key) text_version = text.last_text_version return {'version_key' : text_version.key , 'created': text_version.created} |
'note' : text_version.note, | 'note' : '', | def text_edit(request, key, adminkey=None): text = get_text_by_keys_or_404(key) text_version = text.get_latest_version() if request.method == 'POST': if request.user.is_authenticated(): form = EditTextForm(request.POST) else: form = EditTextFormAnon(request.POST) if form.is_valid(): if request.POST.get('new_version'):... |
import pdb;pdb.set_trace() | def text_version_delete(request, key, text_version_key): text_version = TextVersion.objects.get(key=text_version_key) text=text_version.text if request.method != 'POST': raise UnauthorizedException('Unauthorized') display_message(request, _(u'Text version %(text_version_title)s deleted') %{'text_version_title':text_ver... | |
if real_last_text_version and real_last_text_version != self.last_text_version: | if real_last_text_version and real_last_text_version != last_text_version: | def update_denorm_fields(self): real_last_text_version = self.fetch_latest_version() modif = False if real_last_text_version and real_last_text_version != self.last_text_version: self.last_text_version = real_last_text_version modif = True if real_last_text_version and real_last_text_version.title and real_last_text_... |
texts_with_local_role = Text.objects.filter(userrole__in=UserRole.objects.filter(user=user).filter(~Q(role=None))) | texts_with_local_role = Text.objects.filter(userrole__in=UserRole.objects.filter(user=user)) | def get_texts_with_perm(request, perm_name): assert Permission.objects.get(codename=perm_name) user = get_request_user(request) if user and user.is_staff: return Text.objects.all() # local role only ADDS permissions: ## global perm # if UserRole.objects.filter(text=None).filter(role__permissions__codename__exact=per... |
'tag_list' : Tag.objects.usage_for_queryset(TextVersion.objects.filter(id__in = [t.last_text_version_id for t in get_texts_with_perm(request, 'can_view_text')])), | 'tag_list' : tag_list, | def text_list(request): paginate_by = get_int(request.GET,'paginate',TEXT_PAGINATION) tag_selected = request.GET.get('tag_selected', 0) order_by = get_among(request.GET,'order',('title','author','modified','-title','-author','-modified'),'-modified') if request.method == 'POST': action = request.POST.get('action',Non... |
paginate_by = 10 | def text_share(request, key): display_suspended_users = get_int(request.GET, 'display', 0) tag_selected = request.GET.get('tag_selected', 0) text = get_text_by_keys_or_404(key) order_by = get_among(request.GET,'order',('user__username', 'user__email', '-user__username', '-user__email', 'role__name', '-role__name', ), ... | |
return _text_create_content(request, CreateTextContentForm) | text, rep = _text_create_content(request, CreateTextContentForm) return rep | def text_create_content(request): return _text_create_content(request, CreateTextContentForm) |
return redirect_post_create(text) | return text, redirect_post_create(text) | def _text_create_content(request, createForm): |
return render_to_response('site/text_create_content.html', {'document':document, 'form' : form}, context_instance=RequestContext(request)) | return None, render_to_response('site/text_create_content.html', {'document':document, 'form' : form}, context_instance=RequestContext(request)) | def _text_create_content(request, createForm): |
return redirect_post_create(text) | return text, redirect_post_create(text) | def _text_create_upload(request, createForm): |
return render_to_response('site/text_create_upload.html', {'form' : form}, context_instance=RequestContext(request)) | return None, render_to_response('site/text_create_upload.html', {'form' : form}, context_instance=RequestContext(request)) | def _text_create_upload(request, createForm): |
return _text_create_upload(request, CreateTextUploadForm) | text, rep = _text_create_upload(request, CreateTextUploadForm) return rep | def text_create_upload(request): return _text_create_upload(request, CreateTextUploadForm) |
texts_with_local_role = Text.objects.filter(userrole__in=UserRole.objects.filter(user=user)) | texts_with_local_role = Text.objects.filter(userrole__in=UserRole.objects.filter(Q(user=user) | Q(user=None)).filter(~Q(role=None))) | def get_texts_with_perm(request, perm_name): assert Permission.objects.get(codename=perm_name) user = get_request_user(request) if user and user.is_staff: return Text.objects.all() # local role only ADDS permissions: ## global perm # if UserRole.objects.filter(text=None).filter(role__permissions__codename__exact=per... |
return UserRole.objects.filter(user=user).filter(text=None).filter(Q(role__permissions__codename__exact=perm_name)).count() != 0 | return UserRole.objects.filter(Q(user=user) | Q(user=None)).filter(Q(text=None) | Q(text=text)).filter(Q(role__permissions__codename__exact=perm_name)).count() != 0 | def has_perm(request, perm_name, text=None): # bypass sec if NO_SECURITY if cm_settings.NO_SECURITY: return True # make sure perm exist assert Permission.objects.get(codename=perm_name) user = get_request_user(request) if user and user.is_staff: return True if not text: return UserRole.objects.filter(user=user, tex... |
tag = re.sub('^http://', '', url) if date is not None: tag = re.sub('/', ',%s:/' % time.mktime(date.timetuple()), tag, 1) tag = re.sub(' return u'tag:' + tag | parsed_url = urlparse(url) time_stp = time.mktime(date.timetuple()) if date is not None else '' return u'tag:%s,%s:%s' %(parsed_url.hostname, time_stp, parsed_url.path) | def get_tag_uri(url, date): "Creates a TagURI. See http://diveintomark.org/archives/2004/05/28/howto-atom-id" tag = re.sub('^http://', '', url) if date is not None: tag = re.sub('/', ',%s:/' % time.mktime(date.timetuple()), tag, 1) tag = re.sub('#', '/', tag) return u'tag:' + tag |
notifications = Notification.objects.filter(text=None, active=True) | notifications = Notification.objects.filter(text=None, active=True).exclude(type='own') | def notify(sender, **kwargs): from cm.security import get_viewable_comments, has_perm allready_notified = set() # avoid sending multiple notifications to same user activity = kwargs['instance'] if activity.type in Activity.VIEWABLE_ACTIVITIES.get('view_users'): # user activity: only viewed by managers notifications = ... |
notifications = Notification.objects.filter(Q(text=activity.text) | Q(text=None), active=True) | notifications = Notification.objects.filter(Q(text=activity.text) | Q(text=None), active=True).exclude(type='own') | def notify(sender, **kwargs): from cm.security import get_viewable_comments, has_perm allready_notified = set() # avoid sending multiple notifications to same user activity = kwargs['instance'] if activity.type in Activity.VIEWABLE_ACTIVITIES.get('view_users'): # user activity: only viewed by managers notifications = ... |
for encoding in [chardet.detect(input)['encoding'], 'utf8', 'latin1']: | encodings = ['utf8', 'latin1'] doc_enc = chardet.detect(input)['encoding'] if doc_enc: encodings = [doc_enc,] + encodings for encoding in encodings: | def to_unicode(input): if type(input) == str: res = None for encoding in [chardet.detect(input)['encoding'], 'utf8', 'latin1']: try: res = unicode(input, encoding) break; except UnicodeDecodeError: pass if not res: raise Exception('UnicodeDecodeError: could not decode') return res return input |
from ext.diff_match_patch import diff_match_patch | from cm.ext.diff_match_patch import diff_match_patch | def createlist(x, b=0): mode = 'char' cur = '' out = [] for c in x: if mode == 'tag': if c == '>': if b: cur += ']' else: cur += c out.append(cur); cur = ''; mode = 'char' else: cur += c elif mode == 'char': if c == '<': out.append(cur) if b: cur = '[' else: cur = c mode = 'tag' elif c in string.whitespace: out.append(... |
'save_name' : ungettext(u'Save user', u'Save users', 2 if mass else 1), | 'save_name' : ungettext(u'Add user', u'Add users', 2 if mass else 1), | def user_add(request, key=None, mass=False): text = get_text_by_keys_or_404(key) if key else None if request.method == 'POST': userform = UserForm(request.POST) if not mass else MassUserForm(request.POST) userroleform = UserRoleForm(request.POST) noteform = UserAddForm(request.POST) userprofileform = UserProfileAddForm... |
'title' : _(u'Desactivate notification?'), | 'title' : _(u'Deactivate notification?'), | def desactivate_notification(request, adminkey): try: notification = Notification.objects.get(adminkey=adminkey) except Notification.DoesNotExist: display_message(request, _(u"This notification has already been deactivated.")) return HttpResponseRedirect(reverse('index')) if request.method == 'POST': if request.POST['... |
print "Usage: %s <input metadata> <output repodata>" % sys.argv[0] | parser.print_usage() | def main(args): parser = OptionParser(version='modifyrepo version %s' % __version__) # query options parser.add_option("--mdtype", dest='mdtype', help="specific datatype of the metadata, will be derived from the filename if not specified") (opts, argsleft) = parser.parse_args(args) if len(argsleft) != 2: print "Usage:... |
if int(st.st_size) != size: | if st.st_size != size: | def _handleBase(self, node): top = node node = node.children pkgid = None mtime = None size = None relpath = None do_stat = self.opts.get('do_stat', True) while node is not None: if node.type != "element": node = node.next continue if node.name == "checksum": pkgid = node.content elif node.name == "time": mtime = int(n... |
if st.st_mtime != mtime: | if int(st.st_mtime) != mtime: | def _handleBase(self, node): top = node node = node.children pkgid = None mtime = None size = None relpath = None do_stat = self.opts.get('do_stat', True) while node is not None: if node.type != "element": node = node.next continue if node.name == "checksum": pkgid = node.content elif node.name == "time": mtime = int(n... |
sql_field_names = ('file', 'survey', 'title','abstract', 'survey', 'creation', 'x_min', 'y_min', 'x_max', 'y_max', 'width', 'height', 'dx', 'dy', 'vdatum', 'utm_zone', 'dr_url', 'bag_url', 'metadata_txt','metadata_xml', 'utm_x_min','utm_y_min' , 'utm_x_max' ,'utm_y_max') | sql_field_names = ('file', 'survey', 'title','abstract', 'survey', 'creation', 'x_min', 'y_min', 'x_max', 'y_max', 'width', 'height', 'dx', 'dy', 'vdatum', 'utm_zone', 'dr_url', 'bag_url', 'metadata_txt','metadata_xml', 'utm_x_min','utm_y_min' , 'utm_x_max' ,'utm_y_max', 'software') | def add_bag_to_db(cx, infile_name, survey, filename_base, verbose=False, write_xml=False): # filename_base - without .bag or path print ('file:',infile_name, file=sys.stderr) v = verbose if v: print ('opening:',infile_name,os.path.getsize(infile_name)) f = h5py.File(infile_name) #'H11302_OLS_OSS/H11302_2m_1.bag') #o =... |
if parent in cache: return cache[parent] | if hs in cache: return cache[hs] | def cache(self, parent): cache = self._cache |
cache[parent] = cacheEntry | cache[hs] = cacheEntry | def cache(self, parent): cache = self._cache |
def getHash(ob): | def getHash(self, ob): | def getHash(ob): res = hash(ob) while abs(res) > 0xFFFFFFFF: res = int(res/0xFFFFFFFF) return res |
self.args = map(unicode,args) | self.args = map(Variable,map(unicode,args)) | def __init__(self, args): self.args = map(unicode,args) |
if arg in context: self.args[n] = resolve_variable(arg, context) elif arg[0] == '"' and arg[-1] == '"': self.args[n] = arg[1:-1] elif arg[0] == "'" and arg[-1] == "'": self.args[n] = arg[1:-1] | try: self.resolved_args.insert(n, arg.resolve(context)) if isNumberType(self.resolved_args[n]): self.resolved_args[n] = arg.var except VariableDoesNotExist, e: self.resolved_args.insert(n, arg.var) except Exception, e: assert False, (repr(e), n) | def render(self,context): for n,arg in enumerate(self.args): if arg in context: self.args[n] = resolve_variable(arg, context) elif arg[0] == '"' and arg[-1] == '"': self.args[n] = arg[1:-1] elif arg[0] == "'" and arg[-1] == "'": self.args[n] = arg[1:-1] return self.post_render(context) |
def post_render(self, context): return self.args | def post_render(self, context): return self.resolved_args | def post_render(self, context): return self.args |
self.type = tokens[1] | self.type = Variable(tokens[1]) | def __init__(self, tokens, nodelist): self.type = None self.tokens = [] self.mode = None if tokens and len(tokens)>1: self.type = tokens[1] if tokens[-2] == 'as': self.mode = tokens[-1] self.tokens = tokens[2:-2] else: self.tokens = tokens[2:] self.nodelist = nodelist |
args.append(resolve_variable(t,context)) | args.append(Variable(t).resolve(context)) | def render(self, context): args = [] kwargs = {} for t in self.tokens: try: args.append(resolve_variable(t,context)) except: try: args.append(float(t)) except: arg = str(t) if arg.find('=')>-1: k,v = arg.split('=')[:2] kwargs[k] = v else: args.append(arg) if len(args) == 1 and type(args[0]) in map(type,[[],()]): args =... |
args = args[0] if self.type in dir(GChartWrapper): chart = getattr(GChartWrapper,self.type)(args,**kwargs) elif self.type in GChartWrapper.constants.TYPES: chart = GChartWrapper.GChart(self.type,args,**kwargs) | args = args[0] try: self.resolved_type = self.type.resolve(context) except VariableDoesNotExist, e: self.resolved_type = self.type.var if self.resolved_type in dir(GChartWrapper): chart = getattr(GChartWrapper,self.resolved_type)(args,**kwargs) elif self.resolved_type in GChartWrapper.constants.TYPES: chart = GChart... | def render(self, context): args = [] kwargs = {} for t in self.tokens: try: args.append(resolve_variable(t,context)) except: try: args.append(float(t)) except: arg = str(t) if arg.find('=')>-1: k,v = arg.split('=')[:2] kwargs[k] = v else: args.append(arg) if len(args) == 1 and type(args[0]) in map(type,[[],()]): args =... |
raise TypeError('Chart type %s not recognized'%self.type) imgkwargs = {} | raise TypeError('Chart type %s not recognized'%self.resolved_type) | def render(self, context): args = [] kwargs = {} for t in self.tokens: try: args.append(resolve_variable(t,context)) except: try: args.append(float(t)) except: arg = str(t) if arg.find('=')>-1: k,v = arg.split('=')[:2] kwargs[k] = v else: args.append(arg) if len(args) == 1 and type(args[0]) in map(type,[[],()]): args =... |
self.args = self.args[1:] if self.args[-2] == 'as': mode = self.args[-1] self.args = self.args[:-2] for n,arg in enumerate(self.args): self.args[n] = arg.replace('\\n','\n').replace('\\r','\r') G = self.cls(*self.args) | self.resolved_args = self.resolved_args[1:] if self.resolved_args[-2] == 'as': mode = self.resolved_args[-1] self.resolved_args = self.resolved_args[:-2] for n,arg in enumerate(self.resolved_args): self.resolved_args[n] = arg.replace('\\n','\n').replace('\\r','\r') G = self.cls(*self.resolved_args) | def post_render(self,context): mode = None self.args = self.args[1:] if self.args[-2] == 'as': mode = self.args[-1] self.args = self.args[:-2] for n,arg in enumerate(self.args): self.args[n] = arg.replace('\\n','\n').replace('\\r','\r') G = self.cls(*self.args) if mode: if mode == 'img': return G.img() if mode == 'url'... |
version="0.4.7dev", | version="0.4.7", | def read(name): return open(os.path.join(os.path.dirname(__file__), name)).read() |
response_headers = [('Content-type','image/jpeg')] | response_headers = [('Content-type','image/jpeg'), ('Content-Length', '137823')] | def simple_app(environ, start_response): status = '200 OK' response_headers = [('Content-type','image/jpeg')] #response_headers = [('Content-type','image/jpeg'), ('Content-Length', '137823')] start_response(status, response_headers) # use sendfile(2) return environ.get('wsgi.file_wrapper', FileWrapper)(open('wallpaper.... |
version="0.3", | version="0.3.1", | def read(name): return open(os.path.join(os.path.dirname(__file__), name)).read() |
sock = server._get_socket_fromfd(client.get_fd(), socket.AF_INET, socket.SOCK_STREAM) | sock = socket.fromfd(client.get_fd(), socket.AF_INET, socket.SOCK_STREAM) | def setup(self, environ): protocol_version = None if not (environ.get('HTTP_CONNECTION') == 'Upgrade' and environ.get('HTTP_UPGRADE') == 'WebSocket'): return # See if they sent the new-format headers if 'HTTP_SEC_WEBSOCKET_KEY1' in environ: protocol_version = 76 if 'HTTP_SEC_WEBSOCKET_KEY2' not in environ: # That's ba... |
server.trampolin(fileno, read=True, timeout=int(timeout)) | server.trampoline(fileno, read=True, timeout=int(timeout)) | def wait_read(fileno, timeout=None): if not timeout: timeout = 0 server.trampolin(fileno, read=True, timeout=int(timeout)) |
server.trampolin(fileno, write=True, timeout=int(timeout)) | server.trampoline(fileno, write=True, timeout=int(timeout)) | def wait_write(fileno, timeout=None): if not timeout: timeout = 0 server.trampolin(fileno, write=True, timeout=int(timeout)) |
server.trampolin(fileno, read=True, write=True, timeout=int(timeout)) | server.trampoline(fileno, read=True, write=True, timeout=int(timeout)) | def wait_readwrite(fileno, timeout=None): if not timeout: timeout = 0 server.trampolin(fileno, read=True, write=True, timeout=int(timeout)) |
from meinheld import server | from meinheld import server, cancel_wait | def inet_pton(address_family, ip_string): if address_family == AF_INET: return inet_aton(ip_string) # XXX: ipv6 won't work on windows raise NotImplementedError('inet_ntop() is not available on this platform') |
meinheld.trampolin(fileno, read=True, timeout=timeout) | if not timeout: timeout = 0 server.trampolin(fileno, read=True, timeout=int(timeout)) | def wait_read(fileno, timeout=None): meinheld.trampolin(fileno, read=True, timeout=timeout) |
meinheld.trampolin(fileno, write=True, timeout=timeout) | if not timeout: timeout = 0 server.trampolin(fileno, write=True, timeout=int(timeout)) | def wait_write(fileno, timeout=None): meinheld.trampolin(fileno, write=True, timeout=timeout) |
meinheld.trampolin(fileno, read=True, write=True, timeout=timeout) | if not timeout: timeout = 0 server.trampolin(fileno, read=True, write=True, timeout=int(timeout)) | def wait_readwrite(fileno, timeout=None): meinheld.trampolin(fileno, read=True, write=True, timeout=timeout) |
response_headers = [('Content-type','image/jpeg'), ('Content-Length', '137823')] | response_headers = [('Content-type','image/jpeg')] | def simple_app(environ, start_response): status = '200 OK' response_headers = [('Content-type','image/jpeg'), ('Content-Length', '137823')] start_response(status, response_headers) # use sendfile(2) return environ.get('wsgi.file_wrapper', FileWrapper)(open('wallpaper.jpg', 'rb')) |
ws = environ.get('wsgi.websocket') | ws = environ.pop('wsgi.websocket') | def __call__(self, environ, start_response): client = environ[CLIENT_KEY] g = client.get_greenlet() if not g: # new greenlet g = greenlet.greenlet(self.app) client.set_greenlet(g) c = Continuation(client) environ[CONTINUATION_KEY] = c |
except IOErr: | except IOError: | def _send_closing_frame(self, ignore_send_errors=False): """Sends the closing frame to the client, if required.""" if self.version == 76 and not self.websocket_closed: try: self.socket.send("\xff\x00") except IOErr: # Sometimes, like when the remote side cuts off the connection, # we don't care about this. if not ignor... |
return g.switch(environ, start_response) | response = g.switch(environ, start_response) return response | def __call__(self, environ, start_response): client = environ[CLIENT_KEY] g = client.get_greenlet() if not g: # new greenlet g = greenlet.greenlet(self.app) client.set_greenlet(g) c = Continuation(client) environ[CONTINUATION_KEY] = c |
if result: | if result and response != -1: | def __call__(self, environ, start_response): client = environ[CLIENT_KEY] g = client.get_greenlet() if not g: # new greenlet g = greenlet.greenlet(self.app) client.set_greenlet(g) c = Continuation(client) environ[CONTINUATION_KEY] = c |
print "\n" | print "" | def cgiHandler (service): try: params = {} input = cgi.FieldStorage() for key in input.keys(): params[key] = input[key].value path_info = host = "" if "PATH_INFO" in os.environ: path_info = os.environ["PATH_INFO"] if "HTTP_X_FORWARDED_HOST" in os.environ: host = "http://" + os.environ["HTTP_X_FORWARDED_HOST"] el... |
fmt -- a string describing the input format | fmt -- a string describing the output format | def export_to_memory(self, fmt): """ Export a canvas into a foreign format. |
_lib.caca_export_canvas_to_memory.restype = ctypes.c_void_p ret = _lib.caca_export_canvas_to_memory(self, fmt, p_size_t(ctypes.c_size_t())) return ctypes.c_char_p(ret).value | _lib.caca_export_canvas_to_memory.restype = ctypes.POINTER(ctypes.c_char_p) p = ctypes.c_size_t() ret = _lib.caca_export_canvas_to_memory(self, fmt, p) return ctypes.string_at(ret, p.value) | def export_to_memory(self, fmt): """ Export a canvas into a foreign format. |
fmt -- a string describing the input format | fmt -- a string describing the output format | def export_area_to_memory(self, x, y, width, height, fmt): """ Export a canvas portion into a foreign format. |
ret = _lib.caca_export_area_to_memory(self, x, y, width, height, fmt, p_size_t(ctypes.c_size_t())) return ctypes.c_char_p(ret).value | p = ctypes.c_size_t() ret = _lib.caca_export_area_to_memory(self, x, y, width, height, fmt, p) return ctypes.string_at(ret, p.value) | def export_area_to_memory(self, x, y, width, height, fmt): """ Export a canvas portion into a foreign format. |
bmask, gmask, rmask, amask) | rmask, gmask, bmask, amask) | def __init__(self, bpp, width, height, pitch, rmask, gmask, bmask, amask): """ Dither constructor |
if pointer is not None: | if pointer is None: | def __init__(self, width=0, height=0, pointer=None): """ Canvas constructor. |
def get_chars(self): """ Get the canvas character array, return python list. """ chlist = [] w, h = self.get_width(), self.get_height() _lib.caca_get_canvas_chars.argtypes = [_Canvas] _lib.caca_get_canvas_chars.restype = \ ctypes.POINTER(ctypes.c_uint8 * (w * h)) plist = _lib.caca_get_canvas_chars(self) for item ... | def get_chars(self, *args, **kw): """ Not implemented. """ raise CanvasError, "Not implemented" def get_attrs(self, *args, **kw): """ Not implemented. """ raise CanvasError, "Not implemented" | def get_chars(self): """ Get the canvas character array, return python list. """ chlist = [] #get canvas size w, h = self.get_width(), self.get_height() |
""" Get a canvas's dirty rectangle. | """ Get a canvas's dirty rectangle. Return python dictionnary with coords as keys: x, y, width, height. | def get_dirty_rect(self, idx): """ Get a canvas's dirty rectangle. |
x = ctypes.POINTER(ctypes.c_int) y = ctypes.POINTER(ctypes.c_int) w = ctypes.POINTER(ctypes.c_int) h = ctypes.POINTER(ctypes.c_int) | dct = None x = ctypes.c_int() y = ctypes.c_int() width = ctypes.c_int() height = ctypes.c_int() | def get_dirty_rect(self, idx): """ Get a canvas's dirty rectangle. |
_lib.caca_get_dirty_rect(self, idx, x, y, w, h) return [x.contents.value, y.contents.value, w.contents.value, h.contents.value] | if _lib.caca_get_dirty_rect(self, idx, x, y, width, height) > -1: dct = { 'x': x.value, 'y': y.value, 'width': width.value, 'height': height.value, } return dct | def get_dirty_rect(self, idx): """ Get a canvas's dirty rectangle. |
bg.set_colorkey((0, 0, 0), pygame.locals.RLEACCEL) | bg.set_colorkey((0, 0, 0), locals.RLEACCEL) | def load(self, images): for filename in images: key = filename.split('.')[0] filepath = tools.get_datafile_path('backgrounds', filename) try: bg = pygame.image.load(filepath) bg.set_colorkey((0, 0, 0), pygame.locals.RLEACCEL) bg = bg.convert_alpha() except Exception, message: raise SystemExit, message self.__files[key]... |
if key in ['dns']: props[section][key] = Array(val, signature='u') else: props[section][key] = Array(val, signature=signature) elif key in ['addresses', 'dns', 'routes']: value = map(UInt32, map(convert_int_to_uint, val)) props[section][key] = Array(value, signature='u') | props[section][key] = Array(val, signature=signature) | def patch_list_signature(props, signature='au'): """ Patches empty list signature in ``props`` with ``signature`` :param props: Dictionary with connection options :type props: dict :param signature: The signature to use in empty lists :rtype: dict """ for section in props: for key, val in props[section].iteritems(): i... |
ICERA_MODE_DICT_REV = revert_dict(ICERA_MODE_DICT) | ICERA_MODE_DICT_REV = revert_dict(self.custom.conn_dict) | def get_network_mode_cb(resp): mode = int(resp[0].group('mode')) ICERA_MODE_DICT_REV = revert_dict(ICERA_MODE_DICT) if mode in ICERA_MODE_DICT_REV: return ICERA_MODE_DICT_REV[mode] |
if mode not in ICERA_ALLOWED_DICT: | if mode not in self.custom.allowed_dict: | def set_allowed_mode(self, mode): if mode not in ICERA_ALLOWED_DICT: raise KeyError("Mode %s not found" % mode) |
return self.send_at("AT%%IPSYS=%d" % ICERA_ALLOWED_DICT[mode], | return self.send_at("AT%%IPSYS=%d" % self.custom.allowed_dict[mode], | def set_allowed_mode_cb(orig=None): self.device.set_property(consts.NET_INTFACE, "AllowedMode", mode) return orig |
log.msg("INFO profile.py: (wader.common) - get_profile_by_uuid: " + profile) | log.msg("INFO profile.py: (wader.common) - get_profile_by_uuid: %s" % profile) | def get_profile_by_uuid(self, uuid): """ Returns the :class:`Profile` identified by ``uuid`` |
if self.device.opath == opath: | dev = self.bus.get_object(NM_SERVICE, opath) udi = dev.Get('org.freedesktop.NetworkManager.Devices', 'Udi') if self.device.opath == udi: | def _get_device_opath(self): """ Returns the object path to use in the connection / signal """ if not nm08_present(): return self.device.opath else: obj = self.bus.get_object(NM_SERVICE, NM_OBJPATH) interface = dbus.Interface(obj, NM_INTFACE) for opath in interface.GetDevices(): if self.device.opath == opath: return op... |
sms.status_request = True | def send_sms(self, sms): debug("MAL::send_sms: %s" % sms) sms.status_request = True if not sms.status_request: return self.wrappee.do_send_sms(sms) | |
else: for index, value in self.sms_map.iteritems(): if should_fragment_be_assembled(value, sms): completed = self.sms_map[index].append_sms(sms) debug("MAL::_add_sms multi part SMS with logical " "index %d, completed %s" % (index, completed)) | for index, value in self.sms_map.iteritems(): if should_fragment_be_assembled(value, sms): completed = self.sms_map[index].append_sms(sms) debug("MAL::_add_sms multi part SMS with logical " "index %d, completed %s" % (index, completed)) if completed: notification = self.sms_map[index] if self._is_a_wap_push_notific... | def _add_sms(self, sms, emit=False): """ Adds ``sms`` to the cache |
notification = self.sms_map[index] if self._is_a_wap_push_notification(notification): self._process_wap_push_notification(index, emit) return if emit: self.wrappee.emit_signal(SIG_SMS, index, completed) if completed: self.wrappee.emit_signal(SIG_SMS_COMP, index, completed) return index | self.wrappee.emit_signal(SIG_SMS_COMP, index, completed) return index | def _add_sms(self, sms, emit=False): """ Adds ``sms`` to the cache |
print "middleware.py: send_ussd being run - message is:" + ussd | def send_ussd(self, ussd): """Sends the ussd command ``ussd``""" print "middleware.py: send_ussd being run - message is:" + ussd | |
print "middleware.py: send_ussd - ussd message has been packed" + ussd print "middleware.py: send_ussd - message is being sent:" + ussd | def convert_response(response): resp = response[0].group('resp') index = response[0].group('index') return from_ucs2(resp) | |
user = conf.username passwd = conf.password | user = conf.username if conf.username else '*' passwd = conf.password if conf.password else '*' | def _generate_wvdial_conf(conf, sport): """ Generates a specially crafted wvdial.conf with `conf` and `sport` :param conf: `DialerConf` instance :param sport: The port to use :rtype: str """ user = conf.username passwd = conf.password theapn = conf.apn # build template data = StringIO(get_file_data(WVTEMPLATE)) templ... |
elif plugin.get_property(consts.MDM_INTFACE, 'Driver') == 'cdc': | elif plugin.get_property(consts.MDM_INTFACE, 'Driver') == 'cdc_acm': | def _get_device_from_info(self, sysfs_path, info): """Returns a `DevicePlugin` out of ``info``""" # order the ports before probing ports = info['DEVICES'] natsort(ports) |
return self.sim.initialize() | d = self.sim.initialize() d.addCallback(on_init) return d | def initialize_sim(_): self.sim = self.sim_klass(self.sconn) return self.sim.initialize() |
d.addCallback(lambda ret: auxdef.callback(ret)) | def sim_busy_eb(failure): failure.trap(SimBusy, SimNotStarted, CMSError314) self.wrappee.state_dict['mal_init_retries'] += 1 if self.wrappee.state_dict['mal_init_retries'] > MAX_MAL_RETRIES: raise SimFailure("Could not initialize MAL") | |
def _process_wap_push_notification(self, sms_index, emit): wap_push = self.sms_map.pop(sms_index) | def _process_wap_push_notification(self, index, emit): """ Processes WAP push notification identified by ``index`` If ``emit`` is True, it will emit a MMSReceived signal if this the first time we see this notification. """ wap_push = self.sms_map.pop(index) | def _process_wap_push_notification(self, sms_index, emit): wap_push = self.sms_map.pop(sms_index) notification, tx_id = extract_push_notification(wap_push.text) |
return bool(self.type & SMS_STATUS_REPORT) def extract_datetime(datestr): """ Returns a ``datetime`` instance out of ``datestr`` :param datestr: Date string like YY/MM/DD HH:MM:SS :rtype: :class:`datetime.datetime` """ date, time = datestr.split(' ') year, month, day = map(int, date.split('/')) if year < 68: year +... | return bool(self.type & 0x03) | def is_status_report(self): if self.type is None: return False |
import dbus | def mms_to_dbus_data(mms): import dbus """Converts ``mms`` to a tuple ready to be sent via DBus""" headers = {} data_parts = [] # Convert headers for key, val in mms.headers.items(): if key == 'Content-Type': headers[key] = val[0] else: headers[key] = val del headers['Date'] # Set up data for data_part in mms.data_p... | |
s.send("POST %s HTTP/1.0\r\n\r\n" % mmsc) s.send("Content-type: application/vnd.wap.mms-message\r\n") | s.send("POST %s HTTP/1.0\r\n" % mmsc) s.send("Content-Type: application/vnd.wap.mms-message\r\n") | def do_post_payload(extra_info, payload): host, port = extra_info['wap2'].split(':') mmsc = extra_info['mmsc'] s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.connect((host, int(port))) s.send("POST %s HTTP/1.0\r\n\r\n" % mmsc) s.send("Content-type: application/vnd.wap.mms-message\r\n") s.send("Content-Length:... |
c.executescript(NETWORKS_SCHEMA) | args = dict(version=NetworkProvider.version) c.executescript(NETWORKS_SCHEMA % args) | def setUp(self): self.conn = sqlite3.connect(':memory:', isolation_level=None) c = self.conn.cursor() # create schema c.executescript(NETWORKS_SCHEMA) |
def setUpClass(self): self.store = ContactStore() for provider in providers: self.store.add_provider(provider) | def setUpOnce(self): global store, numtests if store is None: store = ContactStore() map(store.add_provider, providers) | def setUpClass(self): self.store = ContactStore() for provider in providers: self.store.add_provider(provider) |
def tearDownClass(self): self.store.close() | if numtests is None: numtests = len([m for m in dir(self) if m.startswith('test_')]) self.store = store return defer.succeed(True) def tearDownOnce(self): global store return defer.maybeDeferred(store.close) def setUp(self): return self.setUpOnce() def tearDown(self): global numtests, executed if executed is None: ... | def tearDownClass(self): self.store.close() |
for index, value in self.sms_map.iteritems(): if should_fragment_be_assembled(value, sms): completed = self.sms_map[index].append_sms(sms) debug("MAL::_add_sms multi part SMS with logical " "index %d, completed %s" % (index, completed)) if completed: notification = self.sms_map[index] if self._is_a_wap_push_notific... | else: for index, value in self.sms_map.iteritems(): if should_fragment_be_assembled(value, sms): completed = self.sms_map[index].append_sms(sms) debug("MAL::_add_sms multi part SMS with logical " "index %d, completed %s" % (index, completed)) | def _add_sms(self, sms, emit=False): """ Adds ``sms`` to the cache |
self.wrappee.emit_signal(SIG_SMS_COMP, index, completed) return index | notification = self.sms_map[index] if self._is_a_wap_push_notification(notification): self._process_wap_push_notification(index, emit) return if emit: self.wrappee.emit_signal(SIG_SMS, index, completed) if completed: self.wrappee.emit_signal(SIG_SMS_COMP, index, completed) return index | def _add_sms(self, sms, emit=False): """ Adds ``sms`` to the cache |
def get_bands(bitwised_band): """Returns all the bitwised bands in ``bitwised_band``""" return [band for band in MM_NETWORK_BANDS if band & bitwised_band] | def get_dbus_error(e): return e.message | |
self.failUnlessIn(MM_NETWORK_MODE_ANY, modes) | self.failUnlessIn(MM_NETWORK_MODE_ANY, get_network_modes(modes)) | def test_CardSupportedModesProperty(self): """Test for Card.SupportedModes property""" modes = self.device.Get(CRD_INTFACE, 'SupportedModes', dbus_interface=dbus.PROPERTIES_IFACE) if not modes: raise unittest.SkipTest("Cannot be tested") |
super(UsageProvider, self).__init__(path, USAGE_SCHEMA, | args = dict(version=self.version) super(UsageProvider, self).__init__(path, USAGE_SCHEMA % args, | def __init__(self, path): super(UsageProvider, self).__init__(path, USAGE_SCHEMA, detect_types=sqlite3.PARSE_DECLTYPES) |
super(NetworkProvider, self).__init__(path, NETWORKS_SCHEMA) | args = dict(version=self.version) super(NetworkProvider, self).__init__(path, NETWORKS_SCHEMA % args) | def __init__(self, path=NETWORKS_DB): super(NetworkProvider, self).__init__(path, NETWORKS_SCHEMA) |
if 1: | if 0: | def nick_debug(s): if 1: with open(BCM_STARTUP_FILE, 'a', 0) as f: f.write("%s\n" % s) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.