semvec/pypi-packages huggingface dataset:
django-orm-extensions 3.0b3
Advanced improvement of django-orm with a lot of third-party plugins for use different parts of databases are
not covered by the standard orm.
License: BSD

If you want to know in detail what it offers for each database, check the documentation.

* **Documentation**: http://readthedocs.org/docs/django-orm/en/latest/
* **Project page**: http://www.niwi.be/post/project-django-orm/
pylinkmobile 0.3.0
Link Mobile Solutions API wrapper
License: BSD

# pylinkmobile

pylinkmobile is a Python module for interacting with the Link Mobile Solutions API.

The API documentation is available here:
http://msgw.linkmobility.com/MessageService.htm

## Installation

Install `pylinkmobile` (available on PyPi):

	pip install pylinkmobile


## Usage

	from linkmobile.service import MessageService
	
	service = MessageService(username='YOUR_USERNAME', password='YOUR_PASSWORD', debug=False)
	
	# Send SMS
    sms = service.sms(
        Data='Hello World!',
        Originator='Santa',
        Msisdn='+4700000000'
    )
    response = sms.send()
django-isitup 0.1.4
A simple reusable application for managing a small orgs governance in a Django application.
License: BSD

Django Is It Up 
================== 

Is it up is a fairly straight forward app that takes on the task of checking
web services to see if they are up and running. At the moment, the only goal
is to have it checking http services and sending out emails if an error code
is reached at a specified url.


Install
---------

```
pip install django-isitup
```

Else you could follow whatever procedure you use to install python packakges (easy_install, etc)

Configuration
--------------

Currently there is little to configure. The important part is to wire it up in your django project:

```
INSTALLED_APPS = (
    ...
    'isitup',
    ...
)
```

In your urls:

```
urlpatterns += patterns('',
    ...
    (r'^<your hook>/', include('isitup.urls')),
    ...
)
```

Templates (& URLs)
--------------------

All templates go in a 'isitup' directory in your TEMPLATE_DIR:

```
service_list.html (/)

service_create.html (/create/)

service_detail.html (/<slug>/)

service_edit.html (/<slug>/edit/)

```
IterDict 0.2.0
Dict that lazily populates itself with items from the iterator it was constructed with as keys are accessed
License: BSD
Keywords: dict lazy bigdata

# Haven't you always wanted an infinite dict?

IterDicts are similar to regular Python dicts except that they're only
populated upon demand. This gives them most of the same advantages of
generators, such as the ability to operator on very large (or infinite!)
datasets.

## Accessing keys that aren't populated yet

When the `get` or `__getitem__` methods are called, an IterDict tries to
fetch a key in the normal manner. If that fails, it starts consuming the
iterator it was constructed with and adding those items to itself until
it finds the key (or the universe dies of heat death):

    >>> d = IterDict((a, a) for a in xrange(1000000000000000))  # 1 quadrillion (US)
    >>> d[10]
    10
    >>> list(d)
    [you're going to be here a while]

## Important differences

A dict consumes its iterator at initialization, and in the case of duplicates
the last value wins:

    >>> d = dict([(1,1),(1,2)])
    >>> d
    {1: 2}
    >>> del d[1]
    >>> d
    {}

IterDicts differ in that they stop consuming their iterators as soon as the
first instance of a requested key is found:

    >>> i = IterDict([(1,1), (1,2)])
    >>> i
    IterDict<{}, fed by <listiterator object at 0x105bab8d0>>
    >>> i[1]
    1
    >>> i
    IterDict<{1: 1}, fed by <listiterator object at 0x105bab8d0>>

For space, time, and complexity reasons, IterDicts don't track keys that were
present at one point and have been since deleted. This means that keys may
reappear after deletion if the IterDict's iterator yields them again.
Continuing the previous example:

    >>> del i[1]
    >>> i
    IterDict<{}, fed by <listiterator object at 0x105bab890>>
    >>> i[1]
    2
    >>> i
    IterDict<{1: 2}, fed by <listiterator object at 0x105bab890>>
uricore 0.1.2
URI Parsing for Humans.
License: BSD

# urilib

[![Build Status](https://secure.travis-ci.org/core/uricore.png?branch=master)](http://travis-ci.org/core/uricore)

**WARNING: Rough, raw, and fast changing code. Check back later. ;-)**

--

Example of use:

    >>> from httpcore.uri import URI
    >>> from httpcore.iri import IRI
    >>> iri = IRI(u'http://\N{SNOWMAN}/')
    >>> iri
    IRI(u'http://\u2603/')
    >>> uri = URI(iri)
    >>> uri
    URI('http://xn--n3h/')
    >>> iri.netloc
    u'http://\u2603/'
    >>> iri.hostname
    '\u2603'
    >>> iri.port is None
    True
    >>> iri.path
    u'/'
    >>> hasattr(iri, '__hash__')
    True
    >>> iri.replace(port=8000)
    IRI(u'http://\u2603:8000/')
    >>> iriq = iri.update_query({'foo': u'42'})
    >>> iriq
    IRI(u'http://\u2603/?foo=42')
    >>> iriq.update_query(foo=None)
    IRI(u'http://\u2603/')
    >>> iriq.query
    MultiDict([('foo', '42')])
    >>> URI.from_template('http://{domain}/find{?year*}', domain="example.com",
    ... year=("1965", "2000", "2012"))
    URI('http://example.com/find?year=1965&year=2000&year=2012')
unittest_jshint 1.0
python unittest integration for jshint
License: BSD

Introduction
============

This package integrates `JSHint`_ with Python's `unittest`_ module. This
package was inspired by `gocept.jslint`_.

`JSHint`_ is a community-driven tool to detect errors and potential problems in
JavaScript code and to enforce your team's coding conventions.

It provides a special JSHintTestCase class that collects JavaScript files (in
a configurable manner) and dynamically generates a test method for each file
that calls jslint on that file.

.. contents::


Usage
=====

To use it, create a test class like this::

    class MyPackageJSLintTest(unittest_jshint.JSHintTestCase):

        include = (
            'my.package.browser:js',
            'my.package.browser:js/lib',
            )

        options = ( 'curly', 'eqeqeq', )


``include`` is a list of "resource paths" of the form ``packagename:path``
(passed to pkg_resources).

``exclude`` can be a list of filenames (without path) that will not be
collected.

``options`` is a list of arguments that are passed to JSHint (see its
`documentation`_ for details). The default value is::

    options = ()


All files ending in ``.js`` contained in each of these paths will be collected,
and the test class will grow a method named ``test_<filename>.js``.

You can ignore JSHint error by setting ``ignore`` on the test class (a list of
substrings that are matched against each JHLint output line)::

    ignore = (
        "Use a named parameter",
        )


Requirements
============

``unittest_jshint`` was tested with:

- Python 2.6 (unittest2 required)
- Python 2.7

Currently I only test with `Python`_ versions that are used by `Plone`_ so it
just might work for other `Python`_ versions.

``unittest_jshint`` requires ``jshint`` to be in the ``PATH`` or providing
customized environmental variable ``UNITTEST_JSHINT_COMMAND``.


Contributors
============

- `Rok Garbas`_, garbas



.. _`JSHint`: http://www.jshint.com
.. _`gocept.jslint`: http://pypi.python.org/pypi/gocept.jslint
.. _`documentation`: http://www.jshint.com/options/
.. _`Python`: http://www.python.org
.. _`Plone`: http://www.plone.org
.. _`Rok Garbas`: 'http://garbas.si
jasinja 0.8.0
A JavaScript code generator for Jinja templates
License: BSD

About Jasinja
=============

Jasinja is a compiler for Jinja templates targeting Javascript. I started
it when we wanted to start generating or extending some of the pages in
an internal webapp with dynamic webapp. I have grown rather fond of Jinja's
template syntax, and much prefer it to working with JavaScript (which, in
my experience, is rather limited compared to Python itself). I thus wrote
a proof of concept to have Jinja templates compiled to JavaScript, and
Jinja is the result. It works quite well for the (admittedly limited)
subset of Jinja we use at work, and I hope it may work well for you.

Requirements
============

Jasinja has been tested against Python 2.5, 2.6 and 2.7. It only depends on
Jinja (tested against version 2.6) and setuptools/Distribute. However,
running the test suite has two further requirements: python-spidermonkey
(tested with version 0.0.10) and JSON support. For JSON support, either the
stdlib json module can be used or the simplejson library (the latter is
always preferred when installed).