semvec/pypi-packages huggingface dataset:
djmako 0.4
mako template support for Django >=1.2
License: BSD
Keywords: django mako templating

.. -*- rst -*-

Mako templates for django >= 1.2.

Portions of this code are taken from django-smorgasbord's mako
support.  Smorgasbord provided a monkeypatch to facilitate the use of
other templating languages within django 1.1; with django 1.2, this
monkeypatch is no longer necessary, and there is no longer any
particular reason to conjoin template loaders for different languages
in one project.

To use, add ``'djmako.MakoLoader'`` to ``settings.TEMPLATE_LOADERS``, and
define settings.MAKO_TEMPLATE_DIRS (a tuple of directories in which to
look for mako templates -- required) and ``settings.MAKO_TEMPLATE_OPTS``
(a dictionary of other parameters to pass to Mako's ``TemplateLookup``
class -- optional).

For instance, in ``settings.py`` you might have::

  TEMPLATE_LOADERS = (
     'djmako.MakoLoader',
     'django.template.loaders.filesystem.Loader',
     'django.template.loaders.app_directories.Loader',
  )

  MAKO_TEMPLATE_DIRS=(os.path.join(PROJECT_ROOT, 'templates', 'mako'),)

  MAKO_TEMPLATE_OPTS=dict(input_encoding='utf-8',
                          cache_impl='djmakocache', 
                          module_directory=os.path.join(
      tempfile.gettempdir(),
      os.environ.get('LOGNAME', 'someuser'),
      'mysite',
      PROJECT_ROOT.split('/')[-2]))

Note that in the above configuration, the mako loader is checked
first, and django templates afterwards.

Cache Plugin
~~~~~~~~~~~~

As of version 0.4, djmako contains a cache plugin for Mako that
connects the Mako cache to the Django cache system.  To enable, set
``"cache_impl"`` to ``"djmakocache"`` in
``settings.MAKO_TEMPLATE_OPTS``.

License
=======

Copyright (c) 2010 Jacob Smullyan.
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:

 * Redistributions of source code must retain the above copyright
   notice, this list of conditions and the following disclaimer.

 * Redistributions in binary form must reproduce the above copyright
   notice, this list of conditions and the following disclaimer in the
   documentation and/or other materials provided with the
   distribution.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
orb 0.9.4
pip/virtualenv shell script wrapper
License: BSD

orb
===

A utility wrapper for pip_ and virtualenv_.

description
-----------

A shell script facade for creating virtual python environments via virtualenv_
and installing packages within the environment via pip_.

install
-------

virtualenv_ must be available, eg. in Ubuntu:

    $ sudo apt-get install python-virtualenv

pip_ need not be available - it is installed every time to a new environment.

To install, use easy_install to install from pypi.python.org::

    easy_install -Z orb
    
or simply copy the orb script from the source distribution, eg. ::

    $ sudo cp orb /usr/local/bin

usage
-----

Create a virtualenv with the command

    $ orb init myenv

or

    $ orb init2 myenv

to use the latest Python2 as the executable, or

    $ orb init3 myenv

to use the latest Python3 as the executable, or

    $ orb init?.? myenv

(eg. orb init2.6 or orb init3.2) to specify a particular Python version as
the executable.

.. note::

    the various python versions are assumed to be installed and on the user's
    PATH

This creates a virtualenv called 'myenv' and creates an empty '.orb'
file within the virtualenv directory. Subsequent orb commands first search
for the '.orb' file and from this file's location the virtualenv's bin directory
is known. 

To install packages to the env, run the 'orb install' command from within the
env directory::

   cd myenv
   orb install Pygments
   orb install BeautifulSoup

which calls 'pip_' to do the actual downloading and installation.

If passed a python script, orb will call it using the virtualenv's python

   eg. orb setup.py install

and if passed any command expression, orb will temporarily alter the
environment (ie. pip's `source activate` step) before eval-ing the command::

   eg. (Django): orb django-admin.py startproject myproj
   eg. (Python prompt): orb python
   eg. (Sphinx quickstart): orb sphinx-quickstart
   eg. (Sphinx build): orb make html
   eg. (Arbitrary command) orb ./myshellscript

Other options:

orb ls      - list contents of env's site-packages directory
orb link    - symlink from the virtual env's site-packages to a system package
orb download PACKAGE [DEST]
            - just download package, don't install


.. _virtualenv: http://pypi.python.org/pypi/virtualenv/
.. _pip: http://pip.openplans.org/index.html
callchain 0.2.6
callables and components joined in one big happy chain
License: BSD
Keywords: component architecture injection aspect-oriented appspace generator iterator functional

Lets arbitrary callables, components, and event listeners be stringed into one lazily evaluated processing chain.

Some highly contrived examples:

`chain <https://en.wikipedia.org/wiki/Fluent_interface>`_ style:

>>> from callchain import aachainq as chainq
>>> chainqueue = chainq()
>>> chainqueue(('a', 1), ('b', 2), ('c', 3)).reup().wrap(dict).map().value()
{'a': 1, 'b': 2, 'c': 3}

Object-oriented style:

>>> chainqueue(('a', 1), ('b', 2), ('c', 3))
>>> chainqueue.reup()
>>> chainqueue.wrap(dict)
>>> chainqueue.map()
>>> chainqueue.value()
{'a': 1, 'b': 2, 'c': 3}

Mirrored at https://github.com/lcrees/callchain/