Saravanan666/pypi-org huggingface dataset:
Package: django-backward
A Django application to store your previous history and action using differents
backends.With this application you will be able to redirect your users to their previous
location when they tried to access a page where the login is required.You will be also able to record previous action which needed login required.For example, if your user is not logged in your application and try to execute
an action which required authentication (e.g.: an user clicks on a button to follow another user),
this application will record parameters (even on POST) and execute the last action
when your user will be successfully logged.Thanks tooleiadefor the name.InstallationEither check out the package fromGitHubor it pull from a release via PyPIpip install django-backwardAddbackward.middleware.BackwardMiddlewareto yourMIDDLEWARE_CLASSESMIDDLEWARE_CLASSES = (
    'backward.middleware.BackwardMiddleware',
)Addbackward.urlsto yoururls.py# urls.py

from django.conf.urls import patterns, url, include

urlpatterns = patterns(
    '',

    url(r'^backward/', include('backward.urls')),
)Setsettings.LOGIN_REDIRECT_URLas mentioned in yoururls.pyfor example# settings.py

LOGIN_REDIRECT_URL = '/backward/login/redirect/'Configure yourSession engineif you are using the default backendUse the decoratorbackward.decorators.login_requiredif your views need authenticationConfigurationBACKEND_BACKEND_CLASSThe backend used to store information.The default backend class isbackward.backends.session.SessionBackend.backwards.backends.session.SessionBackendStore information inrequest.sessionusing yourSession enginebackwards.backends.session.CookieBackendStore information inrequest.COOKIES, you can configure a few things:BACKWARD_MAX_AGE: the age used to set an expiration date to the cookieBACKWARD_COOKIE_DOMAIN: the domain name used for the cookieBACKWARD_COOKIE_SECURE: if this is set to True, the cookie will be marked assecure, which means browsers may ensure that the cookie is only sent under an HTTPS connection.
Package: django-badbrowser
h1. django-badbrowser readmeh2. InstallationTo install django-badbrowser:# Install with easy_install/pip/whatever# Add @django_badbrowser.middleware.BrowserSupportDetection@ to the @MIDDLEWARE_CLASSES@ setting# Add @django_badbrowser@ to your @INSTALLED_APPS@ setting# Specify the @BADBROWSER_REQUIREMENTS@ setting (see below for details and additional settings)# Copy/sym-link the @django_badbrowser/media/django-badbrowser/@ directory into your media directoryh2. Config optionsh3. BADBROWSER_REQUIREMENTSA list of any specific browser restrictions. Browsers listed here with versions lower than the specified version numbers will be shown the "Unsupported web browser" message. Any browsers not listed here will be free to access the site as normal, as will any clients which do not specify a user agent.Example:<pre>BADBROWSER_REQUIREMENTS = (("firefox", "3.0"),("chrome", "3.0"),("microsoft internet explorer", "8"),("opera", None), # None indicates no support for the given browser, whatever the version)</pre>h3. BADBROWSER_SUGGESTA list of browsers to suggest to the user on the "Unsupported web browser" page.Example:<pre>BADBROWSER_SUGGEST = ("firefox", "chrome", "safari", "opera", "microsoft internet explorer")</pre>h3. BADBROWSER_BASE_TEMPLATEThe base template which should be extended in the rendering of the "Unsupported web browser" page. This page will probably need to have blocks for "extra_head" (within the head tag) and "content" (within the body tag)Example:<pre>BADBROWSER_BASE_TEMPLATE = "myapp/base.html"</pre>
Package: django-badgr
django-badgr===========A resuable [Django](http://www.djangoproject.com) application to display a [Flickr](http://www.flickr.com) badge.django-badgr uses the [Flickr API](http://www.flickr.com/services/api/) to [search](http://www.flickr.com/services/api/flickr.photos.search.html) Flickr and return a user's most recent photos. The results are cached and stored in the Django context. The photo pool is then accessible as a template variable.Requirements------------* [flickrapi](http://stuvel.eu/flickrapi) is used to interface with the Flickr API.Installation------------1. Put the `badgr` directory somewhere inside your Python path (like in your Django project folder).2. Add `badgr.context_processors.flickr` to your `settings.TEMPLATE_CONTEXT_PROCESSORS`.A good way to do this with overriding all of Django's default context processors is to first import the variable from the global settings and then append to it:from django.conf.global_settings import TEMPLATE_CONTEXT_PROCESSORSTEMPLATE_CONTEXT_PROCESSORS += ('badgr.context_processors.flickr',)### OptionalIf you want to take advantage of django-badgr's default template, add `badgr` to your `settings.INSTALLED_APPS`.Usage-----After installing, the `flickr_badge` variable will be available to all templates. This is a list of dictionaries, each containing all information returned by the Flickr API for each photo. In addition, the URL both to the image itself and to the associated Flickr badge have been prebuilt and are included in the dictionary.If you have added `badgr` to your `settings.INSTALLED_APPS`, django-badgr's default template will be available for use. This outputs a list of images, each linked to the corresponding Flickr page. To use it, simply include the template in your desired location.{% include 'badgr/photos.html' %}Settings--------django-badgr includes a few settings that you may define in your project's main `settings` file.### `FLICKR_APIKEY`The Flickr API key to use. This can be acquired at http://www.flickr.com/services/api/keys/### `FLICKR_USERID`The Flickr user ID to use. This is the ugly string on characters, not the pretty name you may have set for your account. If you do not know your user ID, you may find it at http://idgettr.com/### `FLICKR_NUMPHOTOS`The number of photos to pull. This defaults to 12. Flickr's maximum is 500.### `FLICKR_TIMEOUT`For how long should the photo pool be stored in the cache. This defaults to the [Django cache timeout](https://docs.djangoproject.com/en/dev/ref/settings/#std:setting-CACHES-TIMEOUT), which defaults to 300 seconds (5 minutes). Flickr requests that an application not make more than 3600 requests per API key per hour.### `FLICKR_IMAGESIZE`The size of the image you wish to build the URL for. The default is medium (500 on the longest side). Available options are:* 's': small square 75x75* 'q': large square 150x150* 't': thumbnail, 100 on longest side* 'm': small, 240 on longest side* 'n': small, 320 on longest side* '' : medium, 500 on the longest side* 'z': medium, 640 on longest side* 'c': medium, 800 on longest side* 'b': large 1024 on longest side
Package: django-bagou
Tornado WebSocket server backed with PikaClient connected on RabbitMQ.The goal of this architecture is to provide a way to integrate full duplex websockets in
synchronous application with RabbitMQ as message bus.Server is Tornado WebSocketHandler with a PikaClient consumer.Installationgit clone https://github.com/toxinu/django-bagou.git
cd django-bagou/example
virtualenv virtenv
source virtenv/source/activate
pip install django
pip install -e ..
python manage.py runserver
# In another terminal
python manage.py runwebsocket
# Go to http://localhost:8000IncomingFor example, incoming websocket messages from Tornado are pushed to a queue (Celery for example)
or just computed.Browser send websocket messageTornado received it
* Sending AMQP message
* Run Celery task (from Django?)Torndo reply to websocketBrowser received websocket messageSendingDjango application can publish messages on RabbitMQ, which will be consumed by Pika and
pushed to websockets.Running arbitary Python codeSend AMQP message to websocket queuePikaClient wich run with Tornado consumed itPikaClient tell Tornado to send websocket message to browserBrowser received websocket messageTodoChannel permissionUser authentification based on sessionidIntegrated with Celery ?Helpers for getting channels
Package: django-bakery
# # # # #
              __#_#_#_#_#__
             {_` ` ` ` ` `_}
            _{_._._._._._._}_
           {_  D J A N G O  _}
          _{_._._._._._._._._}_
         {_    B A K E R Y    _}
     .---{_._._._._._._._._._._}---.
    (   `"""""""""""""""""""""""`   )
     `~~~~~~~~~~~~~~~~~~~~~~~~~~~~~`A set of helpers for baking your Django site out as flat filesDocumentation:palewi.re/docs/django-bakeryIssues:https://github.com/datadesk/django-bakery/issuesPackaging:https://pypi.python.org/pypi/django-bakeryThe dream, in Powerpoint form:palewi.re/docs/django-bakery/_static/the-dream.pdfFeaturesModels, views and management commands that will build your site as flat files.Management commands to sync your flat files with a bucket on Amazon S3.Optional integration of a Celery job queue to automatically build and publish model objects when they are saved
Package: django-balanced
# django-balanced## How to send ACH payments in 10 minutes1. Visit www.balancedpayments.com and get yourself an API key2. `pip install django-balanced`3. Edit your `settings.py` and add the API key like so:import osBALANCED = {'API_KEY': os.environ.get('BALANCED_API_KEY'),}4. Add `django_balanced` to your `INSTALLED_APPS` in `settings.py`INSTALLED_APPS = (...'django.contrib.admin',  # if you want to use the admin interface'django_balanced',...)5. Run `BALANCED_API_KEY=YOUR_API_KEY django-admin.py syncdb`6. Run `BALANCED_API_KEY=YOUR_API_KEY python manage.py runserver`7. Visit `http://127.0.0.1:8000/admin` and pay some people!
Package: django-balancer
A set of tools for using Django’s multi-db feature to balance database requests
between multiple replicated databases.  It currently provides some basic
routers for using weighted random selection or round robin selection with a
pool of databases, following a master/slave layout where the slaves are
read-only copies of master, and pinning reads to master for a user after that
user completes a write.Since everything is implemented using base classes and mixins, this also serves
as a construction kit for creating your own more complex routers.  Feel free to
contribute routers, and I’ll be happy to incorporate them into the project.InstallInstall django-balancer viapip$pipinstalldjango-balanceror, witheasy_install$easy_installdjango-balancerBut, hey…that’s up to you.Documentationhttps://django-balancer.readthedocs.org/en/latest/
Package: django-balystic
Connect to Balystic API in your Django projectQuickstartInstall Django Balystic:pip install django-balysticThen use it in a project:import balysticFeaturesThis client makes it easy to use the balystic API.
Just add a couple settings:BALYSTIC_API_TOKEN = 'mysecrettoken'
BALYSTIC_API-PATH = 'mycommunity.7dhub.com/api/'Then create a client instance:from balystic.client import Client
client = Client()And use the client to perform the requests:user_list = client.get_users()
user_detail = client.get_user_detail()
client.delete_user()A couple of views have been defined to display information
from your community.blogs:::blog/    | template name = blog_list.html
blog/<slug>/ | template name = blog_detail.htmlqa:::qa/ | template_name = qa_list.html
qa/<pk>/ | template_name= qa_detail.htmlto modify the template, create a folder in your project template folder called
** balystic ** with the same name of the used inside the balystic app.Running TestsDoes the code actually work?source <YOURVIRTUALENV>/bin/activate
(myenv) $ pip install -r requirements_test.txt
(myenv) $ python runtests.pyCreditsTools used in rendering this package:Cookiecuttercookiecutter-djangopackageHistory0.1.0 (2016-07-28)First release on PyPI.
Package: django-banana
Banana is a pure backend split testing addition to Django, which exposes
experiment selections in the template context to be handled by frontend
data collection frameworks. Actual experiment option selection is stored using
the built-in Django sessions.InstallationTo installdjango_banana, do yourself a favor and don’t use anything other thanpip:$pipinstalldjango-bananaAdddjango_bananato the list of installed apps in your settings file:INSTALLED_APPS=('django_banana',..)
Package: django-bankdownloads
#django-bankdownloadsdjango app to import and standardise bank transaction downloadsimports ofx (open financial exchange format) via the ofxparse libraryimports csv using regex to match data columnsbankid and accountid taken from original file if possible, otherwise from a filename in the format<bankid>-<accountid>-YYYYMMDD.<ext>creates a standardised data dictionary with headers:date
transid
value
currency
memo
payee
accountid
bankid
fxcurrency
fxrate
fxamountoutputs data in ofx format##Requirementsworking django site##InstallGet the code> git clone git://github.com/evandavey/django-bankdownloads.git django-bankdownloadsInstall via pip> pip install django-bankdownloadsAdd ‘bankdownloads’ to INSTALLED_APPSAdd BANKDOWNLOADS_IMPORT_PATH,BANKDOWNLOADS_OUTPUT_PATH,BANKDOWNLOADS_EMAILS and BANKDOWNLOADS_NOTIFIER_EXCLUDES to settings##Useprovides a ‘BankDownload’ class that can be reused in other applications> mydownload = BankDownload()> mydownload.original_file=[file]> mydownload.save()access standardised data via the ‘data’ property> data = mydownload.data> ofx = mydownload.export_ofx()use management command bankdownloads_notifier to email if data is missing for a given monthuse management command bankdownloads_processor to batch import bank downloads and output standardised ofx##AuthorsEvan Daveyevan.davey@cochranedavey.com##LicensesCC-SA-NC[Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License][cc-nc-sa].![][img-cc-nc-sa][cc-nc-sa]:http://creativecommons.org/licenses/by-nc-sa/3.0/[img-cc-nc-sa]:http://i.creativecommons.org/l/by-nc-sa/3.0/88x31.png
Package: django-banner
基于django的轮播图模块使用方法:修改settings.py文件:INSTALLED_APPS = (
    ...
    'adminsortable2',
    'banner',
    ...
)添加数据表:python manage.py migrate版本更改:v0.3 添加多语言支持v0.2 添加分组v0.1 第一版
Package: django-banner-simple
Django simple banner template tagLink to repository:https://github.com/Arpaso/django-banner-simpleProvides new template tag to display banner uploaded via admin interface.Bannermodel andBannerAdminis added.UsageYou have to use south migrations to update your database:python manage.py migrateNoteBanner admin page is provided for adding banner through django admin interfaceAdd application to INSTALLED_APPS in settings.py:...
'banner',
...Use template tag in your templates as is:{% get_banner 'banner_name' 150 150 %}Noteget_banner(slug, width, height, queryset=Banner.objects.all())Uses alsosettings.STATIC_URLto display banner image.Written by the development team of Arpaso company:http://arpaso.com
Package: django-banzai
API обёртка на Python над сервисомget-n-post.ru.ЗависимостиПакету требуются:requestsиlxml.Установка и настройкаУстановить пакет из PyPI:$ pip install django-banzaiДобавить приложениеbanzaiв вашиINSTALLED_APPS.Заполнить в настройкахBANZAI_API_KEY- API-ключ, сгенерированный сервисом для вашего IP-адреса.ИспользованиеОтправить email с django-совместимым синтаксисом:from banzai.base import send_mail

send_mail('subject', 'mail body', 'from@myprojectand.me', ['to@lovely.users'])Или отправить email согласно принципам get-n-post:from banzai.mail import MailPackage
from banzai.api import BanzaiAPI

mail_package = MailPackage(email_from, name_from, subject, message)
mail_package.add_recipients(recipient_list)
package = mail_package.save()

banzai_api_obj = BanzaiAPI(package)
package = banzai_api_obj.add()
Package: djangobars
djangobarsAn extension to allow Django to use Handlebars templates through the pybars port
of Handlebars.jsBecause don’t we all want to use the same templates on the client that we do on
the server?NOTE: This project is very early-stage.  Try it out, leave feedback and wishes
in the issues.  And pull-requests welcome!InstallationInstalldjangobars:pip install djangobarsAdd'djangobars'to your installed applications.Add aHANDLEBARS_LOADERSvalue to your settings module. You will probably
want:HANDLEBARS_LOADERS = (
    'djangobars.template.loaders.filesystem.Loader',
    'djangobars.template.loaders.app_directories.Loader',
)(optional)Add aHANDLEBARS_DIRSand/orHANDLEBARS_APP_DIRNAMESvalue to your setting module. By
default, djangobars will search in yourTEMPLATE_DIRSfolder, but you can
use theHANDLEBARS_DIRSvalue to override this behavior. For example, if
you want to use both Django templates and Handlebars templates, you may want
to keep the two in separate directories.UsageUse pretty much just as you would Django’s own built-in templates.  Instead of:from django.shortcuts import render

def my_view(request):
    # View code here...
    return render(request, 'myapp/index.html', {"foo": "bar"},
        content_type="application/xhtml+xml")do this:from djangobars.shortcuts import render

def my_view(request):
    # View code here...
    return render(request, 'myapp/handlebar_index.html', {"foo": "bar"},
        content_type="application/xhtml+xml")And instead of:from django.views.generic import TemplateView

class MyView (TemplateView):
    template_name = 'myapp/index.html'do this:from django.views.generic import TemplateView
from djangobars.response import HandlebarsResponse

class MyView (TemplateView):
    template_name = 'myapp/handlebar_index.html'
    response_class = HandlebarsResponseTemplate TagsYou can also include Handlebars templates with a Django template tag:{% load djangobars %}

{% include_handlebars "handlebars_template_name.html" %}The current template context will be carried over into the Handlebars template.0.2.0Update the installation instructions.0.2.0New dependencies on pymeta3 and pybars3.Include partials of other templates in the project.0.1.5Allow arbitrary objects as context for templates.0.1.4Fix a bug in the app directories template loader where the path names were
callingdecodein Python 2and3.0.1.3Change the installation detailsPip 1.5 makes it difficult to specify installation sources outside of the
PyPI. Also, this is better motivation to get these packages officially on
PyPI.0.1.2Depend on specific forks of pymeta and pybars0.1.1First Release
Package: django-base64field
==================Django Base64Field==================.. image:: https://travis-ci.org/Alir3z4/django-base64field.png:alt: travis-cli tests status for django-base64field:target: https://travis-ci.org/Alir3z4/django-base64field.. contents:: Table of contentsOverview--------- A motherfucking django model field to bring ``base64`` encoded key to models.- It uses ``base64`` from ``django.utils.baseconv`` for encoding.- Tested on Python2.7, Python3.3 .How it works?--------------``Base64Field`` is useful where you need a base64 encoded value frommodel's Primary Key a.k.a PK which is available on every djangoapplication model by default. Sine `base64` encoder works with`integer` value then PK should be also `integer`, Fortunatelyagain `PK` field is `integer` by nature.When a model gets saved, ``post_save`` signal will be emitted,This is where a ``base64`` encoded key will be generated/encodedfrom model's ``PK``, Then model will gets **updated** not getting save again.this operation happens just on the first time model gets saved.In next time model gets saved or updated ``base64`` won't be generated.You wanna know more about how ``django-base64field`` works? Then get da fuckout of ``README.rst`` and look inside the ``django_base64field.tests.py``.Usage-----Here is simple usage of ``Base64Field``::>>> from django.db import models>>> from django_base64field.fields import Base64Field>>>>>> class MyModelianto(models.Model):>>>     ek = Base64Field()>>>>>> modelia = MyModelianto.objects.create(pk=314159265358979323)>>> modelia.ek>>> u''>>> refreshed_modelia = MyModelianto.objects.get(pk=modelia.pk)>>> refreshed_modelia.ek>>> u'HS7Y_sdg3x'As You can see ``ek`` in not available on returned instancefrom ``MyModelianto.objects.create()``, It will be available after retrieving``refreshed_modelia`` from database which is same record as ``modelia`` here.This behavior can be easily controlled with implementing a simple helpermethod on ``MyModelianto``. You can find out more about this solution on``django_base64field.tests.py``, Which it doesn't require to retrievingthe instance from database after first creation just for getting ``ek` field.Installation------------``django-base64field`` is available on pypihttp://pypi.python.org/pypi/django-base64fieldSo easily install it by ``pip``::$ pip install django-base64fieldOr by ``easy_install``::$ easy_install django-base64fieldAnother way is by cloning ``django-base64field``'s`git repo <https://github.com/Alir3z4/django-base64field>`_ ::$ git clone git://github.com/Alir3z4/django-base64field.gitThen install it by running::$ python setup.py installOr I don't know, Install it directly from git.::pip install git+https://github.com/Alir3z4/django-base64field.git#egg=django-base64fieldSome pkgs have no installation method, This is awefuckingsome that``django-base64field`` gives you many ways for installation.
Package: django-baseboard
Dashboards that contain summaries of projects in Basecamp.Depends on the basecampreporting, simplejson and feedparser libraries.Changes in 0.3Better error handling and reporting for the management commands/cron jobsProjects are no longer required to have an RSS feed foreign key (bugfix from 0.2)Changes in 0.2Project.project_url returns the Basecamp project’s homepage URL (because Project.basecamp_url can be any valid URL within a project entered by a user)baseboard.helpers.update_summaries takes and honors a network timeout argument (defaults to 20 seconds)Projects now have RSSFeed foreign keys – suitable for displaying a Trac change log or a project blog, etc.Changes in 0.1Initial release