Saravanan666/pypi-org huggingface dataset:
Package: django-windowsauth
Easy integration and deployment of Django projects into Windows Environments.Documentation is available athttps://django-windowsauth.readthedocs.io/en/latest/PyPI Package athttps://pypi.org/project/django-windowsauth/Django Packages athttps://djangopackages.org/packages/p/django-windowsauth/Requirements:Python (3.6, 3.7, 3.8, 3.9)Django (2.2, 3.0, 3.1)FeaturesDeploy toMicrosoft IISquickly usingwfastcgiAuthenticate viaIIS’s Windows Authentication.Authorize againstActive Directoryusingldap3packageManageLDAP Connectionsfor easy integrationsDebug usingdjango-debug-toolbarNEWCreate Task Schedulers for Django management commandsQuick StartInstall withpip install django-windowsauthRunpy manage.py migrate windows_authAdd “fastcgi application” withwfastcgi-enableConfigure project settingsINSTALLED_APPS=["windows_auth",]MIDDLEWARE=[# ...'django.contrib.auth.middleware.AuthenticationMiddleware','django.contrib.auth.middleware.RemoteUserMiddleware','windows_auth.middleware.UserSyncMiddleware',# ...]AUTHENTICATION_BACKENDS=["windows_auth.backends.WindowsAuthBackend","django.contrib.auth.backends.ModelBackend",]WAUTH_DOMAINS={"<your domain's NetBIOS Name> (EXAMPLE)":{"SERVER":"<domain FQDN> (example.local)","SEARCH_SCOPE":"<search scope> (DC=example,DC=local)","USERNAME":"<bind account username>","PASSWORD":"<bind account password>",}}# optionalSTATIC_URL='/static/'STATIC_ROOT=BASE_DIR/"static"MEDIA_URL='/media/'MEDIA_ROOT=BASE_DIR/"media"Generateweb.configfiles withpy manage.py createwebconfig -s -mCreate new IIS Website from the project filesFor more details visit the docs for installation:https://django-windowsauth.readthedocs.io/en/latest/installation/installation.htmlGetting helpIn case you have trouble while using this module, you may use theGitHub Disccussion.For any bug or issue, open anew GitHub Issue.Contributing
Package: django-winds
A tool to collect and serve wind prediction data. Designed to have pluggable backends for multiple wind-prediction services. So farUCARis the only source and covers just the continental US.InstallationUsepipto install from PyPI:pip install django-windsAdddjango_windsto your settings.py file:INSTALLED_APPS = (
    ...
    'django_winds',
    ...
)Additional Requirementsbeautifulsoup4to parse the XML served by THREDDSdjango-tastypieto generate the APIDjango SettingsDJANGO_WINDS_CACHE_TIMEOUT- Number of minutes to cache endpoint responses.DJANGO_WINDS_DEMO_MODE- True/False… not implemented yet.Acquiring Datadjango-windsis really just a extract and transport layer for data. It exposes an API that takes a Point (latitude/longitude) and returns wind predictions for that location.ContributingThink this needs something else? To contribute todjango-tidescreate a fork onBitbucket. Clone your fork, make some changes, and submit a pull request.Bugs are great contributions too! Feel free to add an issue onBitbucket.
Package: django-wireguard
This is a Django app that provides management via Admin Site for WireGuard interfaces and peers.Checkout theDocumentation.InstallationInstall with pip:pip installdjango-wireguardQuick startAdd “django_wireguard” to your INSTALLED_APPS setting like this:INSTALLED_APPS = [
    ...
    'django_wireguard',
]Runpython manage.py migrateto create the models.Visithttp://localhost:8000/admin/to manage the VPN. Note: you must enable the Django Admin Site firsthttps://docs.djangoproject.com/en/3.1/ref/contrib/admin/.Enabling the Wagtail IntegrationAdd “django_wireguard.wagtail” to your INSTALLED_APPS setting after simple_vpn:INSTALLED_APPS = [
    ...
    'django_wireguard'
    'django_wireguard.wagtail',
]You can manage the VPN from the Wagtail Admin Panel Settings.Inspecta WireguardPeer object to view their configuration.ConfigurationThe following settings can be provided:WIREGUARD_ENDPOINTthe endpoint for the peer configuration. Set it to the server Public IP address or domain. Default:localhost.WIREGUARD_STORE_PRIVATE_KEYSset this to False to disable auto generation of peer private keys. Default:True.WIREGUARD_WAGTAIL_SHOW_IN_SETTINGSset this to False to show WireGuard models in root sidebar instead of settings panel. Default:True.Two signals are sent whenever a WireGuard interface is created or deleted to emulate WireGuard’s PostUp/PostDown configuration options.
These signals are sent upon interface creationat the network level, not at database level.Testing with DockerBuild the test image by running:docker build -f Dockerfile.test -t django_wg_test .Run the testsTo run all tests, including Wireguard integration tests:Make sure the WireGuard kernel modules are installed and loaded on the host machineRun all tests withNET_ADMINcapability enabled:docker run --cap-add NET_ADMIN django_wg_testTo run unit tests without Wireguard support:docker run django_wg_test --exclude-tag net
Package: django-wiretap
Captures HTTP requests & responses for debugging.This is an early release, and isnotsuitable for production use.ScreenshotsListViewUsage:Install the package withpip installdjango-wiretapEdit Django settings:Add'wiretap'toINSTALLED_APPS.Add'wiretap.middleware.WiretapMiddleware'to yourMIDDLEWARE_CLASSES.Create models with./manage.py syncdbGo to Django admin, add a newTap.This contains a pathregex,
which is matched against the full path including the query string.For example, to capture everything within the/api/path of your site,
use'^/api/'.If you just want to test Wiretap, set it to'/'.HTTP request/responses will now be saved to theMessageadmin page.Note that Wiretap will be disabled if Django is not in debug mode.
Package: django-wisdom-pets
Adoptions is a django app to manage pet adoptions.
For now, you can view all pets and view specific pet detailsDetailed documentation is in the docs directoryQuick startAdd “adoptions” to your INSTALLED_APPS setting like this:INSTALLED_APPS = [
    ...
    'adoptions',
]Include the adoptions URLconf in your project urls.py like this:path('adoptions/', include('adoptions.urls')),Runpython manage.py migrateto create the adoptions models.Start the development server and visithttp://127.0.0.1:8000/adoptions/to view adoptions.
Package: django-wishlist
Generic user wishlists for use with any Django model.What is it?Generic user wishlists for shops and the likes.StatusAlpha. Don’t use it, unless you’re willing to fix issues. Will be released
on PyPI as soon as tested in limited production.CompatibilityTested to work with Django 1.8 and 1.9 and Python 2.7.RequirementsPlease refer torequirements.txtfor an updated list of required packages.InstallationThe package is availableTo install:Install the django-wishlist app:pip install django-wishlistIn your Django settings:Add‘wishlist’toINSTALLED_APPS.ConfigureWISHLIST_ITEM_MODELto the model used for wishlist items.Optionally: addwishlist.context_processors.wishlist_itemsto yourTEMPLATE_CONTEXT_PROCESSORS.For example:INSTALLED_APPS = [
    ...
    'wishlist'
    ...
]

TEMPLATE_CONTEXT_PROCESSORS = [
    ...
    'wishlist.context_processors.wishlist_items',
    ...
]

WISHLIST_ITEM_MODEL = 'my_webshop.Product'Inurls.pyadd:(r'^/wishlist/', include('wishlist.urls')),Update the database:./manage.py migrateNote Migrations do not work as the model is dynamically configured.UsageCreate a button to add an item to the wishlist simply from within your template.At the top of the page add:{% load wishlist_tags %}And where you want the button add:{% wishlist_add_form product %}Where product is the product you want to add to the wishlist.TestsTests for pull req’s and the master branch are automatically run throughTravis CI.LicenseThis application is released
under the GNU Affero General Public License version 3.Changes1.0 (6-5-2016)Move tests to project root, use Django’s native test runner.Support Django 1.8 and 1.9.Drop support for Django 1.7 and below.Production release after about a year of internal production use.0.2Never released but used internally in production.
Package: django-with-extra-context-admin
django-with-extra-context-adminProvide a simple way to add extra context for view rendering in Django's admin site.Installpipinstalldjango-with-extra-context-adminUsageNote:There is NO need to add app name django_with_extra_context_admin into INSTALLED_APPS. Just install this application and import the admin extention DjangoWithExtraContextAdmin where you need.app/admin.pyfromdjango.contribimportadminfromdjango_with_extra_context_admin.adminimportDjangoWithExtraContextAdminfrom.modelsimportMyModelclassMyModelAdmin(DjangoWithExtraContextAdmin,admin.ModelAdmin):django_with_extra_context_admin_view_name=Falsedefget_extra_context(self,request,**kwargs):extra_context=super().get_extra_context(request,**kwargs)or{}extra_context.update({..."var1":"value1","var2":"value2",...})returnextra_contextadmin.site.register(MyModel,MyModelAdmin)Where to use?All admin's default views are inject with the extra context.changeform_viewchangelist_viewdelete_viewhistory_viewadd_viewchange_viewAny extra context provided?By default we always adddjango_with_extra_context_admin_view_nameto the extra context. It can be disabled by set add_django_with_extra_context_admin_view_name to False. The value of variable django_with_extra_context_admin_view_name is the the name of current view name, e.g. changeform_view, changelist_view.Releasesv0.1.0 2020/03/13First release.
Package: django-withings
[![Build Status](https://travis-ci.org/orcasgit/django-withings.svg?branch=master)](https://travis-ci.org/orcasgit/django-withings) [![Coverage Status](https://coveralls.io/repos/orcasgit/django-withings/badge.png)](https://coveralls.io/r/orcasgit/django-withings) [![Requirements Status](https://requires.io/github/orcasgit/django-withings/requirements.png?branch=master)](https://requires.io/github/orcasgit/django-withings/requirements/?branch=master)Django-withings is a Django app for integrating a user’s Withings data into your
site.It handles the details of getting your app authorized to access your user’s
Withings data via the Withings API.Documentation is hosted on <http://django-withings.readthedocs.org>.
Package: django-wizard
Django wizard uses Step classes to control page flow.To create a wizard, you need a url route defined that is going to point to a
view and take a step parameter, like this:url(r'^(?P<step>[a-zA-Z]+)?$', views.my_view, name='new_wizard'),That view then must instantiate the wizard passing it the url name, and a list of steps.
Then the wizard’s handle_request method should be called and returned with the request
and the current step name (From the url):def my_view(request, step):
    Wizard('new_wizard', [
    ('StepOne', mysteps.StepOne),
    ('StepTwo', mysteps.StepTwo),
])
return wizard.handle_request(request, step)The wizard also has a defaulted navigation_opts argument that can be passed in the __init__
navigation options are a dictionary with a key of a string that will map to a field in
the Request, and the value is an int. These tell the wizard what direction to go and how far
in which scenarios.The defaults are:wizard_save: 0wizard_continue: 1wizard_previous: -1wizard_next: 1The view can also set a few additional things on the wizard:set_redirect_args(*args, **kwargs)use this to tell the wizard what it needs to privode to django’s reverse function
when doing redirectsset_step_init_args(*args, **kwargs)use this to supply additional arguments to your step class __init__’sset_common_template_args(dict)use this to add stuff that will always be available in all of your wizard created
templatesThe wizard will trigger the following signals:wizard.signals.wizard_pre_savewizard.signals.wizard_post_savewizard.signals.wizard_pre_displaywizard.signals.wizard_post_displaywizard.signals.wizard_pre_prereqwizard.signals.wizard_post_prereqA Step class is just an object that must define the following methodsdisplayonly takes self as an argument and returns the object that should be
passed to django’s template enginesaveonly takes self as an argument and returns nothingtemplateonly takes self as an argument and must return the template object to be used
by the wizard to render the responseIE: return loader.get_template(‘some_template_file.html’)prereqonly takes self as an argument and can raise a wizard.PrereqMissing when an error occurs in the page flowthe __init__ accepts an optional step key, a request and a messageif the step key is provided, the wizard will redirect to that stepif a request and message are provided it will add the message to django’s messaging frameworkSaveStepException is an exception that can be raised in the save method that the wizard know that the step could not be saved and needs to be repeated
Package: django-wkhtmltoimage
Converts HTML to PDFProvides Django views to wrap the HTML to PDF conversion of thewkhtmltopdfbinary.RequirementsInstall thewkhtmltopdf static binary.This requires libfontconfig (on Ubuntu:sudo aptitude install libfontconfig).Python 2.6+ and 3.3+ are supported.InstallationRunpip installdjango-wkhtmltopdf.Add'wkhtmltopdf'toINSTALLED_APPSin yoursettings.py.By default it will execute the firstwkhtmltopdfcommand found on yourPATH.If you can’t add wkhtmltopdf to yourPATH, you can setWKHTMLTOPDF_CMDto a
specific executable:e.g. insettings.py:WKHTMLTOPDF_CMD = '/path/to/my/wkhtmltopdf'or alternatively as env variable:export WKHTMLTOPDF_CMD=/path/to/my/wkhtmltopdfYou may also setWKHTMLTOPDF_CMD_OPTIONSinsettings.pyto a dictionary
of default command-line options.The default is:WKHTMLTOPDF_CMD_OPTIONS = {
    'quiet': True,
}DocumentationDocumentation is available athttp://django-wkhtmltopdf.readthedocs.org/en/latest/.LicenseMIT licensed. See the bundledLICENSEfile for more details.
Package: django-wkhtmltopdf
Converts HTML to PDFProvides Django views to wrap the HTML to PDF conversion of thewkhtmltopdfbinary.RequirementsInstall thewkhtmltopdf static binary.This requires libfontconfig (on Ubuntu:sudo aptitude install libfontconfig).Python 2.6+ and 3.3+ are supported.InstallationRunpip installdjango-wkhtmltopdf.Add'wkhtmltopdf'toINSTALLED_APPSin yoursettings.py.By default it will execute the firstwkhtmltopdfcommand found on yourPATH.If you can’t add wkhtmltopdf to yourPATH, you can setWKHTMLTOPDF_CMDto a
specific executable:e.g. insettings.py:WKHTMLTOPDF_CMD = '/path/to/my/wkhtmltopdf'or alternatively as env variable:export WKHTMLTOPDF_CMD=/path/to/my/wkhtmltopdfYou may also setWKHTMLTOPDF_CMD_OPTIONSinsettings.pyto a dictionary
of default command-line options.The default is:WKHTMLTOPDF_CMD_OPTIONS = {
    'quiet': True,
}DocumentationDocumentation is available athttp://django-wkhtmltopdf.readthedocs.org/en/latest/.LicenseMIT licensed. See the bundledLICENSEfile for more details.
Package: django-wm
django-wmdjango-wmlets you addWebmentionfunctionality to your Django project with minimal setup.UpgradingPlease check thechangelogbefore upgrading.Major versions introduce breaking changes which may require code changes in your application. Please check theupgrade guidefor full instructions on how to handle these.Minor versions may require a database migration for new features - this will be noted in thechangelogand thewiki release pagewhen necessary.Getting startedSetup instructions.Code for an example project.All done? You can use thetesting toolto make sure it works.FeaturesEndpoints:/webmention: Receives incoming Webmentions from other sites./webmention/get: Used to retrieve Webmentions for a page on your site.e.g./webmention/get?url=/my-articlewill return any received Webmentions that target/my-articleon your site.// /webmention/get?url=/my-article
{
  "target_url": "https://my-site.org/my-article",
  "mentions": [
    {
      "hcard": {
        "name": "Jane Bloggs",
        "avatar": "https://gravatar.com/janebloggs",
        "homepage": "https://jane-bloggs-example.org"
      },
      "quote": null,
      "source_url": "https://jane-bloggs-example.org/some-article",
      "published": "2020-01-17T21:45:24.542Z",
      "type": "webmention"
    }
  ]
}WebmentionHeadMiddlewareadds your/webmentionendpoint to the headers of your pages so that it can be discovered by other sites.{% webmentions_endpoint %}template tag to include your/webmentionendpoint to your Django templates  HTML element.MentionableMixinenables automatic submission of Webmentions to other sites when you mention them in your content.
Package: django-wmata-realtime-snapshot
# WMATA Realtime Snapshot### OverviewProvide a point-in-time mirror of Washington DC Metro's realtime train schedule### Installation1. **Install the package**```shellpip install django-wmata-realtime-snapshot```1. **Add the app to your django project's settings**```pythonINSTALLED_APPS = (...wmata_realtime_snapshot,)```1. **Get a WMATA API key**If you don't already have a WMATA API account, sign up here: https://developer.wmata.com/signupAlternatively, you may have success using the demo key provided here: https://developer.wmata.com/ProductsOnce you have a key, (e.g. `1234IAMAKEY`), you can use it to download a dump of the realtime data.1. **Download a JSON and/or XML dump from WMATA**These instructions are for a UNIX based system.JSON Dump:```shellcurl https://api.wmata.com/StationPrediction.svc/json/GetPrediction/All?api_key=1234IAMAKEY > realtime_dump.json```XML Dump:```shellcurl https://api.wmata.com/StationPrediction.svc/GetPrediction/All?api_key=1234IAMAKEY > realtime_dump.xml```To download both at the same time:```shellcurl https://api.wmata.com/StationPrediction.svc/json/GetPrediction/All?api_key=1234IAMAKEY > realtime_dump.json & curl https://api.wmata.com/StationPrediction.svc/GetPrediction/All?api_key=1234IAMAKEY > realtime_dump.xml```1. **Add your dumps to the Django settings file**In your Django settings, define the following variables for the dumps you want to serve.```WMATA_JSON_DUMP='path/to/realtime_dump.json'WMATA_XML_DUMP='path/to/realtime_dump.xml'```Any endpoint type (json or xml) that does not have a dump file to read will return a json/xml error message when querying the snapshot API:```json{"Error": "No JSON resource has been defined. Please read the installation instructions."}``````xml<Error>No XML resource has been defined. Please read the installation instructions.</Error>```1. **Add a url endpoint**```pythonurl(r'^mirror/', include('wmata_realtime_snapshot.urls', namespace='wmata_realtime_snapshot')),```1. **Visit the API**The API path is the same as the real WMATA API for easy plug-n-play:```http://localhost:8000/mirror/StationPrediction.svc/json/GetPrediction/Allhttp://localhost:8000/mirror/StationPrediction.svc/GetPrediction/B01http://localhost:8000/mirror/StationPrediction.svc/json/GetPrediction/K08,D13,A05```
Package: django-wmd
A wmd-editor for django applicationINSTALLATIONTo use jinja-kit usepiporeasy_install:pip install django_wmdoreasy_install django_wmdDJANGO USAGEAddedwmdto yourINSTALLED_APPS:INSTALLED_APPS+='wmd',CONTRIBUTEForkhttps://github.com/lispython/django-wmd/, create commit and pull request.
Package: django-wms
The Django WMS Framework is a toolkit that makes it easy to build aWeb Map Service (WMS)or a x-y-zTile Map Service. Rendering of both vector and raster data formats are supported.For complete documentation please go tohttp://django-wms.readthedocs.orgRequirementsThe processing of spatial data in django-wms relies onMapServerand its python bindingsMapScript. Raster data integration depends on thedjango-rasterpackage. The use ofPostGISas the database backend is required as well, for raster ntegration PostGIS >= 2.0 is required (see also django-raster package).InstallationInstall package withpip installdjango-wmsAdd “wms” to your INSTALLED_APPS setting like this:INSTALLED_APPS = (
    ...
    'wms',
)ExampleTo create a mapping service, subclass the django-wms layer, map and view classes and connect them to an existing model in django that has a spatial field (such as Point, Polygon or MultiPolygon). An examplewms_config.pymodule could be specified as follows### wms_config.py

# Load django-wms classes
from wms import maps, layers, views

# Load model with spatial field (Point, Polygon or MultiPolygon)
from myapp.models import MySpatialModel


# Subclass the WmsVectorLayer class and point it to a spatial model.
# Use WmsRasterLayer for rasters
class MyWmsLayer(layers.WmsVectorLayer):
    model = MySpatialModel

# Subclass the WmsMap class and add the layer to it
class MyWmsMap(maps.WmsMap):
    layer_classes = [ MyWmsLayer ]

# Subclass the WmsView to create a view for the map
class MyWmsView(views.WmsView):
    map_class = MyWmsMapWith the WmsView subclass in place, the only thing left to do to create a functional map service is to hook the view into a url. An example url configurationurls.pycould be### urls.py

# Import the wms view
from myproject.wms_config import MyWmsView

# Add url patterns to setup map services from the view
urlpatterns = patterns('',

    # This creates a WMS endpoint
    url(r'^wms/$', MyWmsView.as_view(), name='wms'),

    # This creates a TMS endpoint
    url(r'^tile/(?P<layers>[^/]+)/(?P<z>[0-9]+)/(?P<x>[0-9]+)/(?P<y>[0-9]+)(?P<format>\.jpg|\.png)$',
        MyWmsView.as_view(), name='tms'),
)The django-wms package will automatically detect the first spatial field it can find inMySpatialModeland create a WMS endpoint from the class based view. If the three argumentsx,yandzare found in the urlpattern, the view functions as TMS endpoint.
Package: django-wordle-auth
Django Wordle AuthDjango Wordle Auth backend that uses today's Wordle word of the day as your password.:fire: Django Wordle Auth is built for demo websites andshould never be used in a production environment. :fire:Installpython-mpipinstalldjango-wordle-authThen adddjango_wordle_auth.backends.DjangoWordleAuthBackendto yoursettings.AUTHENTICATION_BACKENDSlike:AUTHENTICATION_BACKENDS=["django.contrib.auth.backends.ModelBackend","django_wordle_auth.backends.DjangoWordleAuthBackend",]
Package: django-wordpress-api
Easily Install your Wordpress blog in your Django projectThis package  allows to communicate easily with any wordpress project that is using wordpress core >= 4.7.0.Even though the WP REST API package is already on the 2 version; it is still on beta so it was decided that this package will only support v1 until v2 is out of beta.DocumentationThe full documentation is athttps://django-wordpress-api.readthedocs.org.QuickstartInstall Django Wordpres API:pip install django-wordpress-apiThen use it in a project:import wordpress_apiFeaturesConnect to an external wordpress applicationRetrieves all the blog posts ordered by pagesFilter blog posts using several of theavailable filters in WP REST APISearch blog posts using a keywordorder the blog posts by several attributes like author, title, type, etc; ascending and descending order (default order is descending date)Retrieve posts with a different type than “post”Four Views to display the blog page, The Post detail, The Posts filtered by category and the Posts filtered by tag; All of this with the search by keyword optionRunning TestsDoes the code actually work?source <YOURVIRTUALENV>/bin/activate
(myenv) $ pip install -r requirements.txt
(myenv) $ pip install -r requirements_test.txt
(myenv) $ python manage.py testCreditsTools used in rendering this package:Cookiecuttercookiecutter-djangopackageHistory0.1.0 (2016-09-02)First release on PyPI.