Split (1)

train · 481k rows

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.

bugged stringlengths 4 228k	fixed stringlengths 0 96.3M	__index_level_0__ int64 0 481k
def requirements_for(meth): opts = options.copy() if method != 'any': opts['conditions'] = {'method':meth} return opts	def requirements_for(meth): opts = options.copy() if method != 'any': opts['conditions'] = {'method':[meth]} return opts	15,300
def requirements_for(meth): opts = options.copy() if method != 'any': opts['conditions'] = {'method':meth} return opts	def requirements_for(meth): opts = options.copy() if method != 'any': opts['conditions'] = {'method':meth} return opts	15,301
def requirements_for(meth): opts = options.copy() if method != 'any': opts['conditions'] = {'method':meth} return opts	def requirements_for(meth): opts = options.copy() if method != 'any': opts['conditions'] = {'method':meth} return opts	15,302
def requirements_for(meth): opts = options.copy() if method != 'any': opts['conditions'] = {'method':meth} return opts	def requirements_for(meth): opts = options.copy() if method != 'any': opts['conditions'] = {'method':meth} return opts	15,303
def requirements_for(meth): opts = options.copy() if method != 'any': opts['conditions'] = {'method':meth} return opts	def requirements_for(meth): opts = options.copy() if method != 'any': opts['conditions'] = {'method':meth} return opts	15,304
def requirements_for(meth): opts = options.copy() if method != 'any': opts['conditions'] = {'method':meth} return opts	def requirements_for(meth): opts = options.copy() if method != 'any': opts['conditions'] = {'method':meth} return opts	15,305
def requirements_for(meth): opts = options.copy() if method != 'any': opts['conditions'] = {'method':meth} return opts	def requirements_for(meth): opts = options.copy() if method != 'any': opts['conditions'] = {'method':meth} return opts	15,306
def _subdomain_check(config, kargs): if config.mapper.sub_domains: subdomain = kargs.pop('sub_domain', None) hostmatch = config.environ['HTTP_HOST'].split(':') host = hostmatch[0] port = '' if len(hostmatch) > 1: port += ':' + hostmatch[1] sub_match = re.compile('^.+?\.(%s)$' % config.mapper.domain_match) domain = re.sub(sub_match, r'\1', host) if subdomain and not host.startswith(subdomain) and \ subdomain not in config.mapper.sub_domains_ignore: kargs['_host'] = subdomain + '.' + domain + port elif (subdomain in config.mapper.sub_domains_ignore or subdomain is None) and domain != host: kargs['_host'] = domain + port return kargs else: return kargs	def _subdomain_check(config, kargs): if config.mapper.sub_domains: subdomain = kargs.pop('sub_domain', None) fullhost = config.environ.get('HTTP_HOST') or config.environ.get('SERVER_NAME') hostmatch = fullhost.split(':') host = hostmatch[0] port = '' if len(hostmatch) > 1: port += ':' + hostmatch[1] sub_match = re.compile('^.+?\.(%s)$' % config.mapper.domain_match) domain = re.sub(sub_match, r'\1', host) if subdomain and not host.startswith(subdomain) and \ subdomain not in config.mapper.sub_domains_ignore: kargs['_host'] = subdomain + '.' + domain + port elif (subdomain in config.mapper.sub_domains_ignore or subdomain is None) and domain != host: kargs['_host'] = domain + port return kargs else: return kargs	15,307
def find_controllers(dirname, prefix=''): controllers = [] for fname in os.listdir(dirname): filename = dirname + '/' + fname if os.path.isfile(filename) and re.match('^[^_]{1,1}.*\.py$', fname): controllers.append(prefix + fname[:-3]) elif os.path.isdir(filename): controllers.extend(find_controllers(filename, prefix=fname+'/')) return controllers	def find_controllers(dirname, prefix=''): controllers = [] for fname in os.listdir(dirname): filename = dirname + '/' + fname if os.path.isfile(filename) and re.match('^[^_]{1,1}.*\.py$', fname): controllers.append(prefix + fname[:-3]) elif os.path.isdir(filename): controllers.extend(find_controllers(filename, prefix=prefix+fname+'/')) return controllers	15,308
def keysort(a, b): am = a.minkeys a = a.maxkeys b = b.maxkeys lendiffa = len(keys^a) lendiffb = len(keys^b) # If they both match, don't switch them if lendiffa == 0 and lendiffb == 0: return 0 # First, if a matches exactly, use it if lendiffa == 0: return -1 # Or b matches exactly, use it if lendiffb == 0: return 1 # Neither matches exactly, return the one with the most in common if cmp(lendiffa,lendiffb) != 0: return cmp(lendiffa,lendiffb) # Neither matches exactly, but if they both have just as much in common if len(keys&b) == len(keys&a): return cmp(len(a),len(b)) # Then we return the shortest of the two # Otherwise, we return the one that has the most in common else: return cmp(len(keys&b), len(keys&a))	def keysort(a, b): am = a.minkeys a = a.maxkeys b = b.maxkeys lendiffa = len(keys^a) lendiffb = len(keys^b) # If they both match, don't switch them if lendiffa == 0 and lendiffb == 0: return 0 # First, if a matches exactly, use it if lendiffa == 0: return -1 # Or b matches exactly, use it if lendiffb == 0: return 1 # Neither matches exactly, return the one with the most in common if cmp(lendiffa,lendiffb) != 0: return cmp(lendiffa,lendiffb) # Neither matches exactly, but if they both have just as much in common if len(keys&b) == len(keys&a): return cmp(len(a),len(b)) # Then we return the shortest of the two # Otherwise, we return the one that has the most in common else: return cmp(len(keys&b), len(keys&a))	15,309
def keysort(a, b): am = a.minkeys a = a.maxkeys b = b.maxkeys lendiffa = len(keys^a) lendiffb = len(keys^b) # If they both match, don't switch them if lendiffa == 0 and lendiffb == 0: return 0 # First, if a matches exactly, use it if lendiffa == 0: return -1 # Or b matches exactly, use it if lendiffb == 0: return 1 # Neither matches exactly, return the one with the most in common if cmp(lendiffa,lendiffb) != 0: return cmp(lendiffa,lendiffb) # Neither matches exactly, but if they both have just as much in common if len(keys&b) == len(keys&a): return cmp(len(a),len(b)) # Then we return the shortest of the two # Otherwise, we return the one that has the most in common else: return cmp(len(keys&b), len(keys&a))	def keysort(a, b): am = a.minkeys a = a.maxkeys b = b.maxkeys lendiffa = len(keys^a) lendiffb = len(keys^b) # If they both match, don't switch them if lendiffa == 0 and lendiffb == 0: return 0 # First, if a matches exactly, use it if lendiffa == 0: return -1 # Or b matches exactly, use it if lendiffb == 0: return 1 # Neither matches exactly, return the one with the most in common if cmp(lendiffa,lendiffb) != 0: return cmp(lendiffa,lendiffb) # Neither matches exactly, but if they both have just as much in common if len(keys&b) == len(keys&a): return cmp(len(a),len(b)) # Then we return the shortest of the two # Otherwise, we return the one that has the most in common else: return cmp(len(keys&b), len(keys&a))	15,310
def __getattr__(self, name): return self._shared_state.__getattr__(name)	def __getattr__(self, name): return self.__shared_state.__getattr__(name)	15,311
def __setattr__(self, name, value): return self._shared_state.__setattr__(name, value)	def __setattr__(self, name, value): return self.__shared_state.__setattr__(name, value)	15,312
def url_for(args, kargs): """Generates a URL All keys given to url_for are sent to the Routes Mapper instance for generation except for:: anchor specified the anchor name to be appened to the path host overrides the default (current) host if provided protocol overrides the default (current) protocol if provided The URL is generated based on the rest of the keys. When generating a new URL, values will be used from the current request's parameters (if present). The following rules are used to determine when and how to keep the current requests parameters: If the controller is present and begins with '/', no defaults are used * If the controller is changed, action is set to 'index' unless otherwise specified For example, if the current request yielded a dict of {'controller': 'blog', 'action': 'view', 'id': 2}, with the standard ':controller/:action/:id' route, you'd get the following results:: url_for(id=4) => '/blog/view/4', url_for(controller='/admin') => '/admin', url_for(controller='admin') => '/admin/index/4' url_for(action='edit') => '/blog/post/4', url_for(action='list', id=None) => '/blog/list' Static and Named Routes If there is a string present as the first argument, a lookup is done against the named routes table to see if there's any matching routes. The keyword defaults used with static routes will be sent in as GET query arg's if a route matches. If no route by that name is found, the string is assumed to be a raw URL. Should the raw URL begin with ``/`` then appropriate SCRIPT_NAME data will be added if present, otherwise the string will be used as the url with keyword args becoming GET query args. """ anchor = kargs.get('anchor') host = kargs.get('host') protocol = kargs.get('protocol') # Remove special words from kargs, convert placeholders for key in ['anchor', 'host', 'protocol']: if kargs.get(key): del kargs[key] if kargs.has_key(key+'_'): kargs[key] = kargs[key+'_'] del kargs[key+'_'] config = request_config() route = None static = False url = '' if len(args) > 0: route = config.mapper._routenames.get(args[0]) if route and route.defaults.has_key('_static'): static = True newargs = route.defaults.copy() host = newargs.pop('host', '') protocol = newargs.pop('protocol', '') del newargs['_static'] newargs.update(kargs) url = route.generate(_ignore_req_list=True, newargs) if not url: url = '' kargs = None #url = route.routepath # No named route found, assume the argument is a relative path if not route: static = True url = args[0] if url.startswith('/') and hasattr(config, 'environ') \ and config.environ.get('SCRIPT_NAME'): url = config.environ.get('SCRIPT_NAME') + url if static: if kargs: url += '?' url += urllib.urlencode(kargs) if not static: if route: newargs = route.defaults.copy() newargs.update(kargs) # If this route has a filter, apply it if route.filter: newargs = route.filter(newargs) else: newargs = _screenargs(kargs) url = config.mapper.generate(newargs) if config.mapper.append_slash and not url.endswith('/'): url += '/' if anchor: url += '#' + _url_quote(anchor) if host or protocol: if not host: host = config.host if not protocol: protocol = config.protocol url = protocol + '://' + host + url return url	def url_for(args, kargs): """Generates a URL All keys given to url_for are sent to the Routes Mapper instance for generation except for:: anchor specified the anchor name to be appened to the path host overrides the default (current) host if provided protocol overrides the default (current) protocol if provided The URL is generated based on the rest of the keys. When generating a new URL, values will be used from the current request's parameters (if present). The following rules are used to determine when and how to keep the current requests parameters: If the controller is present and begins with '/', no defaults are used * If the controller is changed, action is set to 'index' unless otherwise specified For example, if the current request yielded a dict of {'controller': 'blog', 'action': 'view', 'id': 2}, with the standard ':controller/:action/:id' route, you'd get the following results:: url_for(id=4) => '/blog/view/4', url_for(controller='/admin') => '/admin', url_for(controller='admin') => '/admin/index/4' url_for(action='edit') => '/blog/post/4', url_for(action='list', id=None) => '/blog/list' Static and Named Routes If there is a string present as the first argument, a lookup is done against the named routes table to see if there's any matching routes. The keyword defaults used with static routes will be sent in as GET query arg's if a route matches. If no route by that name is found, the string is assumed to be a raw URL. Should the raw URL begin with ``/`` then appropriate SCRIPT_NAME data will be added if present, otherwise the string will be used as the url with keyword args becoming GET query args. """ anchor = kargs.get('anchor') host = kargs.get('host') protocol = kargs.get('protocol') # Remove special words from kargs, convert placeholders for key in ['anchor', 'host', 'protocol']: if kargs.get(key): del kargs[key] if kargs.has_key(key+'_'): kargs[key] = kargs[key+'_'] del kargs[key+'_'] config = request_config() route = None static = False url = '' if len(args) > 0: route = config.mapper._routenames.get(args[0]) if route and route.defaults.has_key('_static'): static = True newargs = route.defaults.copy() host = newargs.pop('host', '') protocol = newargs.pop('protocol', '') del newargs['_static'] newargs.update(kargs) url = route.generate(_ignore_req_list=True, newargs) if not url: url = '' kargs = None #url = route.routepath # No named route found, assume the argument is a relative path if not route: static = True url = args[0] if url.startswith('/') and hasattr(config, 'environ') \ and config.environ.get('SCRIPT_NAME'): url = config.environ.get('SCRIPT_NAME') + url if static: if kargs: url += '?' url += urllib.urlencode(kargs) if not static: if route: newargs = route.defaults.copy() newargs.update(kargs) # If this route has a filter, apply it if route.filter: newargs = route.filter(newargs) else: newargs = _screenargs(kargs) url = config.mapper.generate(newargs) if config.mapper.append_slash and not url.endswith('/'): url += '/' if anchor: url += '#' + _url_quote(anchor) if host or protocol: if not host: host = config.host if not protocol: protocol = config.protocol url = protocol + '://' + host + url return url	15,313
def match(self, url, environ=None, sub_domains=False, sub_domains_ignore=None, domain_match=''): """Match a url to our regexp. While the regexp might match, this operation isn't guaranteed as there's other factors that can cause a match to fail even though the regexp succeeds (Default that was relied on wasn't given, requirement regexp doesn't pass, etc.). Therefore the calling function shouldn't assume this will return a valid dict, the other possible return is False if a match doesn't work out. """ # Static routes don't match, they generate only if self.static: return False if url.endswith('/') and len(url) > 1: url = url[:-1] m = self.regmatch.match(url) if not m: return False if not environ: environ = {} sub_domain = None if environ.get('HTTP_HOST') and sub_domains: host = environ['HTTP_HOST'].split(':')[0] sub_match = re.compile('^(.+?)\.%s$' % domain_match) subdomain = re.sub(sub_match, r'\1', host) if subdomain not in sub_domains_ignore and host != subdomain: sub_domain = subdomain if self.conditions: if self.conditions.has_key('method') and \ environ.get('REQUEST_METHOD') not in self.conditions['method']: return False # Check sub-domains? use_sd = self.conditions.get('sub_domain') if use_sd and not sub_domain: return False if isinsance(use_sd, list) and sub_domain not in use_sd: return False matchdict = m.groupdict() result = {} extras = frozenset(self.defaults.keys()) - frozenset(matchdict.keys()) for key,val in matchdict.iteritems(): if not val and self.defaults.has_key(key) and self.defaults[key]: result[key] = self.defaults[key] else: result[key] = val for key in extras: result[key] = self.defaults[key] # If there's a function, call it with environ and expire if it # returns False if self.conditions and self.conditions.has_key('function') and \ not self.conditions['function'](environ, result): return False if sub_domain: result['sub_domain'] = sub_domain return result	def match(self, url, environ=None, sub_domains=False, sub_domains_ignore=None, domain_match=''): """Match a url to our regexp. While the regexp might match, this operation isn't guaranteed as there's other factors that can cause a match to fail even though the regexp succeeds (Default that was relied on wasn't given, requirement regexp doesn't pass, etc.). Therefore the calling function shouldn't assume this will return a valid dict, the other possible return is False if a match doesn't work out. """ # Static routes don't match, they generate only if self.static: return False if url.endswith('/') and len(url) > 1: url = url[:-1] m = self.regmatch.match(url) if not m: return False if not environ: environ = {} sub_domain = None if environ.get('HTTP_HOST') and sub_domains: host = environ['HTTP_HOST'].split(':')[0] sub_match = re.compile('^(.+?)\.%s$' % domain_match) subdomain = re.sub(sub_match, r'\1', host) if subdomain not in sub_domains_ignore and host != subdomain: sub_domain = subdomain if self.conditions: if self.conditions.has_key('method') and \ environ.get('REQUEST_METHOD') not in self.conditions['method']: return False # Check sub-domains? use_sd = self.conditions.get('sub_domain') if use_sd and not sub_domain: return False if isinstance(use_sd, list) and sub_domain not in use_sd: return False matchdict = m.groupdict() result = {} extras = frozenset(self.defaults.keys()) - frozenset(matchdict.keys()) for key,val in matchdict.iteritems(): if not val and self.defaults.has_key(key) and self.defaults[key]: result[key] = self.defaults[key] else: result[key] = val for key in extras: result[key] = self.defaults[key] # If there's a function, call it with environ and expire if it # returns False if self.conditions and self.conditions.has_key('function') and \ not self.conditions['function'](environ, result): return False if sub_domain: result['sub_domain'] = sub_domain return result	15,314
def buildnextreg(self, path, clist): """Recursively build our regexp given a path, and a controller list. Returns the regular expression string, and two booleans that can be ignored as they're only used internally by buildnextreg """ if path: part = path[0] else: part = '' reg = '' # noreqs will remember whether the remainder has either a string match, or a non-defaulted # regexp match on a key, allblank remembers if the rest could possible be completely empty (rest, noreqs, allblank) = ('', True, True) if len(path[1:]) > 0: (rest, noreqs, allblank) = self.buildnextreg(path[1:], clist) if isinstance(part, dict) and part['type'] == ':': var = part['name'] partreg = '' # First we plug in the proper part matcher if self.reqs.has_key(var): partreg = '(?P<' + var + '>' + self.reqs[var] + ')' elif var == 'controller': partreg = '(?P<' + var + '>' + '\|'.join(clist) + ')' else: if len(path) > 1: partreg = '(?P<' + var + '>[^' + path[1][0] +']+)' else: partreg = '(?P<' + var + '>[^/]+)' if self.reqs.has_key(var): noreqs = False if not self.defaults.has_key(var): allblank = False noreqs = False # Now we determine if its optional, or required. This changes depending on what is in # the rest of the match. If noreqs is true, then its possible the entire thing is optional # as there's no reqs or string matches. if noreqs: # The rest is optional, but now we have an optional with a regexp. Wrap to ensure that if we match # anything, we match our regexp first. It's still possible we could be completely blank as we have # a default if self.reqs.has_key(var) and self.defaults.has_key(var): reg = '(' + partreg + rest + ')?' # Or we have a regexp match with no default, so now being completely blank form here on out isn't # possible elif self.reqs.has_key(var): allblank = False reg = partreg + rest # Or we have a default with no regexp, don't touch the allblank elif self.defaults.has_key(var): reg = partreg + '?' + rest # Or we have a key with no default, and no reqs. Not possible to be all blank from here else: allblank = False reg = partreg + rest # In this case, we have something dangling that might need to be matched else: # If they can all be blank, and we have a default here, we know its # safe to make everything from here optional. Since something else in # the chain does have req's though, we have to make the partreg here # required to continue matching if allblank and self.defaults.has_key(var): reg = '(' + partreg + rest + ')?' # Same as before, but they can't all be blank, so we have to require it all to ensure # our matches line up right else: reg = partreg + rest elif isinstance(part, dict) and part['type'] == '': var = part['name'] if noreqs: if self.defaults.has_key(var): reg = '(?P<' + var + '>.)' + rest else: reg = '(?P<' + var + '>.)' + rest allblank = False noreqs = False else: if allblank and self.defaults.has_key(var): reg = '(?P<' + var + '>.)' + rest elif self.defaults.has_key(var): reg = '(?P<' + var + '>.)' + rest else: allblank = False noreqs = False reg = '(?P<' + var + '>.)' + rest elif part.endswith('/'): if allblank: reg = part[:-1] + '(/' + rest + ')?' else: allblank = False reg = part + rest # We have a normal string here, this is a req, and it prevents us from being all blank else: noreqs = False allblank = False reg = part + rest return (reg, noreqs, allblank)	def buildnextreg(self, path, clist): """Recursively build our regexp given a path, and a controller list. Returns the regular expression string, and two booleans that can be ignored as they're only used internally by buildnextreg """ if path: part = path[0] else: part = '' reg = '' # noreqs will remember whether the remainder has either a string match, or a non-defaulted # regexp match on a key, allblank remembers if the rest could possible be completely empty (rest, noreqs, allblank) = ('', True, True) if len(path[1:]) > 0: (rest, noreqs, allblank) = self.buildnextreg(path[1:], clist) if isinstance(part, dict) and part['type'] == ':': var = re.escape(part['name']) partreg = '' # First we plug in the proper part matcher if self.reqs.has_key(var): partreg = '(?P<' + var + '>' + self.reqs[var] + ')' elif var == 'controller': partreg = '(?P<' + var + '>' + '\|'.join(clist) + ')' else: if len(path) > 1: partreg = '(?P<' + var + '>[^' + path[1][0] +']+)' else: partreg = '(?P<' + var + '>[^/]+)' if self.reqs.has_key(var): noreqs = False if not self.defaults.has_key(var): allblank = False noreqs = False # Now we determine if its optional, or required. This changes depending on what is in # the rest of the match. If noreqs is true, then its possible the entire thing is optional # as there's no reqs or string matches. if noreqs: # The rest is optional, but now we have an optional with a regexp. Wrap to ensure that if we match # anything, we match our regexp first. It's still possible we could be completely blank as we have # a default if self.reqs.has_key(var) and self.defaults.has_key(var): reg = '(' + partreg + rest + ')?' # Or we have a regexp match with no default, so now being completely blank form here on out isn't # possible elif self.reqs.has_key(var): allblank = False reg = partreg + rest # Or we have a default with no regexp, don't touch the allblank elif self.defaults.has_key(var): reg = partreg + '?' + rest # Or we have a key with no default, and no reqs. Not possible to be all blank from here else: allblank = False reg = partreg + rest # In this case, we have something dangling that might need to be matched else: # If they can all be blank, and we have a default here, we know its # safe to make everything from here optional. Since something else in # the chain does have req's though, we have to make the partreg here # required to continue matching if allblank and self.defaults.has_key(var): reg = '(' + partreg + rest + ')?' # Same as before, but they can't all be blank, so we have to require it all to ensure # our matches line up right else: reg = partreg + rest elif isinstance(part, dict) and part['type'] == '': var = re.escape(part['name']) if noreqs: if self.defaults.has_key(var): reg = '(?P<' + var + '>.)' + rest else: reg = '(?P<' + var + '>.)' + rest allblank = False noreqs = False else: if allblank and self.defaults.has_key(var): reg = '(?P<' + var + '>.)' + rest elif self.defaults.has_key(var): reg = '(?P<' + var + '>.)' + rest else: allblank = False noreqs = False reg = '(?P<' + var + '>.)' + rest elif part.endswith('/'): if allblank: reg = part[:-1] + '(/' + rest + ')?' else: allblank = False reg = part + rest # We have a normal string here, this is a req, and it prevents us from being all blank else: noreqs = False allblank = False reg = part + rest return (reg, noreqs, allblank)	15,315
def buildnextreg(self, path, clist): """Recursively build our regexp given a path, and a controller list. Returns the regular expression string, and two booleans that can be ignored as they're only used internally by buildnextreg """ if path: part = path[0] else: part = '' reg = '' # noreqs will remember whether the remainder has either a string match, or a non-defaulted # regexp match on a key, allblank remembers if the rest could possible be completely empty (rest, noreqs, allblank) = ('', True, True) if len(path[1:]) > 0: (rest, noreqs, allblank) = self.buildnextreg(path[1:], clist) if isinstance(part, dict) and part['type'] == ':': var = part['name'] partreg = '' # First we plug in the proper part matcher if self.reqs.has_key(var): partreg = '(?P<' + var + '>' + self.reqs[var] + ')' elif var == 'controller': partreg = '(?P<' + var + '>' + '\|'.join(clist) + ')' else: if len(path) > 1: partreg = '(?P<' + var + '>[^' + path[1][0] +']+)' else: partreg = '(?P<' + var + '>[^/]+)' if self.reqs.has_key(var): noreqs = False if not self.defaults.has_key(var): allblank = False noreqs = False # Now we determine if its optional, or required. This changes depending on what is in # the rest of the match. If noreqs is true, then its possible the entire thing is optional # as there's no reqs or string matches. if noreqs: # The rest is optional, but now we have an optional with a regexp. Wrap to ensure that if we match # anything, we match our regexp first. It's still possible we could be completely blank as we have # a default if self.reqs.has_key(var) and self.defaults.has_key(var): reg = '(' + partreg + rest + ')?' # Or we have a regexp match with no default, so now being completely blank form here on out isn't # possible elif self.reqs.has_key(var): allblank = False reg = partreg + rest # Or we have a default with no regexp, don't touch the allblank elif self.defaults.has_key(var): reg = partreg + '?' + rest # Or we have a key with no default, and no reqs. Not possible to be all blank from here else: allblank = False reg = partreg + rest # In this case, we have something dangling that might need to be matched else: # If they can all be blank, and we have a default here, we know its # safe to make everything from here optional. Since something else in # the chain does have req's though, we have to make the partreg here # required to continue matching if allblank and self.defaults.has_key(var): reg = '(' + partreg + rest + ')?' # Same as before, but they can't all be blank, so we have to require it all to ensure # our matches line up right else: reg = partreg + rest elif isinstance(part, dict) and part['type'] == '': var = part['name'] if noreqs: if self.defaults.has_key(var): reg = '(?P<' + var + '>.)' + rest else: reg = '(?P<' + var + '>.)' + rest allblank = False noreqs = False else: if allblank and self.defaults.has_key(var): reg = '(?P<' + var + '>.)' + rest elif self.defaults.has_key(var): reg = '(?P<' + var + '>.)' + rest else: allblank = False noreqs = False reg = '(?P<' + var + '>.)' + rest elif part.endswith('/'): if allblank: reg = part[:-1] + '(/' + rest + ')?' else: allblank = False reg = part + rest # We have a normal string here, this is a req, and it prevents us from being all blank else: noreqs = False allblank = False reg = part + rest return (reg, noreqs, allblank)	def buildnextreg(self, path, clist): """Recursively build our regexp given a path, and a controller list. Returns the regular expression string, and two booleans that can be ignored as they're only used internally by buildnextreg """ if path: part = path[0] else: part = '' reg = '' # noreqs will remember whether the remainder has either a string match, or a non-defaulted # regexp match on a key, allblank remembers if the rest could possible be completely empty (rest, noreqs, allblank) = ('', True, True) if len(path[1:]) > 0: (rest, noreqs, allblank) = self.buildnextreg(path[1:], clist) if isinstance(part, dict) and part['type'] == ':': var = part['name'] partreg = '' # First we plug in the proper part matcher if self.reqs.has_key(var): partreg = '(?P<' + var + '>' + self.reqs[var] + ')' elif var == 'controller': partreg = '(?P<' + var + '>' + '\|'.join(map(re.escape, clist)) + ')' else: if len(path) > 1: partreg = '(?P<' + var + '>[^' + path[1][0] +']+)' else: partreg = '(?P<' + var + '>[^/]+)' if self.reqs.has_key(var): noreqs = False if not self.defaults.has_key(var): allblank = False noreqs = False # Now we determine if its optional, or required. This changes depending on what is in # the rest of the match. If noreqs is true, then its possible the entire thing is optional # as there's no reqs or string matches. if noreqs: # The rest is optional, but now we have an optional with a regexp. Wrap to ensure that if we match # anything, we match our regexp first. It's still possible we could be completely blank as we have # a default if self.reqs.has_key(var) and self.defaults.has_key(var): reg = '(' + partreg + rest + ')?' # Or we have a regexp match with no default, so now being completely blank form here on out isn't # possible elif self.reqs.has_key(var): allblank = False reg = partreg + rest # Or we have a default with no regexp, don't touch the allblank elif self.defaults.has_key(var): reg = partreg + '?' + rest # Or we have a key with no default, and no reqs. Not possible to be all blank from here else: allblank = False reg = partreg + rest # In this case, we have something dangling that might need to be matched else: # If they can all be blank, and we have a default here, we know its # safe to make everything from here optional. Since something else in # the chain does have req's though, we have to make the partreg here # required to continue matching if allblank and self.defaults.has_key(var): reg = '(' + partreg + rest + ')?' # Same as before, but they can't all be blank, so we have to require it all to ensure # our matches line up right else: reg = partreg + rest elif isinstance(part, dict) and part['type'] == '': var = part['name'] if noreqs: if self.defaults.has_key(var): reg = '(?P<' + var + '>.)' + rest else: reg = '(?P<' + var + '>.)' + rest allblank = False noreqs = False else: if allblank and self.defaults.has_key(var): reg = '(?P<' + var + '>.)' + rest elif self.defaults.has_key(var): reg = '(?P<' + var + '>.)' + rest else: allblank = False noreqs = False reg = '(?P<' + var + '>.)' + rest elif part.endswith('/'): if allblank: reg = part[:-1] + '(/' + rest + ')?' else: allblank = False reg = part + rest # We have a normal string here, this is a req, and it prevents us from being all blank else: noreqs = False allblank = False reg = part + rest return (reg, noreqs, allblank)	15,316
def buildnextreg(self, path, clist): """Recursively build our regexp given a path, and a controller list. Returns the regular expression string, and two booleans that can be ignored as they're only used internally by buildnextreg """ if path: part = path[0] else: part = '' reg = '' # noreqs will remember whether the remainder has either a string match, or a non-defaulted # regexp match on a key, allblank remembers if the rest could possible be completely empty (rest, noreqs, allblank) = ('', True, True) if len(path[1:]) > 0: (rest, noreqs, allblank) = self.buildnextreg(path[1:], clist) if isinstance(part, dict) and part['type'] == ':': var = part['name'] partreg = '' # First we plug in the proper part matcher if self.reqs.has_key(var): partreg = '(?P<' + var + '>' + self.reqs[var] + ')' elif var == 'controller': partreg = '(?P<' + var + '>' + '\|'.join(clist) + ')' else: if len(path) > 1: partreg = '(?P<' + var + '>[^' + path[1][0] +']+)' else: partreg = '(?P<' + var + '>[^/]+)' if self.reqs.has_key(var): noreqs = False if not self.defaults.has_key(var): allblank = False noreqs = False # Now we determine if its optional, or required. This changes depending on what is in # the rest of the match. If noreqs is true, then its possible the entire thing is optional # as there's no reqs or string matches. if noreqs: # The rest is optional, but now we have an optional with a regexp. Wrap to ensure that if we match # anything, we match our regexp first. It's still possible we could be completely blank as we have # a default if self.reqs.has_key(var) and self.defaults.has_key(var): reg = '(' + partreg + rest + ')?' # Or we have a regexp match with no default, so now being completely blank form here on out isn't # possible elif self.reqs.has_key(var): allblank = False reg = partreg + rest # Or we have a default with no regexp, don't touch the allblank elif self.defaults.has_key(var): reg = partreg + '?' + rest # Or we have a key with no default, and no reqs. Not possible to be all blank from here else: allblank = False reg = partreg + rest # In this case, we have something dangling that might need to be matched else: # If they can all be blank, and we have a default here, we know its # safe to make everything from here optional. Since something else in # the chain does have req's though, we have to make the partreg here # required to continue matching if allblank and self.defaults.has_key(var): reg = '(' + partreg + rest + ')?' # Same as before, but they can't all be blank, so we have to require it all to ensure # our matches line up right else: reg = partreg + rest elif isinstance(part, dict) and part['type'] == '': var = part['name'] if noreqs: if self.defaults.has_key(var): reg = '(?P<' + var + '>.)' + rest else: reg = '(?P<' + var + '>.)' + rest allblank = False noreqs = False else: if allblank and self.defaults.has_key(var): reg = '(?P<' + var + '>.)' + rest elif self.defaults.has_key(var): reg = '(?P<' + var + '>.)' + rest else: allblank = False noreqs = False reg = '(?P<' + var + '>.)' + rest elif part.endswith('/'): if allblank: reg = part[:-1] + '(/' + rest + ')?' else: allblank = False reg = part + rest # We have a normal string here, this is a req, and it prevents us from being all blank else: noreqs = False allblank = False reg = part + rest return (reg, noreqs, allblank)	def buildnextreg(self, path, clist): """Recursively build our regexp given a path, and a controller list. Returns the regular expression string, and two booleans that can be ignored as they're only used internally by buildnextreg """ if path: part = path[0] else: part = '' reg = '' # noreqs will remember whether the remainder has either a string match, or a non-defaulted # regexp match on a key, allblank remembers if the rest could possible be completely empty (rest, noreqs, allblank) = ('', True, True) if len(path[1:]) > 0: (rest, noreqs, allblank) = self.buildnextreg(path[1:], clist) if isinstance(part, dict) and part['type'] == ':': var = part['name'] partreg = '' # First we plug in the proper part matcher if self.reqs.has_key(var): partreg = '(?P<' + var + '>' + self.reqs[var] + ')' elif var == 'controller': partreg = '(?P<' + var + '>' + '\|'.join(clist) + ')' else: if len(path) > 1: partreg = '(?P<' + var + '>[^' + path[1][0] +']+)' else: partreg = '(?P<' + var + '>[^/]+)' if self.reqs.has_key(var): noreqs = False if not self.defaults.has_key(var): allblank = False noreqs = False # Now we determine if its optional, or required. This changes depending on what is in # the rest of the match. If noreqs is true, then its possible the entire thing is optional # as there's no reqs or string matches. if noreqs: # The rest is optional, but now we have an optional with a regexp. Wrap to ensure that if we match # anything, we match our regexp first. It's still possible we could be completely blank as we have # a default if self.reqs.has_key(var) and self.defaults.has_key(var): reg = '(' + partreg + rest + ')?' # Or we have a regexp match with no default, so now being completely blank form here on out isn't # possible elif self.reqs.has_key(var): allblank = False reg = partreg + rest # Or we have a default with no regexp, don't touch the allblank elif self.defaults.has_key(var): reg = partreg + '?' + rest # Or we have a key with no default, and no reqs. Not possible to be all blank from here else: allblank = False reg = partreg + rest # In this case, we have something dangling that might need to be matched else: # If they can all be blank, and we have a default here, we know its # safe to make everything from here optional. Since something else in # the chain does have req's though, we have to make the partreg here # required to continue matching if allblank and self.defaults.has_key(var): reg = '(' + partreg + rest + ')?' # Same as before, but they can't all be blank, so we have to require it all to ensure # our matches line up right else: reg = partreg + rest elif isinstance(part, dict) and part['type'] == '': var = part['name'] if noreqs: if self.defaults.has_key(var): reg = '(?P<' + var + '>.)' + rest else: reg = '(?P<' + var + '>.)' + rest allblank = False noreqs = False else: if allblank and self.defaults.has_key(var): reg = '(?P<' + var + '>.)' + rest elif self.defaults.has_key(var): reg = '(?P<' + var + '>.)' + rest else: allblank = False noreqs = False reg = '(?P<' + var + '>.)' + rest elif part.endswith('/'): if allblank: reg = re.escape(part[:-1]) + '(/' + rest + ')?' else: allblank = False reg = part + rest # We have a normal string here, this is a req, and it prevents us from being all blank else: noreqs = False allblank = False reg = part + rest return (reg, noreqs, allblank)	15,317
def buildnextreg(self, path, clist): """Recursively build our regexp given a path, and a controller list. Returns the regular expression string, and two booleans that can be ignored as they're only used internally by buildnextreg """ if path: part = path[0] else: part = '' reg = '' # noreqs will remember whether the remainder has either a string match, or a non-defaulted # regexp match on a key, allblank remembers if the rest could possible be completely empty (rest, noreqs, allblank) = ('', True, True) if len(path[1:]) > 0: (rest, noreqs, allblank) = self.buildnextreg(path[1:], clist) if isinstance(part, dict) and part['type'] == ':': var = part['name'] partreg = '' # First we plug in the proper part matcher if self.reqs.has_key(var): partreg = '(?P<' + var + '>' + self.reqs[var] + ')' elif var == 'controller': partreg = '(?P<' + var + '>' + '\|'.join(clist) + ')' else: if len(path) > 1: partreg = '(?P<' + var + '>[^' + path[1][0] +']+)' else: partreg = '(?P<' + var + '>[^/]+)' if self.reqs.has_key(var): noreqs = False if not self.defaults.has_key(var): allblank = False noreqs = False # Now we determine if its optional, or required. This changes depending on what is in # the rest of the match. If noreqs is true, then its possible the entire thing is optional # as there's no reqs or string matches. if noreqs: # The rest is optional, but now we have an optional with a regexp. Wrap to ensure that if we match # anything, we match our regexp first. It's still possible we could be completely blank as we have # a default if self.reqs.has_key(var) and self.defaults.has_key(var): reg = '(' + partreg + rest + ')?' # Or we have a regexp match with no default, so now being completely blank form here on out isn't # possible elif self.reqs.has_key(var): allblank = False reg = partreg + rest # Or we have a default with no regexp, don't touch the allblank elif self.defaults.has_key(var): reg = partreg + '?' + rest # Or we have a key with no default, and no reqs. Not possible to be all blank from here else: allblank = False reg = partreg + rest # In this case, we have something dangling that might need to be matched else: # If they can all be blank, and we have a default here, we know its # safe to make everything from here optional. Since something else in # the chain does have req's though, we have to make the partreg here # required to continue matching if allblank and self.defaults.has_key(var): reg = '(' + partreg + rest + ')?' # Same as before, but they can't all be blank, so we have to require it all to ensure # our matches line up right else: reg = partreg + rest elif isinstance(part, dict) and part['type'] == '': var = part['name'] if noreqs: if self.defaults.has_key(var): reg = '(?P<' + var + '>.)' + rest else: reg = '(?P<' + var + '>.)' + rest allblank = False noreqs = False else: if allblank and self.defaults.has_key(var): reg = '(?P<' + var + '>.)' + rest elif self.defaults.has_key(var): reg = '(?P<' + var + '>.)' + rest else: allblank = False noreqs = False reg = '(?P<' + var + '>.)' + rest elif part.endswith('/'): if allblank: reg = part[:-1] + '(/' + rest + ')?' else: allblank = False reg = part + rest # We have a normal string here, this is a req, and it prevents us from being all blank else: noreqs = False allblank = False reg = part + rest return (reg, noreqs, allblank)	def buildnextreg(self, path, clist): """Recursively build our regexp given a path, and a controller list. Returns the regular expression string, and two booleans that can be ignored as they're only used internally by buildnextreg """ if path: part = path[0] else: part = '' reg = '' # noreqs will remember whether the remainder has either a string match, or a non-defaulted # regexp match on a key, allblank remembers if the rest could possible be completely empty (rest, noreqs, allblank) = ('', True, True) if len(path[1:]) > 0: (rest, noreqs, allblank) = self.buildnextreg(path[1:], clist) if isinstance(part, dict) and part['type'] == ':': var = part['name'] partreg = '' # First we plug in the proper part matcher if self.reqs.has_key(var): partreg = '(?P<' + var + '>' + self.reqs[var] + ')' elif var == 'controller': partreg = '(?P<' + var + '>' + '\|'.join(clist) + ')' else: if len(path) > 1: partreg = '(?P<' + var + '>[^' + path[1][0] +']+)' else: partreg = '(?P<' + var + '>[^/]+)' if self.reqs.has_key(var): noreqs = False if not self.defaults.has_key(var): allblank = False noreqs = False # Now we determine if its optional, or required. This changes depending on what is in # the rest of the match. If noreqs is true, then its possible the entire thing is optional # as there's no reqs or string matches. if noreqs: # The rest is optional, but now we have an optional with a regexp. Wrap to ensure that if we match # anything, we match our regexp first. It's still possible we could be completely blank as we have # a default if self.reqs.has_key(var) and self.defaults.has_key(var): reg = '(' + partreg + rest + ')?' # Or we have a regexp match with no default, so now being completely blank form here on out isn't # possible elif self.reqs.has_key(var): allblank = False reg = partreg + rest # Or we have a default with no regexp, don't touch the allblank elif self.defaults.has_key(var): reg = partreg + '?' + rest # Or we have a key with no default, and no reqs. Not possible to be all blank from here else: allblank = False reg = partreg + rest # In this case, we have something dangling that might need to be matched else: # If they can all be blank, and we have a default here, we know its # safe to make everything from here optional. Since something else in # the chain does have req's though, we have to make the partreg here # required to continue matching if allblank and self.defaults.has_key(var): reg = '(' + partreg + rest + ')?' # Same as before, but they can't all be blank, so we have to require it all to ensure # our matches line up right else: reg = partreg + rest elif isinstance(part, dict) and part['type'] == '': var = part['name'] if noreqs: if self.defaults.has_key(var): reg = '(?P<' + var + '>.)' + rest else: reg = '(?P<' + var + '>.)' + rest allblank = False noreqs = False else: if allblank and self.defaults.has_key(var): reg = '(?P<' + var + '>.)' + rest elif self.defaults.has_key(var): reg = '(?P<' + var + '>.)' + rest else: allblank = False noreqs = False reg = '(?P<' + var + '>.)' + rest elif part.endswith('/'): if allblank: reg = part[:-1] + '(/' + rest + ')?' else: allblank = False reg = re.escape(part) + rest # We have a normal string here, this is a req, and it prevents us from being all blank else: noreqs = False allblank = False reg = re.escape(part) + rest return (reg, noreqs, allblank)	15,318
def buildnextreg(self, path, clist): """Recursively build our regexp given a path, and a controller list. Returns the regular expression string, and two booleans that can be ignored as they're only used internally by buildnextreg """ if path: part = path[0] else: part = '' reg = '' # noreqs will remember whether the remainder has either a string match, or a non-defaulted # regexp match on a key, allblank remembers if the rest could possible be completely empty (rest, noreqs, allblank) = ('', True, True) if len(path[1:]) > 0: (rest, noreqs, allblank) = self.buildnextreg(path[1:], clist) if isinstance(part, dict) and part['type'] == ':': var = part['name'] partreg = '' # First we plug in the proper part matcher if self.reqs.has_key(var): partreg = '(?P<' + var + '>' + self.reqs[var] + ')' elif var == 'controller': partreg = '(?P<' + var + '>' + '\|'.join(clist) + ')' else: if len(path) > 1: partreg = '(?P<' + var + '>[^' + path[1][0] +']+)' else: partreg = '(?P<' + var + '>[^/]+)' if self.reqs.has_key(var): noreqs = False if not self.defaults.has_key(var): allblank = False noreqs = False # Now we determine if its optional, or required. This changes depending on what is in # the rest of the match. If noreqs is true, then its possible the entire thing is optional # as there's no reqs or string matches. if noreqs: # The rest is optional, but now we have an optional with a regexp. Wrap to ensure that if we match # anything, we match our regexp first. It's still possible we could be completely blank as we have # a default if self.reqs.has_key(var) and self.defaults.has_key(var): reg = '(' + partreg + rest + ')?' # Or we have a regexp match with no default, so now being completely blank form here on out isn't # possible elif self.reqs.has_key(var): allblank = False reg = partreg + rest # Or we have a default with no regexp, don't touch the allblank elif self.defaults.has_key(var): reg = partreg + '?' + rest # Or we have a key with no default, and no reqs. Not possible to be all blank from here else: allblank = False reg = partreg + rest # In this case, we have something dangling that might need to be matched else: # If they can all be blank, and we have a default here, we know its # safe to make everything from here optional. Since something else in # the chain does have req's though, we have to make the partreg here # required to continue matching if allblank and self.defaults.has_key(var): reg = '(' + partreg + rest + ')?' # Same as before, but they can't all be blank, so we have to require it all to ensure # our matches line up right else: reg = partreg + rest elif isinstance(part, dict) and part['type'] == '': var = part['name'] if noreqs: if self.defaults.has_key(var): reg = '(?P<' + var + '>.)' + rest else: reg = '(?P<' + var + '>.)' + rest allblank = False noreqs = False else: if allblank and self.defaults.has_key(var): reg = '(?P<' + var + '>.)' + rest elif self.defaults.has_key(var): reg = '(?P<' + var + '>.)' + rest else: allblank = False noreqs = False reg = '(?P<' + var + '>.)' + rest elif part.endswith('/'): if allblank: reg = part[:-1] + '(/' + rest + ')?' else: allblank = False reg = part + rest # We have a normal string here, this is a req, and it prevents us from being all blank else: noreqs = False allblank = False reg = part + rest return (reg, noreqs, allblank)	def buildnextreg(self, path, clist): """Recursively build our regexp given a path, and a controller list. Returns the regular expression string, and two booleans that can be ignored as they're only used internally by buildnextreg """ if path: part = path[0] else: part = '' reg = '' # noreqs will remember whether the remainder has either a string match, or a non-defaulted # regexp match on a key, allblank remembers if the rest could possible be completely empty (rest, noreqs, allblank) = ('', True, True) if len(path[1:]) > 0: (rest, noreqs, allblank) = self.buildnextreg(path[1:], clist) if isinstance(part, dict) and part['type'] == ':': var = part['name'] partreg = '' # First we plug in the proper part matcher if self.reqs.has_key(var): partreg = '(?P<' + var + '>' + self.reqs[var] + ')' elif var == 'controller': partreg = '(?P<' + var + '>' + '\|'.join(clist) + ')' else: if len(path) > 1: partreg = '(?P<' + var + '>[^' + path[1][0] +']+)' else: partreg = '(?P<' + var + '>[^/]+)' if self.reqs.has_key(var): noreqs = False if not self.defaults.has_key(var): allblank = False noreqs = False # Now we determine if its optional, or required. This changes depending on what is in # the rest of the match. If noreqs is true, then its possible the entire thing is optional # as there's no reqs or string matches. if noreqs: # The rest is optional, but now we have an optional with a regexp. Wrap to ensure that if we match # anything, we match our regexp first. It's still possible we could be completely blank as we have # a default if self.reqs.has_key(var) and self.defaults.has_key(var): reg = '(' + partreg + rest + ')?' # Or we have a regexp match with no default, so now being completely blank form here on out isn't # possible elif self.reqs.has_key(var): allblank = False reg = partreg + rest # Or we have a default with no regexp, don't touch the allblank elif self.defaults.has_key(var): reg = partreg + '?' + rest # Or we have a key with no default, and no reqs. Not possible to be all blank from here else: allblank = False reg = partreg + rest # In this case, we have something dangling that might need to be matched else: # If they can all be blank, and we have a default here, we know its # safe to make everything from here optional. Since something else in # the chain does have req's though, we have to make the partreg here # required to continue matching if allblank and self.defaults.has_key(var): reg = '(' + partreg + rest + ')?' # Same as before, but they can't all be blank, so we have to require it all to ensure # our matches line up right else: reg = partreg + rest elif isinstance(part, dict) and part['type'] == '': var = part['name'] if noreqs: if self.defaults.has_key(var): reg = '(?P<' + var + '>.)' + rest else: reg = '(?P<' + var + '>.)' + rest allblank = False noreqs = False else: if allblank and self.defaults.has_key(var): reg = '(?P<' + var + '>.)' + rest elif self.defaults.has_key(var): reg = '(?P<' + var + '>.)' + rest else: allblank = False noreqs = False reg = '(?P<' + var + '>.)' + rest elif part.endswith('/'): if allblank: reg = part[:-1] + '(/' + rest + ')?' else: allblank = False reg = re.escape(part) + rest # We have a normal string here, this is a req, and it prevents us from being all blank else: noreqs = False allblank = False reg = re.escape(part) + rest return (reg, noreqs, allblank)	15,319
def requirements_for(meth): """Returns a new dict to be used for all route creation as the route options""" opts = options.copy() if method != 'any': opts['conditions'] = {'method':[meth]} return opts	def requirements_for(meth): """Returns a new dict to be used for all route creation as the route options""" opts = options.copy() if method != 'any': opts['conditions'] = {'method':[meth]} return opts	15,320
def requirements_for(meth): """Returns a new dict to be used for all route creation as the route options""" opts = options.copy() if method != 'any': opts['conditions'] = {'method':[meth]} return opts	def requirements_for(meth): """Returns a new dict to be used for all route creation as the route options""" opts = options.copy() if method != 'any': opts['conditions'] = {'method':[meth]} return opts	15,321
def requirements_for(meth): """Returns a new dict to be used for all route creation as the route options""" opts = options.copy() if method != 'any': opts['conditions'] = {'method':[meth]} return opts	def requirements_for(meth): """Returns a new dict to be used for all route creation as the route options""" opts = options.copy() if method != 'any': opts['conditions'] = {'method':[meth]} return opts	15,322
def requirements_for(meth): """Returns a new dict to be used for all route creation as the route options""" opts = options.copy() if method != 'any': opts['conditions'] = {'method':[meth]} return opts	def requirements_for(meth): """Returns a new dict to be used for all route creation as the route options""" opts = options.copy() if method != 'any': opts['conditions'] = {'method':[meth]} return opts	15,323
def requirements_for(meth): """Returns a new dict to be used for all route creation as the route options""" opts = options.copy() if method != 'any': opts['conditions'] = {'method':[meth]} return opts	def requirements_for(meth): """Returns a new dict to be used for all route creation as the route options""" opts = options.copy() if method != 'any': opts['conditions'] = {'method':[meth]} return opts	15,324
def __init__(self, conf, mapfactory, opsonlineresource): self.conf = conf self.mapfactory = mapfactory if self.conf.has_option('service', 'epsg'): self.crs = CRS('EPSG', self.conf.get('service', 'epsg')) else: ServerConfigurationError('EPSG code not properly configured.')	def __init__(self, conf, mapfactory, opsonlineresource): self.conf = conf self.mapfactory = mapfactory if self.conf.has_option('service', 'epsg'): self.crs = CRS('EPSG', self.conf.get('service', 'epsg')) else: ServerConfigurationError('EPSG code not properly configured.')	15,325
def __init__(self): """Init database""" #Get repos present on machine self.repos = os.listdir("/var/lib/pacman")	def __init__(self): """Init database""" #Get repos present on machine self.repos = os.listdir("/var/lib/pacman")	15,326
def _set_filelist(self, pac, path): """Set installed files list for the given pac""" if not pac.installed: return _("%s is not installed") %pac.name files = open("%s/files" %path).read() begin = files.index("%FILES%") + len("%FILES%") end = files.find("%", begin) - len("%") filelist = files[begin:end].strip() pac.filelist = filelist return	def _set_filelist(self, pac, path): """Set installed files list for the given pac""" if not pac.installed: return _("%s is not installed") %pac.name files = open("%s/files" %path).read() begin = files.index("%FILES%") + len("%FILES%") end = files.find("%", begin) - len("%") filelist = files[begin:end].strip() pac.filelist = filelist return	15,327
def run(self): self.show_all() self.terminal.fork_command() self.terminal.feed_child("pacman -Sy;exit\n")	def run(self): self.show() self.terminal.fork_command() self.terminal.feed_child("pacman -Sy;exit\n")	15,328
def _setup_layout(self):	def _setup_layout(self):	15,329
def run(self):	def run(self):	15,330
def run(self): self.show_all() self.terminal.do_upgrade()	def run(self): self.show() self.terminal.do_upgrade()	15,331
def _setup_pacs_models(self): self.models = {}	def _setup_pacs_models(self): self.models = {}	15,332
def _setup_pacs_models(self): self.models = {}	def _setup_pacs_models(self): self.models = {}	15,333
def get_by_keywords(self, keywords): """Return pacs which have keywords as name or in description""" keys = [] #Split keywords by '+' or spaces if keywords.count("+") and keywords.count(" "): keys_1 = keywords.split("+") for key in keys_1: keys = key.split(" ") elif keywords.count(" "): keys = keywords.split() elif keyword.count("+"): keys = keyword.split("+") else: keys = keywords	def get_by_keywords(self, keywords): """Return pacs which have keywords as name or in description""" keys = [] #Split keywords by '+' or spaces if keywords.count("+") and keywords.count(" "): keys_1 = keywords.split("+") for key in keys_1: keys = key.split(" ") elif keywords.count(" "): keys = keywords.split() elif keywords.count("+"): keys = keywords.split("+") else: keys = keywords	15,334
def _setup_notebook(self): """Setup the notebook""" notebook = self.gld.get_widget("notebook")	def _setup_notebook(self): """Setup the notebook""" notebook = self.gld.get_widget("notebook")	15,335
def _setup_notebook(self): """Setup the notebook""" notebook = self.gld.get_widget("notebook")	def _setup_notebook(self): """Setup the notebook""" notebook = self.gld.get_widget("notebook")	15,336
def _setup_notebook(self): """Setup the notebook""" notebook = self.gld.get_widget("notebook")	def _setup_notebook(self): """Setup the notebook""" notebook = self.gld.get_widget("notebook")	15,337
def _setup_notebook(self): """Setup the notebook""" notebook = self.gld.get_widget("notebook")	def _setup_notebook(self): """Setup the notebook""" notebook = self.gld.get_widget("notebook")	15,338
def _get_selected_page(self, repo_tree): model, tree_iter = repo_tree.get_selection().get_selected() if tree_iter is None: tree_iter = model.get_iter_from_string("0")	def _get_selected_page(self, repo_tree, toggle=None): model, tree_iter = repo_tree.get_selection().get_selected() if tree_iter is None: tree_iter = model.get_iter_from_string("0")	15,339