def __getattr__(self, key):
settings.depr('Attribute access is deprecated.') #0.12
if key not in self and key[0].isupper():
self[key] = self.Namespace(self, key)
if key not in self and key.startswith('__'):
raise AttributeError(key)
return self.get(key)
def translate(self):
if self.offset: raise RuntimeError('Parser is a one time instance.')
while True:
m = self.re_split.search(self.source[self.offset:])
if m:
text = self.source[self.offset:self.offset + m.start()]
self.text_buffer.append(text)
self.offset += m.end()
if m.group(1): # New escape syntax
line, sep, _ = self.source[self.offset:].partition('\n')
self.text_buffer.append(
m.group(2) + m.group(5) + line + sep)
self.offset += len(line + sep) + 1
continue
elif m.group(5): # Old escape syntax
env_settings.depr(
'Escape code lines with a backslash.') #0.12
line, sep, _ = self.source[self.offset:].partition('\n')
self.text_buffer.append(m.group(2) + line + sep)
self.offset += len(line + sep) + 1
continue
self.flush_text()
self.read_code(multiline=bool(m.group(4)))
else:
break
self.text_buffer.append(self.source[self.offset:])
self.flush_text()
return ''.join(self.code_buffer)
def __init__(self, *a, **ka):
self._meta = {}
self._on_change = lambda name, value: None
if a or ka:
settings.depr(
'Constructor does no longer accept parameters.') #0.12
self.update(*a, **ka)
def __setattr__(self, key, value):
if key in self.__slots__:
return dict.__setattr__(self, key, value)
settings.depr('Attribute assignment is deprecated.') #0.12
if hasattr(dict, key):
raise AttributeError('Read-only attribute.')
if key in self and self[key] and isinstance(self[key], self.Namespace):
raise AttributeError('Non-empty namespace attribute.')
self[key] = value
def _include(self, _env, _name=None, **kwargs):
if _name is None:
env_settings.depr('Rebase function called without arguments.'
' You were probably looking for {{base}}?',
True) #0.12
env = _env.copy()
env.update(kwargs)
if _name not in self.cache:
self.cache[_name] = self.__class__(name=_name, lookup=self.lookup)
return self.cache[_name].execute(env['_stdout'], env)
def __setattr__(self, key, value):
if key in ('_config', '_prefix'):
self.__dict__[key] = value
return
settings.depr('Attribute assignment is deprecated.') #0.12
if hasattr(settings.DictMixin, key):
raise AttributeError('Read-only attribute.')
if key in self and self[key] and isinstance(
self[key], self.__class__):
raise AttributeError('Non-empty namespace attribute.')
self[key] = value
def _context(self):
settings.depr(
'Switch to Plugin API v2 and access the Route object directly.'
) #0.12
return dict(rule=self.rule,
method=self.method,
callback=self.callback,
name=self.name,
app=self.app,
config=self.config,
apply=self.plugins,
skip=self.skiplist)
def mount(self, prefix, app, **options):
''' Mount an application (:class:`Bottle` or plain WSGI) to a specific
URL prefix. Example::
root_app.mount('/admin/', admin_app)
:param prefix: path prefix or `mount-point`. If it ends in a slash,
that slash is mandatory.
:param app: an instance of :class:`Bottle` or a WSGI application.
All other parameters are passed to the underlying :meth:`route` call.
'''
if isinstance(app, settings.basestring):
settings.depr('Parameter order of Bottle.mount() changed.',
True) # 0.10
segments = [p for p in prefix.split('/') if p]
if not segments: raise ValueError('Empty path prefix.')
path_depth = len(segments)
def mountpoint_wrapper():
try:
http_wsgi.request.path_shift(path_depth)
rs = http_wsgi.HTTPResponse([])
def start_response(status, headerlist, exc_info=None):
if exc_info:
try:
settings._raise(*exc_info)
finally:
exc_info = None
rs.status = status
for name, value in headerlist:
rs.add_header(name, value)
return rs.body.append
body = app(http_wsgi.request.environ, start_response)
if body and rs.body:
body = settings.itertools.chain(rs.body, body)
rs.body = body or rs.body
return rs
finally:
http_wsgi.request.path_shift(-path_depth)
options.setdefault('skip', True)
options.setdefault('method', 'PROXY')
options.setdefault('mountpoint', {'prefix': prefix, 'target': app})
options['callback'] = mountpoint_wrapper
self.route('/%s/<:re:.*>' % '/'.join(segments), **options)
if not prefix.endswith('/'):
self.route('/' + '/'.join(segments), **options)
def code(self):
source = self.source
if not source:
with open(self.filename, 'rb') as f:
source = f.read()
try:
source, encoding = env_settings.touni(source), 'utf8'
except UnicodeError:
env_settings.depr(
'Template encodings other than utf8 are no longer supported.'
) #0.11
source, encoding = env_settings.touni(source, 'latin1'), 'latin1'
parser = StplParser(source, encoding=encoding, syntax=self.syntax)
code = parser.translate()
self.encoding = parser.encoding
return code
def local_property(name=None):
if name:
settings.depr(
'local_property() is deprecated and will be removed.') #0.12
ls = settings.threading.local()
def fget(self):
try:
return ls.var
except AttributeError:
raise RuntimeError("Request context not initialized.")
def fset(self, value):
ls.var = value
def fdel(self):
del ls.var
return property(fget, fset, fdel, 'Thread-local property')
def search(cls, name, lookup=[]):
""" Search name in all directories specified in lookup.
First without, then with common extensions. Return first hit. """
if not lookup:
env_settings.depr(
'The template lookup path list should not be empty.') #0.12
lookup = ['.']
if os.path.isabs(name) and os.path.isfile(name):
env_settings.depr(
'Absolute template path names are deprecated.') #0.12
return os.path.abspath(name)
for spath in lookup:
spath = os.path.abspath(spath) + os.sep
fname = os.path.abspath(os.path.join(spath, name))
if not fname.startswith(spath): continue
if os.path.isfile(fname): return fname
for ext in cls.extensions:
if os.path.isfile('%s.%s' % (fname, ext)):
return '%s.%s' % (fname, ext)
def fix_backward_compatibility(self, line, comment):
parts = line.strip().split(None, 2)
if parts and parts[0] in ('include', 'rebase'):
env_settings.depr(
'The include and rebase keywords are functions now.') #0.12
if len(parts) == 1:
return "_printlist([base])", comment
elif len(parts) == 2:
return "_=%s(%r)" % tuple(parts), comment
else:
return "_=%s(%r, %s)" % tuple(parts), comment
if self.lineno <= 2 and not line.strip() and 'coding' in comment:
m = env_settings.re.match(r"#.*coding[:=]\s*([-\w.]+)", comment)
if m:
env_settings.depr(
'PEP263 encoding strings in templates are deprecated.'
) #0.12
enc = m.group(1)
self.source = self.source.encode(self.encoding).decode(enc)
self.encoding = enc
return line, comment.replace('coding', 'coding*')
return line, comment
def __call__(self, *a, **ka):
settings.depr("Some APIs changed to return Route() instances instead of"\
" callables. Make sure to use the Route.call method and not to"\
" call Route instances directly.") #0.12
return self.call(*a, **ka)
def __call__(self, *a, **ka):
settings.depr(
'Calling ConfDict is deprecated. Use the update() method.') #0.12
self.update(*a, **ka)
return self
def __getitem__(self, key):
settings.depr(
'Accessing namespaces as dicts is discouraged. '
'Only use flat item access: '
'cfg["names"]["pace"]["key"] -> cfg["name.space.key"]') #0.12
return self._config[self._prefix + '.' + key]
def _rebase(self, _env, _name=None, **kwargs):
if _name is None:
env_settings.depr('Rebase function called without arguments.'
' You were probably looking for {{base}}?',
True) #0.12
_env['_rebase'] = (_name, kwargs)
