Saravanan666/pypi-org huggingface dataset:
Package: django-frontend-notification
Django application to display on the frontend the list of notifications and run some basic actions such as “view all notifications”, “delete notifications”, it also provides helpers to display notifications.This works with twitter bootstrap (http://twitter.github.com/bootstrap/) but can easily be adapted with other front-end frameworks.DocumentationExtensive documentation is available on ‘Read the Docs’:http://django-frontend-notification.readthedocs.orgContributingIf you’ve found a bug, implemented a feature or customized the template and
think it is useful then please consider contributing. Patches, pull requests
and suggestions are welcome!Source code:http://github.com/areski/django-frontend-notificationBug tracker:https://github.com/areski/django-frontend-notification/issuesLicenseCopyright (c) 2011-2014 Star2Billing S.L. <info@star2billing.com>django-frontend-notification is licensed under MIT, seeMIT-LICENSE.txt.Creditdjango-frontend-notification is a Star2Billing-Sponsored Community Project, for more information visithttp://www.star2billing.comor email us atinfo@star2billing.com
Package: django-frontend-presets
Django frontend presets provide a command line that allow you to rapidly swap the front-end scaffolding for the application.DocumentationThe full documentation is athttps://django-frontend-presets.readthedocs.io.QuickstartInstall Django Frontend Presets:pip install django-frontend-presetsAdd it to yourINSTALLED_APPS:INSTALLED_APPS=(...'django_frontend_presets.apps.DjangoFrontendPresetsConfig',...)Add Django Frontend Presets’s URL patterns:fromdjango_frontend_presetsimporturlsasdjango_frontend_presets_urlsurlpatterns=[...url(r'^',include(django_frontend_presets_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.2 (2020-04-13)First release on PyPI.
Package: django-frontend-settings
AbstractThis project provides an API that expose settings and feature flags for the frontend.It usesdjango-drfto create an endpoint to expose flags and settings configured indjango-waffleanddjango-constanceUsageRequirements
Python (3.6, 3.7, 3.8, 3.9)
Django (2.2, 3.0, 3.1, 3.2)InstallationInstall using pip:pip install django-frontend-settingsAdd ‘frontend-settings’ to your INSTALLED_APPS setting.INSTALLED_APPS=[...'frontend_settings',]Expose the view in your urls:fromfrontend_settings.viewsimportsettingsasfrontend_settings_viewurl(r"^frontend-settings/",frontend_settings_view,name="frontend-settings"),Then your flags from waffle and setting from constance should be returned on a get in this route:$ curl 'http://localhost:8000/frontend-settings/'
{"data":{"flags":{"MY_FEATURE_FLAG":true},"settings":{}}}In that case I hadFRONTEND_MY_FEATURE_FLAGflag in waffle.
The default prefix for flags isFRONTEND_, if you like to change it you can do by changing the following config on settings.py:FRONTEND_SETTINGS={"WAFFLE_FLAG_PREFIX":"FRONTEND_",# Prefix used to filter out the flag that should be exposed in the endpoint"CONSTANCE_KEY_PREFIX":"FRONTEND_",# Prefix used to filter out the settings in constance}
Package: django-frontend-skeleton
Django Frontend Skeleton is a basic Django template skeleton built onHTML5 BoilerplateandTwitter Bootstrap.With the convenience of an installable Django application, create custom templates built on top of one of the most well-known, widespread templates (HTML5 Boilerplate) and a robust front-end framework (Twitter Bootstrap.)Version 2.0.0 of Django Frontend Skeleton is a much simpler package - it’s now just a small extended ‘skeleton’ template, which requires Django Frontend. No more duplication!StarringHTML5 Boilerplate (based on 4.3.0/master)Modernizr (2.7.1)jQuery (1.11.0) and (2.1.0)Twitter Bootstrap (3.0.3)iOS-Orientationchange-FixMore InformationFor more information, instructions on how to get started, and a changelogread the documentation.
Package: django-frontend-static
A basic Django application to install often used static files.With the convenience of an installable Django application, easily add some of the most widely used static files.There are no templates included. If you want a skeleton application built on HTML5 Boilerplate and Twitter Bootstrap then checkoutdjango-frontend-skeleton. If you want a light-weight template built on HTML5 Boilerplate without any static files then check outdjango-frontend-template.InactiveDjango Frontend Static is now inactive. Please usedjango-frontend.While continuing to use Django Frontend Static, be sure to force upgrade to avoid namespacing problems.Read this articlefor more information.StarringHTML5 Boilerplate (based on 4.2.0)Modernizr (2.6.2)jQuery (1.10.2) and (2.0.3)jQuery UI (1.10.3)jQuery DataTables (1.9.4)jQuery Dynamic Formset (1.2)jQuery ScrollTo (1.4.6)jQuery Smooth Scroll (1.4.11)Twitter Bootstrap (3.0.0 RC2)iOS-Orientationchange-Fixfamfamfam’s Silk IconsMore InformationFor more information, instructions on how to get started, a changelog and a roadmapread the documentation.
Package: django-frontend-template
Django Frontend Template is a very basic Django template built onHTML5 Boilerplate.With the convenience of a light-weight installable Django application, create custom templates built on top of one of the most well-known, widespread templates (HTML5 Boilerplate.)There are no static files included. If you want a heavier-weight application built on HTML5 Boilerplate and Twitter Bootstrap then checkoutdjango-frontend-skeleton. If you want to include often used static files then without any templates check outdjango-frontend-static.InactiveDjango Frontend Template is now inactive. Please usedjango-frontend.While continuing to use Django Frontend Template, be sure to force upgrade to avoid namespacing problems.Read this articlefor more information.StarringHTML5 Boilerplate (based on 4.2.0)More InformationFor more information, instructions on how to get started, a changelog and a roadmapread the documentation.
Package: django-front-end-validators
Django Front End ValidatorsDjango Front End Validators allows you to reuse server-sidemodel field validatorsto perform front end form validation in JavaScript.DocumentationDocumentation is available in thedocs directoryand athttps://johnfraney.github.io/django-front-end-validators.Supported Python versionsCurrently support is planned for only Python 3.6 and 3.7, on which Transcrypt 3.6 and 3.7 depend.CreditsTools used in rendering this package:TranscryptCookiecuttercookiecutter-djangopackageCode of ConductEveryone interacting in the project's codebases, issue trackers, chat rooms, and mailing lists is expected to follow thePyPA Code of Conduct.History
Package: django-frontier
Django-FrontierThe django front-end scaffold tool you requested.Tired of always having to setup your front end apps(react, vue, bootstrap tailwindcss)for your django projects, not any more. Every django developer knows how annoying it is to setup a front end for your django apps with the latest and greatest frontend frameworks, withdjango-frontieryou get to set up your frontend scaffold with a single command. A breeze 😇Before you installBefore you installdjango-frontier, please make sure you have python installed and you have a working django project either with with your local python installation or a virtual environment. We recommend the latterInstallation guideOpen your terminal and install thedjango-frontierpackage using pip$pipinstalldjango-frontierAfter the installation, add the ‘frontier’ app to theINSTALLED_APPSof your django project settingsINSTALLED_APPS=[...'frontier',...]Now you can use the frontier command by navigating to the root of your project directory, where ‘manage.py’ file is and run the frontier with either preset(vue, react, tailwind, or bootstrap)for example, a react scaffold looks like this:$pythonmanage.pyfrontierreactThis generates a resources directory with your react application scaffold. Your directory structure looks like this:your_project/
    resources/
        js/
            App.js
            index.js
            components/
                Example.js
    manage.py
    webpack.mix.js
    package.json
    .babelrc

    ...Configure your static assets by editing webpack.mix.js file.constmix=require('laravel-mix');mix.js('resources/js/index.js','static/').react();NOTE: django-frontier useslaravel-mix js <https://laravel-mix.com>_ to compile and bundle all of it assets. You can read more aboutlaravel mix <https://laravel-mix.com>_ on thier websiteYou can then compile your assets by running$npmrunwatchThis spits out the complied assets in a static/ directory at the root of your projectstatic/
      js/
        index.js
        index.map.js
      css/
        index.css
        index.map.cssYou can modify the output of the compiled assets in your‘webpack.mix.js’file.After compilation, setup yourSTATIC_URLandSTATICFILES_DIRSin your django project settings.# settings.pySTATIC_URL='/static/'STATICFILES_DIRS=[BASE_DIR/'static/']#new in django 3.0 which uses pathlib moduleSetup your template<!DOCTYPE html>{% load static %}<html><head>...<!-- if your dist folder includes css files --><linkrel="stylesheet"href="{% static 'css/index.css' %}"/>...</head><body><!-- for your react / vue app, set up to include the compiled js files --><divid="app"></div><scriptsrc="{% static 'js/index.js' %}"></script></body></html>For production, run thebuildcommand to minify the js and css for a smaller bundle$npmrunbuildMORE: Run the frontier command with -h flag for help and more options$pythonmanage.pyfrontier-hEnjoy 😇
Package: django-frontify
DocumentationSeeREQUIREMENTSin thesetup.pyfile for additional dependencies:Installationrunpip installdjango-frontifyadddjango_frontifyto yourINSTALLED_APPSadd configuration (as mentioned below) to your settings fileConfigurationSetDJANGO_FRONTIFY_DOMAIN="<your-frontify-donmain>"in your settings.pySetDJANGO_FRONTIFY_FINDER_VERSION=2in your settings.pySetDJANGO_FRONTIFY_CLIENT_ID="<your-client-id>"in your settings.pyVersion usageFrontify has released a new version of its Finder, which made the previous version (v1) a legacy version.
To still use the legacy version, setDJANGO_FRONTIFY_FINDER_VERSION=1.
Otherwise, beware that you’ve setDJANGO_FRONTIFY_CLIENT_ID="<your-client-id>"Tecnical questions about frontify?Frontify Slack Channel:https://frontify-friends.slack.com/join/shared_invite/zt-b910hbol-9cGnIaCet11a9D4uzpVWmQ#/shared-invite/emailFrontify API Documentation:https://developer.frontify.com/DevelopmentLocalsetupRun this command in one terminalmake runserverand this in a othermake watch_staticnow you should be able to accesses the example django project viahttp://localhost:8000Release requirementsto release a package you have to add the following filevim ~/.pypircwith the following contentand installtwinewithpip install twine.Release packageFirst do a test release with this command:make test_releasethen run this for the real release:make release
Package: django-frontpage
Django FrontpageShow a page before your users authenticate into the admin site.Valid users will go straight to the admin site, others will land in the frontpage
where you can show an app description, warning, etc. You only need to provide
your own template.After clicking the login button in the frontpage, the user will be redirected to the
original url. If there was no original url, the user will be redirected to theFRONTPAGE_ADMIN_PREFIX.Getting startedWorks with Django version 2.0 to 3.1.Tested with Django-supported Python versions.Install:pip install django-frontpageThen modify your Django settings:Add thefrontpageapplication toINSTALLED_APPS:INSTALLED_APPS=(...'frontpage',...)Add the middleware toMIDDLEWAREafterAuthenticationMiddlewareor any
other authentication middleware like OAuth2:MIDDLEWARE=[...'django.contrib.auth.middleware.AuthenticationMiddleware','oauth2_provider.backends.OAuth2Backend','frontpage.middleware.FrontpageMiddleware',...]Default admin prefix is'/admin/'change it if necessary:FRONTPAGE_ADMIN_PREFIX='/admin/'Add the frontpage view to your urls:fromfrontpage.viewsimportFrontpageViewurlpatterns=[path('',FrontpageView.as_view(),name='frontpage'),path('admin/',admin.site.urls),...]DemoHere's how the default template looks like:Custom frontpage templatePlace a different frontpage template infrontpage/index.html.Or use thetemplate_nameattribute inurls.py:fromfrontpage.viewsimportFrontpageViewurlpatterns=[path('',FrontpageView.as_view(template_name='my_frontpage.html'),name='frontpage'),path('admin/',admin.site.urls),...]Seefrontpage/templates/frontpage/index.htmlfor the default frontpage template.SettingsOptionDefaultDescriptionFRONTPAGE_ADMIN_PREFIX'/admin/'mandatory, the path of the admin site.FRONTPAGE_URL_NAME'frontpage'name of the frontpage urlFRONTPAGE_LOGIN_URL_NAME'admin:login'name of the login urlFRONTPAGE_LOGOUT_URL_NAME'admin:logout'name of the logout urlFRONTPAGE_RELOGIN_URL_NAME'admin:login'name of the relogin urlFrontpage needs to know about the logout url because that one should not be redirected.Relogin is necessary if you are logged in as an user that does not have access to the admin.
You may need to implement a custom view to logout the user then redirect to some login URL.FlowWhen thefrontpageis accessed then:if the useris_authenticatedandis_staffthen:the user will be redirected to theadminsiteif the useris_authenticatedbut NOTis_staffthen:frontpageis rendered with a specific messageif the user is anonymous then:frontpageis rendered with a specific messageWhen any page of theadminsite is accessed then:if the useris_authenticatedandis_staffthen:everything is ok,frontpagewill do nothing hereif the useris_authenticatedbut NOTis_staffthen:the user will be redirected to thefrontpagepageif the user is anonymous then:the user will be redirected to thefrontpagepageTestspip install -r requirements-dev.txt
pip install Django
pytestAuthors
Package: django-fs-dump
PrerequisitesThe package postgresql-client should be installed on the host.Introductiondjango-fs-dump is the Django-related reusable app provides the ability to dump database and media files via an admin interface.InstallationInstalldjango-fs-dumpusingpip:$ pip install django-fs-dumpAdd the'fs_dump'application to theINSTALLED_APPSsetting of your Django projectsettings.pyfile:INSTALLED_APPS = (
    ...
    'fs_dump',
    ...
)Runmigrate:$ ./manage.py migrateCreditsFogstream
Package: django-fs-email
Introductiondjango-fs-email is the Django-related reusable app provides the ability to send multipart emails and store them in a database.The distinctive feature of this app is storing sent emails in database. It means that you have ability to check each sent email from admin interface.InstallationInstalldjango-fs-emailusingpip:$ pip install django-fs-emailAdd'email'to yourINSTALLED_APPSsetting:INSTALLED_APPS = (
    ...
    'fs_email',
    ...
)Runmigrate:$ ./manage.py migrateUsageJust importsend_emailfunction and use it:from fs_email import send_email

send_email('from_email@example.com', 'to_email@example.com', 'fs_email/email_template.html', {})

send_email('from_email@example.com', ['to_email_1@example.com', 'to_email_2@example.com'], 'fs_email/email_template.html', {})CreditsFogstream
Package: django-fs-email-helper
Introductiondjango-fs-email-helper is the Django-related reusable app provides the ability to send multipart emails and store them in a database.The distinctive feature of this app is storing sent emails in database. It means that you have ability to check each sent email from admin interface.InstallationInstalldjango-fs-email-helperusingpip:$ pip install django-fs-email-helperAdd'email_helper'to yourINSTALLED_APPSsetting:INSTALLED_APPS = (
    ...
    'email_helper',
    ...
)Runsyncdbormigrate:$ ./manage.py syncdb

or

$ ./manage.py migrateUsageJust importsend_emailfunction and use it:from email_helper import send_email

send_email('from_email@example.com', 'to_email@example.com', 'email_helper/email_template.html', {})

send_email('from_email@example.com', ['to_email_1@example.com', 'to_email_2@example.com'], 'email_helper/email_template.html', {})CreditsFogstream
Package: django-fsforms
A reusable Django application for rendering forms withFoundation for
Sites.RequirementsPython 3.5, 3.6 and 3.7Django 2.0.x, 2.1.x and 2.2.x (Jinja2 is not supported yet)Foundation for Sites 6.xNote that this application does not include Foundation for Sites assets
so that you can customize it as you need. Get started by reading itsdocumentation!FeaturesDisplays the field label as well as its help textRenders the Django base Widgets following theForms
component’s
guidelinesShows the field errors as needed and sets the proper CSS classes on
the field label and the inputInstallationInstall Foundation Forms for Django:pip install django-fsformsAdd it to theINSTALLED_APPSin yoursettings.py:INSTALLED_APPS=(...'fsforms',...)Set theFORM_RENDERERin yoursettings.pyto usefsforms’ one:If you are using Django templates:FORM_RENDERER='fsforms.renderers.DjangoTemplates'If you are usingTemplateSettingas form renderer, you just
have to ensure that thefsformstemplates will be sourced
before the built-in widgets templates directory.Note that this step is required since Django is loading templates
first from the built-in form templates directory indjango/formswhen using those backends (see theBuilt-in-template form renderers’
doc).UsageIn your template, you will just have to loadfsformsthen use thefsfieldtag to render a form field.{%loadfsforms%}<form action="/url/to/submit/" method="post">{%csrf_token%}<ul class="no-bullet">
    <li>{%fsfieldform.simple_field%}</li>
    <li>{%fsfieldform.other_fieldlabel_class="my-field"%}</li>
  </ul>
  <div class="button-holder">
    <button type="submit" class="button">Submit</button>
  </div>
</form>Here are the special arguments you can pass to thefsfieldtag: -show_label: a boolean which turns on or off the label output. Note
that label of choices widgets will always be displayed. -label_class: a string which contains additional CSS classes to apply
to the label element. -show_errors: a boolean which turns on or off
the field errors’ output as well as the CSS classes applied to the
elements - e.g.is-invalid-inputandis-invalid-label. Default
isTrue. -as_list: a boolean which controls the rendering of
choices widgets - i.e. RadioSelect and CheckboxSelectMultiple. When set
toTrue- the default, the fields will be rendered inline and
wrapped inside a fieldset as suggested by the Forms component.
Otherwise, they will be rendered as a list.All the remaining arguments will be added to the widget attributes. As
regards therequiredone, you can alter its value too but only with
client-side effect. It means that if a field is defined as required in
the form class and you passrequired=Falseto the tag, it will
appear as non-required to the user but will still be validated at the
form’s submission.LicenseYou can use this under GNU AGPLv3+. SeeLICENSEfile for
details.Changelog[6.0.0] - 2019-09-23FixedAdd compatibility for Django >= 2.1 and Python 3.5[6.0.0rc2] - 2018-04-11Addedfsfieldtag to render a form field using Foundation Forms
structure.
Package: django-fs-leonid
Introductiondjango-fs-leonid is the Django-related reusable app provides the ability to create and store in a database files such as robots.txt, sitemap.xml and so on.InstallationInstalldjango-fs-leonidusingpip:$ pip install django-fs-leonidAdd'fs_leonid'to yourINSTALLED_APPSsetting:INSTALLED_APPS = (
    ...
    'fs_leonid',
    ...
)Update yoururls.py:path('', include('fs_leonid.urls')),Runmigrate:$ ./manage.py migrateCreditsFogstream
Package: django-fs-livesettings
Introductiondjango-fs-livesettings is the Django-related reusable app provides the ability to store settings in a database and configure settings via an admin interface.InstallationInstalldjango-fs-livesettingsusingpip:$ pip install django-fs-livesettingsAdd the'livesettings'application to theINSTALLED_APPSsetting of your Django projectsettings.pyfile:INSTALLED_APPS = (
    ...
    'livesettings',
    ...
)AddLIVESETTINGS_CONFto asettings.pyfile:LIVESETTINGS_CONF = (
    ('MY_SETTING_1', 'email', u'Description of this setting.'),
    ('MY_SETTING_2', 'char', u'Description of this setting.'),
)where, first parameter is a setting’s name, second — it’s type and third — description.List of types:boolean
char
date
datetime
decimal
email
file
image
integer
time
urlUsageJust import livesttings and call that setting you want:from livesettings.conf import livesettings
print livesettings.MY_SETTING_1CreditsFogstream
Package: django-fsm-admin
Mixin and template tags to integratedjango-fsmstate transitions into the
Django Admin.Installation$pipinstalldjango-fsm-adminOr from GitHub:$pipinstall-egit://github.com/gadventures/django-fsm-admin.git#egg=django-fsm-adminUsageAddfsm_adminto yourINSTALLED_APPS.Ensure that you have"django.core.context_processors.request"in yourTEMPLATE_CONTEXT_PROCESSORSin Django settings. If the setting variable
is not yet defined, add:fromdjango.confimportsettingsTEMPLATE_CONTEXT_PROCESSORS=settings.TEMPLATE_CONTEXT_PROCESSORS+("django.core.context_processors.request",)In youradmin.pyfile, useFSMTransitionMixinto add behaviour to your
ModelAdmin.FSMTransitionMixinshould be beforeModelAdmin, the order is
important.It assumes that your workflow state field is namedstate, however you can
override it or add additional workflow state fields with the attributefsm_field.fromfsm_admin.mixinsimportFSMTransitionMixinclassYourModelAdmin(FSMTransitionMixin,admin.ModelAdmin):# The name of one or more FSMFields on the model to transitionfsm_field=['wf_state',]admin.site.register(YourModel,YourModelAdmin)By addingcustom=dict(admin=False)to the transition decorator, one can
disallow a transition to show up in the admin interface. This specially is
useful, if the transition method accepts parameters without default values,
since indjango-fsm-adminno arguments can be passed into the transition
method.@transition(field='state',source=['startstate'],target='finalstate',custom=dict(admin=False),)defdo_something(self,param):# will not add a button "Do Something" to your admin model interfaceBy addingFSM_ADMIN_FORCE_PERMIT = Trueto your configuration settings, the
above restriction becomes the default. Then one must explicitly allow that a
transition method shows up in the admin interface.@transition(field='state',source=['startstate'],target='finalstate',custom=dict(admin=True),)defproceed(self):# will add a button "Proceed" to your admin model interfaceThis is useful, if most of your state transitions are handled by other means,
such as external events communicating with the API of your application.Try the example$gitclonegit@github.com:gadventures/django-fsm-admin.git$cddjango-fsm-admin$mkvirtualenvfsm_admin$pipinstall-rrequirements.txt$pythonsetup.pydevelop$cdexample$pythonmanage.pysyncdb$pythonmanage.pyrunserver