{ "info": { "author": "Chris McDonough, Agendaless Consulting", "author_email": "repoze-dev@lists.repoze.org", "bugtrack_url": null, "classifiers": [ "Framework :: BFG", "Intended Audience :: Developers", "License :: Repoze Public License", "Programming Language :: Python", "Topic :: Internet :: WWW/HTTP", "Topic :: Internet :: WWW/HTTP :: WSGI" ], "description": "repoze.bfg\n==========\n\n``repoze.bfg`` is a small, fast, down-to-earth, open source Python web\ndevelopment framework. It makes real-world web application development\nand deployment more fun, more predictable, and more productive.\n\nSupport and Documentation\n-------------------------\n\nSee the `repoze.bfg website `_ to view\ndocumentation, report bugs, and obtain support.\n\nLicense\n-------\n\n``repoze.bfg`` is offered under the BSD-derived `Repoze Public License\n`_.\n\nAuthors\n-------\n\n``repoze.bfg`` is made available by `Agendaless Consulting\n`_ and a team of contributors.\n\n\n\n1.3 (2010-11-01)\n================\n\nFeatures\n--------\n\n- Raise more understandable error when a Jython application attempts to use a\n Chameleon template.\n\n1.3b3 (2010-10-29)\n==================\n\nBug Fixes\n---------\n\n- When a default permission was in effect, and a \"static view\" had\n been registered (via\n ``repoze.bfg.configuration.Configurator.add_static_view``, or via the\n ``static`` ZCML directiveq), the static view, was, by default,\n protected by the default permission, without a way to indicate that\n it was anonymously viewable. As of this release, a static view is\n registered using the permission sentinel\n ``__no_permission_required__`` as the permission by default, making\n its resources viewable by completely anonymous users.\n\nFeatures\n--------\n\n- A ``permission`` argument has been added to the\n ``repoze.bfg.configuration.Configurator.add_static_view`` method and\n a ``permission`` attribute is now available on the ``static`` ZCML\n directive. \n\nDocumentation\n-------------\n\n- A \"default permission\" glossary entry was added to the glossary.\n\n1.3b2 (2010-10-28)\n==================\n\nBug Fixes\n---------\n\n- The ``repoze.bfg.security.view_execution_permitted`` API could\n return the wrong boolean result due to a bug in the configurator,\n leading to inappropriate view execution by persons without\n permission when it was imported and used directly. Thanks to Shane\n Hathaway for a bug report and a patch.\n\nBackwards Incompatibilities\n---------------------------\n\n- Previously, the sentinel to register a view as explicitly \"no\n permission required\" (most useful when a default permission is in\n effect) was to register it explicitly with the value ``None`` as an\n argument to the ``permission`` parameter of the\n ``repoze.bfg.configuration.Configurator.add_view``. Using ``None``\n as a sentinel meaning \"no permission required\" in that location,\n however, was incompatible with the expectations of both the ``view``\n ZCML directive and the ``bfg_view`` decorator, which both passed\n ``None`` explicitly to ``add_view``, overriding any default\n permission. The symptom was that any \"default permission\"\n configured appeared to not work if either ZCML or the ``bfg_view``\n directive was used to register a view (although using ``add_view``\n directly did work). The ``None`` value as a sentinel could also not\n be spelled using ZCML.\n\n Now, the sentinel meaning \"no permission required\" is the string\n ``__no_permission_required__``, which satisfies the expectation of\n the ``view`` ZCML directive and the ``bfg_view`` decorator, and,\n since it's a string, it can be spelled in both Python and within\n ZCML.\n\n Thanks to Wichert Akkerman for the bug report.\n\n1.3b1 (2010-10-25)\n==================\n\nFeatures\n--------\n\n- The ``paster`` template named ``bfg_routesalchemy`` has been updated\n to use SQLAlchemy declarative syntax. Thanks to Ergo^.\n\nBug Fixes\n---------\n\n- When a renderer factory could not be found, a misleading error\n message was raised if the renderer name was not a string.\n\nDocumentation\n-------------\n\n- The \"\"bfgwiki2\" (SQLAlchemy + url dispatch) tutorial has been\n updated slightly. In particular, the source packages no longer\n attempt to use a private index, and the recommended Python version\n is now 2.6. It was also updated to take into account the changes to\n the ``bfg_routesalchemy`` template used to set up an environment.\n\n- The \"bfgwiki\" (ZODB + traversal) tutorial has been updated slightly.\n In particular, the source packages no longer attempt to use a\n private index, and the recommended Python version is now 2.6.\n\n1.3a15 (2010-09-30)\n===================\n\nFeatures\n--------\n\n- The ``repoze.bfg.traversal.traversal_path`` API now eagerly attempts\n to encode a Unicode ``path`` into ASCII before attempting to split\n it and decode its segments. This is for convenience, effectively to\n allow a (stored-as-Unicode-in-a-database, or\n retrieved-as-Unicode-from-a-request-parameter) Unicode path to be\n passed to ``find_model``, which eventually internally uses the\n ``traversal_path`` function under the hood. In version 1.2 and\n prior, if the ``path`` was Unicode, that Unicode was split on\n slashes and each resulting segment value was Unicode. An\n inappropriate call to the ``decode()`` method of a resulting Unicode\n path segment could cause a ``UnicodeDecodeError`` to occur even if\n the Unicode representation of the path contained no 'high order'\n characters (it effectively did a \"double decode\"). By converting\n the Unicode path argument to ASCII before we attempt to decode and\n split, genuine errors will occur in a more obvious place while also\n allowing us to handle (for convenience) the case that it's a Unicode\n representation formed entirely from ASCII-compatible characters.\n\n1.3a14 (2010-09-14)\n===================\n\nBug Fixes\n---------\n\n- If an exception view was registered through the legacy\n ``set_notfound_view`` or ``set_forbidden_view`` APIs, the context\n sent to the view was incorrect (could be ``None`` inappropriately).\n\nFeatures\n--------\n\n- Compatibility with WebOb 1.0.\n\nRequirements\n------------\n\n- Now requires WebOb >= 1.0.\n\nBackwards Incompatibilities\n---------------------------\n\n- Due to changes introduced WebOb 1.0, the\n ``repoze.bfg.request.make_request_ascii`` event subscriber no longer\n works, so it has been removed. This subscriber was meant to be used\n in a deployment so that code written before BFG 0.7.0 could run\n unchanged. At this point, such code will need to be rewritten to\n expect Unicode from ``request.GET``, ``request.POST`` and\n ``request.params`` or it will need to be changed to use\n ``request.str_POST``, ``request.str_GET`` and/or\n ``request.str_params`` instead of the non-``str`` versions of same,\n as the non-``str`` versions of the same APIs always now perform\n decoding to Unicode.\n\nErrata\n------\n\n- A prior changelog entry asserted that the ``INewResponse`` event was\n not sent to listeners if the response was not \"valid\" (if a view or\n renderer returned a response object that did not have a\n status/headers/app_iter). This is not true in this release, nor was\n it true in 1.3a13.\n\n1.3a13 (2010-09-14)\n===================\n\nBug Fixes\n---------\n\n- The ``traverse`` route predicate could not successfully generate a\n traversal path.\n\nFeatures\n--------\n\n- In support of making it easier to configure applications which are\n \"secure by default\", a default permission feature was added. If\n supplied, the default permission is used as the permission string to\n all view registrations which don't otherwise name a permission.\n These APIs are in support of that:\n\n - A new constructor argument was added to the Configurator:\n ``default_permission``.\n\n - A new method was added to the Configurator:\n ``set_default_permission``.\n\n - A new ZCML directive was added: ``default_permission``.\n\n- Add a new request API: ``request.add_finished_callback``. Finished\n callbacks are called by the router unconditionally near the very end\n of request processing. See the \"Using Finished Callbacks\" section\n of the \"Hooks\" narrative chapter of the documentation for more\n information.\n\n- A ``request.matched_route`` attribute is now added to the request\n when a route has matched. Its value is the \"route\" object that\n matched (see the ``IRoute`` interface within\n ``repoze.bfg.interfaces`` API documentation for the API of a route\n object).\n\n- The ``exception`` attribute of the request is now set slightly\n earlier and in a slightly different set of scenarios, for benefit of\n \"finished callbacks\" and \"response callbacks\". In previous\n versions, the ``exception`` attribute of the request was not set at\n all if an exception view was not found. In this version, the\n ``request.exception`` attribute is set immediately when an exception\n is caught by the router, even if an exception view could not be\n found.\n\n- The ``add_route`` method of a Configurator now accepts a\n ``pregenerator`` argument. The pregenerator for the resulting route\n is called by ``route_url`` in order to adjust the set of arguments\n passed to it by the user for special purposes, such as Pylons\n 'subdomain' support. It will influence the URL returned by\n ``route_url``. See the ``repoze.bfg.interfaces.IRoutePregenerator``\n interface for more information.\n\nBackwards Incompatibilities\n---------------------------\n\n- The router no longer sets the value ``wsgiorg.routing_args`` into\n the environ when a route matches. The value used to be something\n like ``((), matchdict)``. This functionality was only ever\n obliquely referred to in change logs; it was never documented as an\n API.\n\n- The ``exception`` attribute of the request now defaults to ``None``.\n In prior versions, the ``request.exception`` attribute did not exist\n if an exception was not raised by user code during request\n processing; it only began existence once an exception view was\n found.\n\nDeprecations\n------------\n\n- The ``repoze.bfg.interfaces.IWSGIApplicationCreatedEvent`` event\n interface was renamed to\n ``repoze.bfg.interfaces.IApplicationCreated``. Likewise, the\n ``repoze.bfg.events.WSGIApplicationCreatedEvent`` class was renamed\n to ``repoze.bfg.events.ApplicationCreated``. The older aliases will\n continue to work indefinitely.\n\n- The ``repoze.bfg.interfaces.IAfterTraversal`` event interface was\n renamed to ``repoze.bfg.interfaces.IContextFound``. Likewise, the\n ``repoze.bfg.events.AfterTraversal`` class was renamed to\n ``repoze.bfg.events.ContextFound``. The older aliases will continue\n to work indefinitely.\n\n- References to the WSGI environment values ``bfg.routes.matchdict``\n and ``bfg.routes.route`` were removed from documentation. These\n will stick around internally for several more releases, but it is\n ``request.matchdict`` and ``request.matched_route`` are now the\n \"official\" way to obtain the matchdict and the route object which\n resulted in the match.\n\nDocumentation\n-------------\n\n- Added documentation for the ``default_permission`` ZCML directive.\n\n- Added documentation for the ``default_permission`` constructor value\n and the ``set_default_permission`` method in the Configurator API\n documentation.\n\n- Added a new section to the \"security\" chapter named \"Setting a\n Default Permission\".\n\n- Document ``renderer_globals_factory`` and ``request_factory``\n arguments to Configurator constructor.\n\n- Added two sections to the \"Hooks\" chapter of the documentation:\n \"Using Response Callbacks\" and \"Using Finished Callbacks\".\n\n- Added documentation of the ``request.exception`` attribute to the\n ``repoze.bfg.request.Request`` API documentation.\n\n- Added glossary entries for \"response callback\" and \"finished\n callback\".\n\n- The \"Request Processing\" narrative chapter has been updated to note\n finished and response callback steps.\n\n- New interface in interfaces API documentation: ``IRoutePregenerator``.\n\n- Added a \"The Matched Route\" section to the URL Dispatch narrative\n docs chapter, detailing the ``matched_route`` attribute.\n\n1.3a12 (2010-09-08)\n===================\n\nBug Fixes\n---------\n\n- Fix a bug in ``repoze.bfg.url.static_url`` URL generation: if two\n resource specifications were used to create two separate static\n views, but they shared a common prefix, it was possible that\n ``static_url`` would generate an incorrect URL.\n\n- Fix another bug in ``repoze.bfg.static_url`` URL generation: too\n many slashes in generated URL.\n\n- Prevent a race condition which could result in a ``RuntimeError``\n when rendering a Chameleon template that has not already been\n rendered once. This would usually occur directly after a restart,\n when more than one person or thread is trying to execute the same\n view at the same time: https://bugs.launchpad.net/karl3/+bug/621364\n\nFeatures\n--------\n\n- The argument to ``repoze.bfg.configuration.Configurator.add_route``\n which was previously called ``path`` is now called ``pattern`` for\n better explicability. For backwards compatibility purposes, passing\n a keyword argument named ``path`` to ``add_route`` will still work\n indefinitely.\n\n- The ``path`` attribute to the ZCML ``route`` directive is now named\n ``pattern`` for better explicability. The older ``path`` attribute\n will continue to work indefinitely.\n\nDocumentation\n-------------\n\n- All narrative, API, and tutorial docs which referred to a route\n pattern as a ``path`` have now been updated to refer to them as a\n ``pattern``.\n\n- The ``repoze.bfg.interfaces`` API documentation page is now rendered\n via ``repoze.sphinx.autointerface``.\n\n- The URL Dispatch narrative chapter now refers to the ``interfaces``\n chapter to explain the API of an ``IRoute`` object.\n\nPaster Templates\n----------------\n\n- The routesalchemy template has been updated to use ``pattern`` in\n its route declarations rather than ``path``.\n\nDependencies\n------------\n\n- ``tests_require`` now includes ``repoze.sphinx.autointerface`` as a\n dependency.\n\nInternal\n--------\n\n- Add an API to the ``Configurator`` named ``get_routes_mapper``.\n This returns an object implementing the ``IRoutesMapper`` interface.\n\n- The ``repoze.bfg.urldispatch.RoutesMapper`` object now has a\n ``get_route`` method which returns a single Route object or\n ``None``.\n\n- A new interface ``repoze.bfg.interfaces.IRoute`` was added. The\n ``repoze.bfg.urldispatch.Route`` object implements this interface.\n\n- The canonical attribute for accessing the routing pattern from a\n route object is now ``pattern`` rather than ``path``.\n\n- Use ``hash()`` rather than ``id()`` when computing the \"phash\" of a\n custom route/view predicate in order to allow the custom predicate\n some control over which predicates are \"equal\".\n\n- Use ``response.headerlist.append`` instead of\n ``response.headers.add`` in\n ``repoze.bfg.request.add_global_response_headers`` in case the\n response is not a WebOb response.\n\n- The ``repoze.bfg.urldispatch.Route`` constructor (not an API) now\n accepts a different ordering of arguments. Previously it was\n ``(pattern, name, factory=None, predicates=())``. It is now\n ``(name, pattern, factory=None, predicates=())``. This is in\n support of consistency with ``configurator.add_route``.\n\n- The ``repoze.bfg.urldispatch.RoutesMapper.connect`` method (not an\n API) now accepts a different ordering of arguments. Previously it\n was ``(pattern, name, factory=None, predicates=())``. It is now\n ``(name, pattern, factory=None, predicates=())``. This is in\n support of consistency with ``configurator.add_route``.\n\n1.3a11 (2010-09-05)\n===================\n\nBug Fixes\n---------\n\n- Process the response callbacks and the NewResponse event earlier, to\n enable mutations to the response to take effect.\n\n1.3a10 (2010-09-05)\n===================\n\nFeatures\n--------\n\n- A new ``repoze.bfg.request.Request.add_response_callback`` API has\n been added. This method is documented in the new\n ``repoze.bfg.request`` API chapter. It can be used to influence\n response values before a concrete response object has been created.\n\n- The ``repoze.bfg.interfaces.INewResponse`` interface now includes a\n ``request`` attribute; as a result, a handler for INewResponse now\n has access to the request which caused the response.\n\n- Each of the follow methods of the Configurator now allow the\n below-named arguments to be passed as \"dotted name strings\"\n (e.g. \"foo.bar.baz\") rather than as actual implementation objects\n that must be imported:\n\n setup_registry\n root_factory, authentication_policy, authorization_policy,\n debug_logger, locale_negotiator, request_factory,\n renderer_globals_factory\n\n add_subscriber\n subscriber, iface\n\n derive_view\n view\n\n add_view\n view, ``for_``, context, request_type, containment\n\n add_route()\n view, view_for, factory, ``for_``, view_context\n\n scan\n package\n\n add_renderer\n factory\n\n set_forbidden_view\n view\n\n set_notfound_view\n view\n\n set_request_factory\n factory\n\n set_renderer_globals_factory()\n factory\n\n set_locale_negotiator\n negotiator\n\n testing_add_subscriber\n event_iface\n\nBug Fixes\n---------\n\n- The route pattern registered internally for a a local \"static view\"\n (either via the ``static`` ZCML directive or via the\n ``add_static_view`` method of the configurator) was incorrect. It\n was regsistered for e.g. ``static*traverse``, while it should have\n been registered for ``static/*traverse``. Symptom: two static views\n could not reliably be added to a system when they both shared the\n same path prefix (e.g. ``/static`` and ``/static2``).\n\nBackwards Incompatibilities\n---------------------------\n\n- The INewResponse event is now not sent to listeners if the response\n returned by view code (or a renderer) is not a \"real\" response\n (e.g. if it does not have ``.status``, ``.headerlist`` and\n ``.app_iter`` attribtues).\n\nDocumentation\n-------------\n\n- Add an API chapter for the ``repoze.bfg.request`` module, which\n includes documentation for the ``repoze.bfg.request.Request`` class\n (the \"request object\").\n\n- Modify the \"Request and Response\" narrative chapter to reference the\n new ``repoze.bfg.request`` API chapter. Some content was moved from\n this chapter into the API documentation itself.\n\n- Various changes to denote that Python dotted names are now allowed\n as input to Configurator methods.\n\nInternal\n--------\n\n- The (internal) feature which made it possible to attach a\n ``global_response_headers`` attribute to the request (which was\n assumed to contain a sequence of header key/value pairs which would\n later be added to the response by the router), has been removed.\n The functionality of\n ``repoze.bfg.request.Request.add_response_callback`` takes its\n place.\n\n- The ``repoze.bfg.events.NewResponse`` class's construct has changed:\n it now must be created with ``(request, response)`` rather than\n simply ``(response)``.\n\n1.3a9 (2010-08-22)\n==================\n\nFeatures\n--------\n\n- The Configurator now accepts a dotted name *string* to a package as\n a ``package`` constructor argument. The ``package`` argument was\n previously required to be a package *object* (not a dotted name\n string).\n\n- The ``repoze.bfg.configuration.Configurator.with_package`` method\n was added. This method returns a new Configurator using the same\n application registry as the configurator object it is called\n upon. The new configurator is created afresh with its ``package``\n constructor argument set to the value passed to ``with_package``.\n This feature will make it easier for future BFG versions to allow\n dotted names as arguments in places where currently only object\n references are allowed (the work to allow dotted names isntead of\n object references everywhere has not yet been done, however).\n\n- The new ``repoze.bfg.configuration.Configurator.maybe_dotted``\n method resolves a Python dotted name string supplied as its\n ``dotted`` argument to a global Python object. If the value cannot\n be resolved, a ``repoze.bfg.configuration.ConfigurationError`` is\n raised. If the value supplied as ``dotted`` is not a string, the\n value is returned unconditionally without any resolution attempted.\n\n- The new\n ``repoze.bfg.configuration.Configurator.absolute_resource_spec``\n method resolves a potentially relative \"resource specification\"\n string into an absolute version. If the value supplied as\n ``relative_spec`` is not a string, the value is returned\n unconditionally without any resolution attempted.\n\nBackwards Incompatibilities\n---------------------------\n\n- The functions in ``repoze.bfg.renderers`` named ``render`` and\n ``render_to_response`` introduced in 1.3a6 previously took a set of\n ``**values`` arguments for the values to be passed to the renderer.\n This was wrong, as renderers don't need to accept only dictionaries\n (they can accept any type of object). Now, the value sent to the\n renderer must be supplied as a positional argument named ``value``.\n The ``request`` argument is still a keyword argument, however.\n\n- The functions in ``repoze.bfg.renderers`` named ``render`` and\n ``render_to_response`` now accept an additonal keyword argument\n named ``package``.\n\n- The ``get_renderer`` API in ``repoze.bfg.renderers`` now accepts a\n ``package`` argument.\n\nDocumentation\n-------------\n\n- The ZCML ``include`` directive docs were incorrect: they specified\n ``filename`` rather than (the correct) ``file`` as an allowable\n attribute.\n\nInternal\n--------\n\n- The ``repoze.bfg.resource.resolve_resource_spec`` function can now\n accept a package object as its ``pname`` argument instead of just a\n package name.\n\n- The ``_renderer_factory_from_name`` and ``_renderer_from_name``\n methods of the Configurator were removed. These were never APIs.\n\n- The ``_render``, ``_render_to_response`` and ``_make_response``\n functions with ``repoze.bfg.render`` (added in 1.3a6) have been\n removed.\n\n- A new helper class ``repoze.bfg.renderers.RendererHelper`` was\n added.\n\n- The _map_view function of ``repoze.bfg.configuration`` now takes\n only a renderer_name argument instead of both a ``renderer`` and\n ``renderer``_name argument. It also takes a ``package`` argument\n now.\n\n- Use ``imp.get_suffixes`` indirection in\n ``repoze.bfg.path.package_name`` instead of hardcoded ``.py``\n ``.pyc`` and ``.pyo`` to use for comparison when attemtping to\n decide if a directory is a package.\n\n- Make tests runnable again under Jython (although they do not all\n pass currently).\n\n- The reify decorator now maintains the docstring of the function it\n wraps.\n\n1.3a8 (2010-08-08)\n==================\n\nFeatures\n--------\n\n- New public interface: ``repoze.bfg.exceptions.IExceptionResponse``.\n This interface is provided by all internal exception classes (such\n as ``repoze.bfg.exceptions.NotFound`` and\n ``repoze.bfg.exceptions.Forbidden``), instances of which are both\n exception objects and can behave as WSGI response objects. This\n interface is made public so that exception classes which are also\n valid WSGI response factories can be configured to implement them or\n exception instances which are also or response instances can be\n configured to provide them.\n\n- New API class: ``repoze.bfg.view.AppendSlashNotFoundViewFactory``.\n\n There can only be one Not Found view in any ``repoze.bfg``\n application. Even if you use\n ``repoze.bfg.view.append_slash_notfound_view`` as the Not Found\n view, ``repoze.bfg`` still must generate a ``404 Not Found``\n response when it cannot redirect to a slash-appended URL; this not\n found response will be visible to site users.\n\n If you don't care what this 404 response looks like, and you only\n need redirections to slash-appended route URLs, you may use the\n ``repoze.bfg.view.append_slash_notfound_view`` object as the Not\n Found view. However, if you wish to use a *custom* notfound view\n callable when a URL cannot be redirected to a slash-appended URL,\n you may wish to use an instance of the\n ``repoze.bfg.view.AppendSlashNotFoundViewFactory`` class as the Not\n Found view, supplying the notfound view callable as the first\n argument to its constructor. For instance::\n\n from repoze.bfg.exceptions import NotFound\n from repoze.bfg.view import AppendSlashNotFoundViewFactory\n\n def notfound_view(context, request):\n return HTTPNotFound('It aint there, stop trying!')\n\n custom_append_slash = AppendSlashNotFoundViewFactory(notfound_view)\n config.add_view(custom_append_slash, context=NotFound)\n\n The ``notfound_view`` supplied must adhere to the two-argument view\n callable calling convention of ``(context, request)`` (``context``\n will be the exception object).\n\nDocumentation\n--------------\n\n- Expanded the \"Cleaning Up After a Request\" section of the URL\n Dispatch narrative chapter.\n\n- Expanded the \"Redirecting to Slash-Appended Routes\" section of the\n URL Dispatch narrative chapter.\n\nInternal\n--------\n\n- Previously, two default view functions were registered at\n Configurator setup (one for ``repoze.bfg.exceptions.NotFound`` named\n ``default_notfound_view`` and one for\n ``repoze.bfg.exceptions.Forbidden`` named\n ``default_forbidden_view``) to render internal exception responses.\n Those default view functions have been removed, replaced with a\n generic default view function which is registered at Configurator\n setup for the ``repoze.bfg.interfaces.IExceptionResponse`` interface\n that simply returns the exception instance; the ``NotFound`` and\n ``Forbidden`` classes are now still exception factories but they are\n also response factories which generate instances that implement the\n new ``repoze.bfg.interfaces.IExceptionResponse`` interface.\n\n1.3a7 (2010-08-01)\n==================\n\nFeatures\n--------\n\n- The ``repoze.bfg.configuration.Configurator.add_route`` API now\n returns the route object that was added.\n\n- A ``repoze.bfg.events.subscriber`` decorator was added. This\n decorator decorates module-scope functions, which are then treated\n as event listeners after a scan() is performed. See the Events\n narrative documentation chapter and the ``repoze.bfg.events`` module\n documentation for more information.\n\nBug Fixes\n---------\n\n- When adding a view for a route which did not yet exist (\"did not yet\n exist\" meaning, temporally, a view was added with a route name for a\n route which had not yet been added via add_route), the value of the\n ``custom_predicate`` argument to ``add_view`` was lost. Symptom:\n wrong view matches when using URL dispatch and custom view\n predicates together.\n\n- Pattern matches for a ``:segment`` marker in a URL dispatch route\n pattern now always match at least one character. See \"Backwards\n Incompatibilities\" below in this changelog.\n\nBackwards Incompatibilities\n---------------------------\n\n- A bug existed in the regular expression to do URL matching. As an\n example, the URL matching machinery would cause the pattern\n ``/{foo}`` to match the root URL ``/`` resulting in a match\n dictionary of ``{'foo':u''}`` or the pattern ``/{fud}/edit might\n match the URL ``//edit`` resulting in a match dictionary of\n ``{'fud':u''}``. It was always the intent that ``:segment`` markers\n in the pattern would need to match *at least one* character, and\n never match the empty string. This, however, means that in certain\n circumstances, a routing match which your application inadvertently\n depended upon may no longer happen.\n\nDocumentation\n--------------\n\n- Added description of the ``repoze.bfg.events.subscriber`` decorator\n to the Events narrative chapter.\n\n- Added ``repoze.bfg.events.subscriber`` API documentation to\n ``repoze.bfg.events`` API docs.\n\n- Added a section named \"Zope 3 Enforces 'TTW' Authorization Checks By\n Default; BFG Does Not\" to the \"Design Defense\" chapter.\n\n1.3a6 (2010-07-25)\n==================\n\nFeatures\n--------\n\n- New argument to ``repoze.bfg.configuration.Configurator.add_route``\n and the ``route`` ZCML directive: ``traverse``. If you would like\n to cause the ``context`` to be something other than the ``root``\n object when this route matches, you can spell a traversal pattern as\n the ``traverse`` argument. This traversal pattern will be used as\n the traversal path: traversal will begin at the root object implied\n by this route (either the global root, or the object returned by the\n ``factory`` associated with this route).\n\n The syntax of the ``traverse`` argument is the same as it is for\n ``path``. For example, if the ``path`` provided is\n ``articles/:article/edit``, and the ``traverse`` argument provided\n is ``/:article``, when a request comes in that causes the route to\n match in such a way that the ``article`` match value is '1' (when\n the request URI is ``/articles/1/edit``), the traversal path will be\n generated as ``/1``. This means that the root object's\n ``__getitem__`` will be called with the name ``1`` during the\n traversal phase. If the ``1`` object exists, it will become the\n ``context`` of the request. The Traversal narrative has more\n information about traversal.\n\n If the traversal path contains segment marker names which are not\n present in the path argument, a runtime error will occur. The\n ``traverse`` pattern should not contain segment markers that do not\n exist in the ``path``.\n\n A similar combining of routing and traversal is available when a\n route is matched which contains a ``*traverse`` remainder marker in\n its path. The ``traverse`` argument allows you to associate route\n patterns with an arbitrary traversal path without using a a\n ``*traverse`` remainder marker; instead you can use other match\n information.\n\n Note that the ``traverse`` argument is ignored when attached to a\n route that has a ``*traverse`` remainder marker in its path.\n\n- A new method of the ``Configurator`` exists:\n ``set_request_factory``. If used, this method will set the factory\n used by the ``repoze.bfg`` router to create all request objects.\n\n- The ``Configurator`` constructor takes an additional argument:\n ``request_factory``. If used, this argument will set the factory\n used by the ``repoze.bfg`` router to create all request objects.\n\n- The ``Configurator`` constructor takes an additional argument:\n ``request_factory``. If used, this argument will set the factory\n used by the ``repoze.bfg`` router to create all request objects.\n\n- A new method of the ``Configurator`` exists:\n ``set_renderer_globals_factory``. If used, this method will set the\n factory used by the ``repoze.bfg`` router to create renderer\n globals.\n\n- A new method of the ``Configurator`` exists: ``get_settings``. If\n used, this method will return the current settings object (performs\n the same job as the ``repoze.bfg.settings.get_settings`` API).\n\n- The ``Configurator`` constructor takes an additional argument:\n ``renderer_globals_factory``. If used, this argument will set the\n factory used by the ``repoze.bfg`` router to create renderer\n globals.\n\n- Add ``repoze.bfg.renderers.render``,\n ``repoze.bfg.renderers.render_to_response`` and\n ``repoze.bfg.renderers.get_renderer`` functions. These are\n imperative APIs which will use the same rendering machinery used by\n view configurations with a ``renderer=`` attribute/argument to\n produce a rendering or renderer. Because these APIs provide a\n central API for all rendering, they now form the preferred way to\n perform imperative template rendering. Using functions named\n ``render_*`` from modules such as ``repoze.bfg.chameleon_zpt`` and\n ``repoze.bfg.chameleon_text`` is now discouraged (although not\n deprecated). The code the backing older templating-system-specific\n APIs now calls into the newer ``repoze.bfg.renderer`` code.\n\n- The ``repoze.bfg.configuration.Configurator.testing_add_template``\n has been renamed to ``testing_add_renderer``. A backwards\n compatibility alias is present using the old name.\n\nDocumentation\n-------------\n\n- The ``Hybrid`` narrative chapter now contains a description of the\n ``traverse`` route argument.\n\n- The ``Hooks`` narrative chapter now contains sections about\n changing the request factory and adding a renderer globals factory.\n\n- The API documentation includes a new module:\n ``repoze.bfg.renderers``.\n\n- The ``Templates`` chapter was updated; all narrative that used\n templating-specific APIs within examples to perform rendering (such\n as the ``repoze.bfg.chameleon_zpt.render_template_to_response``\n method) was changed to use ``repoze.bfg.renderers.render_*``\n functions.\n\nBug Fixes\n---------\n\n- The ``header`` predicate (when used as either a view predicate or a\n route predicate) had a problem when specified with a name/regex\n pair. When the header did not exist in the headers dictionary, the\n regex match could be fed ``None``, causing it to throw a\n ``TypeError: expected string or buffer`` exception. Now, the\n predicate returns False as intended.\n\nDeprecations\n------------\n\n- The ``repoze.bfg.renderers.rendered_response`` function was never an\n official API, but may have been imported by extensions in the wild.\n It is officially deprecated in this release. Use\n ``repoze.bfg.renderers.render_to_response`` instead.\n\n- The following APIs are *documentation* deprecated (meaning they are\n officially deprecated in documentation but do not raise a\n deprecation error upon their usage, and may continue to work for an\n indefinite period of time):\n\n In the ``repoze.bfg.chameleon_zpt`` module: ``get_renderer``,\n ``get_template``, ``render_template``,\n ``render_template_to_response``. The suggested alternatives are\n documented within the docstrings of those methods (which are still\n present in the documentation).\n\n In the ``repoze.bfg.chameleon_text`` module: ``get_renderer``,\n ``get_template``, ``render_template``,\n ``render_template_to_response``. The suggested alternatives are\n documented within the docstrings of those methods (which are still\n present in the documentation).\n\n In general, to perform template-related functions, one should now\n use the various methods in the ``repoze.bfg.renderers`` module.\n\nBackwards Incompatibilities\n---------------------------\n\n- A new internal exception class (*not* an API) named\n ``repoze.bfg.exceptions.PredicateMismatch`` now exists. This\n exception is currently raised when no constituent view of a\n multiview can be called (due to no predicate match). Previously, in\n this situation, a ``repoze.bfg.exceptions.NotFound`` was raised. We\n provide backwards compatibility for code that expected a\n ``NotFound`` to be raised when no predicates match by causing\n ``repoze.bfg.exceptions.PredicateMismatch`` to inherit from\n ``NotFound``. This will cause any exception view registered for\n ``NotFound`` to be called when a predicate mismatch occurs, as was\n the previous behavior.\n\n There is however, one perverse case that will expose a backwards\n incompatibility. If 1) you had a view that was registered as a\n member of a multiview 2) this view explicitly raised a ``NotFound``\n exception *in order to* proceed to the next predicate check in the\n multiview, that code will now behave differently: rather than\n skipping to the next view match, a NotFound will be raised to the\n top-level exception handling machinery instead. For code to be\n depending upon the behavior of a view raising ``NotFound`` to\n proceed to the next predicate match, would be tragic, but not\n impossible, given that ``NotFound`` is a public interface.\n ``repoze.bfg.exceptions.PredicateMismatch`` is not a public API and\n cannot be depended upon by application code, so you should not\n change your view code to raise ``PredicateMismatch``. Instead, move\n the logic which raised the ``NotFound`` exception in the view out\n into a custom view predicate.\n\n- If, when you run your application's unit test suite under BFG 1.3, a\n ``KeyError`` naming a template or a ``ValueError`` indicating that a\n 'renderer factory' is not registered may is raised\n (e.g. ``ValueError: No factory for renderer named '.pt' when looking\n up karl.views:templates/snippets.pt``), you may need to perform some\n extra setup in your test code.\n\n The best solution is to use the\n ``repoze.bfg.configuration.Configurator.testing_add_renderer`` (or,\n alternately the deprecated\n ``repoze.bfg.testing.registerTemplateRenderer`` or\n ``registerDummyRenderer``) API within the code comprising each\n individual unit test suite to register a \"dummy\" renderer for each\n of the templates and renderers used by code under test. For\n example::\n\n config = Configurator()\n config.testing_add_renderer('karl.views:templates/snippets.pt')\n\n This will register a basic dummy renderer for this particular\n missing template. The ``testing_add_renderer`` API actually\n *returns* the renderer, but if you don't care about how the render\n is used, you don't care about having a reference to it either.\n\n A more rough way to solve the issue exists. It causes the \"real\"\n template implementations to be used while the system is under test,\n which is suboptimal, because tests will run slower, and unit tests\n won't actually *be* unit tests, but it is easier. Always ensure you\n call the ``setup_registry()`` method of the Configurator . Eg::\n\n reg = MyRegistry()\n config = Configurator(registry=reg)\n config.setup_registry()\n\n Calling ``setup_registry`` only has an effect if you're *passing in*\n a ``registry`` argument to the Configurator constructor.\n ``setup_registry`` is called by the course of normal operations\n anyway if you do not pass in a ``registry``.\n\n If your test suite isn't using a Configurator yet, and is still\n using the older ``repoze.bfg.testing`` APIs name ``setUp`` or\n ``cleanUp``, these will register the renderers on your behalf.\n\n A variant on the symptom for this theme exists: you may already be\n dutifully registering a dummy template or renderer for a template\n used by the code you're testing using ``testing_register_renderer``\n or ``registerTemplateRenderer``, but (perhaps unbeknownst to you)\n the code under test expects to be able to use a \"real\" template\n renderer implementation to retrieve or render *another* template\n that you forgot was being rendered as a side effect of calling the\n code you're testing. This happened to work because it found the\n *real* template while the system was under test previously, and now\n it cannot. The solution is the same.\n\n It may also help reduce confusion to use a *resource specification*\n to specify the template path in the test suite and code rather than\n a relative path in either. A resource specification is unambiguous,\n while a relative path needs to be relative to \"here\", where \"here\"\n isn't always well-defined (\"here\" in a test suite may or may not be\n the same as \"here\" in the code under test).\n\n1.3a5 (2010-07-14)\n==================\n\nFeatures\n--------\n\n- New internal exception: ``repoze.bfg.exceptions.URLDecodeError``.\n This URL is a subclass of the built-in Python exception named\n ``UnicodeDecodeError``.\n\n- When decoding a URL segment to Unicode fails, the exception raised\n is now ``repoze.bfg.exceptions.URLDecodeError`` instead of\n ``UnicodeDecodeError``. This makes it possible to register an\n exception view invoked specifically when ``repoze.bfg`` cannot\n decode a URL.\n\nBug Fixes\n---------\n\n- Fix regression in\n ``repoze.bfg.configuration.Configurator.add_static_view``. Before\n 1.3a4, view names that contained a slash were supported as route\n prefixes. 1.3a4 broke this by trying to treat them as full URLs.\n\nDocumentation\n-------------\n\n- The ``repoze.bfg.exceptions.URLDecodeError`` exception was added to\n the exceptions chapter of the API documentation.\n\nBackwards Incompatibilities\n----------------------------\n\n- in previous releases, when a URL could not be decoded from UTF-8\n during traversal, a ``TypeError`` was raised. Now the error which\n is raised is a ``repoze.bfg.exceptions.URLDecodeError``.\n\n1.3a4 (2010-07-03)\n==================\n\nFeatures\n--------\n\n- Undocumented hook: make ``get_app`` and ``get_root`` of the\n ``repoze.bfg.paster.BFGShellCommand`` hookable in cases where\n endware may interfere with the default versions.\n\n- In earlier versions, a custom route predicate associated with a url\n dispatch route (each of the predicate functions fed to the\n ``custom_predicates`` argument of\n ``repoze.bfg.configuration.Configurator.add_route``) has always\n required a 2-positional argument signature, e.g. ``(context,\n request)``. Before this release, the ``context`` argument was\n always ``None``.\n\n As of this release, the first argument passed to a predicate is now\n a dictionary conventionally named ``info`` consisting of ``route``,\n and ``match``. ``match`` is a dictionary: it represents the\n arguments matched in the URL by the route. ``route`` is an object\n representing the route which was matched.\n\n This is useful when predicates need access to the route match. For\n example::\n\n def any_of(segment_name, *args):\n def predicate(info, request):\n if info['match'][segment_name] in args:\n return True\n return predicate\n\n num_one_two_or_three = any_of('num, 'one', 'two', 'three')\n\n add_route('num', '/:num', custom_predicates=(num_one_two_or_three,))\n\n The ``route`` object is an object that has two useful attributes:\n ``name`` and ``path``. The ``name`` attribute is the route name.\n The ``path`` attribute is the route pattern. An example of using\n the route in a set of route predicates::\n\n def twenty_ten(info, request):\n if info['route'].name in ('ymd', 'ym', 'y'):\n return info['match']['year'] == '2010'\n\n add_route('y', '/:year', custom_predicates=(twenty_ten,))\n add_route('ym', '/:year/:month', custom_predicates=(twenty_ten,))\n add_route('ymd', '/:year/:month:/day', custom_predicates=(twenty_ten,))\n\n- The ``repoze.bfg.url.route_url`` API has changed. If a keyword\n ``_app_url`` is present in the arguments passed to ``route_url``,\n this value will be used as the protocol/hostname/port/leading path\n prefix of the generated URL. For example, using an ``_app_url`` of\n ``http://example.com:8080/foo`` would cause the URL\n ``http://example.com:8080/foo/fleeb/flub`` to be returned from this\n function if the expansion of the route pattern associated with the\n ``route_name`` expanded to ``/fleeb/flub``.\n\n- It is now possible to use a URL as the ``name`` argument fed to\n ``repoze.bfg.configuration.Configurator.add_static_view``. When the\n name argument is a URL, the ``repoze.bfg.url.static_url`` API will\n generate join this URL (as a prefix) to a path including the static\n file name. This makes it more possible to put static media on a\n separate webserver for production, while keeping static media\n package-internal and served by the development webserver during\n development.\n\nDocumentation\n-------------\n\n- The authorization chapter of the ZODB Wiki Tutorial\n (docs/tutorials/bfgwiki) was changed to demonstrate authorization\n via a group rather than via a direct username (thanks to Alex\n Marandon).\n\n- The authorization chapter of the SQLAlchemy Wiki Tutorial\n (docs/tutorials/bfgwiki2) was changed to demonstrate authorization\n via a group rather than via a direct username.\n\n- Redirect requests for tutorial sources to\n http://docs.repoze.org/bfgwiki-1.3 and\n http://docs.repoze.org/bfgwiki2-1.3/ respectively.\n\n- A section named ``Custom Route Predicates`` was added to the URL\n Dispatch narrative chapter.\n\n- The Static Resources chapter has been updated to mention using\n ``static_url`` to generate URLs to external webservers.\n\nInternal\n--------\n\n- Removed ``repoze.bfg.static.StaticURLFactory`` in favor of a new\n abstraction revolving around the (still-internal)\n ``repoze.bfg.static.StaticURLInfo`` helper class.\n\n1.3a3 (2010-05-01)\n==================\n\nPaster Templates\n----------------\n\n- The ``bfg_alchemy`` and ``bfg_routesalchemy`` templates no longer\n register a ``handle_teardown`` event listener which calls\n ``DBSession.remove``. This was found by Chris Withers to be\n unnecessary.\n\nDocumentation\n-------------\n\n- The \"bfgwiki2\" (URL dispatch wiki) tutorial code and documentation\n was changed to remove the ``handle_teardown`` event listener which\n calls ``DBSession.remove``.\n\n- Any mention of the ``handle_teardown`` event listener as used by the\n paster templates was removed from the URL Dispatch narrative chapter.\n\n- A section entitled Detecting Available Languages was added to the\n i18n narrative docs chapter.\n\n1.3a2 (2010-04-28)\n==================\n\nFeatures\n--------\n\n- A locale negotiator no longer needs to be registered explicitly. The\n default locale negotiator at\n ``repoze.bfg.i18n.default_locale_negotiator`` is now used\n unconditionally as... um, the default locale negotiator.\n\n- The default locale negotiator has become more complex.\n\n * First, the negotiator looks for the ``_LOCALE_`` attribute of\n the request object (possibly set by a view or an event listener).\n \n * Then it looks for the ``request.params['_LOCALE_']`` value.\n\n * Then it looks for the ``request.cookies['_LOCALE_']`` value.\n\nBackwards Incompatibilities\n---------------------------\n\n- The default locale negotiator now looks for the parameter named\n ``_LOCALE_`` rather than a parameter named ``locale`` in\n ``request.params``.\n\nBehavior Changes\n----------------\n\n- A locale negotiator may now return ``None``, signifying that the\n default locale should be used.\n\nDocumentation\n-------------\n\n- Documentation concerning locale negotiation in the\n Internationalizationa and Localization chapter was updated.\n\n- Expanded portion of i18n narrative chapter docs which discuss\n working with gettext files.\n\n1.3a1 (2010-04-26)\n==================\n\nFeatures\n--------\n\n- Added \"exception views\". When you use an exception (anything that\n inherits from the Python ``Exception`` builtin) as view context\n argument, e.g.::\n\n from repoze.bfg.view import bfg_view\n from repoze.bfg.exceptions import NotFound\n from webob.exc import HTTPNotFound\n\n @bfg_view(context=NotFound)\n def notfound_view(request):\n return HTTPNotFound()\n\n For the above example, when the ``repoze.bfg.exceptions.NotFound``\n exception is raised by any view or any root factory, the\n ``notfound_view`` view callable will be invoked and its response\n returned.\n\n Other normal view predicates can also be used in combination with an\n exception view registration::\n\n from repoze.bfg.view import bfg_view\n from repoze.bfg.exceptions import NotFound\n from webob.exc import HTTPNotFound\n\n @bfg_view(context=NotFound, route_name='home')\n def notfound_view(request):\n return HTTPNotFound()\n\n The above exception view names the ``route_name`` of ``home``,\n meaning that it will only be called when the route matched has a\n name of ``home``. You can therefore have more than one exception\n view for any given exception in the system: the \"most specific\" one\n will be called when the set of request circumstances which match the\n view registration. The only predicate that cannot be not be used\n successfully is ``name``. The name used to look up an exception\n view is always the empty string.\n\n Existing (pre-1.3) normal views registered against objects\n inheriting from ``Exception`` will continue to work. Exception\n views used for user-defined exceptions and system exceptions used as\n contexts will also work.\n\n The feature can be used with any view registration mechanism\n (``@bfg_view`` decorator, ZCML, or imperative ``config.add_view``\n styles).\n\n This feature was kindly contributed by Andrey Popp.\n\n- Use \"Venusian\" (`http://docs.repoze.org/venusian\n `_) to perform ``bfg_view``\n decorator scanning rather than relying on a BFG-internal decorator\n scanner. (Truth be told, Venusian is really just a generalization\n of the BFG-internal decorator scanner).\n\n- Internationalization and localization features as documented in the\n narrative documentation chapter entitled ``Internationalization and\n Localization``.\n\n- A new deployment setting named ``default_locale_name`` was added.\n If this string is present as a Paster ``.ini`` file option, it will\n be considered the default locale name. The default locale name is\n used during locale-related operations such as language translation.\n\n- It is now possible to turn on Chameleon template \"debugging mode\"\n for all Chameleon BFG templates by setting a BFG-related Paster\n ``.ini`` file setting named ``debug_templates``. The exceptions\n raised by Chameleon templates when a rendering fails are sometimes\n less than helpful. ``debug_templates`` allows you to configure your\n application development environment so that exceptions generated by\n Chameleon during template compilation and execution will contain\n more helpful debugging information. This mode is on by default in\n all new projects.\n\n- Add a new method of the Configurator named ``derive_view`` which can\n be used to generate a BFG view callable from a user-supplied\n function, instance, or class. This useful for external framework and\n plugin authors wishing to wrap callables supplied by their users\n which follow the same calling conventions and response conventions\n as objects that can be supplied directly to BFG as a view callable.\n See the ``derive_view`` method in the\n ``repoze.bfg.configuration.Configurator`` docs.\n\nZCML\n----\n\n- Add a ``translationdir`` ZCML directive to support localization.\n\n- Add a ``localenegotiator`` ZCML directive to support localization.\n\nDeprecations\n------------\n\n- The exception views feature replaces the need for the\n ``set_notfound_view`` and ``set_forbidden_view`` methods of the\n ``Configurator`` as well as the ``notfound`` and ``forbidden`` ZCML\n directives. Those methods and directives will continue to work for\n the foreseeable future, but they are deprecated in the\n documentation.\n\nDependencies\n------------\n\n- A new install-time dependency on the ``venusian`` distribution was\n added.\n\n- A new install-time dependency on the ``translationstring``\n distribution was added.\n\n- Chameleon 1.2.3 or better is now required (internationalization and\n per-template debug settings).\n\nInternal\n--------\n\n- View registrations and lookups are now done with three \"requires\"\n arguments instead of two to accomodate orthogonality of exception\n views.\n\n- The ``repoze.bfg.interfaces.IForbiddenView`` and\n ``repoze.bfg.interfaces.INotFoundView`` interfaces were removed;\n they weren't APIs and they became vestigial with the addition of\n exception views.\n\n- Remove ``repoze.bfg.compat.pkgutil_26.py`` and import alias\n ``repoze.bfg.compat.walk_packages``. These were only required by\n internal scanning machinery; Venusian replaced the internal scanning\n machinery, so these are no longer required.\n\nDocumentation\n-------------\n\n- Exception view documentation was added to the ``Hooks`` narrative\n chapter.\n\n- A new narrative chapter entitled ``Internationalization and\n Localization`` was added.\n\n- The \"Environment Variables and ``ini`` File Settings\" chapter was\n changed: documentation about the ``default_locale_name`` setting was\n added.\n\n- A new API chapter for the ``repoze.bfg.i18n`` module was added.\n\n- Documentation for the new ``translationdir`` and\n ``localenegotiator`` ZCML directives were added.\n\n- A section was added to the Templates chapter entitled \"Nicer\n Exceptions in Templates\" describing the result of setting\n ``debug_templates = true``.\n\nPaster Templates\n----------------\n\n- All paster templates now create a ``setup.cfg`` which includes\n commands related to nose testing and Babel message catalog\n extraction/compilation.\n\n- A ``default_locale_name = en`` setting was added to each existing paster\n template.\n\n- A ``debug_templates = true`` setting was added to each existing\n paster template.\n\nLicensing\n---------\n\n- The Edgewall (BSD) license was added to the LICENSES.txt file, as\n some code in the ``repoze.bfg.i18n`` derives from Babel source.", "description_content_type": null, "docs_url": null, "download_url": "UNKNOWN", "downloads": { "last_day": -1, "last_month": -1, "last_week": -1 }, "home_page": "http://bfg.repoze.org", "keywords": "web wsgi bfg", "license": "BSD-derived (http://www.repoze.org/LICENSE.txt)", "maintainer": null, "maintainer_email": null, "name": "repoze.bfg", "package_url": "https://pypi.org/project/repoze.bfg/", "platform": "UNKNOWN", "project_url": "https://pypi.org/project/repoze.bfg/", "project_urls": { "Download": "UNKNOWN", "Homepage": "http://bfg.repoze.org" }, "release_url": "https://pypi.org/project/repoze.bfg/1.3/", "requires_dist": null, "requires_python": null, "summary": "The repoze.bfg web application framework", "version": "1.3" }, "last_serial": 798789, "releases": { "1.0.1": [ { "comment_text": "", "digests": { "md5": "ec2fd6866c1c459cc5c66b28a5e1adad", "sha256": "80e93c41465259a87fcd435870a6eb715f1941502c719b1d11e8da73f58d3e06" }, "downloads": -1, "filename": "repoze.bfg-1.0.1.tar.gz", "has_sig": false, "md5_digest": "ec2fd6866c1c459cc5c66b28a5e1adad", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 730273, "upload_time": "2009-08-22T01:45:06", "url": "https://files.pythonhosted.org/packages/1e/fa/afaeafd88043114dcd8262c2f05b8e4974f2ab3e4d2ab94ac8494e14418b/repoze.bfg-1.0.1.tar.gz" } ], "1.1": [ { "comment_text": "", "digests": { "md5": "f83bd3d7d511849e40b06aa71569dc64", "sha256": "217c8ee196b7d84922f2537799419949879ae4e447b3589411324ac6493a57bb" }, "downloads": -1, "filename": "repoze.bfg-1.1.tar.gz", "has_sig": false, "md5_digest": "f83bd3d7d511849e40b06aa71569dc64", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1098534, "upload_time": "2009-11-16T04:12:50", "url": "https://files.pythonhosted.org/packages/6b/f6/f5630250ce6c8fd07ee5a4f77f5566912165088ee0f69f072f2042f59662/repoze.bfg-1.1.tar.gz" } ], "1.1.1": [ { "comment_text": "", "digests": { "md5": "73ffaf7e5528a5dd0aa3918b772c03be", "sha256": "16f7458f8794f83f315ee1b138b2dc75c4c6beb04005c7d68d52da60b64e0194" }, "downloads": -1, "filename": "repoze.bfg-1.1.1.tar.gz", "has_sig": false, "md5_digest": "73ffaf7e5528a5dd0aa3918b772c03be", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1099475, "upload_time": "2009-11-21T06:14:40", "url": "https://files.pythonhosted.org/packages/4e/95/838dcf05d44a5387e0fb17c849f4b2ee27fb6579abd515fd2073b68ab75f/repoze.bfg-1.1.1.tar.gz" } ], "1.1.2": [ { "comment_text": "", "digests": { "md5": "a919f521a18c670d56abfe5b2fb80db2", "sha256": "d4168ce0016ee97e1d4e6b072f0a5b45d6c4194ae98d5dd7031e78b10d553047" }, "downloads": -1, "filename": "repoze.bfg-1.1.2.tar.gz", "has_sig": false, "md5_digest": "a919f521a18c670d56abfe5b2fb80db2", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1102725, "upload_time": "2009-11-26T18:49:38", "url": "https://files.pythonhosted.org/packages/33/b9/79fef305f293205764a9f2683ae5e21b29e54c137a872817c2cce0de99d2/repoze.bfg-1.1.2.tar.gz" } ], "1.1.3": [ { "comment_text": "", "digests": { "md5": "574064e608aef82b31f3015f670e0359", "sha256": "aa21ff16b12f465894049ec75c82ee3665e42ab6f165b4a60bee1535ac4a67c9" }, "downloads": -1, "filename": "repoze.bfg-1.1.3.tar.gz", "has_sig": false, "md5_digest": "574064e608aef82b31f3015f670e0359", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1102928, "upload_time": "2009-12-02T16:20:42", "url": "https://files.pythonhosted.org/packages/40/eb/00e5e2909aae0d466b76ff26d3969976e9dc3df66ee76d2e065fa3d6eb82/repoze.bfg-1.1.3.tar.gz" } ], "1.1.4": [ { "comment_text": "", "digests": { "md5": "c7110e36bb068b97a609438b2bed079b", "sha256": "1b2b7b26b87af9137d9243acc9631499a5aabf72546e2f0a3c7392294b6a3a7d" }, "downloads": -1, "filename": "repoze.bfg-1.1.4.tar.gz", "has_sig": false, "md5_digest": "c7110e36bb068b97a609438b2bed079b", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1103569, "upload_time": "2009-12-02T23:58:29", "url": "https://files.pythonhosted.org/packages/77/3f/2aab302e8836d1a66c86afa8da6752b3b021ffcdf601b6c46c9f5632f99f/repoze.bfg-1.1.4.tar.gz" } ], "1.1.5": [ { "comment_text": "", "digests": { "md5": "d373c7bf60d6febe5058c87707a06640", "sha256": "3a71a2c7d5a6e29985db0f1f7263529b9239c865cc4b333378a000e575301b8d" }, "downloads": -1, "filename": "repoze.bfg-1.1.5.tar.gz", "has_sig": false, "md5_digest": "d373c7bf60d6febe5058c87707a06640", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1103760, "upload_time": "2009-12-07T12:57:08", "url": "https://files.pythonhosted.org/packages/8d/07/50be9e739523f0adc219ded4635366354b76b1368f7ba61899c65fa6e7cf/repoze.bfg-1.1.5.tar.gz" } ], "1.1a1": [ { "comment_text": "", "digests": { "md5": "ff28ccfe32d8062a15746796cfbf5c87", "sha256": "01593a6151c0fbb56e4ce7717c372155903352a85aebfcdf7474b620c823485f" }, "downloads": -1, "filename": "repoze.bfg-1.1a1.tar.gz", "has_sig": false, "md5_digest": "ff28ccfe32d8062a15746796cfbf5c87", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 735682, "upload_time": "2009-09-06T07:31:08", "url": "https://files.pythonhosted.org/packages/6f/9b/6ab9dc006d889b8b32d1dfbe7e239bcff03ac88315251b4a138f2bb019c6/repoze.bfg-1.1a1.tar.gz" } ], "1.1a2": [ { "comment_text": "", "digests": { "md5": "bc2db7e506366ea8aece57a84ad7b15d", "sha256": "d95f33bf556dea6389f8be830543db15043a0243aa76edae4e3de2780db98b98" }, "downloads": -1, "filename": "repoze.bfg-1.1a2.tar.gz", "has_sig": false, "md5_digest": "bc2db7e506366ea8aece57a84ad7b15d", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 742554, "upload_time": "2009-09-14T07:36:32", "url": "https://files.pythonhosted.org/packages/7f/8c/4d2cbe63125cc009fe144d93d7c2eaff9fe19bb82967090d0677ce4cd503/repoze.bfg-1.1a2.tar.gz" } ], "1.1a3": [ { "comment_text": "", "digests": { "md5": "61e5039bd8267ef988c23c4c5cefd5d9", "sha256": "602e07d252ddc41122a51e8d060e8e6d906fac981bf302986a751e691c758301" }, "downloads": -1, "filename": "repoze.bfg-1.1a3.tar.gz", "has_sig": false, "md5_digest": "61e5039bd8267ef988c23c4c5cefd5d9", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 749684, "upload_time": "2009-09-16T21:52:22", "url": "https://files.pythonhosted.org/packages/9e/22/25954bf85024c7d23ad7651b8334029968fc07fce601f624af24b297e915/repoze.bfg-1.1a3.tar.gz" } ], "1.1a4": [ { "comment_text": "", "digests": { "md5": "f7d82bab80dd9f1b5ea4a32da9d635d6", "sha256": "13d2bdf3222c2bd004fcad90ed95592e36b0f6328d4a1e3121dcb02b99bee52d" }, "downloads": -1, "filename": "repoze.bfg-1.1a4.tar.gz", "has_sig": false, "md5_digest": "f7d82bab80dd9f1b5ea4a32da9d635d6", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 761847, "upload_time": "2009-09-23T06:04:08", "url": "https://files.pythonhosted.org/packages/11/3f/f6cd77821c03ffb17c4f865114faf05955d563bdf780f903567865c766d8/repoze.bfg-1.1a4.tar.gz" } ], "1.1a5": [ { "comment_text": "", "digests": { "md5": "891bad3a74d473109afad5224459bb26", "sha256": "37442c3fc1889a21242d8fdf47643df380167c4b1e00d7ea0260078cf7a0b285" }, "downloads": -1, "filename": "repoze.bfg-1.1a5.tar.gz", "has_sig": false, "md5_digest": "891bad3a74d473109afad5224459bb26", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1152188, "upload_time": "2009-10-10T07:19:02", "url": "https://files.pythonhosted.org/packages/bb/cf/1b9985fc88c76e7728a1bdc2ca0cf8e727fd2c633328745693c619b428ae/repoze.bfg-1.1a5.tar.gz" } ], "1.1a6": [ { "comment_text": "", "digests": { "md5": "1347ddc924696428f6de3df17bd3bfe9", "sha256": "1e76a0908f95d8559310067c948ba7f4c24ba2fbf0030c1e37a2e68c0c2fb086" }, "downloads": -1, "filename": "repoze.bfg-1.1a6.tar.gz", "has_sig": false, "md5_digest": "1347ddc924696428f6de3df17bd3bfe9", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1163714, "upload_time": "2009-10-16T03:09:56", "url": "https://files.pythonhosted.org/packages/be/ce/f5053ea46b3058c4301205bfcf1509728656d0c3a0bbbe8a4a0c1ba4a505/repoze.bfg-1.1a6.tar.gz" } ], "1.1a7": [ { "comment_text": "", "digests": { "md5": "ebd81532632de21285540a4b21ce597f", "sha256": "a2c8e5b74d11518257fd90dcb0a4fd99efefd6c7838b27dc8f03b41fd3d56738" }, "downloads": -1, "filename": "repoze.bfg-1.1a7.tar.gz", "has_sig": false, "md5_digest": "ebd81532632de21285540a4b21ce597f", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1164934, "upload_time": "2009-10-19T04:47:14", "url": "https://files.pythonhosted.org/packages/13/97/0f9971ff6e5459e3f7f83695417baf1540cfd709357e8b31abc57941bfc7/repoze.bfg-1.1a7.tar.gz" } ], "1.1a8": [ { "comment_text": "", "digests": { "md5": "924b5d1ec1ae925fdef161526b55218f", "sha256": "a60c00a4f4a9ca8aef2e4007426935fb5f1170eab346b9de7b5be63ce7816d01" }, "downloads": -1, "filename": "repoze.bfg-1.1a8.tar.gz", "has_sig": false, "md5_digest": "924b5d1ec1ae925fdef161526b55218f", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1174776, "upload_time": "2009-10-28T01:53:09", "url": "https://files.pythonhosted.org/packages/75/61/f97be270d38fb2d17838b80372d3919220164bf1e9ac541bf4ade0a10190/repoze.bfg-1.1a8.tar.gz" } ], "1.1a9": [ { "comment_text": "", "digests": { "md5": "7ab4bcb82f625a82e16c2d17aade3097", "sha256": "40c011a3bbbf0efab0e5fd57a5edc09511a8682d303edaa822dbcaae2def51c0" }, "downloads": -1, "filename": "repoze.bfg-1.1a9.tar.gz", "has_sig": false, "md5_digest": "7ab4bcb82f625a82e16c2d17aade3097", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1180342, "upload_time": "2009-11-01T02:05:21", "url": "https://files.pythonhosted.org/packages/18/02/d4e5416065d63d83b360edd3da62b29a01fc2eb592fc16f70cfed4ac6e9d/repoze.bfg-1.1a9.tar.gz" } ], "1.1b1": [ { "comment_text": "", "digests": { "md5": "8ea9a09b0d27f6a9eb23bab11bfcf276", "sha256": "3032b9ba7a72190ae02ebd4c84e9d69caa2aff894cb3c082964a893910865a3f" }, "downloads": -1, "filename": "repoze.bfg-1.1b1.tar.gz", "has_sig": false, "md5_digest": "8ea9a09b0d27f6a9eb23bab11bfcf276", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1183166, "upload_time": "2009-11-01T23:15:54", "url": "https://files.pythonhosted.org/packages/20/c8/5281a7b16b84e8ee03c1e745f351f829c326436b05317c425d5de06b2e67/repoze.bfg-1.1b1.tar.gz" } ], "1.1b2": [ { "comment_text": "", "digests": { "md5": "7d66ac4bd71b358a1ce135076893312c", "sha256": "f837bb2ec2238488606507338afa01c0dd00b2bcd23f511b970310123306e9cb" }, "downloads": -1, "filename": "repoze.bfg-1.1b2.tar.gz", "has_sig": false, "md5_digest": "7d66ac4bd71b358a1ce135076893312c", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1194615, "upload_time": "2009-11-02T15:43:14", "url": "https://files.pythonhosted.org/packages/5f/6b/099bff75a92e24890442027ea432085cc792e662a36978d8039bd9426ab8/repoze.bfg-1.1b2.tar.gz" } ], "1.1b3": [ { "comment_text": "", "digests": { "md5": "2531312b2bd42f8bec8f24fc20a53f7b", "sha256": "6c42577e2dc7168093d5fb325abbc2087418fb34c29aff3a7e4f6d18a48ba95a" }, "downloads": -1, "filename": "repoze.bfg-1.1b3.tar.gz", "has_sig": false, "md5_digest": "2531312b2bd42f8bec8f24fc20a53f7b", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1196767, "upload_time": "2009-11-07T01:24:56", "url": "https://files.pythonhosted.org/packages/74/2e/8c0317acf5fea992cb6276c97772069f5e3b39357433235c8961703bb435/repoze.bfg-1.1b3.tar.gz" } ], "1.1b4": [ { "comment_text": "", "digests": { "md5": "fdb5c9ecb2c42bb2a804d2970e1f7409", "sha256": "6df17169d2334a5bfa1f76d332db5624a9692f7ea83d4397fcd346aea93b04ab" }, "downloads": -1, "filename": "repoze.bfg-1.1b4.tar.gz", "has_sig": false, "md5_digest": "fdb5c9ecb2c42bb2a804d2970e1f7409", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1087667, "upload_time": "2009-11-13T01:00:49", "url": "https://files.pythonhosted.org/packages/b3/2b/44ac0641018cfea0ec9f6e7bf64eeb5d454884fc539f5d8651c751900d4e/repoze.bfg-1.1b4.tar.gz" } ], "1.2": [ { "comment_text": "", "digests": { "md5": "6bc1d64c84d499d858dec4718417f6b5", "sha256": "98dba1d8003bf724aa3af7f2780ee8ce4d5bccf9af7c3e145d7d70b4f94ec7aa" }, "downloads": -1, "filename": "repoze.bfg-1.2.tar.gz", "has_sig": false, "md5_digest": "6bc1d64c84d499d858dec4718417f6b5", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1210846, "upload_time": "2010-02-10T06:16:32", "url": "https://files.pythonhosted.org/packages/4b/a7/307ce9a52bbd23676e217bea281ab88bd0c58a6a660ddc5b47f57a111673/repoze.bfg-1.2.tar.gz" } ], "1.2.1": [ { "comment_text": "", "digests": { "md5": "68b20bcc602d143132703e1105240569", "sha256": "e59ea91f1eaef61a1111ebe35ada855b05cd568cb7ee9de0e203d362d5edf228" }, "downloads": -1, "filename": "repoze.bfg-1.2.1.tar.gz", "has_sig": false, "md5_digest": "68b20bcc602d143132703e1105240569", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1210348, "upload_time": "2010-04-08T00:00:23", "url": "https://files.pythonhosted.org/packages/89/d9/c538ce3ffba54e5819c1dccf263d362fcb72a32f4d0f832f1a7ada0e39ea/repoze.bfg-1.2.1.tar.gz" } ], "1.2.2": [ { "comment_text": "", "digests": { "md5": "b33273a26253df10003631d84b70bbd7", "sha256": "bcd8550c03c86da444aa2792c5519b60667de0940604ce83c7213d13aed28852" }, "downloads": -1, "filename": "repoze.bfg-1.2.2.tar.gz", "has_sig": false, "md5_digest": "b33273a26253df10003631d84b70bbd7", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1220265, "upload_time": "2010-09-21T19:29:34", "url": "https://files.pythonhosted.org/packages/de/d3/8e42307f3eb54c32721206387673c08452eced6c993194b8f56334b1c4fa/repoze.bfg-1.2.2.tar.gz" } ], "1.2a1": [ { "comment_text": "", "digests": { "md5": "b25aa266936e21f9aba06f88cbcc0570", "sha256": "d756b0bf02074e6fb815f5aa9a6abdbe8d56d81dfbe4ec8e243cd906cdb8513d" }, "downloads": -1, "filename": "repoze.bfg-1.2a1.tar.gz", "has_sig": false, "md5_digest": "b25aa266936e21f9aba06f88cbcc0570", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1144726, "upload_time": "2009-11-29T02:07:46", "url": "https://files.pythonhosted.org/packages/2c/f0/157d401b25071a26b42685c524493cf95ad8308f4e2fa35bb05105c615da/repoze.bfg-1.2a1.tar.gz" } ], "1.2a10": [ { "comment_text": "", "digests": { "md5": "d324227d6dcf379d71246731fa7d54fb", "sha256": "efe8c164f8e61716fca3508c964c5041410ac970551f7ffe8fa26b7bd8bbe75e" }, "downloads": -1, "filename": "repoze.bfg-1.2a10.tar.gz", "has_sig": false, "md5_digest": "d324227d6dcf379d71246731fa7d54fb", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1174197, "upload_time": "2010-01-04T14:52:22", "url": "https://files.pythonhosted.org/packages/b3/00/b5ff1a1570a10fa229beefe9e35427a3974f6dd7c7c98fee84ffe3cc8568/repoze.bfg-1.2a10.tar.gz" } ], "1.2a11": [ { "comment_text": "", "digests": { "md5": "3a36e972cb3174b5551f23df25844506", "sha256": "e858f203af7916ddf8abaf69d9584f70fc8d963d469a97bf5774325582f1775a" }, "downloads": -1, "filename": "repoze.bfg-1.2a11.tar.gz", "has_sig": false, "md5_digest": "3a36e972cb3174b5551f23df25844506", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1177222, "upload_time": "2010-01-06T04:17:35", "url": "https://files.pythonhosted.org/packages/74/5f/1ba77028c1484e91670b53731e01ade84de5e1f5b7040dc67d9fbf024c7d/repoze.bfg-1.2a11.tar.gz" } ], "1.2a2": [ { "comment_text": "", "digests": { "md5": "eabad2e620b9d05bef3d5b1adff32be1", "sha256": "c8352ae14e7e88cafbf59455328a9e9ee7aac35715423c69427c2b7edad2f464" }, "downloads": -1, "filename": "repoze.bfg-1.2a2.tar.gz", "has_sig": false, "md5_digest": "eabad2e620b9d05bef3d5b1adff32be1", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1117980, "upload_time": "2009-11-30T00:10:30", "url": "https://files.pythonhosted.org/packages/49/0d/7526786dbd4f039b74bbb4b8426f05df6f9ffef556c49e46601cabdf02b0/repoze.bfg-1.2a2.tar.gz" } ], "1.2a3": [ { "comment_text": "", "digests": { "md5": "1fc3eca2065f65ceb124793497e21620", "sha256": "b47456be6ea4e028aba21d1c9b28b03c22cca00e7fdf1dcc12c282d1f6ebe00c" }, "downloads": -1, "filename": "repoze.bfg-1.2a3.tar.gz", "has_sig": false, "md5_digest": "1fc3eca2065f65ceb124793497e21620", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1121001, "upload_time": "2009-12-03T00:03:03", "url": "https://files.pythonhosted.org/packages/50/2c/657ba91f61b43c6ae602d7929f6b00faaa54855efae70181e22d5c69ed86/repoze.bfg-1.2a3.tar.gz" } ], "1.2a4": [ { "comment_text": "", "digests": { "md5": "9af8f69cda4a9b9ec7eef4bcdb7cb3a8", "sha256": "0a09d810048cdc016d50a16b3e111414a254910d335a77d6552da9f2ebe0affa" }, "downloads": -1, "filename": "repoze.bfg-1.2a4.tar.gz", "has_sig": false, "md5_digest": "9af8f69cda4a9b9ec7eef4bcdb7cb3a8", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1122243, "upload_time": "2009-12-07T12:57:25", "url": "https://files.pythonhosted.org/packages/5a/2e/eb66d3a801ba4c7cdc5e91ce7ef51f1cc8fd6fd1971bbcba5ec53e9788a9/repoze.bfg-1.2a4.tar.gz" } ], "1.2a5": [ { "comment_text": "", "digests": { "md5": "1d4958b8f6e88e2358f705e4a63a3b73", "sha256": "f3746105439b1ceb813e7c802693eedb838008c679c5b1f0660cd37fe480fef2" }, "downloads": -1, "filename": "repoze.bfg-1.2a5.tar.gz", "has_sig": false, "md5_digest": "1d4958b8f6e88e2358f705e4a63a3b73", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1123480, "upload_time": "2009-12-10T17:03:14", "url": "https://files.pythonhosted.org/packages/9f/42/deb0d9d7882e2e637b2b81e721326232c88f5b60991cfe7c6f16fe73b38b/repoze.bfg-1.2a5.tar.gz" } ], "1.2a6": [ { "comment_text": "", "digests": { "md5": "410a61021ae1a5c6a453dd68978fb835", "sha256": "f543eb2ea1bbfee8acc0a62e490cee77e2ad595c3c551b3c7e6798a5def4c243" }, "downloads": -1, "filename": "repoze.bfg-1.2a6.tar.gz", "has_sig": false, "md5_digest": "410a61021ae1a5c6a453dd68978fb835", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1131021, "upload_time": "2009-12-18T19:14:28", "url": "https://files.pythonhosted.org/packages/d0/5b/e6f3d7760fd9ff472b7ed004e456b102de6f1bef33448438e6e6f4f31b50/repoze.bfg-1.2a6.tar.gz" } ], "1.2a7": [ { "comment_text": "", "digests": { "md5": "9447c6750db1639e43be039aa2bbc5c3", "sha256": "210016365337a8b8e5fc24dab2364b891bc8bdafd69d586ff7fdf96ec2aacde7" }, "downloads": -1, "filename": "repoze.bfg-1.2a7.tar.gz", "has_sig": false, "md5_digest": "9447c6750db1639e43be039aa2bbc5c3", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1134937, "upload_time": "2009-12-20T15:18:32", "url": "https://files.pythonhosted.org/packages/71/a0/c3fbd64db5cc7f15732539f8e49fa0c17cb6a78411ec0f9b0613a133ee27/repoze.bfg-1.2a7.tar.gz" } ], "1.2a8": [ { "comment_text": "", "digests": { "md5": "2be0ab5d742dabda5509fbdbd4fa0bc3", "sha256": "f551630df5980c3a29d7fa8f17c39be6405227bd1328abe61edc1c3254c323bb" }, "downloads": -1, "filename": "repoze.bfg-1.2a8.tar.gz", "has_sig": false, "md5_digest": "2be0ab5d742dabda5509fbdbd4fa0bc3", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1141596, "upload_time": "2009-12-24T12:19:10", "url": "https://files.pythonhosted.org/packages/9e/0a/7d2c435529a2df3a037c23451d9a3333c4b6adb05603a5f9c18b0551a73f/repoze.bfg-1.2a8.tar.gz" } ], "1.2a9": [ { "comment_text": "", "digests": { "md5": "fd16b78c691cb0fc5b622db724b18b75", "sha256": "0e9ed77bf1a2de3c158acdae1c3d1bb4fa0d10770d0d7dc4ac8c0438845e42c9" }, "downloads": -1, "filename": "repoze.bfg-1.2a9.tar.gz", "has_sig": false, "md5_digest": "fd16b78c691cb0fc5b622db724b18b75", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1153661, "upload_time": "2009-12-28T00:17:34", "url": "https://files.pythonhosted.org/packages/22/8b/66479bf6183aa7c87b04880dd5a33f7516c50ebcd3da59b2d514f95f0582/repoze.bfg-1.2a9.tar.gz" } ], "1.2b1": [ { "comment_text": "", "digests": { "md5": "70ecfab648e6266969bf84fa11ea49b3", "sha256": "fb1ed4ea275705a50700227053a2b4f07285b1b13ab5732d22e5ec4bb9f7b4a6" }, "downloads": -1, "filename": "repoze.bfg-1.2b1.tar.gz", "has_sig": false, "md5_digest": "70ecfab648e6266969bf84fa11ea49b3", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1196947, "upload_time": "2010-01-18T19:26:53", "url": "https://files.pythonhosted.org/packages/f2/7c/e5d90c1ee9e9d6cc6cefa3171ac8d8c354594cc855c1809b85e996eb8dba/repoze.bfg-1.2b1.tar.gz" } ], "1.2b2": [ { "comment_text": "", "digests": { "md5": "c794d52e8742984a40df7084116ccbe3", "sha256": "d5579ccca058c5a2c2e96bc112a090b94edf576ffb6df93bcc0adcf6eab5c400" }, "downloads": -1, "filename": "repoze.bfg-1.2b2.tar.gz", "has_sig": false, "md5_digest": "c794d52e8742984a40df7084116ccbe3", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1202659, "upload_time": "2010-01-21T16:53:08", "url": "https://files.pythonhosted.org/packages/c8/3d/a205a647709a19aa09404fc4b21d8372978eaac491534d55655d3d1e49d9/repoze.bfg-1.2b2.tar.gz" } ], "1.2b3": [ { "comment_text": "", "digests": { "md5": "a0e44d577b3efd8651f03529d434bf99", "sha256": "45b95d65df837af349eb9c2faf357c5fb240271994952a43d167363d13edc821" }, "downloads": -1, "filename": "repoze.bfg-1.2b3.tar.gz", "has_sig": false, "md5_digest": "a0e44d577b3efd8651f03529d434bf99", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1204389, "upload_time": "2010-01-24T22:33:49", "url": "https://files.pythonhosted.org/packages/21/64/c4b2679cfc9be4895c0fb35a318967eab6a23d94981ab8e1787c72a86662/repoze.bfg-1.2b3.tar.gz" } ], "1.2b4": [ { "comment_text": "", "digests": { "md5": "4de42483f119dc22f0c258c81245dee9", "sha256": "3ac7439e518a062ca9c863811ee7c50470ca9d80702a932e336ee71f8486ba87" }, "downloads": -1, "filename": "repoze.bfg-1.2b4.tar.gz", "has_sig": false, "md5_digest": "4de42483f119dc22f0c258c81245dee9", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1207802, "upload_time": "2010-02-03T06:10:14", "url": "https://files.pythonhosted.org/packages/ef/99/d1ca447dc96e24bd02f2a0b5c3c83f59db69107992298c6a135d06604fd9/repoze.bfg-1.2b4.tar.gz" } ], "1.2b5": [ { "comment_text": "", "digests": { "md5": "81cb64acadb4d6d1d4edefad9eee58f3", "sha256": "adc299e12223f5d616523c2415d3929c216b52c7cdb3118d3666f67fb5010f47" }, "downloads": -1, "filename": "repoze.bfg-1.2b5.tar.gz", "has_sig": false, "md5_digest": "81cb64acadb4d6d1d4edefad9eee58f3", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1209335, "upload_time": "2010-02-04T20:58:00", "url": "https://files.pythonhosted.org/packages/03/00/8315f34e260672f41e7d873be1ac0c6375406b5808ea23475980b3053ead/repoze.bfg-1.2b5.tar.gz" } ], "1.2b6": [ { "comment_text": "", "digests": { "md5": "2c17d6d13ae87c1c03bf9535a62703a7", "sha256": "fb0d244cb4d6a5d30644d91d4848e3d277df2fc9c615c53a5f4e7c77fba9cc77" }, "downloads": -1, "filename": "repoze.bfg-1.2b6.tar.gz", "has_sig": false, "md5_digest": "2c17d6d13ae87c1c03bf9535a62703a7", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1209857, "upload_time": "2010-02-07T03:29:03", "url": "https://files.pythonhosted.org/packages/44/dc/82f08b7440a8f8b88a40097a29a04e23550d1230af34f4b14b0cbba0b394/repoze.bfg-1.2b6.tar.gz" } ], "1.3": [ { "comment_text": "", "digests": { "md5": "fe971617e0630b4e6b8f4069e8208b30", "sha256": "d3585334b2bd92325d2ec3a6fd57f7dbc49a2437aa17a72833a9199f4edb288c" }, "downloads": -1, "filename": "repoze.bfg-1.3.tar.gz", "has_sig": false, "md5_digest": "fe971617e0630b4e6b8f4069e8208b30", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1326559, "upload_time": "2010-11-01T17:45:53", "url": "https://files.pythonhosted.org/packages/10/ce/2ec312e8ff18000acb1a4c532918566c8b967c349507aeb99e4679ddb318/repoze.bfg-1.3.tar.gz" } ], "1.3a1": [ { "comment_text": "", "digests": { "md5": "c68a4369002234c203ecb5cf1da27eaf", "sha256": "a382145b99ebb447eaaeb8e8cb2ce86dd1a3fc9668043e5f36dc3c238ce016b3" }, "downloads": -1, "filename": "repoze.bfg-1.3a1.tar.gz", "has_sig": false, "md5_digest": "c68a4369002234c203ecb5cf1da27eaf", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1216294, "upload_time": "2010-04-26T07:43:51", "url": "https://files.pythonhosted.org/packages/06/10/ec1675ceb12197450b8d8fce8220bc52b885908900e89f73e38af60a9607/repoze.bfg-1.3a1.tar.gz" } ], "1.3a10": [ { "comment_text": "", "digests": { "md5": "06ed9ff23ca60c5b6d47662c05d631e1", "sha256": "a534a9d44c4f00b1c493982f060aa35f42575f9935e2e24de8ec7d171c637af7" }, "downloads": -1, "filename": "repoze.bfg-1.3a10.tar.gz", "has_sig": false, "md5_digest": "06ed9ff23ca60c5b6d47662c05d631e1", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1299627, "upload_time": "2010-09-06T02:23:54", "url": "https://files.pythonhosted.org/packages/79/e9/6ac2d228f7e0f0d890bf52eed8ae2e213996a1bb22f3611890d5e6fe7f9a/repoze.bfg-1.3a10.tar.gz" } ], "1.3a11": [ { "comment_text": "", "digests": { "md5": "8e220d7735305d109bb74e4c9faeef58", "sha256": "38f63d5fd66424db9038ef563d0d332933cf93a15fbb69dbb9fe0b95eb8ab066" }, "downloads": -1, "filename": "repoze.bfg-1.3a11.tar.gz", "has_sig": false, "md5_digest": "8e220d7735305d109bb74e4c9faeef58", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1299632, "upload_time": "2010-09-06T02:59:04", "url": "https://files.pythonhosted.org/packages/3d/ea/b75a5809c427654c968e7101000876168ec88ec1cc3da489f6ec934e5b2e/repoze.bfg-1.3a11.tar.gz" } ], "1.3a12": [ { "comment_text": "", "digests": { "md5": "fe23e077b6150cc6073daac83e5a31ba", "sha256": "9ff3285d095eea4a4ab1ff1e2682fb32c0266d1f69a21aaaa8bfa0876b5ba281" }, "downloads": -1, "filename": "repoze.bfg-1.3a12.tar.gz", "has_sig": false, "md5_digest": "fe23e077b6150cc6073daac83e5a31ba", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1303548, "upload_time": "2010-09-08T08:03:53", "url": "https://files.pythonhosted.org/packages/d2/f5/93f28c5b61a0440f88d25fad48768032693c52e5fe8bfd9001199c40ace2/repoze.bfg-1.3a12.tar.gz" } ], "1.3a13": [ { "comment_text": "", "digests": { "md5": "b58cfd11d755c0ca43d14c29a0aa0e86", "sha256": "76fc195a4aa8b5d9f87a8edfbcdc8d44cdd5eab396ca9119c9dd0384b7dc7c14" }, "downloads": -1, "filename": "repoze.bfg-1.3a13.tar.gz", "has_sig": false, "md5_digest": "b58cfd11d755c0ca43d14c29a0aa0e86", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1315386, "upload_time": "2010-09-14T14:46:05", "url": "https://files.pythonhosted.org/packages/af/ac/64453f4b3cfbb969d7016e89c7b30c778ae86c23b1e114e081cf5172ee89/repoze.bfg-1.3a13.tar.gz" } ], "1.3a14": [ { "comment_text": "", "digests": { "md5": "5ccd1beab528e465fe13f6cc2c556d68", "sha256": "f816b0b156e996a711298904f315373f3d19e369a495ed60e25b356eb975804e" }, "downloads": -1, "filename": "repoze.bfg-1.3a14.tar.gz", "has_sig": false, "md5_digest": "5ccd1beab528e465fe13f6cc2c556d68", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1317449, "upload_time": "2010-09-15T02:31:36", "url": "https://files.pythonhosted.org/packages/0e/ca/b50f17eac64a7d8b9819658b94dbdc9f0f03d0cc995249d92efa4eedbf3f/repoze.bfg-1.3a14.tar.gz" } ], "1.3a15": [ { "comment_text": "", "digests": { "md5": "b0c179fefd05c0e455abd36e5bdf0fd0", "sha256": "138a30252a90b5dd453ec260a38e0aec978d3fbaa5691b669b57d158c9cfc65b" }, "downloads": -1, "filename": "repoze.bfg-1.3a15.tar.gz", "has_sig": false, "md5_digest": "b0c179fefd05c0e455abd36e5bdf0fd0", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1319781, "upload_time": "2010-09-30T08:10:35", "url": "https://files.pythonhosted.org/packages/6c/91/2306d3b34e16ee558f6f3dc9c63628521ba9081c80b94b40d8aaf363f541/repoze.bfg-1.3a15.tar.gz" } ], "1.3a2": [ { "comment_text": "", "digests": { "md5": "8c77807f9bacd3c86204058f7c42749d", "sha256": "11341e6a6e70cdf2e5330d53e546e606b86b1d0beffa124de941ccba89c8fdf9" }, "downloads": -1, "filename": "repoze.bfg-1.3a2.tar.gz", "has_sig": false, "md5_digest": "8c77807f9bacd3c86204058f7c42749d", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1220118, "upload_time": "2010-04-28T10:06:54", "url": "https://files.pythonhosted.org/packages/59/ef/766cdd2ef1c4949f440b3823d6a79b7e7638fe9eba0efc10d190c12b2f34/repoze.bfg-1.3a2.tar.gz" } ], "1.3a3": [ { "comment_text": "", "digests": { "md5": "e99a0096e9b64496241ea82f7c246e02", "sha256": "49281ed63159f7a9376fb42b3edbafc6db6336387c7856309734bd7c65d1173f" }, "downloads": -1, "filename": "repoze.bfg-1.3a3.tar.gz", "has_sig": false, "md5_digest": "e99a0096e9b64496241ea82f7c246e02", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1227992, "upload_time": "2010-05-02T01:24:23", "url": "https://files.pythonhosted.org/packages/64/96/dceea7ed878557bf3c7125377443e0fcf77122194197b19f63bdf74294bf/repoze.bfg-1.3a3.tar.gz" } ], "1.3a4": [ { "comment_text": "", "digests": { "md5": "79376b4e9b0e533c699a75018825648a", "sha256": "8230d99a5e8aed8425efcea57fb5c0fca9dcacee6d63a8cb2c2efd0e5a090330" }, "downloads": -1, "filename": "repoze.bfg-1.3a4.tar.gz", "has_sig": false, "md5_digest": "79376b4e9b0e533c699a75018825648a", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1240736, "upload_time": "2010-07-04T04:11:59", "url": "https://files.pythonhosted.org/packages/73/ee/9822e3a78a89b662ac3a4cb8d9d2ea4164241b7345f764d53ec22bc75d11/repoze.bfg-1.3a4.tar.gz" } ], "1.3a5": [ { "comment_text": "", "digests": { "md5": "2ba4475ca1516aee4c4ab210d7d227a9", "sha256": "778dbd67437ad4f4ec38d13a52fdc0c6ed74527db02385cb81103a954bf945b9" }, "downloads": -1, "filename": "repoze.bfg-1.3a5.tar.gz", "has_sig": false, "md5_digest": "2ba4475ca1516aee4c4ab210d7d227a9", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1241095, "upload_time": "2010-07-14T15:42:24", "url": "https://files.pythonhosted.org/packages/b5/1a/a1e97d036143890703edc9c5ed1bc68fe3a1e3c7f0c3d9385f5d5cdfe84c/repoze.bfg-1.3a5.tar.gz" } ], "1.3a6": [ { "comment_text": "", "digests": { "md5": "734efb2c950b83f7fb33b01a9b7bfa1f", "sha256": "fa5401b170ad829758b0b62f7f74ebfa2518f234757309f8448d92cc4669f93f" }, "downloads": -1, "filename": "repoze.bfg-1.3a6.tar.gz", "has_sig": false, "md5_digest": "734efb2c950b83f7fb33b01a9b7bfa1f", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1261056, "upload_time": "2010-07-26T02:45:12", "url": "https://files.pythonhosted.org/packages/ed/24/315922c303c90b8dd7607916f804c01c97b60828f8254b6e236394e0080e/repoze.bfg-1.3a6.tar.gz" } ], "1.3a7": [ { "comment_text": "", "digests": { "md5": "7fff781f64c63bcca46b67dc4615b15d", "sha256": "1ee6af5589af135eab5c767657b748199924d836fad463c334833e92f15b7e23" }, "downloads": -1, "filename": "repoze.bfg-1.3a7.tar.gz", "has_sig": false, "md5_digest": "7fff781f64c63bcca46b67dc4615b15d", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1268073, "upload_time": "2010-08-01T18:42:49", "url": "https://files.pythonhosted.org/packages/08/e9/ca5dbf2f2144f970ae75e935a13a561448fcb66afbde37d48095793a0e75/repoze.bfg-1.3a7.tar.gz" } ], "1.3a8": [ { "comment_text": "", "digests": { "md5": "388111c0ac7af7ed038426436b2ea4ae", "sha256": "899c611e5b534411b57fd165781a81decca4f4047f3fa6b7cd22eeb44a2e75d6" }, "downloads": -1, "filename": "repoze.bfg-1.3a8.tar.gz", "has_sig": false, "md5_digest": "388111c0ac7af7ed038426436b2ea4ae", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1286021, "upload_time": "2010-08-09T04:59:23", "url": "https://files.pythonhosted.org/packages/41/51/c6e35b7470d6bba446b1496d86a2cd809c8b2dc5edd37293ac2733dfb9a1/repoze.bfg-1.3a8.tar.gz" } ], "1.3a9": [ { "comment_text": "", "digests": { "md5": "c6ee06df96618016d15c4c5886850b2e", "sha256": "f15bb9bf002a29b046dfdcc4f6f9f621160f2eff434c811857117c36ad8ae468" }, "downloads": -1, "filename": "repoze.bfg-1.3a9.tar.gz", "has_sig": false, "md5_digest": "c6ee06df96618016d15c4c5886850b2e", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1293053, "upload_time": "2010-08-23T05:21:36", "url": "https://files.pythonhosted.org/packages/08/ff/3514625506d5ad7bd10ea7cf0174b6aa4df7e66d01ba80e13965cd8990d1/repoze.bfg-1.3a9.tar.gz" } ], "1.3b1": [ { "comment_text": "", "digests": { "md5": "0281841e051c7d57a8944c90f6f75be5", "sha256": "1e448146fddb6be40eb4ddc0a55c22fe6b3c5d5231f9089616c760b994d2384c" }, "downloads": -1, "filename": "repoze.bfg-1.3b1.tar.gz", "has_sig": false, "md5_digest": "0281841e051c7d57a8944c90f6f75be5", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1323062, "upload_time": "2010-10-25T22:51:59", "url": "https://files.pythonhosted.org/packages/fe/cd/5dcb1e7f10abb43699a17a4bf37fa4b496b2c156f95f03df8ead586b547e/repoze.bfg-1.3b1.tar.gz" } ], "1.3b2": [ { "comment_text": "", "digests": { "md5": "efafd1a29df501ec6da6e5faeb69fe9a", "sha256": "edd7a757c789080d8f1c4d551b0e17898427dc9585ee7793ff1dc61715905ed4" }, "downloads": -1, "filename": "repoze.bfg-1.3b2.tar.gz", "has_sig": false, "md5_digest": "efafd1a29df501ec6da6e5faeb69fe9a", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1324825, "upload_time": "2010-10-28T09:21:54", "url": "https://files.pythonhosted.org/packages/2b/92/997e75f9fe0378962a4c638578362bed55e12c7916c5c5efdacfd64e8aa3/repoze.bfg-1.3b2.tar.gz" } ], "1.3b3": [ { "comment_text": "", "digests": { "md5": "bbe80b27b6ab3413328dab3b2436373a", "sha256": "0e08b2bb4ca30bb56f6686716fc074f10bd4b4da47121a7f1bc7327664f9b0d3" }, "downloads": -1, "filename": "repoze.bfg-1.3b3.tar.gz", "has_sig": false, "md5_digest": "bbe80b27b6ab3413328dab3b2436373a", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1326554, "upload_time": "2010-10-29T09:18:14", "url": "https://files.pythonhosted.org/packages/99/7f/29b831cb3cee7f02b8e4bbee63691d4c58c0b7ad5c7d0f6c61de78575641/repoze.bfg-1.3b3.tar.gz" } ] }, "urls": [ { "comment_text": "", "digests": { "md5": "fe971617e0630b4e6b8f4069e8208b30", "sha256": "d3585334b2bd92325d2ec3a6fd57f7dbc49a2437aa17a72833a9199f4edb288c" }, "downloads": -1, "filename": "repoze.bfg-1.3.tar.gz", "has_sig": false, "md5_digest": "fe971617e0630b4e6b8f4069e8208b30", "packagetype": "sdist", "python_version": "source", "requires_python": null, "size": 1326559, "upload_time": "2010-11-01T17:45:53", "url": "https://files.pythonhosted.org/packages/10/ce/2ec312e8ff18000acb1a4c532918566c8b967c349507aeb99e4679ddb318/repoze.bfg-1.3.tar.gz" } ] }