Saravanan666/pypi-org huggingface dataset:
Package: django-litetest
A lightweight Djangomanage.py litetestcommand for quick unittest
runs.If you’ve been developing in Django for a while, you probably have
plenty of tests written. This is great, but they probably take a long
time to run. If you do any sort of Test-Driven Development, slow tests
means a frustrating edit-test loop.django-litetesthelps you run quick, lightweight tests by doing a
few things:Use in-memory SQLite databases instead of your usual test
databases,Use in-memory caches instead of your usual caches,If you’re using South, creates models directly.Withdjango-litetest, fixing a bug becomes as quick as this:Add a new test to reproduce the bug,Runmanage.py litetesttestname,Edit the code to fix the bug,Runmanage.py litetesttestnameagain,Runmanage.py testto ensure that all your tests pass.InstallationYou can get a copy of the source by using:$ git clone https://github.com/sfllaw/django-litetest.gitThis app requires:Python 2.6 or higher,Django 1.3 or higher,SpatiaLite(optional for GIS).As well, this app is available from PyPi:$ pip install django-litetestConfigurationIn your Djangosettingsfile:Add'django_litetest'toINSTALLED_APPS(after'south'if you are using it),Add'LITETEST': Trueto each of theDATABASESyou want sped up,Add'LITETEST': Trueto each of theCACHESyou want sped up,If you are using South, setSOUTH_TESTS_MIGRATE = 'LITETEST'to
avoid migrations.ExamplesettingsfileINSTALLED_APPS = (
    'south',
    'django_litetest',
    ...
)

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'db',
        'USER': 'user',
        'PASSWORD': 'password',
        'HOST': 'db.example.com',
        'PORT': '',
        'LITETEST': True,
    }
}

CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',
        'LOCATION': 'memcache.example.com:11211',
        'LITETEST': True,
    },
}

SOUTH_TESTS_MIGRATE = 'LITETEST'Reporting bugs and submitting patchesPlease check ourissue trackerfor known bugs and feature requests.We accept pull requests for fixes and new features.AuthorsSimon Law <sfllaw@sfllaw.ca>
Package: djangolive
djangolive package is basically a bunch of beautifully  crafted apps. It can also be considered
as a template project for new django developers. I will be adding new apps into the apps package.
Any feedbacks to improve the code quality, features, test are really appreciated. I am able to put
20Hrs every week to make the project alive. Any contributors with same wavelength are welcome to the
community.For full documentation, visitdjangolive.readthedocs.io.FeaturesUser activity tracking and loggingTrack users in django admin panelTestcasesFeatures in the scheduleCommon interface for commad patternCommon interface for strategy patternHelper utils for common taskRich Mixin collectionInstallationInstall djangolive by running:pip install djangoliveConfigurationWe need to hookdjangoliveinto our project.Putdjangolive.apps.activeuserinto yourINSTALLED_APPSat settings module:INSTALLED_APPS=(...'djangolive.apps.activeuser',)Add extra middleware backend to yoursettings.py:MIDDLEWARE=["...","apps.activeuser.middleware.ActivityMiddleware",]Createdjangolivedatabase tables by running:python manage.py migrateContributeIssue Tracker: github.com/tomvictor/djangolive/issuesSource Code: github.com/tomvictor/djangoliveSupportIf you are having issues, please let raise issue on github.LicenseThe project is licensed under the MIT license.
Package: django-livechat
django-livechat===============django-livechat provides a simple application to enable a very rudimentary"live" chat session around a selected topic. It is based on functionalityoriginally developed for the Ummeli website.A LiveChat model can be instantiated on its own, or hanging of another contenttype. It subclasses jmbo.ModelBase to use the commenting, moderating, likes,etc. functionality provided by the jmbo framework.In the admin site, on any live chat model's change form view, there is a newbutton in the toolbar at the top right of the page to enable a moderator orexpert to participate in the livechat, and respond to questions or posts.A context processor checks for active live chats, and will add it to therequest context for use in templates, and to modify URLs, if necessary.There are template tags that will display an entire live chat and its commentsthread in a template, as well as to display a banner advertising an upcominglive chat.Dependencies------------### System libraries- T.B.D.### Python packages- Django 1.4.5- South 0.8.1- jmbo 0.5.5                The version is important!Other dependencies include:- django-category 0.1.1- django-likes 0.0.12- django-photologue 2.7- django-preferences 0.0.6- django-publisher 0.0.3- django-secretballot 0.2.3- django-sites-groups 0.1.2- django-tastypie 0.10.0- python-dateutil 2.1Usage-----For production, install the application with:python setup.py installFor development, install the application with:python setup.py develop### SettingsThe following settings must be added to settings.py:INSTALLED_APPS += ('livechat',)The jmbo application and its dependecies should also be installed, but will probablyalready be installed. Refer to the jmbo application's documentation for moreinformation.You can add a context processor to add the newest live chat that is in progressto the request context.TEMPLATE_CONTEXT_PROCESSORS += ("livechat.context_processors.current_livechat",)Authors=======Praekelt Foundation-------------------* Jurgen Blignaut* Milton MadandaChangelog=========1.0.0=====- Initial release to pypi2013-09-17 - Created Initial Live Chat Product
Package: django-livefield
django-livefieldAboutA Django field that enables convenient soft-deletion. For Python 2.7/3.3+ and Django 1.8+InstallationSimple:pip installdjango-livefield.Example Usage>>>fromdjango.dbimportmodels>>>fromlivefieldimportLiveField,LiveManager>>>>>>>>>classPerson(models.Model):...name=models.CharField()...live=LiveField()......objects=LiveManager()...all_objects=LiveManager(include_soft_deleted=True)......classMeta:...unique_together=('name','live')......defdelete(self,using=None):...self.live=False...self.save(using=using)...>>>john=Person.objects.create(name='John Cleese')>>>doppelganger=Person(name='John Cleese')>>>doppelganger.save()# Raises an IntegrityError>>>john.delete()>>>doppelganger.save()# Succeeds!LicenseMIT. See LICENSE.txt for details.ContributingPull requests welcome! To save everyone some hassle, please open an
issue first so we can discuss your proposed change.In your PR, be sure to add your name to AUTHORS.txt and include some
tests for your spiffy new functionality.  CI will green-light your
build once it passes the unit tests (./setup.py test) and our
linters (./lint.sh).Changelog4.1.0Add support for Python 3.12Add support for Django 5.04.0.0Add support for Python 3.8 - 3.11Add support for Django 4.1 and 4.2Remove support for old Django versionsRemove support for old Python versions3.3.0Django 3.x supportswitch to BooleanField as base (Django 4.x deprecation)3.2.1Fix rST formatting in this file to pass PyPI rendering check3.2.0 (Not released)Support Django 2.2Support Python 3.7Fix metadata to remove deprecated Django versionsExpand travis tests for versions and database enginesRemove obsolete pylint suppressionsThanks to [@shurph](https://github.com/shurph) for the above!3.1.0Fix [deprecation of context param for Field.from_db_value](https://code.djangoproject.com/ticket/28370)Support for Django 2.1 (Thanks [@lukeburden](https://github.com/lukeburden)Switch tests suite to use pytestRemove pylint-django plugin, no longer needed3.0.0Add support for Python 3.6Add support for Django 2.0Remove support for Python 3.4Remove support for old Django versionsRemove GIS2.5.0 (Not released)Added official Python 3 support.Re-added support for Django 1.8. Now supports Django 1.8 and 1.9.2.4.0 (2016-02-11)Drop support for Django 1.8Add number of affected rows for delete methods (hard_delete, soft_delete, delete). Note: Django 1.9+ only.2.1.0 (2014-09-04)Add support for Django 1.7.2.0.0 (2014-07-13)Renamed top-level namespace tolivefield.Restructured internally to match Django convention.Added GIS support.Added South support.1.0.0 (2014-02-14)Initial release.Separated existing code from main application repository.Developed and maintained byHearsay Social, Inc..ContributorsAdam DePueAkshay ShahJohn LynnDylan VerheulGrant McConnaugheyLuke BurdenJames AddisonKrisztian Csizmazia
Package: django-livejs2
Integrateslive.jsinto your django project.There is already a project named django-livejs, so I added “2” to the name to avoid conflict. (Additionally I think my version is better than that one :P )InstallationEither runpython setup.py installor usepipto install the package.Edit yoursettings.pyto add'django_livejs2.middleware.LiveJsMiddleware'toMIDDLEWARE_CLASSES. Also add'django_livejs2'toINSTALLED_APPSif you want to use the shippedlive.js.UsageJust visit any page withlive=1in query string to enable the module. When enabled,live.jswill be included in every HTML page. The module will also make all files uncacheable by browser, so that any updates to static files will have effect immediately. (Without that Firefox may cache static files for 1 minute)Disabling is also easy, visit any page withlive=0in query string and you are done.Note: Ifsettings.DEBUGis notTrue, the module will be completely disabled since it is not really useful in production environment.SettingsLIVEJS2_SCRIPT_SRCIf you want to use a custom version oflive.js, set this to URL of the script.
Package: django-live-log
=====Django Live Log=====django_live_log is a package which can see live stream of file, such as log file, etc.Installation------------pip install django_live_logQuick start-----------1. Add "django_live_log" to your INSTALLED_APPS setting like this::INSTALLED_APPS = [...'django_live_log',]2. Include the django_live_log URLconf in your project urls.py like this::url(r'^dll/', include('django_live_log.urls')),3. Add "DLL_FILE" to settings.py::DLL_FILE = '/var/log/myfile.log' (should have read permission)4. Visit http://127.0.0.1:8000/dll/Options----------* DLL_URL in settings.py.Usage:DLL_URL = "/myurl/"so dll wii serve at `domain.com/dll/myurl/`* DLL_GROUP_PERMISSION in settings.pyGroup name or list of group names.Usage:DLL_GROUP_PERMISSION = "My group name" # or ["My group name1", "My group name2"] (strict in PROD mode)* fromStart pointer reading from file.Usage:domain.com/dll/myurl/?from=500* file_pathabsolute path of file to logUsage:domain.com/dll/myurl/?file_path=/var/log/myfile.log- Should have read permission
Package: django-live-logging
Allow live editing of logging configuration in django projects and/or log to internal database table.This project does not pretend to be ‘state of the art’,
was written in few hours to help to troubleshoot applications where is not possible to access to log file easily.
It allow you to temporarly enable database logging and change/add logging level and loggers using django admin interface.Thanks to Joeri Bekker for thehttps://github.com/joeribekker/django-logdbapplication
from which the database logging part of this package was taken.NoteOnly tested on Django 1.7Quick Installationpip install django-live-loggingOnce installed, update your Djangosettings.pyand addlive_loggingto your
INSTALLED_APPS:INSTALLED_APPS = (
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    ...
    'live_logging',
)Configure Database loggingCreate an handler in your logging configuration to store into database.LOGGING = {
    ...
     'handlers': {
        ...
        'db': {
            'level': 'DEBUG',
            'class': 'live_logging.handlers.DjangoDatabaseHandler',
            },
      }
    }
Package: django-live-profiler
Django-live-profiler is a low-overhead data access and code profiler for Django-based applications. For more information, check outhttp://invitebox.github.com/django-live-profiler/InstallationRunpip install django-live-profilerAdd‘profiler’app toINSTALLED_APPSAdd‘profiler.middleware.ProfilerMiddleware’toMIDDLEWARE_CLASSESOptionally add‘profiler.middleware.StatProfMiddleware’toMIDDLEWARE_CLASSESto enable Python code statistical profiling (usingstatprof). WARNING: this is an experimental feature, beware of possible incorrect output.Addurl(r’^profiler/’, include(‘profiler.urls’))to your urlconfUsageIn order to start gathering data you need to start the aggregation server:$ aggregated --host 127.0.0.1 --port 5556Visithttp://yoursite.com/profiler/for results.
Package: django-livereload
Application performing aLiveReloadwithtiny-lronce the development
server is ready.Why this project ?I recently started usingGulpandLiveReloadto automatize some
tasks. Everytime an HTML, CSS or JS file changes, a livereload is performed in
the browser to reflect those changes, and I was pretty happy with that.But I found one limitation, I cannot perform a livereload of the current
page when editing Python files because the development server provided by
Django is not necessary ready as soon as the livereload request is emitted.That’s why I created this application.InstallationFirst install the package on your system:$ pip install django-livereloadThen register the'livereload'application in yourINSTALLED_APPSsetting, before the'django.contrib.staticfiles'application if used.UsageIf the livereload server provided bytiny-lris launched (viaGulp,Gruntor whatever), therunservercommand will do a livereload on
your browser whenever the Django development server is ready.The scriptIf you want tolivereload-jsscript injected into your pages because you
don’t want to deal with a plug-in, simply register this middleware in your
project:'livereload.middleware.LiveReloadScript'.
Package: django-livereload-server
This django app adds a management command that starts a livereload server watching all your static files and templates as well
as a customrunservercommand that issues livereload requests when the development server is ready after a restart.InstallationInstall package:$ pip install django-livereload-serverAdd'livereload'to theINSTALLED_APPS, before'django.contrib.staticfiles'if this is used:INSTALLED_APPS = (
    ...
    'livereload',
    ...
)Next you need to inject the loading of the livereload javascript. You can do this in one of two ways:Through middleware by adding'livereload.middleware.LiveReloadScript'toMIDDLEWARE(probably at the end):MIDDLEWARE = (
    ...
    'livereload.middleware.LiveReloadScript',
)Through a templatetag in yourbase.html(or similar) template:{% load livereload_tags %}
...
{% livereload_script %}
</head>Either of these options will inject thelivereload.jsscript into your webpages ifDEBUGsetting is on.ConfigurationIf you need the livereload server to use a different host and port than the default 127.0.0.1 and 35729,
specify them by settingLIVERELOAD_HOSTandLIVERELOAD_PORTinsettings.py.UsageStart the livereload server:$ python manage.py livereloadkeep the livereload server running.Start the django development server as usual (in another console):$ python manage.py runserverIn the browser’s address bar access your web app by doing:127.0.0.1:8000 or localhost:8000now every time you hit save in your editor, the django-development-server/livereload-server automatically updates the staticfilesCustomizationBy default both template and staticfiles directories are watched.You can ignore template directories using:$ ./manage.py livereload --ignore-template-dirsOr staticfiles directories using:$ ./manage.py livereload --ignore-static-dirsYou can ignore file extensions:$ ./manage.py livereload --ignore-file-extensions=.less,.scssExtra files and/or paths to watch for changes can be added as positional arguments. By default livereload server watches the files that are found by your staticfiles finders and your template loaders.$ python manage.py livereload path/to/my-extra-directory/This will be excluded from the paths ignored by–ignore-template-dirsand–ignore-static-dirs.Host and port can be overridden with--hostand--portoptions.$ python manage.py livereload --host=myhost.com --port=9090the runserver commandpython manage.py runserveralso accepts three additional options:* ``--nolivereload`` to disable livereload functionality
* ``--livereload-host`` to override both default and settings file specified host address
* ``--livereload-port`` to override both default and settings file specified portBackgroundThis project is based on a merge ofpython-livereloadanddjango-livereload, excellent projects both and even better for
smooth django development when combined.
Package: django-liveserver
Django LiveServer==================A simple backport/extraction of the Django 1.4a LiveServerTestCase. Use selenium, splinter, or other browser clients for advanced functional testing. Credit goes to the Django core developers and extracted code comes from https://gist.github.com/1685139.Quick Start-----------First install using pip or setup.py:`pip install django-liveserver`Install selenium or another browser testing framework:`pip install selenium`Create your own test case. Here is an example:```pythonfrom django_liveserver.testcases import LiveServerTestCasefrom selenium.webdriver.firefox.webdriver import WebDriverclass MySeleniumTests(LiveServerTestCase):fixtures = ['test-data.json']@classmethoddef setUpClass(cls):cls.selenium = WebDriver()super(MySeleniumTests, cls).setUpClass()@classmethoddef tearDownClass(cls):super(MySeleniumTests, cls).tearDownClass()cls.selenium.quit()def test_hello(self):self.selenium.get(self.live_server_url)self.assertIn("Hello World", self.selenium.title)```Notes-----Since this code extraction, the 1.4 code has changed and this version might not include some useful improvements.
Package: django-live-server
This is purely the implementation of theLiveServerTestCasecode
due out in Django 1.4.Details are here:https://docs.djangoproject.com/en/dev/releases/1.4/#support-for-in-browser-testing-frameworkshttps://code.djangoproject.com/changeset/17241I make no claim at all to this code - it was written by people
much smarter than I!
Package: django-live-support
django-live-support=================A live support chat app for django that lets you chat with visitors to yoursite through the Django Admin interface.Dependancies============- django (tested with 1.3)- simplejson (required if using python 2.5, suggested otherwise)Getting Started=============To get started simply install using ``pip``:::pip install django-live-supportAdd ``live_support`` to your installed apps and ``syncdb`` (or migrate, ifyou have south installed).Your installed apps should look something like this:::INSTALLED_APPS = ('django.contrib.auth','django.contrib.contenttypes','django.contrib.sessions','django.contrib.sites','django.contrib.messages','django.contrib.admin','live_support',)Add ``live_support.urls`` to your urls.py, like so:::from django.conf.urls.defaults import patterns, include, urlfrom django.contrib import adminadmin.autodiscover()urlpatterns = patterns('',url(r'^admin/', include(admin.site.urls)),url(r'^support/', include('live_support.urls')),)If you are going to use the chat_iframe templatetag, be sure that you have'django.core.context_processors.request' in your TEMPLATE_CONTEXT_PROCESSORS.Usage=============You can either override the template for the ``start_chat``(live_support/start_chat.html) and ``client_chat``(live_support/live_support.html) views and just point users to the rootof the live_support app as defined in your urls.py file, or you can dropthe ``{% chat_iframe %}`` templatetag into your base template, but be sureto include {% load live_support_tags %} at the top of your template, whichwill render the chat sidebar (which pops out into a chat window) on everypage.
Package: django-live-templates
Django-Live-Templatesis
an extension toDjangoandChannelswhich adds
support for live updating Django template snippets on model changes.This project is based upon and a partial reimplementation to Channels ofSwampDragon-livewhich was build
usingSwampDragonwith SwampDragon-auth and django-redis.InstallationInstall the latest version from pypi.python.org:pip install django-live-templatesInstall the development version by cloning the source from github.com:pip install git+https://github.com/mback2k/django-live-templates.gitConfigurationAdd the package to yourINSTALLED_APPS:INSTALLED_APPS += (
    'channels',
    'django_live_templates',
)ExampleMake sure to use django-redis as a Cache backend named 'django-live-templates' or 'default':CACHES = {
    'django-live-templates': {
        'BACKEND': 'django_redis.cache.RedisCache',
        'LOCATION': 'redis://localhost:6379/0',
        'OPTIONS': {
            'CLIENT_CLASS': 'django_redis.client.DefaultClient',
        }
    }
}Load the required JavaScript template-tags within your Django template:{% load django_live_template %}Add the required JavaScript to your Django template:<script type="text/javascript" src="{{ STATIC_URL }}js/django_live_template.js"></script>Use the include_live template-tag instead of the default include template-tag,
with rows being a Django database QuerySet to listen for added, changed, deleted instances:{% include_live 'includes/table_body.html' rows=rows perms=perms %}Use the include_live template-tag instead of the default include template-tag,
with row being a single Django database Model instance to listen for changes:{% include_live 'includes/row_cols.html' row=row perms=perms %}Use the django_live_template variable within the included template to add the
required classes to the root-tag of this template, e.g. the first tag-node:<tr class="{{ django_live_template }}">...</tr>You can check if your template is being live rendered by a content pusher by
using the context variableis_django_live_templatelike this:{% if is_django_live_template %}
<style onload="alert('Hello World!');"></style>
{% endif %}A real-world example can be found in the Django project WebGCal:https://github.com/mback2k/django-webgcal/blob/master/webgcal/apps/webgcal/templates/show_dashboard.htmlhttps://github.com/mback2k/django-webgcal/tree/master/webgcal/apps/webgcal/templates/includesLicenseReleased under MIT LicenseCopyright (c) 2015-2019 Marc Hoerskeninfo@marc-hoersken.de
Package: django-livevalidation
Django Live Validation provides quick and easy client-side form validation which validates as you type.
It uses theLive ValidationJS library in conjunction with Django Forms.
This is by no means a replacement to Django’s built in form validation, but it is a suppliment which is purely client-side baed which cuts down on server-side requests for validation.
This version of django-livevalidation requires Django >= 1.2, for previous versions please use this project:http://opensource.washingtontimes.com/projects/django-livevalidation/InstallPlace'livevalidaiton'into yourINSTALLED_APPSand make sure it is above the Django admin since it overrides some of the admin templates:INSTALLED_APPS = (
    'livevalidation',
    ...
    'django.contrib.admin',
)UsageTo use livevalidation in your templates, make sure you load the headers first before doing anything:{% include 'livevalidation/header.html' %}This loads the JS library atjs/livevalidation_standalone.compressed.jsand the CSS atcss/livevalidation.css. Feel free to tweak the CSS to your likingNow you can use the templatetag to validate a form instance:{% live_validate form [option=value ...] %}Where theformis anydjango.forms.Form(or subclass) instance.
The optional option=value kwargs are in pairs as follows:validMessage- message to be used upon successful validation (DEFAULT: “Thankyou!”)onValid- javascript function name to execute when field passes validationonInvalid- javascript function name to execute when field fails validationinsertAfterWhatNode- id of node to have the message inserted after (DEFAULT: the field that is being validated)onlyOnBlur- whether you want it to validate as you type or only on blur (DEFAULT: False)wait- the time you want it to pause from the last keystroke before it validates (milliseconds) (DEFAULT: 0)onlyOnSubmit- if it is part of a form, whether you want it to validate it only when the form is submitted (DEFAULT: False)