Saravanan666/pypi-org huggingface dataset:
Package: django-dnoticias-utils
Utils module (dnoticias.pt)Django package used in subscriptions, editions, comments and mail system.
This package has the most common functions used in every project, like http error handlers, delete functions,
checkers, etc.ViewsSelect2ViewView used to construct the select2 inputs dataTo make this view works, you will need to replace this attrs:AttributeDescriptionSEARCH_PARAMSThe model attribute you will search for. I.e: Name, dni, etcSEARCH_TYPEDjango search type (icontains, lte, gte, etc)ORDER_BY_PARAMSThe model attribute you will order forMODELModel used in the inputMODEL_VERBOSE_NAMESInput nameGenericDeleteViewView used to delete an object from database.LivenessCheckViewThis view is used to do the liveness check. This will check the following things:Database connectionHomepage load (optional)And, in case of failure, will send an email (if configured) to the DEFAULT_IT_EMAIL.SettingTypeDescriptionDEFAULT_IT_EMAILStringEmail address that will be notified in case of failureEMAIL_TEMPLATE_LIVENESS_FAIL_UUIDStringEmail template UUIDLIVENESS_CHECK_HOMEPAGEBooleanCheck homepage?LIVENESS_SEND_EMAIL_ON_FAILUREBooleanSend email on failure?LIVENESS_CACHE_NAMEStringCache cooldown nameLIVENESS_EMAIL_COOLDOWNStringCache cooldown timeIn case of having middleware (yes), you will need to add the liveness check url to the OIDC_EXEMPT_URLS and AUTH_EXEMPT_URLS
regex listre.compile(r'(?:\/check\/health)(.*)'),And now, remember to add the liveness to the main path urls.pyfrom django.urls import path
...
from dnoticias_utils.views import LivenessCheckView
...

urlpatterns = [
    ...

    # Liveness check url
    path('check/health/', LivenessCheckView.as_view(), name="liveness-check"),
]Error views (error_views.py)This file contains functions to handle the different http errors. Instead of use different views in html, we have
only one view with context.
Package: django-dnsmanager
This is a DNS manager Django app.InstallationThe following lines creates a Python3 virtualenv and installsdjango-dnsmanagerinside.$python3-mvenvvenv$sourcevenv/bin/activate$pipinstalldjango-dnsmanagerFeaturesPolymorphic models based onDjango Polymorphic;Integration with Django Contrib Admin and AdminDocs ;Integration with Django Rest Framework ;Generation of ready to use zone files.This app targets Django 2.2 (last LTS and current Debian version (from Debian 11 Bullseye)), 3.2 and 4.1.
It runs on Python 3.7 to 3.10.Running a demo projectWe assume this package is installed in your Python 3 environment.Clone the project and go toexampledirectory.Now we need to create the database tables and an admin user. Run the
following and follow the instructions:$./manage.pymigrate$./manage.pycreatesuperuserNow you may run the Django development server:$./manage.pyrunserverYou should then be able to open your browser onhttp://127.0.0.1:8000and see this app running.LicenseDjango-dnsmanager uses the same license as Django (BSD-like)
because we believe in open development.
Please see LICENSE file for more details.
Package: django-dnt
django-dntoffers an easy way to pay attention to theDNT(Do Not Track) HTTP header. If
users are sendingDNT: 1,DoNotTrackMiddlewarewill setrequest.DNT = True, else it will setrequest.DNT = False.Just adddnt.middleware.DoNotTrackMiddlewareto yourMIDDLEWARE_CLASSES(Django 1.9 and earlier) orMIDDLEWARE(Django 1.10 and later) and you’re
good to go.Release Historyv1.0 - 2020-08-12No new features, but marking the project as mature since neither DNT or this
implementation is likely to change, except to follow Django releases.Add support for Django 2.0, 2.1, and 2.2Add support for Python 3.7v0.2.0 - 2017-02-17Supported Django versions: 1.8, 1.9, 1.10, and 1.11Supported Python versions: 2.7, 3.3, 3.4. 3.5, 3.6Add “DNT” to Vary header in response (eillarra)v0.1.0 - 2011-02-16Initial Release
Package: django-dob-widget
django-dob-widgetA Django date widget optimised for usability in entering dates of birth.This is based on the guidelines put forward by the UK Government Digital Service athttps://designnotes.blog.gov.uk/2013/12/05/asking-for-a-date-of-birth/Usage:from django import forms
from dobwidget import DateOfBirthWidget

class PersonModelForm(forms.ModelForm):
    """
    Model form for people.
    """

    class Meta(object):
        model = Person
        fields = ['name', 'date_of_birth']
        widgets = {
            'date_of_birth': DateOfBirthWidget(),
        }The DateOfBirthWidget can take an optional order parameter, to make it useful in non-UK jurisdictions:class Meta(object):
        model = Person
        fields = ['name', 'date_of_birth']
        widgets = {
            'date_of_birth': DateOfBirthWidget(order='MDY'),
        }Changes1.2.0Add support for Django 1.101.1.3Handle far future dates that raise OverflowError when given to datetime.date1.1.2Do not clear inputs if an invalid date is entered1.1.1Bug fix around character-based input1.1.0Allow attrs of the individual subwidgets to be set using day_attrs, month_attrs and year_attrs.1.0.0Initial releaseContributors"Matthew Wilkes"matt@matthewwilkes.name"Martin Sanders"martin@forwardpartners.com
Package: django-docdata
Python/Django client to the Docdata payment system.What it doesThis package offers Python and Django integration for Docdata’s WebMenu
product. It offers a direct abstraction of the API living indocdata.interfacewhich does not use Django for anything other than UTF-8
encoding of URL’s. On top of this we implemented a Django persistence layer
and apayment_status_changedsignal for easy integration into webshops and
other applications requiring payments.Supported versionsThis package officially supports Python 2.7 and Django 1.8 and 1.9, pull requests for Python 3 are encouraged.Who uses thisWe are using this package in-house over atVisualspace, on a fairly large production webshop. Some version of this software has been included inpcommerce.payment.docdataby Huub Bouma.TestsThis package has fairly extensive test coverage. However, a significant
portion of the tests currently requires a testing account and
henceDOCDATA_MERCHANT_NAMEandDOCDATA_MERCHANT_PASSWORDto be setup in
the filetest_secrets.py(seetest_secrets.example). After that the tests
can be run with:./runtests.pyCoverageOnly offline tests are currently being run with Travis, hence the actual coverage should be much higher. To run the online tests as well, Docdata credentials need to be configured intest_project/test_project/test_secrets.py.Pull requests for properly mocked online interactions based on the examples in Docdata’s implementation manual are greatly appreciated.SettingsDOCDATA_MERCHANT_NAMECredentials as supplied by the payment provider.DOCDATA_MERCHANT_PASSWORDCredentials as supplied by the payment provider.DOCDATA_DEBUGWhether or not to run in testing mode. Defaults toTrue.DOCDATA_PROFILEWhich profile to use for processing payments. Defaults tostandard.
Package: django-docker-engine
django_docker_engineThis Django app manages and proxies requests to Docker containers.
The primary goal has been to provide a visualization framework for theRefinery Project,
but nothing should prevent its use in other contexts, as well.In order for a Docker container to work with this package it must at a minimum:listen on some port for HTTP connections, andaccept a single JSON file as input.Quick DemoInstallDockerif you haven't already, then download the project, install dependencies, and
run the demo server:$ git clone https://github.com/refinery-platform/django_docker_engine.git
$ cd django_docker_engine
$ pip install -r requirements-dev.txt
$ pip install -r requirements.txt
$ ./manage.py runserverVisit thedemo server: From there you can pick a visualization
tool and a data file to launch a container, see the requests made against
each container, and kill the containers you've launched.MotivationVisualization tools have been built with a range of languages and they may have numerous, and possibly conflicting, dependencies. For theRefinery Platform, a data management, analysis, and visualization system for bioinformatics and computational biology applications, we have tried to accommodate the widest range of tools by creatingdjango_docker_engine, a Python package, available on PyPI, which launches Docker containers, proxies requests from Django to the containers, and records each request.For each tool the wrapping Docker container will parse the input data provided on launch and start listening for requests. Currently, wrappers are in use for pure JavaScript applications, and for client-server applications, such asHiGlassfor exploring genomic contact matrices, and aPlotly Dash toolfor gene expression data. The containers themselves may run on the same host as Django, or on separate instances.In the Refinery Platform, interactive visualizations managed bydjango_docker_enginecomplement workflows managed by Galaxy: Both tools lower barriers to entry and make it possible for end users to run sophisticated analyses on their own data. Refinery adds user management, access control, and provenance tracking facilities to make research more reproducible.django_docker_enginewill be useful in any environment which needs to provide access to pre-existing or independently developed tools from within a Django application with responsibility for user authentication, access control, and data management.More informationFor the demo server,tools.pydefines the tools
which are available and specifies default inputs. Analogously,
thevisualization-toolsrepodefines the tools which can be loaded into Refinery.More information:for users of the libraryfor developers of the libraryfor developers of visualizationsbackground readingAPI documentationBOSC 2018 posterRelease processIn your branch update VERSION.txt, using semantic versioning:
When the PR is merged, the successful Travis build will push a new version to pypi.
Package: django-dockerizer
django-dockerizerA package used to dockerize and make ready Django projects to deploy.InstallationRunpip install django-dockerizerUsageWithout celeryRundockerizecommand in project's base directory (in the same directory with manage.py file)With celeryRundockerize --celerycommand in project's base directory (in the same directory with manage.py file)RequirementsIt createsrequirements.txtfiles inbin/devandbin/prodfolders. And all packages which installed in virtual environment(if there is an activated one) or in the system, will be written inrequirements.txtfiles. Just be sure there are Django, psycopg2-binary, celery, django_celery_results, django_celery_beat in INSTALLED_APPS in settings.pyDatabaseIt configures docker-compose for Postgresql database, so be sure your DATABASE configuration in settings.py is okay for Postgresql database with credentials in .env fileCreditsOriginally developed byIsa ArifogluLicenseReleased underMIT License.Supporting:star: Star this project onGitHub:octocat: Follow me onGitHub:blue_heart: Follow me onTwitter
Package: django-dockit
IntroductionDjango-DocKit provides a Document ORM in django. DocKit attempts to provide a batteries included experience while preserving django’s various conventions.FeaturesBackendable support for document and index storageMongodbDjango Model with support for celery or ztask indexingIntegrates with hyperadmin (https://github.com/zbyte64/django-hyperadmin)Supports inlinesList Field supportSupports editing documents with deeply nested schemasClass based viewsDjango forms supportDynamically typed documents and schemasDocument and Index routing to multiple backendsHelp & FeedbackWe have a mailing list for general discussion and help:http://groups.google.com/group/django-dockit/InstallationRequirementsPython 2.6 or laterDjango 1.3 or laterSettingsPut ‘dockit’ into yourINSTALLED_APPSsection of your settings file.Configuring Document Store BackendDjango DocumentSet the following in your settings file:DOCKIT_BACKENDS = {
    'default': {
        'ENGINE': 'dockit.backends.djangodocument.backend.ModelDocumentStorage',
    }
}
DOCKIT_INDEX_BACKENDS = {
    'default': {
        'ENGINE': 'dockit.backends.djangodocument.backend.ModelIndexStorage',
    },
}

#Uncomment to use django-ztask for indexing
#DOCKIT_INDEX_BACKENDS['default']['INDEX_TASKS'] = 'dockit.backends.djangodocument.tasks.ZTaskIndexTasks'

#Uncomment to use django-celery for indexing
#DOCKIT_INDEX_BACKENDS['default']['INDEX_TASKS'] = 'dockit.backends.djangodocument.tasks.CeleryIndexTasks'Then add ‘dockit.backends.djangodocument’ toINSTALLED_APPSMongodbSet the following in your settings file:DOCKIT_BACKENDS = {
    'default': {
        'ENGINE':'dockit.backends.mongo.backend.MongoDocumentStorage',
        'USER':'travis',
        'PASSWORD':'test',
        'DB':'mydb_test',
        'HOST':'127.0.0.1',
        'PORT':27017,
    }
}
DOCKIT_INDEX_BACKENDS = {
    'default': {
        'ENGINE':'dockit.backends.mongo.backend.MongoIndexStorage',
        'USER':'travis',
        'PASSWORD':'test',
        'DB':'mydb_test',
        'HOST':'127.0.0.1',
        'PORT':27017,
    },
}
Package: django-dockitcms
============CMS written using django-dockit.Demo Site: http://dockitcmsdemo.herokuapp.com/Demo Site Code: https://github.com/zbyte64/dockitcmsdemo--------Features--------* Document based CMS* Create collections, indexes, and views in an admin or API* Integrates with hyperadmin* Configurable plugins (mixins)Installation============------------Requirements------------* Python 2.6 or later* Django 1.3 or later* django-datatap: https://github.com/zbyte64/django-datatap* django-dockit: https://github.com/webcube/django-dockit* django-hyperadmin: https://github.com/webcube/django-hyperadmin* django-hyperadmin-dockitresource: https://github.com/webcube/django-hyperadmin-dockitresource* django-hyperadmin-client: https://github.com/webcube/django-hyperadmin-client--------Settings--------Put 'dockitcms' and 'dockitcms.widgetblock' into your ``INSTALLED_APPS`` section of your settings file.Add the following middleware: 'dockitcms.middleware.DefaultScopeMiddleware'Set the following in your settings file::SCOPE_PROCESSORS = ['dockitcms.widgetblock.scope_processors.widgets','dockitcms.widgetblock.scope_processors.modelwidgets',]Add the following to your urls.py after eveything else::urlpatterns += patterns('',url(r'^', include('dockitcms.urls')),)
Package: django-doclib
DOCLIBA document library that integrates with multiple data sources (like digiLocker, Google Drive, local storage etc.) and storage services (like S3 and Google Cloud Storage) and uploads data from these data sources to the chosen storage service. It can be integrated with any Django Project.TECHNOLOGIESPythonDjango: Django builds better web apps with less codeDRF: A powerful and flexible toolkit for building Rest APIs with DjangoFrontend: HTML5, Bootstrap, JSArchitecture of the LibraryCURRENT SUPPORTED SERVICESDATA SOURCESGoogle DriveLocal StorageDigimocker (mock ofDigilocker)STORAGE SERVICESAmazon S3Google Cloud StorageQUICKSTARTInstall the packagepipinstalldjango-doclibBefore running the server, make sureDirectorylooks likedemo_proj
├── credentials_dir
|      └── credentials_gcs.json
├── media
└── django_project_folder
    ├── settings.py
    ├── asgi.py
    ├── .env
    ├── wsgi.py
    └── urls.pyFollow the stepsAdddoclibandrest_frameworkto your INSTALLED_APPS setting like thisINSTALLED_APPS = [...'doclib','rest_framework',]Include the doclib URLconf in your project urls.py like thispath('doclib/', include('doclib.urls'))ProvideMEDIA_ROOTin your project settings.py, something like thisMEDIA_ROOT = os.path.join(BASE_DIR, 'media')For integrating with Google DriveMake a directory with namecredentials_dirat the project root levelPut the google api client secret json file with name ascredentials_gcs.jsonincredentials_dirdirectory
For getting the API and Developer keys, visithere.Make a.envfile in the project folder directory (at the project settings.py level) and put the Browser API keys obtained from the Google API Console like this (don’t use quotations around strings)DEVELOPER_KEY=##################CLIENT_ID=##################APP_ID=##################For setting the environment variables, follow thisAdd these below lines in the projectsettings.pyimportenvironenv=environ.Env()environ.Env.read_env()For setting the above API Keys put these below lines in thesettings.pyDEVELOPER_KEY=env("DEVELOPER_KEY")CLIENT_ID=env("CLIENT_ID")APP_ID=env("APP_ID")Runpython manage.py migrateto create the doclib models.Start the development server and visithttp://localhost:8000/doclib/to access the doclib.
Package: django-docme
Django-docmeDjango-docme is a python library to generate user documentation automatically. For that it uses the behavior tests written with Behave.Basic usageAdd this to settings.py
'''
AUTO_DOC = True
'''
This flag controls the generation of documentationOn environment.py, write like this:#importsfromdocmeimportdocme#Hooks definitions like: before_all, after_scenario, etc.options={"output-formats":["pdf"]}docme.auto_doc(locals(),"App name",options)The options variable provides the configuration parameters for generating the documentation. Possible parameters are:output-formats -> provide output documentation formats. Available formats are: 'pdf' e  'html'.step_vertical_html -> path to custom html file to document vertical formatted steps. This is optional.step_horizontal_html -> path to custom html file to document horizontal formatted steps. This is optional.css_file -> path to custom css file to customize the documentation style. This is optional.Marks on features filesTo guide the documentation process, it is necessary to create markups in the files that describe the features.
The markings are added to the names of the features, scenarios and steps as shown below:Feature: showing off behave:docme
 Feature descripton

 Scenario: run a simple test:docme
    Scenario description
    Given we have behave installed:docme:vertical
    """
       Text that describes what the step does.
    """
    When we implement a test
    Then behave will test it for us!:docmeThe possible markings are::docme -> Indicates that the element (features, scenarios and steps), must be documented.:vertical -> This mark is exclusive for steps. By default, the step is displayed horizontally in the documentation. A screenshot of the browser is displayed on the left side and its title and description on the right. With this mark, the step indicate to be displayed vertically, that is, the scrrenshot above and title and description below.:dumpme -> Exclusive for scenarios, this markup provides a sql dump after run scenario.:before ->  Exclusive for scenarios with :dumpme mark, this markup provides a sql dump before run scenario.:notitle -> Exclusive for steps, indicates that the title will not be displayed in the documentation.Steps tablesSome steps do interactions with forms. The fields and values of this interaction are
sometimes expressed through the steps tables. These tables can be documented as shown below.Scenario: some scenario
   Given that I log in:docme:withformexample
     | name:label   | department:value  |
     | username     | username_value    |
     | password     | password_value    |As can be seen in the example, to document tables steps it is necessary to add the flags
:docme and :withformexample to the step name. In addition, it is necessary to indicate the
column with the field name, using the flag :label and the column with the field value,
using the flag :value.
Package: django-docopt-command
Django docopt commandDjango-docopt-command allows you to writeDjangomanage.pycommands using thedocoptlibrary. This means that you can define commands using usage strings.References:Django: The Web framework for perfectionists with deadlinesThe docopt library: Command-line interface description languageWriting custom django-admin commandsclassCommand(DocOptCommand):# This usage string defines the command options:docs="Usage: command <option1> <option2> [--flag1]"defhandle_docopt(self,arguments):# arguments contains a dictionary with the optionspassDjango-docopt-command is tested with Django 2.2 - 3.1 and Python 3.5 - 3.8 and is hosted ongithub.Note that version 1.0.0 also supports Django 2.1 and version 0.5.0 supports Django 1.11 and Django 2.0.ExampleSee thetestproject/docopt_examplein the django-docopt-command github repository.UsageInstall django-docopt-command.pip install django-docopt-commandStep 1 - management commandWrite a Django custom management command, as described inWriting custom django-admin commands.Step 2 - inherit from DocOptCommandclassCommand(DocOptCommand):passStep 3 - add a docs stringclassCommand(DocOptCommand):docs="Usage: command <option1> <option2> [--flag1]"Step 4 - override handle_docoptclassCommand(DocOptCommand):docs="Usage: command <option1> <option2> [--flag1]"defhandle_docopt(self,arguments):option1=arguments['option1']option2=arguments['option2']LicenseDjango-docopt-command is licensed under the Apache 2.0 License.
Package: django-docrootcms-tagulous
django-docrootcms-tagulousFork of tagulous with patch for Django3NOTE: this should not be used unless you are installing the docrootcms which requires django2.2 or above.  I am using this fork until the official tagulous branch is updated to remove legacy code and support django3.Official Repo:http://radiac.net/projects/django-tagulous/Source:https://github.com/radiac/django-tagulousBug Report for not supporting Django 3.x:https://github.com/radiac/django-tagulous/issues/85Special thanks to ensignavenger for providing a patch for python3.8 django3.x here:https://github.com/ensignavenger/tagulousI will remove this dependency and reference the official library once this bug is resolved.
Package: django-docs
django-docsallows to serve Sphinx generated docs directly from Django.DependenciesPython 3.6+ for Django 3.0 or higherCreditsProject on GitHub:littlepea/django-docsDocumentation on Read The DocsMaintained byEvgeny DemchenkoInstallationInstalldjango-docspackage:pip install django-docsAdddocsto INSTALLED_APPS in settings.py:INSTALLED_APPS = (
    ...
    'docs',
    ...
)Adddocs.urlsto urls.py:urlpatterns = [
    ...
    url(r'^docs/', include('docs.urls')),
    ...
]Customize configuration:DOCS_ROOT = os.path.join(PROJECT_PATH, '../docs/_build/html')
DOCS_ACCESS = 'staff'ConfigurationDOCS_ROOT (required)Absolute path to the root directory of html docs generated by Sphinx (just like STATIC_ROOT / MEDIA_ROOT settings).DOCS_ACCESS (optional)Docs access level (public by default). Possible values:public - (default) docs are visible to everyonelogin_required - docs are visible only to authenticated usersstaff - docs are visible only to staff users (user.is_staff == True)superuser - docs are visible only to superusers (user.is_superuser == True)Running the testsMake sure to installtest_requirements.txtfirst:pip install -r test_requirements.txt
pip install -e .You can run the tests with via:python setup.py testor:python docs/tests/runtests.pyTo run all tests against different versions of Django simply run:toxRunning the example projectMake sure to installrequirements.txtfirst:virtualenv env
. env/bin/activate
pip install -r test_requirements.txt
pip install -e .You can run the example project with via:cd example
python manage.py migrate
python manage.py runserverScreenshot