desc stringlengths 3 26.7k | decl stringlengths 11 7.89k | bodies stringlengths 8 553k |
|---|---|---|
'Set the meta field for a key to a new value. This triggers the
on-change handler for existing keys.'
| def meta_set(self, key, metafield, value):
| self._meta.setdefault(key, {})[metafield] = value
if (key in self):
self[key] = self[key]
|
'Return an iterable of meta field names defined for a key.'
| def meta_list(self, key):
| return self._meta.get(key, {}).keys()
|
'Return the current default application.'
| def __call__(self):
| return self[(-1)]
|
'Add a new :class:`Bottle` instance to the stack'
| def push(self, value=None):
| if (not isinstance(value, Bottle)):
value = Bottle()
self.append(value)
return value
|
'Add a new path to the list of search paths. Return False if the
path does not exist.
:param path: The new search path. Relative paths are turned into
an absolute and normalized form. If the path looks like a file
(not ending in `/`), the filename is stripped off.
:param base: Path used to absolutize relative search pa... | def add_path(self, path, base=None, index=None, create=False):
| base = os.path.abspath(os.path.dirname((base or self.base)))
path = os.path.abspath(os.path.join(base, os.path.dirname(path)))
path += os.sep
if (path in self.path):
self.path.remove(path)
if (create and (not os.path.isdir(path))):
os.makedirs(path)
if (index is None):
se... |
'Iterate over all existing files in all registered paths.'
| def __iter__(self):
| search = self.path[:]
while search:
path = search.pop()
if (not os.path.isdir(path)):
continue
for name in os.listdir(path):
full = os.path.join(path, name)
if os.path.isdir(full):
search.append(full)
else:
(... |
'Search for a resource and return an absolute file path, or `None`.
The :attr:`path` list is searched in order. The first match is
returend. Symlinks are followed. The result is cached to speed up
future lookups.'
| def lookup(self, name):
| if ((name not in self.cache) or DEBUG):
for path in self.path:
fpath = os.path.join(path, name)
if os.path.isfile(fpath):
if (self.cachemode in ('all', 'found')):
self.cache[name] = fpath
return fpath
if (self.cachemode == '... |
'Find a resource and return a file object, or raise IOError.'
| def open(self, name, mode='r', *args, **kwargs):
| fname = self.lookup(name)
if (not fname):
raise IOError(('Resource %r not found.' % name))
return self.opener(fname, mode=mode, *args, **kwargs)
|
'Wrapper for file uploads.'
| def __init__(self, fileobj, name, filename, headers=None):
| self.file = fileobj
self.name = name
self.raw_filename = filename
self.headers = (HeaderDict(headers) if headers else HeaderDict())
|
'Name of the file on the client file system, but normalized to ensure
file system compatibility. An empty filename is returned as \'empty\'.
Only ASCII letters, digits, dashes, underscores and dots are
allowed in the final filename. Accents are removed, if possible.
Whitespace is replaced by a single dash. Leading or t... | @cached_property
def filename(self):
| fname = self.raw_filename
if (not isinstance(fname, unicode)):
fname = fname.decode('utf8', 'ignore')
fname = normalize('NFKD', fname)
fname = fname.encode('ASCII', 'ignore').decode('ASCII')
fname = os.path.basename(fname.replace('\\', os.path.sep))
fname = re.sub('[^a-zA-Z0-9-_.\\s]', '... |
'Save file to disk or copy its content to an open file(-like) object.
If *destination* is a directory, :attr:`filename` is added to the
path. Existing files are not overwritten by default (IOError).
:param destination: File path, directory or file(-like) object.
:param overwrite: If True, replace existing files. (defau... | def save(self, destination, overwrite=False, chunk_size=(2 ** 16)):
| if isinstance(destination, basestring):
if os.path.isdir(destination):
destination = os.path.join(destination, self.filename)
if ((not overwrite) and os.path.exists(destination)):
raise IOError('File exists.')
with open(destination, 'wb') as fp:
self._c... |
'Create a new template.
If the source parameter (str or buffer) is missing, the name argument
is used to guess a template filename. Subclasses can assume that
self.source and/or self.filename are set. Both are strings.
The lookup, encoding and settings parameters are stored as instance
variables.
The lookup parameter s... | def __init__(self, source=None, name=None, lookup=None, encoding='utf8', **settings):
| self.name = name
self.source = (source.read() if hasattr(source, 'read') else source)
self.filename = (source.filename if hasattr(source, 'filename') else None)
self.lookup = ([os.path.abspath(x) for x in lookup] if lookup else [])
self.encoding = encoding
self.settings = self.settings.copy()
... |
'Search name in all directories specified in lookup.
First without, then with common extensions. Return first hit.'
| @classmethod
def search(cls, name, lookup=None):
| if (not lookup):
depr('The template lookup path list should not be empty.', True)
lookup = ['.']
if (os.path.isabs(name) and os.path.isfile(name)):
depr('Absolute template path names are deprecated.', True)
return os.path.abspath(name)
f... |
'This reads or sets the global settings stored in class.settings.'
| @classmethod
def global_config(cls, key, *args):
| if args:
cls.settings = cls.settings.copy()
cls.settings[key] = args[0]
else:
return cls.settings[key]
|
'Run preparations (parsing, caching, ...).
It should be possible to call this again to refresh a template or to
update settings.'
| def prepare(self, **options):
| raise NotImplementedError
|
'Render the template with the specified local variables and return
a single byte or unicode string. If it is a byte string, the encoding
must match self.encoding. This method must be thread-safe!
Local variables may be provided in dictionaries (args)
or directly, as keywords (kwargs).'
| def render(self, *args, **kwargs):
| raise NotImplementedError
|
'Render the template using keyword arguments as local variables.'
| def render(self, *args, **kwargs):
| env = {}
stdout = []
for dictarg in args:
env.update(dictarg)
env.update(kwargs)
self.execute(stdout, env)
return ''.join(stdout)
|
'Tokens as a space separated string (default: <% %> % {{ }})'
| def get_syntax(self):
| return self._syntax
|
'reset analyser, clear any state'
| def reset(self):
| self._mDone = False
self._mTotalChars = 0
self._mFreqChars = 0
|
'feed a character with known length'
| def feed(self, aBuf, aCharLen):
| if (aCharLen == 2):
order = self.get_order(aBuf)
else:
order = (-1)
if (order >= 0):
self._mTotalChars += 1
if (order < self._mTableSize):
if (512 > self._mCharToFreqOrder[order]):
self._mFreqChars += 1
|
'return confidence based on existing data'
| def get_confidence(self):
| if ((self._mTotalChars <= 0) or (self._mFreqChars <= MINIMUM_DATA_THRESHOLD)):
return SURE_NO
if (self._mTotalChars != self._mFreqChars):
r = (self._mFreqChars / ((self._mTotalChars - self._mFreqChars) * self._mTypicalDistributionRatio))
if (r < SURE_YES):
return r
return... |
'Create a new libmagic wrapper.
mime - if True, mimetypes are returned instead of textual descriptions
mime_encoding - if True, codec is returned
magic_file - use a mime database other than the system default'
| def __init__(self, mime=False, magic_file=None, mime_encoding=False):
| flags = MAGIC_NONE
if mime:
flags |= MAGIC_MIME
elif mime_encoding:
flags |= MAGIC_MIME_ENCODING
self.cookie = magic_open(flags)
magic_load(self.cookie, magic_file)
|
'Identify the contents of `buf`'
| def from_buffer(self, buf):
| return magic_buffer(self.cookie, buf)
|
'Identify the contents of file `filename`
raises IOError if the file does not exist'
| def from_file(self, filename):
| if (not os.path.exists(filename)):
raise IOError(('File does not exist: ' + filename))
return magic_file(self.cookie, filename)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.