Saravanan666/pypi-org huggingface dataset:
Package: django-waffle-session
Django Waffle is (yet another) feature flipper for Django. You can
define the conditions for which a flag should be active, and use it in
a number of ways.Code:https://github.com/jsocol/django-waffleLicense:BSD; see LICENSE fileIssues:https://github.com/jsocol/django-waffle/issuesDocumentation:http://waffle.readthedocs.org/# Contributing to Waffle
Waffle is pretty simple to hack, and has a decent test suite! Here’s how to hack Waffle, add tests, run them, and contribute changes.Clone this repo2. Set Up
Setting up an environment is easy! You’ll want virtualenv and pip, then just create a new virtual environment and install the requirements:$ mkvirtualenv waffle$ pip install -r requirements.txtDone!3. Running Things
Waffle comes with a helper shell script to run tests and create schema migrations: run.sh. To run the tests, just:$ ./run.sh testRun the script with no arguments to see all the options.
Package: django-wagtail-customforms
Customforms is a simple Django app to attach forms to pages.Quick startinstall django-wagtail-customforms fromhttps://pypi.python.org/pypi/django-wagtail-customformspip install django-wagtail-customformsAdd “customforms” to your INSTALLED_APPS setting like this:INSTALLED_APPS = [
    ...
    'customforms',
]Check out the example app for usage.Runpython manage.py migrateonce your models are set up.
Package: django-wagtail-feeds
Support RSS Feeds, JSON Feed, Facebook Instant Articles and Apple News. Syndication feeds come in two flavors:BasicFeed-  A standardRSS V 2.0.1feed designed to be used without item enclosures.ExtendedFeed- An RSS V2/Atom Feed with support for item enclosures such as images or video. Use this if when want to integrate your feed with services like MailChimp or Flipboard.JSON feed come in two flavors:BasicJsonFeed-  A standardJSON feeddesigned to be used without content html.ExtendedJsonFeed- A JSON feed with support for content html in items.Getting StartedThe latest release (0.1.0) breaks backward compatibility  with previous versions of Wagtail which were baseed Django 1.x. Use 0.0.8 for projects based on older versions of WagtailTo use Django Wagtail Feeds in a project:pip install django-wagtail-feedsRemember to addwagtail_feedsto installed apps in settings file.django-wagtail-feedshas a dependency onwagtail settingsapp. You must addwagtail.contrib.settingsto your INSTALLED_APPS:INSTALLED_APPS += [
    'wagtail.contrib.settings',
    'wagtail_feeds',
]Run migrations for Wagtail feeds:./manage.py migrate wagtail_feedsAdd Feed settings in the Wagtail adminFinally reference it in the url.pyfrom wagtail_feeds.feeds import BasicFeed, BasicJsonFeed, ExtendedFeed, ExtendedJsonFeed

url(r'^blog/feed/basic$', BasicFeed(), name='basic_feed'),
url(r'^blog/feed/extended$', ExtendedFeed(), name='extended_feed'),

# JSON feed
url(r'^blog/feed/basic.json$', BasicJsonFeed(), name='basic_json_feed'),
url(r'^blog/feed/extended.json$', ExtendedJsonFeed(), name='extended_json_feed'),ContributingContributions are welcome, and they are greatly appreciated! Every
little bit helps, and credit will always be given.History0.1.0 (2018-05-8)Adds support for Django 2+ and Wagtail 2+. This release breaks backward compatibility  with versions of Wagtail which are based on Wagtail/Django 1.x. Use 0.0.8 for projects based on older versions of Wagtail0.0.8 (2017-06-26)Provide initial support forJSON Feed_.The JSON Feed format is a pragmatic syndication format, like RSS and Atom, but with one big difference: it’s JSON instead of XML.0.0.7 (2017-05-22)Support for Django 1.11 and Wagtail 1.10.1Temporarily reduce test coverage0.0.6 (2016-10-06)More comprehensive test coverage0.0.5 (2016-10-05)Added tests for StreamFields0.0.4 (2016-09-29)TheExtendedFeednow supports content fields based on StreamFieldsPrevious versions automatically added the post/article’s feed image to the content
enclosure. In this version, this can be toggled on or off with
a checkbox option in the Feed App SettingsSeveral bug fixes related to issues such the rendering of embedded objects in posts
and improperly formatted images0.0.3 (2016-07-18)Needed to pin html5lib version due to problems with BS40.0.2 (2016-07-13)First release on PyPI.
Package: django_wagtailmedium
Wagtailmedium is a Medium Editor integration for the Wagtail CMS.Note: A more detailed documentation is available in.codestoryformat, along with a sample project to fiddle with.InstallInstall from pip:pip install django-wagtailmediumAdd wagtailmedium to your apps:INSTALLED_APPS = [
  ...
  'wagtailmedium',
]3.Add a wagtailmedium widget to ``WAGTAILADMIN_RICH_TEXT_EDITORS``(implemented by wagtail, undocumented yet)WAGTAILADMIN_RICH_TEXT_EDITORS = {
     'default': {
         'WIDGET': 'wagtail.wagtailadmin.rich_text.HalloRichTextArea'
     },
     'medium': {
         'WIDGET': 'wagtailmedium.rich_text.MediumRichTextArea',
         'OPTIONS': {
             'custom_buttons': {
                 'code': {
                   'contentDefault': '<b>Code</b>',
                   'contentFA': '<i class="fa fa-code"></i>',
                   'tag': 'code',
                   'className': 'code',  # optional
                 },
                 'test': {
                     'contentDefault': '<b>Test</b>',
                     'contentFA': '<i class="fa fa-code"></i>',
                     'tag': 'span',
                     'className': 'test',  # optional
                 },
             },
             'medium': {  # https://github.com/yabwe/medium-editor#options-example
                 # 'buttonLabels': 'fontawesome',
                 'toolbar': {
                     'buttons': [  # https://github.com/yabwe/medium-editor#all-buttons
                         'bold', 'italic', 'underline',
                         'code',
                         'test',
                         'link',
                         'linkdoc',
                         'h2', 'h3', 'orderedlist', 'unorderedlist', 'strikethrough'
                     ]
                 },
             },
         },
     },
 }Register whitelister element rulesThis wagtailhookdefines which HTML elements are allowed in rich text areas.wagtail_hooks.py:from wagtail.wagtailcore import hooks
from wagtail.wagtailcore.whitelist import attribute_rule, allow_without_attributes


# http://docs.wagtail.io/en/v1.7/reference/hooks.html#construct-whitelister-element-rules
@hooks.register('construct_whitelister_element_rules')  # #7bFcf#
def whitelister_element_rules():
    return {
        'u': allow_without_attributes,
        'span': attribute_rule({'class': True}),
        'code': allow_without_attributes,
        'blockquote': allow_without_attributes,
    }Use wagtailmedium in a RichTextField of your modelmodels.py:from wagtail.wagtailcore.models import Page, StreamField, RichTextField

class HomePage(Page):
    # a default, Hallo editor
    hallo = RichTextField(blank=True)
    # a medium editor
    medium = RichTextField(editor='medium', blank=True)
Package: django-waitinglist
PinaxPinax is an open-source platform built on the Django Web Framework. It is an ecosystem of reusable Django apps, themes, and starter project templates.
This collection can be found athttp://pinaxproject.com.This app was developed as part of the Pinax ecosystem but is just a Django app and can be used independently of other Pinax apps.django-waitinglistdjango-waitinglistis a Django waiting list app for running a private beta with cohorts support.RequirementsDjango 1.4django-appconf (included ininstall_requires)django-user-accounts(not included ininstall_requires)DocumentationThe django-waitinglist documentation is available athttp://django-waitinglist.readthedocs.org/. The Pinax documentation is available athttp://pinaxproject.com/pinax/.Code of ConductIn order to foster a kind, inclusive, and harassment-free community, the Pinax Project has a code of conduct, which can be found herehttp://pinaxproject.com/pinax/code_of_conduct/.Pinax Project Blog and TwitterFor updates and news regarding the Pinax Project, please follow us on Twitter at @pinaxproject and check out our bloghttp://blog.pinaxproject.com.
Package: django-waitress
django-waitress===============Run a production-ready server from manage.py!This Django app just provides a management command that serves your Django project using Waitress, a production-ready and `Heroku-friendly <heroku>`_ WSGI server... _heroku: http://blog.etianen.com/blog/2014/01/19/gunicorn-heroku-django/Usage-----.. code-block:: sh# Serve on http://0.0.0.0:7000python manage.py serve --host 0.0.0.0 --port 7000# Serve on the Unix socket /var/run/myapppython manage.py serve --unix /var/run/myapp# Serve on the host defined by WAITRESS_HOST# and the port defined by WAITRESS_PORT# in settings.py# (defaults to localhost:8000)python manage.py serveAlternatives------------You could just install Waitress itself, and run the ``waitress-serve`` command it provides, pointing to your ``wsgi.py`` file; the only thing that this project does is provide a Django management command, and remove the need for a ``wsgi.py`` in your project.License-------This project was extracted from `CMV's cookiecutter-django <ccdj>`_.. _ccdj: https://gitlab.com/abre/cookiecutter-django.. raw:: html<p xmlns:dct="http://purl.org/dc/terms/" xmlns:vcard="http://www.w3.org/2001/vcard-rdf/3.0#"><a rel="license"href="http://creativecommons.org/publicdomain/zero/1.0/"><img src="http://i.creativecommons.org/p/zero/1.0/88x31.png" style="border-style: none;" alt="CC0" /></a><br />To the extent possible under law,<span resource="[_:publisher]" rel="dct:publisher"><span property="dct:title">Commercial Motor Vehicles Pty Ltd</span></span>have waived all copyright and related or neighboring rights to<span property="dct:title">cookiecutter-django</span>.This work is published from:<span property="vcard:Country" datatype="dct:ISO3166"content="AU" about="[_:publisher]">Australia</span>.</p>
Package: django-wallet
django-walletApple Wallet integration for a django a projectGetting StartedTo get started you should copy the 'wallets' folder to the your project directorygit clone https://github.com/Silver3310/django-wallets
cp -r django-wallets/wallets your-project-directoryPrerequisitesIf you want to make asynchronous pushes to users when their passes are updated you should install celerypip install celeryInstallingAfter you copied the app to your project directory, you should do the following stepsAdd the app to your project settingsINSTALLED_APPS=[...'wallets',...]# Wallets managementpath("/",include("index_auth_service.wallets.urls")),Define the model with your Pass from PassAbstract and add fields you needfromwallets.modelsimportPassAbstractclassPass(PassAbstract):"""The pass model for Apple Wallet"""discount_card=models.ForeignKey(DiscountCard,on_delete=models.CASCADE,verbose_name=_('Discount card'))Add the necessary constants# APPLE WALLETWALLET_CERTIFICATE_PATH='path-to-certificate-pem-file'WALLET_KEY_PATH='path-to-key-certificate-pem-file'WALLET_WWDR_PATH='path-to-wwdr-certificate-pem-file'WALLET_PASS_TYPE_ID='pass.com.you.pass.id'WALLET_PASS_PATH=os.path.join('the-path-where-you-want-store-passes','passes','pass{}.pkpass')WALLET_TEAM_IDENTIFIER='your-team-identifier'WALLET_ORGANIZATION_NAME='organization-name'WALLET_APN_HOST=('gateway.push.apple.com',2195)WALLET_ANDROID_HOST='https://push.walletunion.com/send'WALLET_ANDROID_API_KEY='get-it-in-the-official-site'WALLET_PASSWORD='certificate-key-passowrd'WALLET_ENABLE_NOTIFICATIONS=False# True if you want to send notifications (Celery needed for it)PASS_MODEL='your_app.your_model'Make migrations for your model and the wallets app and migrate thempython manage.py makemigrations
python manage.py migrateLicenseThis project is licensed under the MIT License - see theLICENSE.txtfile for details
Package: django-walleter
Django WalleterInstallationRun thepipcommand to install the latest version:pipinstalldjango_walleterAdddjango_walleterto yourINSTALLED_APPSin settings.py:INSTALLED_APPS=(...'django_walleter',)Run the migration command:pythonmanage.pymigrateUsageAdd theHasWalletmaixin to your model.fromdjango.dbimportmodelsfromdjango_walleterimportHasWalletclassProfile(models.Model,HasWallet):phone=models.CharField(max_length=255,verbose_name='Phone')address=models.TextField(max_length=512,verbose_name='Address')Then you can easily make transactions from your model.profile=Profile.objects.get(pk=1)profile.balance//0profile.deposit(100)profile.balance//100profile.withdraw(20)profile.balance//80profile2=Profile.objects.get(pk=2)profile.transfer(profile2,20)//orprofile.transfer(profile2.wallet,20)Remember ,you may use thedjango_walleter.HasWalletmixin on any of your models. You are not limited to only including it on yourProfilemodel.
Package: django-walletone
Django WalletOne is a pluggable application that integrates
with WalletOne online payments provider.Django WalletOne supports Django 1.7 to 1.9 on Python 2.7, 3.4.Seehttps://django-walletone.readthedocs.org/for application documentation.Seehttps://www.walletone.com/en/merchant/documentation/for
native WalletOne documentation.
Package: django-wallets
BTC, LTC, DASH, DOGE wallets for each user with withdraw with webhookDocumentationThe full documentation is athttps://django-wallets.readthedocs.io.QuickstartInstall Django wallets:pip install django-walletsAdd it to yourINSTALLED_APPS:INSTALLED_APPS=(...'wallets.apps.WalletsConfig',...)Add Django wallets’s URL patterns:fromwalletsimporturlsaswallets_urlsurlpatterns=[...url(r'^',include(wallets_urls)),...]FeaturesTODORunning TestsDoes the code actually work?source <YOURVIRTUALENV>/bin/activate
(myenv) $ pip install tox
(myenv) $ toxCreditsTools used in rendering this package:Cookiecuttercookiecutter-djangopackageHistory0.1.0 (2018-03-20)First release on PyPI.
Package: django-walrus
django-walrusInstallationpip install django-walrusAddwalrusto your settings'sINSTALLED_APPSThat's it. Now you can go for a swim in ice-cold water, or maybe hunt a penguin.UsageOncedjango-walrusis installed, you can use the power of thewalrus operatorin your template's{% if %}statements:{%ifresult:=my_mode.some_expensive_method%}Wow, check out this result:{{result}}.{%else%}Nothing to see here.{%endif%}Is this real?As real as a two ton polar mammal.OptimizedYou can activate some optimizations by settingWALRUS_OPTIMIZED=1in your shellenvironment.
Package: django-wamp-client
Installation$ pip install django-wamp-clientAddchannelsandwampclientto yourINSTALLED_APPS:INSTALLED_APPS = [
    'channels',
    'wampclient',
]In your settings, configure your connection to the WAMP Router:WAMP_CONNECTION = {
    'URL': "ws://127.0.0.1:9100/ws",
    'AUTHID': 'authid',
    'AUTHSECRET': 'secret',
    'REALM': "realname",
}Configure your routing to includewampclient.routing:channel_routing = [
    route("wamp.join", "testproject.consumers.wamp_join"),
    include('wampclient.routing'),
]Start the channel workers:$ ./manage.py runworkerStart the client that will connect to the WAMP Router:$ ./manage.py wamp_clientUsagefrom wampclient import publish, subscribe


def wamp_hello(greeting):
    publish('com.example.hello', "'sup?")


def wamp_join(message):
    # This consumer will be connected to the ``wamp.join`` channel
    subscribe('com.example.hello', wamp_hello)
    publish('com.example.hello', "Hi!", options={'exclude_me': False})LICENSEThis software is released under the MIT License. See theLICENSEfile.StatusThis project should be considered a proof of concept.
Package: django-wangeditor
1.Install or add django-wangeditor to your python path.:pip install django-wangeditor2.Add “wangeditor” to your INSTALLED_APPS setting like this:INSTALLED_APPS = [
    ...
    'wangeditor',
]3.Run the collectstatic management command:$ ./manage.py collectstatic.This will copy static CKEditor required media resources into the directory given by the STATIC_ROOT setting. See Django’s documentation on managing static files for more info.UsageFieldThe quickest way to add rich text editing capabilities to your models is to use the included RichTextField model field type.
For example:from django.db import models
from wangeditor.fields import WangRichTextField

class Post(models.Model):
    content = WangRichTextField()Use upload local pictures1.Add a WANGEDITOR_UPLOAD_PATH setting to the project’s settings.py file. This setting specifies a relative path to your wangeditor media upload directory. CKEditor uses Django’s storage API. By default, Django uses the file system storage backend (it will use your MEDIA_ROOT and MEDIA_URL):MEDIA_URL = '/media/'
MEDIA_ROOT = os.path.join(BASE_DIR, 'media')

WANGEDITOR_UPLOAD_PATH = "uploads/"2.Include the wangeditor URLconf in your project urls.py like this:from django.conf.urls.static import static
from django.conf import settings
# django >= 2.0
path('wangeditor/', include('wangeditor.urls'))
# django < 2.0
url(r'wangeditor/', include('wangeditor.urls'))
if settings.DEBUG:
    urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)configOptional - customizing wangEditor editor Add a WANGEDITOR_CONFIGS setting to the project’s settings.py file.:WANGEDITOR_CONFIGS = {
 "default": {
   "toolbar_config":{
     "modalAppendToBody": False,
   }
   "menu_conf": {
      "uploadImage": {
         "server": "/wangeditor/img_upload/",
       },
       "uploadVideo": {
         "server": "/wangeditor/video_upload/"
       }
   }
}
# toobar_config and menu_conf cong please see https://www.wangeditor.com/v5/toolbar-config.html and https://www.wangeditor.com/v5/menu-config.htmlUpdate Logversion-2.0.01、update wangeditor to wangeditor-v5;version-1.0.21、Resolve compatibility issues with django 4.0Refer to the configuration for more information, please seehttps://www.kancloud.cn/wangfupeng/wangeditor3/332599
Package: django-warehouse
Simple warehouse management system for Django 1.7+django-warehouseis a simple warehouse management system for Django 1.7+RequirementsDjango>=1.7.1
django-appcore==0.0.3
django-image-cropping==0.9
easy-thumbnails==2.2
PyYAML==3.11UsageYou may find detailed documentation is in the “docs” directory.
Package: django-warmama
# django-warmama[![build-status-image]][travis][![pypi-version]][pypi]## OverviewDjango app for qfusion authentication server## InstallationInstall using `pip`, please use a virtualenv...```bash$ pip install django-warmama```## Basic UsageAn example project is provided and is sufficient for testing with QFusion.Just get the server started.```bashcd example-projectpython manage.py migratepython manage.py createsuperuserpython manage.py runserver```To use it with QFusion, you need to add some User, Server and Player models; sonavigate over to the admin page at[http://localhost:8000/admin/](http://localhost:8000/admin/) and create some.1. Create some normal django users first, qf clients will use these usernamepassword combinations to connect.2. Create warmama Player models. The `login` field must be the username of apreviously created User.3. Create warmama Server models. The `login` field here will be the server'sauthtoken. Either `regip` or `regipv6` must be set to the server's ipaddress,for local testing `127.0.0.1` is allowed.Finally configure the QFusion server and clients to use warmama for matchmaking.For the server, set `sv_mm_enable` to `1` and `sv_mm_authtoken` to the `login`value of the Server created above. For both the server and client set `mm_url`to `http://127.0.0.1:8000` (without a trailing slash).## Advanced UsageThen configure your django project to use the app, you can override any of thewarmama settings (found in warmama/settings.py) in your project's settings.pyfile.```python# project/settings.pyINSTALLED_APPS = (...'warmama',)# project/urls.pyurlpatterns = [...url(r'^warmama/', include('warmama.urls', namespace='warmama', app_name='warmama')),]```Finally, run the migrations and (optionally) load the fixtures```bashpython manage.py migratepython manage.py loaddata --app warmama gametypespython manage.py loaddata --app warmama weapons```## TestingInstall testing requirements.```bash$ pip install -r requirements.txt```Run with runtests.```bash$ ./runtests.py```You can also use the excellent [tox](http://tox.readthedocs.org/en/latest/)testing tool to run the tests against all supported versions of Python andDjango. Install tox globally, and then simply run:```bash$ tox```## DocumentationTo build the documentation, you'll need to install `mkdocs`.```bash$ pip install mkdocs```To preview the documentation:```bash$ mkdocs serveRunning at: http://127.0.0.1:8000/```To build the documentation:```bash$ mkdocs build```[build-status-image]: https://secure.travis-ci.org/kalhartt/django-warmama.png?branch=master[travis]: http://travis-ci.org/kalhartt/django-warmama?branch=master[pypi-version]: https://pypip.in/version/django-warmama/badge.svg[pypi]: https://pypi.python.org/pypi/django-warmama
Package: django-warthog
Simple embeddable CMS for Django. Supports for:addition of CMS pagesembedded content blocksscheduled (un)publishing of contenthandling of multiple sites (via Django sites framework)management of templatesInstallationAdd warthog to your INSTALLED_APPS setting:INSTALLED_APPS = (
    ...
    'warthog',
    ...
)Add the warthog middleware into the MIDDLEWARE_CLASSES:MIDDLEWARE_CLASSES = (
    ...
    'warthog.middleware.CmsMiddleware',
    ...
)Enable template loaders for customising any template:# For Django 1.8+
TEMPLATES = (
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'OPTIONS': {
            'loaders': (
                'django.template.loaders.app_directories.Loader',
                'warthog.loaders.CmsTemplateLoader',
            )
        }
    }
)
Package: django-watch
django-watchLight and useful django middleware for real-time logging in development.https://github.com/Sobolev5/django-watchHow to use itTo install run:pip install django-watchAdd the following lines at the end ofsettings.pyfile:ifDEBUG:INSTALLED_APPS=INSTALLED_APPS+('django_watch',)MIDDLEWARE=(MIDDLEWARE+('django_watch.middleware.WatchMiddleware',))Open your development console and see the result:░░GETmain/views.py•profile•Linenumber191░░GETmain/views.py•profile[OK]•STATUS200•Totaltime•8.92s
Package: django-watchfiles
Usewatchfilesin Django’s autoreloader.Improve your Django and Git skillswithmy books.RequirementsPython 3.8 to 3.12 supported.Django 3.2 to 5.0 supported.InstallationInstall withpip:python-mpipinstalldjango-watchfilesAdd django-watchfiles to yourINSTALLED_APPS:INSTALLED_APPS=[...,"django_watchfiles",...,]That’s it! 😅Django doesn’t provide an official API for alternative autoreloader classes.
Therefore, django-watchfiles monkey-patchesdjango.utils.autoreloadto make its own reloader the only available class.
You can tell it is installed asrunserverwill listWatchfilesReloaderas in use:$./manage.pyrunserverWatchingforfilechangeswithWatchfilesReloader...Unlike Django’s built-inWatchmanReloader, there is no need for a fallback toStatReloader, sincewatchfilesimplements its own internal fallback to usingstat.
Package: django-watson
django-watsondjango-watsonis a fast multi-model full-text search plugin for Django.It is easy to install and use, and provides high quality search results.FeaturesSearch across multiple models.Order results by relevance.No need to install additional third-party modules or services.Fast and scaleable enough for most use cases.Supports Django 2+, Python 3.6+.DocumentationPlease read theGetting Startedguide for more information.Download instructions, bug reporting and links to full documentation can be
found at themain project website.You can keep up to date with the latest announcements by joining thedjango-watson discussion group.ContributingBug reports, bug fixes, and new features are always welcome. Please raise issues on thedjango-watson github repository, and submit
pull requests for any new code.You can run the test suite yourself from within a virtual environment with the following
commands.pip install psycopg2 mysqlclient -e .
    tests/runtests.py
    tests/runtests.py -d psql
    tests/runtests.py -d mysqlMore informationThe django-watson project was developed by Dave Hall. You can get the code
from thedjango-watson project site.Dave Hall is a freelance web developer, based in Cambridge, UK. You can usually
find him on the Internet in a number of different places:WebsiteTwitterGoogle Profile