Saravanan666/pypi-org huggingface dataset:
Package: django-webdriver
# django-webdriverDjango app to run selenium tests with webdriver## FeaturesExtends the feature of [django-nose](https://github.com/django-nose/django-nose) to manage the selenium tests.## InstallationYou can get django-webdriver from PyPi:```bashpip install django-webdriver```To use it you should add it to your `INSTALLED_APPS` in `settings.py`.Django-webdriver uses django-nose to run the tests, so you should also configure django-nose in your project:```pythonINSTALLED_APPS = (...'django_webdriver','django_nose',...)TEST_RUNNER = 'django_nose.NoseTestSuiteRunner'```## UsageWith django-webdriver you may run just unit tests or just selenium tests or the both.### Launch tests* `--selenium-only`: only run selenium tests* `--with-selenium`: run all tests (unit and selenium)* ` `: will only run unit test.### Configure#### LocalAdd `--webdriver=` to specify webdriver you want to use locally.It can be one of these for example (be careful to case):* Firefox* PhantomJS* Chrome* ...* [More here](http://selenium-python.readthedocs.org/en/latest/api.html#webdriver-api)##### Example```bash./manage.py test --with-selenium --webdriver=PhantomJS```#### Remote* Add `--remote_selenium_provider=` to specify which remote grid you want to use.* Add configuration for each grid in your `settings.py`:```pythonDJANGO_WEBDRIVER_SETTINGS = {'remote_providers': {'grid': {'url': 'http://192.168.0.18:4444/wd/hub',# will use 'default' capabilities},'sauce-lab': {'url': 'http://my_url','capabilities': 'ie',},},'remote_capabilities': {'default': [{'browser': 'firefox','platform': 'WINDOWS'},],'ie': [{'browser: 'internet explorer','version': 6,}]}}```### Write selenium testsTo write selenium tests you have to name the files `tests_selenium.py`. You may also use a python module name `tests_selenium` but you have to define your test files in the `__init__.py`.Your selenium test classes have to inherit of `django_webdriver.base.DjangoWebdriverTestCase`.You have not to manage the life cycle of the webdriver in the setUp or in the tearDown methods. The webdriver is instanciated before the setUp and it is stoped after the tearDown, so you may use it in these methods.```pythonfrom django_webdriver.base import DjangoWebdriverTestCaseclass TestSelenium(DjangoWebdriverTestCase):def setUp(self):self.webdriver.get('http://wwww.github.com') #it's okself.webdriver = '...' #it's forbiden because you break the life cycle.def tearDown(self):self.webdriver... #it's okself.webdriver.quit() #it's forbiden because you break the life cycle too.def test_google(self):url = 'https://www.google.fr/'self.webdriver.get(url)self.assertEqual(url, self.webdriver.current_url)```
Package: django-web-exceptions
Throwing web exceptions like in AioHTTPWhat and why?InAioHTTPyou can raise any response as exception (this is very cool).
But Django can raise only 3+1 web exceptions.400SuspiciousOperation403PermissionDenied404Http404500Any other non catched exceptionThis package allow you to raise as exception any of HTTP response.DocumentationThe full documentation is athttps://web-exceptions.readthedocs.io.QuickstartInstall Django Web Exceptions:pip install django-web-exceptionsAdd it to yourMIDDLEWARE:# settings.pyMIDDLEWARE=(# ...'web_exceptions.middleware.WebExceptionsMiddleware',# ...)FeaturesImport exceptions and raise anywhere# views.pyfromweb_exceptionsimportexceptions# ...defindex(request):""" Simple view raise redirectexception """raiseexceptions.HTTPMovedPermanently('/foo')Also you can customize any kind of exception status code as custom handler,
defined inurls.pylikedjango error handlers.# urls.pyfrommyappimportviewshandler300=<callableview>handler400=<callableview>handler<status_code>=<callableview>For more example seeexample projRunning TestsDoes the code actually work?source <YOURVIRTUALENV>/bin/activate
(myenv) $ pip install tox
(myenv) $ toxCreditsTools used in rendering this package:Cookiecuttercookiecutter-djangopackage
Package: django-webfilemanager
=====Filemanager=====A simple and standalone file manager and browser for django projects. Supports multiple instances which can be used within the admin area or for the frontend as well.Key features------------Standalone file browser and managerNo external dependencies except djangoFeature rich uploader included (jQuery File Upload)Based on django storage backendQuick start-----------1. Add "filemanager" to your INSTALLED_APPS setting like this::INSTALLED_APPS = [...'filemanager',]2. Include the filemanager URLconf in your project urls.py like this::url(r'^your-url/', include('filemanager.urls', namespace='filemanager')),3. Run `python manage.py migrate` for initial migrations.4. Add STATIC_URL, STATIC_ROOT, MEDIA_URL and MEDIA_ROOT to the settings.5. Make sure the base folder defined in your settings for filemanager does exist. By default it is located at MEDIA_ROOT/uploads.5. Run `python manage.py collectstatic` to save the staticfile to your STATIC_ROOT.6. If you have 'base.html' in your project then add::<html><head>{% block head%}{% endblock %}</head><body>{% block content %}{% endblock %}</body></html>
Package: django-webgate
A Django Authentication Middleware for WebGate Oracle Access Manager.This is a subclass of the RemoteUserMiddleware. The header value is
configurable by setting a django setting of WEBGATE_HEADER.WEBGATE_HEADER='CUSTOM_WEBGATE_HEADER'Note:The default header value isOAM_REMOTE_USERQuick Start1. Install using pip:pip install django-webgate2. Include “webgate” to your INSTALLED_APPS:INSTALLED_APPS=['webgate',]3. Include “OracleAccessManagerMiddleware” in MIDDLEWARE_CLASSES:MIDDLEWARE_CLASSES=('webgate.middleware.OracleAccessManagerMiddleware',)
Package: django-webhooks2
# django-webhooks[![Build Status](https://travis-ci.org/cbmi/django-webhooks.png?branch=master)](https://travis-ci.org/cbmi/django-webhooks)[![Coverage Status](https://coveralls.io/repos/cbmi/django-webhooks/badge.png?branch=master)](https://coveralls.io/r/cbmi/django-webhooks?branch=master)## Install```bash# Yes.. with a two on the endpip install django-webhooks2```## SetupAdd `webhooks` to `INSTALLED_APPS`:```pythonINSTALLED_APPS = ('webhooks',...)```## Settings- `WEBHOOK_TIMEOUT` - Seconds to wait until a request times out- `WEBHOOK_THREADS` - Maximum number of threads to be used in a worker pool- `WEBHOOK_USER_AGENT` - The user-agent string for POST requests. Defaults to the current site name if the Django sites apps is installed.- `WEBHOOK_VERSION` - The webhook version. If not None, this will be added to the user-agent string, e.g. 'Webhooks/1.0'. Default is 1.0.## Trigger Execution1. Events are triggered using `webhooks.trigger(event, [*args, [**kwargs]])`2. If a handler is registered for the event, the arguments are passed into the handler to generate a JSON-serializable payload.3. All URLs registered for this event are collected and each URL receives a POST request with the JSON payload**Notes:**- If no URLs are registered for the event, the payload is not generated (since it would be wasted computation)- All requests are sent in parallel using threads- Logging is heavily use to catch any undesirable or unexpected behaviors (such as failing requests, errors or data serialization)## Usage```pythonimport webhooks# Define and register a handler for an eventdef handler():return { ... }webhooks.events.register('event', handler)# Bind a URL to the eventwebhooks.bind('event', 'http://example.com')# Trigger the event. Any arguments after the event name# will be passed into the handler to produce the data that# will be POSTed to the bound URLs.webhooks.trigger('event')```
Package: django-webix
Use theWebixJavaScript UI library with DjangoDocumentationThe full documentation is athttps://django-webix.readthedocs.io.QuickstartCreate a new virtualenv:$python-mvenvdjango-webix$sourcedjango-webix/bin/activateInstall Django Webix:$pipinstalldjango-webixExtra packages for Django Webix:$pipinstalldjango-webix-sender$pipinstalldjango-dal$pipinstalldjango-filtersmerger$pipinstalldjango-webix-filterAdddjango-webixto yourINSTALLED_APPSINSTALLED_APPS=[# ...'django_webix',# ...]Adddjango-webixURLconf to your projecturls.pyfilefromdjango.conf.urlsimporturl,includeurlpatterns=[# ...url(r'^django-webix/',include('django_webix.urls')),# ...]Add internationalization toTEMPLATESTEMPLATES=[{# ...'OPTIONS':{'context_processors':[# ...'django.template.context_processors.i18n',],},},]Includewebix static filesfolder in your django staticfiles folder aswebixand add static configurationSTATICFILES_FINDERS=('django.contrib.staticfiles.finders.FileSystemFinder','django.contrib.staticfiles.finders.AppDirectoriesFinder',)STATICFILES_DIRS=(os.path.join(BASE_DIR,'staticfiles'),)STATIC_URL='/static/'Running TestsDoes the code actually work?$source<YOURVIRTUALENV>/bin/activate$(myenv)$pipinstalltox$(myenv)$toxSponsorsContributorsHere is a list of Django-Webix’s contributors.
Package: django-webix-sender
DocumentationThe full documentation is athttps://django-webix-sender.readthedocs.io.QuickstartInstall Django Webix Sender:$pipinstalldjango-webix-senderAdddjango-webix-senderto yourINSTALLED_APPSINSTALLED_APPS=[# ...'django_webix_sender',# ...]Adddjango-webix-senderURLconf to your projecturls.pyfilefromdjango.conf.urlsimporturl,includeurlpatterns=[# ...url(r'^django-webix-sender/',include('django_webix_sender.urls')),# ...]Running TestsDoes the code actually work?$source<YOURVIRTUALENV>/bin/activate$(myenv)$pipinstalltox$(myenv)$tox
Package: django-webline-notifications
Django webline Notifications===========================###Screen shot![screen shot](http://i.imgur.com/TxoZeaG.png)###What is Django webline NotificationsThis is a django application to notify user about events.You can simply inform user about all kind of updates.###Features* Chose notification status and color* Thumbnail for notification* Notification has a URL, can passed in other notifications* Send group (to list of users) notification##How to install###Downloading the packageProbably the best way to install is by using PIP:```$ pip install django-webline-notifications```If you want to clone the main repository:```$ git clone https://github.com/alireza-molaee/django-webline-notifications.git$ cd django-webline-notifications$ python setup.py install```###install on djangonow you can add django-simple-notifications to the settings.py file:```INSTALLED_APPS = (...'webline-notifications','django.contrib.admin',)```Then run migrations:```$ python manage.py migrate webline-notifications```Then collectstatic:```$ python manage.py collectstatic```now if run server you can see notifications in django admin:```$ python manage.py runserver```##Settingsyou can limit archive notification for all user by `WEBLINE_NOTIFICATIONS_LIMIT` default is `False` it mean (no limit)for example `myproject.settings.py`:```...WEBLINE_NOTIFICATIONS_LIMIT = 50...```##Usageto notify every thing you want:1. import Notification2. use Notification.send to send notification```from webline_notification.model import NotificationNotification.send(...)```#####send option:1. list of user:list of user object that you want to receive this notification `[obj, obj, ...]`2. content:a small text about event `'some one join us'`3. icon:icon css class `'fa-info'`4. color:color hex id `'#c3c3c3'`5. link:you notification can have a url to where reason of event `'http://www.google.com/'` *(optional)*you can use default color in Notification `Notification.COLOR_DANGER`you can filter notification by color in django admin if you use default color#####defult colors:* <span style="color:#f39c12;">COLOR_WARNING</span>* <span style="color:#f56954;">COLOR_DANGER</span>* <span style="color:#00c0ef;">COLOR_INFO</span>* <span style="color:#00a65a;">COLOR_SUCCESS</span>* <span style="color:#3c8dbc;">COLOR_PRIMARY</span>* <span style="color:#d2d6de;">COLOR_GRAY</span>* <span style="color:#111111;">COLOR_BLACK</span>#####example:```from webline_notifications.models import Notificationfrom django.contrib.auth.models import Useruser = User.objects.get(pk=1)Notification.send([user],'foo','fa-info',Notification.COLOR_DANGER,url='http://www.google.com/')```##TODO- [x] add test for models- [x] add template tags to use any template- [x] add view to change see status- [x] add test for view- [ ] add default settings- [ ] font files- [x] default notification count to show- [x] max of notification can be archived- [x] handle events by AJAX
Package: django-weblog
Django WeblogRequirementsThis app is tested with Django 1.1. It might also work with older versions, but
I haven’t tested it.If you want to run the tests, you’ll need to installMock.There are no other requirements.InstallationIf you read this, you have probably managed to extract the archive containing
these files. Next, open a Terminal andcdto the directory containing this
file (e.g.cd~/Downloads/django-weblog). Then execute:python setup.py installIf you checked out the repository and always want to use the newest version,
type:pip install -e path/to/django-weblogUsageThe Documentation can be found in thedocs/directory oronline.Changelog for django-lastfm0.2.0 – 2013-08-07:[CHANGE] A lot of various changes that accumulated over time.0.1.0 – 2010-05-02:[NEW] Initial public releaseAuthorsThe primary author of django-weblog is Stefan Scherfke, who may be found online
athttp://stefan.sofa-rockers.org/.
Package: django-weblogtools
Weblogtools is a simple Django app to log http request to database, in order to have a nice interface to check the input / output data with external service.Quick startAdd “weblogtools” to your INSTALLED_APPS setting like this:INSTALLED_APPS = [
    ...
    'weblogtools',
]Include the weblogtools URLconf in your project urls.py like this:path('weblogtools/', include('weblogtools.urls')),Runpython manage.py migrateto create the weblogtools models.now you can use weblogtools like belows. more see the weblogtools package source code:with weblogtools.biz.TimeIt() as timeit:
    res = requests.post(url, json=payload)
weblogtools.biz.http_log_from_response('upload_case', res, timeit.duration)
Package: django-webmap-corpus
Django webmap corpusCorpus for making web map applications.InstallationTo get the latest stable release from PyPipipinstalldjango-webmap-corpusTo get the latest commit from GitHubpipinstall-egit+https://github.com/auto-mat/django-webmap-corpus.git#egg=webmapAddwebmapto yourINSTALLED_APPSINSTALLED_APPS=(...,'author','colorful','adminsortable2','django.contrib.gis','constance.backends.database','constance','import_export','webmap','rest_framework','easy_thumbnails',)Add Author middlewareMIDDLEWARE_CLASSES=(...,'author.middlewares.AuthorDefaultBackendMiddleware',)Add Constance settingsCONSTANCE_APP_NAME="webmap"CONSTANCE_CONFIG={'MAP_BASELON':(14.4211,u'zeměpisná délka základní polohy mapy'),'MAP_BASELAT':(50.08741,u'zeměpisná délka základní polohy mapy'),'MAP_BOUNDS':("14.22, 49.95, 14.8, 50.18",u'hranice zobrazení mapy'),'DEFAULT_STATUS_ID':(2,u'id defaultního statusu'),}CONSTANCE_BACKEND='constance.backends.database.DatabaseBackend'Add thewebmapURLs to yoururls.pyurlpatterns=patterns('',...url(r'^webmap/',include('webmap.urls')),)Don’t forget to migrate your database./manage.pymigratewebmapNote: If you don’t have Constance migrated yet, remove the ‘webmap’ line from INSTALLED_APPS, then migrate Constance and then the line re-add and migrate again.UsageTODO: Describe usage or point to docs. Also describe available settings and
templatetags.ContributeIf you want to contribute to this project, please perform the following steps# Fork this repository
# Clone your forkmkvirtualenv-ppythondjango-webmap-corpusmakedevelopgitco-bfeature_branchmaster# Implement your feature and testsgitadd.&&gitcommitgitpush-uoriginfeature_branch# Send us a pull request for your feature branch
Package: django-webmaster
Picture the scene: you own and/or manage multiple domain names, purchased from a number of different registrars. You use a few different DNS and web hosting providers and have multiple servers dotted around the globe. Keeping track of all that is a pain. If a server, or any other link in the above chain goes down, how can you quickly find what is hosted where? How many of your clients are affected? You can create a complex spreadsheet and employ various filters to do all that for you, but this is hopefully a little less painful.
Package: django-webmaster-verification
This application allows various webmaster tools to verify that a Django site is
managed by you.The only supported method of verification is by accessing a file on your
server.Supported services:Google Webmaster ToolsBing Webmaster ToolsYandex Webmaster ToolsMajestic SEOAlexaUsageGetdjango-webmaster-verificationinto your python path:pip install django-webmaster-verificationAddwebmaster_verificationto your INSTALLED_APPS in settings.py:INSTALLED_APPS = (
    ...,
    'webmaster_verification',
    ...,
)Addwebmaster_verificationto your root urlconf (urls.py):urlpatterns = [
    ...,
    url(r'', include('webmaster_verification.urls')),
    ...,
]Add settings just as:WEBMASTER_VERIFICATION = {
    'bing': '<bing verification code>',
    'google': '<google verification code>',
    'majestic': '<majestic verification code>',
    'yandex': '<yandex verification code>',
    'alexa': '<alexa verification code>',
}The codes are alphanumeric and don’t include suffixes like ‘html’, e.g.847e1f379a99c28afor google, not847e1f379a99c28a.html.Multiple codes are supported as well, except for bing:WEBMASTER_VERIFICATION = {
    'bing': '<bing verification code>',
    'google': (
            '<google verification code 1>',
            '<google verification code 2>',
    ),
    'majestic': (
            '<majestic verification code 1>',
            '<majestic verification code 2>',
    ),
    'yandex': (
            '<yandex verification code 1>',
            '<yandex verification code 2>',
    ),
    'alexa': (
            '<alexa verification code 1>',
            '<alexa verification code 2>',
    ),
}NotesAsBingalways accesses the same verification file I’m not sure if it’s
possible to support more than one code for it. Please let me know if yes, and
how, as I don’t really use their tools.TheAlexacodes I saw all had a length of 27 characters, so that’s what this
app assumes is used. Please let me know if your codes differ and I need to
modify the app.Changelog0.4.3 (2022-02-09)Move tests to azure pipelines for now0.4.2 (2020-08-24)Repackage0.4.1 (2020-08-24)Fix issue with new verification yandex file0.4.0 (2020-08-23)Use docker-based travis testingTest against Django >=3.0Removed tests for Python 2, 3.4, and add 3.6 to 3.8I only ran the tests, I don’t think I use it on any prod site right nowIf any provider doesn’t work please let me know and I’ll probably remove it, I
don’t have the time to work on this code. Or send patches.Apologies for deleting issues, I deleted the old repo in between0.3.0 (2016-02-20)Python 2.7 and Django 1.8 are required0.2.4 (2015-02-26)Add Django 1.8 (beta1) support and drop 1.5 tests0.2.3 (2014-04-13)Django 1.7 (beta1) support0.2.2 (2014-01-12)Django 1.6 supportRemoved Python 2.5 testing0.2.1 (2013-03-25)Add alexa supportRefactor the test project to use a different structure0.2 (2013-02-16)Python 3.2 supportIntegrate testing with travis0.1.10 (2012-12-21)Fix test errors when running from a real project0.1.9 (2012-12-19)Pypi updates0.1.8 (2012-12-19)Yandex Webmaster Tools support added.0.1.7 (2012-05-07)Bugfix for multiple verification codes for one provider.
Package: django-webmention
django-webmentionwebmentionfor Django projects.What this project isThis package provides a way to integratewebmention endpoint discoveryandwebmention receiptsinto your project. Once you follow the installation instructions, you should be able to use something likewebmention.rocksto generate a test webmention and see it in the Django admin panel.Once you receive a webmention, you can click through to the page the webmention was sent from and see what people are saying about your site. Afterward, you can mark the webmention as reviewed in the Django admin so you can more easily see the latest webmentions you receive.Once you verify that you're receiving webmentions successfully, you can use the webmention information as you like. As an example, you could query the webmentions that are responses to a specific page and display them on that page.What this project isn'tThis package does not currently provide functionality forsending webmentions.Installation$ pip install django-webmentionAdd'webmention'toINSTALLED_APPSRunpython manage.py migrate webmentionAdd the URL patterns to your top-levelurls.pypath('webmention/', include('webmention.urls'))for Django >= 3.2UsageInclude webmention information by either:Installing the middleware insettings.py(affects all views)Appendwebmention.middleware.webmention_middlewareto yourMIDDLEWAREsettingsDecorating a specific view withwebmention.middleware.include_webmention_informationView webmention responses in the Django admin interface and mark them as reviewed as neededDevelopmentSetupInstalltoxRunning TestsYou can run tests usingtox:$tox--parallel=auto
Package: django-webnodes
django-webnodes===============The goal of `django-webnodes` is to create a new way of writing django templates which is fully compatible with the current django templating infrastructure.It's born to make it easy to support standard, reusable `bussiness components` across your application.`django-webnodes` are like special functional calls to render components of your page.## Usage:This use as django templatetags{% webnode node_name [value1 value2 ... key1=value1 key2=value2 ...] %}- ``value1``: position value passed as ``value1`` in ``get_context()`` and ``render()`` methods- ``key1=value1``: dictionary key-value pairs passed as ``key1`` in ``get_context()`` and ``render()`` methods## DemoFor example, if you are implementing a app statistics website, and you want to have app ratings appear on both list page and detail page, you can make an `RatingsNode` to render them on both pages.First, create a Python module for your webnodes, e.g., webnodes.py(place it in ``yourapp`` module)from webnodes import WebNodeclass RatingsNode(WebNode):template = 'webnodes/ratings.html'def get_context(self, app_id):...ratings = ...return {'ratings': ratings}Calling from template:{% load webnode %}<p>{% webnode RatingsNode app.id %}</p>## ExtensionIf you want see this webnode independently, you can add this in your urls' urlpatternsurl(r'^webnodes/', include('webnodes.ext.urls'))Then open `http://127.0.0.1:8000/webnodes/RatingsNode?app_id=414603431` in your browser, you will see it.## Why use this?1. Decoupling the logic of front-end and back-end separately;2. Make each component as a webnode will improve cohesion(because each component's template and data(include the logic of fetch data) are always strongly correlated);3. We can test each component independently;4. easy to realize partial renewal.## Todossupport css and javascript# RefsInspired by [tornado UI Module](https://github.com/facebook/tornado/blob/master/tornado/web.py), [django custom templatetags](https://docs.djangoproject.com/en/dev/howto/custom-template-tags/).Based on [django-widgets(1)](https://code.google.com/p/django-widgets) and [django-widgets(2)](https://github.com/marcinn/django-widgets)
Package: django-webodt
django-webodtis a django module which aims to create documents in various
formats from Open Document templates (odt). Django-webodt supports virtually
all formats supported by chosen backend tool. We have positive experience of
creating PDF, HTML, RTF and MS Word (.doc) documents.Document conversion is performed with help of external tools, each of which is
served by its own backend. Currently there are three built-in backends:ooffice: performs format conversion using big and fat OpenOffice.
Especially suitable for documents with complicated formatting, where all
other backends can fail. OpenOffice should be launched as daemon before.abiword: relatively lightweight converter which uses abiword as
converting engine.  Best choice for those who have restricted amount of
resources and/or don’t want to worry about daemon launching.googledocs: uses free service from Google, the only possible variant for
shared-hosting users or users with limited amount of resources who don’t care
much about their privacy.