semvec/pypi-packages huggingface dataset:
tgidproviders 0.1
A collection of Identity providers for Turbogears
License: MIT
Keywords: turbogears.identity.provider

TGIDProviders is a collection of Identity providers that help you get up and running quickly when you want to validate passwords against an LDAP directory, a UNIX password file, or a SMB provider under Windows.  It takes advantage of TurboGears' entry points (provided by SetupTools) to extend the capabilities of the default identity providers to support other authentication methods.

OpenID is not yet supported, but patches are welcome!
gsquickstart 1.0
TurboGears Genshi quickstart template
License: MIT
Keywords: turbogears.quickstart.template

gsquickstart is a TurboGears quickstart template plug-in for Genshi templates.
It will install a paste template which can be used with TurboGears' 
``tg-admin quickstart`` command.


Installation
------------

Installation with setuptools::

    $easy_install gsquickstart


Usage
-----

Creating a project
~~~~~~~~~~~~~~~~~~

The gsquickstart template is used like any other quickstart template with 
tg-admin quickstart, you just have to specify the template name, which is 
"tggenshi" (for TurboGears Genshi) with the ``-t`` option  template instead 
of the default kid template::

    $tg-admin quickstart -t tggenshi [project name]

This will install three basic Genshi tempaltes and set up the project 
configuration to use Gensi templates as default.


Updating a project
~~~~~~~~~~~~~~~~~~

For updating a project with the basic Genshi templates, change into your
project directory and run::

    tg-admin update -t tggenshi

Since the "turbogears" template already installs Kid templates in 
``<package>/templates``, they are removed by gsquickstart in a 
post-template-creation step. But when update your project dir, the Kid 
templates will be created again. Now gsquickstart can not just delete them 
again, because they might have been created earlier and on purpose by the 
developer.

What the new code does is: if it is an update command, prompt the user, 
if the files ``<package>/templates/{login,master,welcome}.kid`` should 
be removed (for each file). The default answer is 'n'. 


Notice
------

The TurboGears 1.0 documentation is written with the default setting of 
Kid & SQLObject in mind. The syntax of Genshi templates is very similar 
to that of Kid but there are some differences to bear in mind. 

For example, you need to make some changes to your templates, if you use 
widgets with Genshi templates: put ``${ET(myform())}`` instead of 
``${myform()}`` as a placeholder for widgets in the template.

You can find more information in the `TurboGears documentation`_ and on 
the `Genshi website`_.

.. _TurboGears documentation :http://docs.turbogears.org/1.0/GenshiTemplating
.. _Genshi website: http://genshi.edgewall.org/wiki/GenshiFaq


What's new?
-----------

1.0
---

* The quickstart template was stripped of almost all files shared with the
  standard "turbogears" template and now inherits from this template instead
  of from "tgbase". The only files that are added/overwritten by "tggenshi"
  are ``setup.py``, ``<package>/config/app.cfg`` and the Genshi templates
  in ``<package>/templates/*.html``. But see the "Updating a project" section
  above.
  
  The new template structure makes it easier to stay synchronized with changes
  to the standard turbogears template since most files will just be
  inherited from.

* Synchronized ``app.cfg_tmpl` and `setup.py_tmpl`` with the latest 
  "turbogears" template.


1.0Beta2
--------

* Able to be indexed by turbogears cogbin.
WSGIRewrite 0.1.3.1
Path rewriter WSGI middleware with mod_rewrite compatible rules
License: MIT
Keywords: wsgi rewrite middleware mod_rewrite

WSGIRewrite is a path rewriter WSGI middleware that uses the same syntax as the (in)famous ``mod_rewrite`` module for Apache.

The latest version is available in a `Subversion repository <http://wsgirewrite.googlecode.com/svn/trunk#egg=WSGIRewrite-dev>`_.
StructArray 0.1
Fast operations on arrays of structured data.
License: MIT

===========
StructArray
===========

StructArray allows you to perform fast arithmetic operations on
arrays of structured (or unstructured) data.

This library is useful for performing the same operation on every item in an
array.

I've included an example showing a simple particle engine.  It animates 10,000
particles without much trouble.

*This is the "release early" part of the "release early, release often"
equation. It's 80% done.  I just need to finish the other 80%.*

Quick Introduction
==================

Here's a quick introduction to what you can do with it:

>>> import structarray, random

First, create a ``StructArray`` with attributes for position and velocity,
starting with a length of 1000.

>>> particles = structarray.StructArray(('x', 'y', 'dx', 'dy'), size=10000)

Let's give the particles a little random motion.  We can loop through each item
and assign attributes.

>>> for p in particles:
...     p.dx = random.random() * 20 - 10
...     p.dy = random.random() * 50

We can also assign values by index like this:

>>> particles[0].dy = 100

Or we could assign all four values to an index:

>>> particles[0] = (0, 20, 5, 100)             # (x, y, dx, dy)

We can assign a value to every item by assigning it directly to an attribute of
the array:

>>> particles.x = 0          # set x to zero for every item

We can also copy the values of one attribute into another:

>>> particles.y = particles.x

We can also do arithmetic while we are at it:

>>> particles.y = particles.x + 10

So now, how would we go about a simulation loop?

>>> particles.x += particles.dx
>>> particles.y += particles.dy
>>> particles.dy -= 9.81

What's important here is that each of these three operations is applied to
*every* item in the array.  And it all happens in a tight loop in C, so it's
*very* fast.  Even for 10,000 particles.

Sending the data off to the video card is pretty easy:

>>> glVertexPointer(2, GL_FLOAT,
...     particles.get_data_stride(),
...     particles.get_data_addr())

Of course there's more to it than that to get it to display.  Check out the
source distribution for a working example


Download
========

I always upload the latest version to the `StructArray page on PyPI`__.

__ http://cheeseshop.python.org/pypi/StructArray/


Installation
============

Run this command to download and install a precompiled binary.::

    sudo easy_install StructArray

To compile StructArray from source, you need the python development headers
installed.  (This is named ``python-dev`` in debian and ubuntu distributions.
I think rpm distros name it ``python-devel``.)

The C files are included, so you don't need Pyrex installed.  However, if you
*do* have Pyrex, I've only tested it with Pyrex-0.9.6.3.  Results may vary with
older versions.

Installing is just like most any other python module::

    python setup.py build
    sudo python setup.py install


Documentation
=============

You can find the `StructArray reference documentation here`__

__ http://matthewmarshall.org/projects/structarray/docs/structarray/

It's also included when you download the source distribution.