| Age | Commit message (Collapse) | Author |
|---|
|
and ``lookup``. ``Lookup`` will be an instance of a lookup class which
supplies (late-bound) arguments for debug, reload, and translate. Any
third-party renderers which use (the non-API) function
``pyramid.renderers.template_renderer_factory`` will need to adjust their
implementations to obey the new callback argument list. This change was to
kill off inappropriate use of threadlocals.
|
|
a ``registry`` attribute on the ZCML context (kill off use of
threadlocals).
|
|
--------
- The ``settings`` object which used to be available only when
``request.settings.get_settings`` was called is now available as
``registry.settings`` (e.g. ``request.registry.settings`` in view code).
Deprecations
------------
- Obtaining the ``settings`` object via
``registry.{get|query}Utility(ISettings)`` is now deprecated. Instead,
obtain the ``settings`` object via the ``registry.settings`` attribute. A
backwards compatibility shim was added to the registry object to register
the settings object as an ISettings utility when ``setattr(registry,
'settings', foo)`` is called, but it will be removed in a later release.
- Obtaining the ``settings`` object via ``pyramid.settings.get_settings`` is
now deprecated. Obtain it as the ``settings`` attribute of the registry
now (obtain the registry via ``pyramid.threadlocal.get_registry`` or as
``request.registry``).
|
|
``pyramid_routesalchemy`` paster template.
|
|
``route_url``. These are simple passthroughs for their respective
functions in ``pyramid.url``.
- Documented the ``matchdict`` and ``matched_route`` attributes of the
request object in the Request API documentation.
|
|
|
|
pyramid.request.Request. Each is set to None.
|
|
(``your_app_secret_string``) for the ``session.secret`` setting in the
generated ``development.ini``. This was a security risk if left unchanged
in a project that used one of the templates to produce production
applications. It now uses a randomly generated string.
|
|
|
|
--------
- Normalized all paster templates: each now uses the name ``main`` to
represent the function that returns a WSGI application, each now uses
WebError, each now has roughly the same shape of development.ini style.
Bug Fixes
---------
- The pylons_* paster templates erroneously used the ``{squiggly}`` routing
syntax as the pattern supplied to ``add_route``. This style of routing is
not supported. They were replaced with ``:colon`` style route patterns.
|
|
|
|
|
|
to :app:`Pyramid`. A custom role setting was added to ``docs/conf.py`` to
allow for this. (internal)
|
|
|
|
(e.g. ``pyramid.interfaces.INewRequest``) have been changed to reference
their concrete classes (e.g. ``pyramid.events.NewRequest``) in
documentation about making subscriptions.
|
|
|
|
|
|
|
|
``pyramid.configuration.Configurator.add_view`` method, or the
``pyramid.view.view_config`` decorator (nee ``bfg_view``) is no longer
permitted to be one of the strings ``GET``, ``HEAD``, ``PUT``, ``POST`` or
``DELETE``, and now must always be an interface. Accepting the
method-strings as ``request_type`` was a backwards compatibility strategy
servicing repoze.bfg 1.0 applications. Use the ``request_method``
parameter instead to specify that a view a string request-method predicate.
|
|
``pyramid_routesalchemy`` paster template.
|
|
``pyramid_zodb`` paster template.
|
|
|
|
|
|
now defaults to ``auth_tkt`` (it used to default to ``repoze.bfg.auth_tkt``).
- The default ``cookie_name`` value of the
``pyramid.authentication.AuthTktAuthenticationPolicy`` constructor now
defaults to ``auth_tkt`` (it used to default to ``repoze.bfg.auth_tkt``).
|
|
|
|
that it is imported from pyramid. API docs can mention its inheritance from
webob (aka "Provide a webob.Response class facade for forward compat").
|
|
during internationalization were never APIs. These however have changed to
``localizer`` and ``locale_name``, respectively.
|
|
an exception occurs is now deprecated. Instead, code which relies on this
environ value should use the ``exception`` attribute of the request
(e.g. ``request.exception[0]``) to retrieve the message.
|
|
is sent as an event before a renderer is invoked (but after the
application-level renderer globals factory added via
``pyramid.configurator.configuration.set_renderer_globals_factory``, if any,
has injected its own keys). Applications may now subscribe to the
``IBeforeRender`` event type in order to introspect the and modify the set of
renderer globals before they are passed to a renderer. The event object
iself has a dictionary-like interface that can be used for this purpose. For
example::
from repoze.events import subscriber
from pyramid.interfaces import IRendererGlobalsEvent
@subscriber(IRendererGlobalsEvent)
def add_global(event):
event['mykey'] = 'foo'
If a subscriber attempts to add a key that already exist in the renderer
globals dictionary, a ``KeyError`` is raised. This limitation is due to the
fact that subscribers cannot be ordered relative to each other. The set of
keys added to the renderer globals dictionary by all subscribers and
app-level globals factories must be unique.
|
|
|
|
object itself to a renderer rather than a dictionary derivation)
|
|
at at least one setting to determine how to do rendering
|
|
specification or an absolute path. The dictonary contains the following
keys: ``name`` (the ``renderer=`` value), ``package`` (the 'current package'
when the renderer configuration statement was found), ``type``: the renderer
type, and ``registry``: the current registry.
Third-party ``repoze.bfg`` renderer implementations that must be ported to
Pyramid will need to account for this.
This change was made to support more flexible Mako template rendering.
|
|
|
|
|
|
|
|
|
|
that uses cookies
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
message was raised if the renderer name was not a string.
|
|
|
|
|
|
to encode a Unicode ``path`` into ASCII before attempting to split
it and decode its segments. This is for convenience, effectively to
allow a (stored-as-Unicode-in-a-database, or
retrieved-as-Unicode-from-a-request-parameter) Unicode path to be
passed to ``find_model``, which eventually internally uses the
``traversal_path`` function under the hood. In version 1.2 and
prior, if the ``path`` was Unicode, that Unicode was split on
slashes and each resulting segment value was Unicode. An
inappropriate call to the ``decode()`` method of a resulting Unicode
path segment could cause a ``UnicodeDecodeError`` to occur even if
the Unicode representation of the path contained no 'high order'
characters (it effectively did a "double decode"). By converting
the Unicode path argument to ASCII before we attempt to decode and
split, genuine errors will occur in a more obvious place while also
allowing us to handle (for convenience) the case that it's a Unicode
representation formed entirely from ASCII-compatible characters.
|
