semvec/pypi-packages huggingface dataset:
django-shortwave 0.9.1
Django app for managing Shortwave command files.
License: BSD

=================================================
 Django app for managing Shortwave command files
=================================================

This application provides the ability for users to create and manage
custom command files for use with Shortwave_.

Using the instructions found in the `default commands file`_, users can add
their own commands to a custom wave file. They can then provide the URL of
their custom commands file to Shortwave_ and save their new bookmarklet.

From that point users can add, delete, and change their custom commands from a
Web interface and their bookmarklet updates immediately (that's the beauty of
Shortwave_).

Refer to the documentation_ for further information.

.. _Shortwave: http://shortwaveapp.com/
.. _default commands file: http://shortwaveapp.com/waves.txt
.. _Django: http://www.djangoproject.com/
.. _documentation: http://readthedocs.org/docs/django-shortwave/
django-extra-form-fields 0.0.1
Additional form fields for Django applications
License: BSD
Keywords: django,module

Additional form fields to use in Django applications:

* NextUrlField - add to forms that need to store url of next page
* get_next_url - utility function to extract next url from the request object
* UserNameField - field to enter user name - allows unique username site-wide
* UserEmailField - allows unique email address site-wide if ``EMAIL_UNIQUE`` setting is ``True``
multi-registry 0.0.2
A module that aggregates key-value attributes from multiple sources
License: BSD
Keywords: settings,registry

Allows to aggregate key-value data from many sources.
    Can be used, for example, as a proxy to settings object in Django framework.

    The sources of key-value data are appended to :class:`MultiRegistry`
    vi ``append()`` method, then looked up via standard Python
    dotted notation, as explained in more detail below.

    Upon access, attributes will be looked up in the parent objects
    in the order the latter were appended.

    For example, if we have two settings like objects:
    ``A`` with attribute ``a``
    and ``B`` with attribute ``b``
    and a third one, found in module importable from ``'some.registry.C'``,
    we can construct the registry as:

    >>>r = MultiRegistry(A, B, 'some.registry.C')

    or alternatively:

    >>>r = MultiRegistry()
    >>>r.append(A)
    >>>r.append(B)
    >>>r.insert(2, 'some.registry.C')

    .. note::
        The registries can be provided as python objects or
        dotted python paths. In the latter case an import error will
        be raised if module at the path does not exist

    then access the registry as:

    r.b - attrubute b will be first looked
    up in the object A, then in the object B, where
    it will be found.

    If there is an attribute present in more than one appended object,
    the first one will be returned - in the same order the 
    registries are stored internally, which takes into account:

    * order the registries were provided at the object initialization
    * order of ``append()`` calls.
    * taking into account indices provided with ``insert()`` call

    If the attribute is not found, attribute error will be 
    raised.
import-utils 0.0.1
A module that supports simple programmatic module imports
License: BSD
Keywords: import,module

Utilities for loading modules,
supporting programmatic imports of types::

    >>>from import_utils import import_module_from, import_module
    >>>import x as mod_x
    >>>mod_x = import_module('x')
    >>>
    >>>import x.y as mod_xy
    >>>mod_xy = import_module('x.y')
    >>>
    >>>from x.y import z
    >>>z = import_module_from('x.y.z')
django-order 0.0.7
Django app allowing users to manually order objects via admin.
License: BSD

Django Order
============
**Django app allowing users to manually order objects via admin.**

Provides an additional *order* tool within admin with which objects can be ordered by any number of arbitrary ``settings`` defined fields. A ``user_order_by`` queryset method allows for retrieval of objects as they were ordered by users via admin. 

.. contents:: Contents
    :depth: 5

Installation
------------

#. Install or add ``django-order`` to your Python path.

#. Install ``django-object-tools`` as described `here <http://pypi.python.org/pypi/django-object-tools#id3>`_.

#. Add ``order`` to your ``INSTALLED_APPS`` setting.
   
#. Add an ``ORDERABLE_MODELS`` setting to your project's ``settings.py`` file. This settings is a dictionary containing model-app label strings for those models you want to make orderable as keys. Values take the form of a tupple containing field names on which you want the relevant model to be orderable. I.e. to make the ``User`` model orderable for hypothetical *home* and *users* pages, add the following ``ORDERABLE_MODELS`` setting::

    ORDERABLE_MODELS = {
        'auth.User': ('home', 'users'),
    }

Usage
-----

Admin
~~~~~
Once a model has been registered as orderable an additional *Order* object tool should be visible on the model's change list view.

.. image:: http://cloud.github.com/downloads/praekelt/django-order/django-order-tool.jpg

You can order your items using this tool for each field name specified for you orderable model.

Querysets
~~~~~~~~~

With the ``order`` app installed all queryset objects will have a new ``user_order_by`` method. This method behaves exactly the same as Django's builtin ``order_by`` method except that it expects one of the settings defined field names for the model being queried. It will order the queryset based on the field name you provide. For example, to order users for the *home* page in our hypothetical example you would use the method as follows::

    User.objects.all().user_order_by('home')

Authors
=======

Praekelt Foundation
-------------------

* Shaun Sephton

Changelog
=========

0.0.7 (2011-09-15)
------------------
#. django-object-tools refactor.

0.0.6
-----
#. Tests, docs, cleanup, descending ordering, bugfixes.

0.0.5
-----
#. No longer use class_prepared signal.

0.0.4
-----
#.Initial public release.
PyLogDecorate 0.33.4
Advanced python logging decorators.
License: BSD
Keywords: python logging decorators

Have you ever wanted to have logging decorators for logging function calls and for automatic creation of logger object in class, based on class hierarchy.

If your answer is true, here is my implementation https://github.com/offlinehacker/PyLogDecorate. 

There is very nice option i’ve implemented called subdecorate, enabling for functions in derived classes being logged, even if decorator is only applied on base class functions. 

I've also added option to recursively trace function calls betwene objects. I've implemented this using a set of trace series. Well you actually only speciffy on class functions, that you want to trace, name of trace(tracename) series and class attribute that you want to be written to log when you enter or leave this this function. If you do this, LogCall will write a logging message to logger when you enter and leave function, with additional parameters of log series(tracename) and specificed class attribute(traceattr). Processing these messages with python log Formatter you can reconstruct execution for one or more trace series. This is much better than stack trace, because you can trace what you want to trace, not the whole stack and helps you a lot with complicated recursive programs.

- Install:
    python setup.py install or easy_install PyLogDecorate.


- Example code:

 ::

    from log import LogCall, LogClass
    
    @LogCall()
    def test():
        print "x"
    
    @LogClass({"subdecorate": True})
    class test1(object):
        name="kekec" 
        name2="kekec2"
        @LogCall({"subdecorate": True, "tracename": "tracetest", "traceattr": "name"})
        def test(self):
            pass
        
        @LogCall({"subdecorate": True, "tracename": "tracetest", "traceattr": "name2"})  
        def test2(self):
            self.logger.debug("Inside base class!")
    
    @LogClass()
    class test2(test1):
        def __init__(self):
            pass
        
        def test(self):
            self.logger.debug("Inside funtion.")
            self.test2()
            
    @LogClass()   
    class test3(test2):
        def __init__(self):
            pass
        
        def test(self):
            self.logger.debug("Inside funtion2.")
            self.test2()
        
        
    test()
    b=test3()
    c=test2()
    b.test()
    c.test()