Saravanan666/pypi-org huggingface dataset:
Package: django-queue-mailer
A reusable Django app for controlling queuing and sending of app emails.
Key use case is to move sending of emails out of requests to speed-up
request time and help to solve problems with sending email, handling
deferring of email and logging of app email communication.App started as a fork of Derek Stegelman’sDjango Mail
Queueand heavilly
inspired by James Tauber’sdjango-mailer.Any feedback, issues and suggestions are welcome. In that case please
useBitbucket’s
issues.Key featuresEmails are queued and send as asynchronous task with help of Celery
or Huey or as a crontab job scheduler.With use of own backend easily integrated into existing app.Easily configurable to use different mail backends as Django’s SMTP
backend or Amazon SES usingSea
Cucumber.InstallationInstall django_queue_mailer:$ pip install django_queue_mailerAdd the following to your settings.py:# Add django_queue_mailer to INSTALLED_APPS
INSTALLED_APPS = (
    ...
    "django_queue_mailer",
    ...
)

# Add django_queue_mailer's backend
EMAIL_BACKEND = "django_queue_mailer.backend.DbBackend"

# Setup email backend for sending queued emails
DJANGO_QUEUE_MAILER_EMAIL_BACKEND = "django.core.mail.backends.smtp.EmailBackend"

# Or other backed as Sea Cucumber
DJANGO_QUEUE_MAILER_EMAIL_BACKEND = "seacucumber.backend.SESBackend"You need to create the necessary tables. If you usesouth, just run
migrations:$ python manage.py migrate django_queue_mailerIf not, normalsyncdbwill do. For easier package upgrades usingsouthfor database
migrations is strongly recommended.$ python manage.py syncdbBasic usageSend emails and put them in queue with Django’s send_mail function:from django.core.mail import send_mail

send_mail('Subject here', 'Here is the message.', 'from@example.com',
    ['to@example.com'], fail_silently=False)Alternatively you can queue message with use of Queue model:from django_queue_mailer.models import Queue

new_message = Queue()
new_message.subject = "Testing subject"
new_message.to_address = "nobody@example.com, noone@example.com"
new_message.bcc_address = "blindcopy@example.com"
new_message.from_address = "hello@example.com"
new_message.content = "Mail content"
new_message.html_content = "<h1>Mail Content</h1>"
new_message.app = "someapp"
new_message.save()Queued messages can be send with use ofCeleryas asynchronous
tasks. Example of Celery task, tasks.py in your app folder:from django_queue_mailer.models import Queue

@celery.task
def send_mail():
    Queue.objects.send_queued()Hueyis a perfect lightweight
Celery alternative. Example of using it’s multi-threaded tasks,
periodical or event based (called from request when needed). Configure
task in tasks.py:from huey.djhuey import task, periodic_task, crontab
from django.core.management import call_command

@task()
@periodic_task(crontab(minute='*/2'))
def send_mail():
    call_command('send_queued_messages')Simplest solution is to run crontab job, configure crontab usingcrontab-e:*/2 * * * * path-to-virtualenv/bin/python path-to-app-folder/manage.py send_queued_messagesFurther documentationWill be added.
Package: django-quickadmin
This is a small Django application which automatically registers all found models withtin the current project into the admin area.FeaturesAdd all found models from other installed applications into admin sectionConfigurable exclusion of specific applications and modelsAuto exclude models from stock applications of DjangoInstallationTo install the latest release, just using pip:pip install django-quickadminThen insert ‘quickadmin’ into INSTALLED_APPS inside settings module:INSTALLED_APPS = (
    'django.contrib.admin',
    ...
    'quickadmin',
    ...
)Please be sure that ‘django.contrib.admin’ is present, otherwise Django will throw error when starting.For any questions or comments regarding this application, please email to me[at]zniper.net.
Package: django-quickapi
Is an easy way to setup mechanism calls for Django projects.
For the exchange of data is used JSON. The API is built on the RPC
scheme: one URL address - many methods. This scheme allows you to share
hard-structured data, such as nested into each other JavaScript
objects:$.quickAPI({url:"/api/",data:{method:"settings.update",kwargs:{value:{suppliers:['s1','s2','s33'],skip_goods:{s1:['g123','g321'],s33:['g098']}}}},callback:function(json,status,xhr){},})fromquickapi.clientimportBaseClientapi=BaseClient()api.url='https://example.org/api/'api.username='login'api.password='passw'settings={'suppliers':['s1','s2','s33'],'skip_goods':{'s1':['g123','g321'],'s33':['g098']}}response=api.method('settings.update',value=settings)Read thedocumentationfor details.
Package: django-quickblocks
* Django-quickblocks** OverviewDjango Quickblocks is a plugable Django based web application. Quickblocks has been developed to be more genericon how contents are being integrated within web applications.Quickblocks key factor is how easy it is to categorize contents depending on where and how you want to display them bygiving the users the power to use their creativity. Designing django-quickblocks we have focused on howcontents are being displayed from thousand sites and from there we managed to make it more generic.Quickblocks makes content management for average general sites a blast.** Features- Create quickblock types- Create different quicblock from quickblock type- Use fields of your choice (quickblocks type maybe used most of the time.)- Template tags that integrates quickblocks in the template on the fly- more...** Download*** From GithubYou can always get the latest version of django-quickblocks from github. Using git you can clone the django-quickblocksor download either zipped version within your favorite browser and put it into your project folder.My prefered way is to have requirements into a simple text file in the root of your project.We like to call it =pip-requires.txt=(your choice).Put =-e git+http://github.com/nyaruka/django-quickblocks.git#egg=django_quickblocks= on its own lineand install everything in the file as following:#+BEGIN_EXAMPLEpip install -r pip-requires.txt#+END_EXAMPLE** ConfigurationTo enable django-quickblocks for your project edit the projects =settings.py= and add the following:#+BEGIN_EXAMPLEINSTALLED_APPS = (Other apps ...'django_reversion','django_quickblocks')#+END_EXAMPLEThen syncronize your database to include these apps#+BEGIN_EXAMPLE% python manage.py syncdb#+END_EXAMPLE** Getting StartedOnce you have quickblock types and quickblocks it is time to display them in the template. There is where template tags comes into play.This app offers one templatetag =load_quickblocks=. Which does a query for all active Quickblock objects for the passed QuickblockTypeidentified by its slug. You can then access that list within your context.It accepts one parameter the =slug=*** Syntax#+BEGIN_EXAMPLE{% load_quickblocks [name]  %}#+END_EXAMPLE*** Example usage:#+BEGIN_EXAMPLE{% load_quickblocks  %}...{% load_quickblocks "home_banner_blocks" %}...#+END_EXAMPLE**** Note:You may also use the shortcut tag =load-qbs= as ={% load_qbs "home_banner_blocks" %}=If you specify a slug that hos noi associated quicl block, then an error message will be inserted in yourtemplate. You man change this text by setting the value fothe =QUICKBLOCK_IF_INVALID= in your settings
Package: django-quickbooks
Django QuickbooksThis is an ongoing project to integrate any Django project with Quickbooks Desktop and Quickbooks Online. Quickbooks
integration support forPython 3.6+andDjango 2.0+Join our active, engaged community:|Spectrum|Version:0.6.4.2Download:https://pypi.org/project/django-quickbooks/Source:https://github.com/weltlink/django-quickbooks/Keywords:quickbooks,quickbooks-django,django,quickbooks-desktop,quickbooks-online,qb,qbwc,qwc,integration,django-quickbooksFeaturesQuickbooks DesktopSoap session handling for 8 basic quickbooks web connector operations:authenticate()clientVersion()closeConnection()connectionError()getLastError()getServerVersion()receiveResponseXML()sendRequestXML()interactiveDone() - not really implementedinteractiveRejected() - not really implementedinteractiveUrl() - not really implementedSeveral Realm management model (for handling multiple web connector integration)Realm Session management model (for handling concurrent web connector connections)QuickBooks Task management model (for handling object synchronization updates)Abstract Processor implementation for easier QBXML response handlingAbstract Object implementation for easier QBXML bidirectional data conversionAbstract Service implementation for easier QBXML object manipulationQuickbooks Online...RoadmapQuickbooks Desktop Integration (most of the job is done, but can be improved)Add all other remaining quickbooks objects (or most important ones)Add all other remaining services (or most important ones)Add all other remaining processors (or most important ones)Quickbooks Online Integration (or most important ones)RequirementsPython 3.6+Django 2.0+RabbitMQ (or reimplementation of QueueManager)Celery (for handling asynchronous tasks)NoticeSoap server for Quickbooks Web Connector is built on top of Spyne and Lxml.Setup & DocumentationContributingCheck out oursmaller-roadmaporlarger-roadmapto see on what you can help us to improve. Or if you have any problem just drop us a line
or open anissueand we’ll work out how to handle it.LinksDjango Web FrameworkSpyne Official Repositorylxml Official RepositoryReferencesThis library could not be possible without contributions from other open-source projects.
Thanks forquickbooks-phpfor giving the concept of
creating quickbooks toolkit. Thanks forDjango_to_QuickBooks_APIandpyqwcfor giving core realization of soap server which made this library possible.
Package: django-quickmigrate
Quick migrations via manage.pyWhen executed without arguments, it will search for theQUICK_MIGRATEsetting in settings.py,
make migrations for every app in it and apply them.Otherwise, it will do the same only upon apps given as arguments.Promptpy manage.py quickmigrate -hfor more specific details on argumentsorread the docs below.QuickstartInstallationOpen your Django project and activatevirtual environment.After activating virtual environment install the package usingpip install django-quickmigrateOpen your settings.py and add'quickmigrate'to yourINSTALLED_APPSAdd additional listQUICK_MIGRATEinto your settings. It should look pretty much
likeINSTALLED_APPS, except you fill it only with apps you want to be migrated when you
callpy manage.py quickmigratewithout arguments.And that's it. Now you can usequickmigratein your project!Additional argumentsQuickmigrate allows you to choose a variety of apps to migrate during one call.You can manipulate this using additional arguments listed below:-i,--inst— command will look at yourINSTALLED_APPSinstead ofQUICK_MIGRATE.
In its turn, this flag takes one optional argument: eitherbaseorall(defaults toall).basewill just callmakemigrationsandmigratecommands. As the result, only basic apps such asadminwill be migrated.allwill make and apply migrations for allINSTALLED_APPSwhich support migrations.-a,--apps— command will look for specific apps. It can take any amount of arguments
starting from 1.e.g.py manage.py quickmigrate --apps myapp1 myapp2 admin authWith no arguments provided, the command will look in yourQUICK_MIGRATEsetting.
Package: django-quickstart
Django QuickstartA command line interface for automating the Django project creation process.Operating SystemThese instructions are meant for Mac OS.SetupNavigate to this directory and runchmod +x quickstart.shRun./quickstart.shand the names for the project and app when promptedMove project to desired directory.Virtual environmentCreate a virtual environmentvirtualenv venvActivate virtual environmentsource venv/bin/activateRunpip install -r requirements.txtDatabaseRunpython manage.py migrateRunpython manage.py createsuperuserthen enter the requested informationStart the serverpython manage.py runserverThe app should now be viewable in a browser window athttp://localhost:8000/[APP NAME]/.
Package: django_quick_test
django-quick-testDjango quick test is a custom nose based test runner that
separates testing and test related database manipulations.Usualy running this command instead of the defaultmanage.py testwill give you 10-15 times speed boost. So you will be able to run
your test suite in seconds instead of minutes.Installation1. Install the package withpip install django_quick_testor alternatively you can
download the tarball and runpython setup.py installAddquick_testto your INSTALLED_APPS list in settings.pyINSTALLED_APPS = ('quick_test')Add your test database details in settings.py.DATABASES = {
        'default':{
                'ENGINE':'',
},
        'test':{
                'ENGINE': '',
                'NAME': 'test_database',
        }
}And finally replace the default Django test runner with this one. Again in settings.py:TEST_RUNNER = 'quick_test.testrunner.NoseTestSuiteRunner'Usagedjango-quick-test assumes that you have created your test database manualy and
you have loaded the required test data(fixtures)Commands you have to run before using the commandpython manage.py syncdb --database=test
python manage.py migrate --database=testand finaly run your tests withpython manage.py quick_testAdditional notesIf you are using the default Django TestCase class
you have to ovewrite the_pre_setupmethod which is executed
automatically when you call the class. If you don’t overwrite it
thequick_testcommand will still work, but your test data
will be lost. Even if you don’t have any fixtures in the database
overwriting this method will give you additional speed boost.from django.test import TestCase

class SimpleTest(TestCase)

        def _pre_setup(self):
                # this method flushes the database and installs
                # the fixtures defined in the fixtures=[] list
                # we are doing everything manually, so we don't
                # really need it

        # these are the results I get with 1 test before
        and after ovewriting the method
        # Before -> Ran 1 test in 2.336s
        # After -> Ran 1 test in 0.004s
                pass

        def test_basic_addition(self):
                self.assertEqual(1 + 1, 2)RequirementsDjango 1.2+nose
Package: django-quickview
Author: Thomas Augestad Weholt, <thomas@weholt.org>.License: Modified BSD.Source:https://bitbucket.org/weholt/django-quickview/srcPackage:https://pypi.python.org/pypi/django-quickview/Requirements:Django 1.5Python 2.7.x or 3.3Read more athttps://bitbucket.org/weholt/django-quickview/src/fde97a0a0befaeda0ab2317035f8e7cd9c311511/docs/basic.md?at=defaultVersion history0.3     - Fleshed out some docs, fixed some bugs, cleaned up code.0.2     - Refactored code; QuickView is not dependent on a model. A subclass of QuickView named ModelQuickView takescare of all model related magic. This makes it easier to write non-model based views based on the same concept.0.1     - Initial release.
Package: django-quieter-formset
A formset that validates its data and puts them into non-form errors
as opposed to raising 500 errors.Usage:from quieter_formset.formset import BaseFormSet, BaseModelFormSet

modelformset_factory(User, formset=BaseModelFormSet)
formset_factory(ArticleForm, formset=BaseFormSet)Errors will be pushed into non_form_errors. Make sure you show those in your form.
Because the management form breaks, we don’t know information about the form and
so form data will be lost and the form breaks. However it was going to do this anyway.Version 0.4 requires Django 1.6 or later.License: BSDAuthor: Andy McKay,amckay@mozilla.com
Package: django-quiet-runserver
A quieter version of the default Djangorunserver.The defaultrunserverprints out alotof information,
and not all of it is useful.
This packages removes most of the information printed,
leaving only the important stuff:Requests to some static assets are not logged304 Not Modifiedrequests are not loggedTimestamps are no longer included. Most of the time, these are noiseThe common response typesGETandPOSTare abbreviated toGandPGETquery strings are logged on a separate, slightly indented line,
allowing for easy differentiation.Example:200 G /
200 G /static/styles.css
200 G /search/
  ?q=foo&sort=date
200 G /item/123/
301 P /item/123/
200 G /item/123/InstallingInstall this package:pip install djangoquietrunserverInclude it in yourINSTALLED_APPS:INSTALLED_APPS += (
    'djangoquietrunserver',
)UsingUserunserver--instead ofrunserver:python manage.py runserver--Monkey patchingIf you do not want to userunserver--, you can monkey patch Django so that
the defaultrunserverwill use the quieter logging by default. If you’re
running Django 1.7 or above, use the following in your INSTALLED_APPS instead:INSTALLED_APPS += (
    'djangoquietrunserver.apps.MonkeypatchConfig',
)If you’re running an older version of Django, enable the monkeypatch by adding
the following lines to yourmanage.py, just after theimport sysline:import djangoquietrunserver.monkeypatch
djangoquietrunserver.monkeypatch()
Package: django-quill-editor
django-quill-editordjango-quill-editormakesQuill.jseasy to use on Django Forms and admin sitesNo configuration required for static files!The entire code for inserting WYSIWYG editor is less than 30 linesIt can be used in both admin and Django viewsLive Demohttps://quill.lhy.kr/Form |https://quill.lhy.kr/posts/create/normal/ModelForm |https://quill.lhy.kr/posts/create/Form (Initial HTML) |https://quill.lhy.kr/posts/create/normal/html/Form (Initial Text) |https://quill.lhy.kr/posts/create/normal/text/Admin |https://quill.lhy.kr/admin/login/DocumentationThe full document is inhttps://django-quill-editor.readthedocs.io/, including everything about how to use the Form or ModelForm, and where you can add custom settings.Please refer to theQuickStartsection below for simple usage.QuickStartSetupInstalldjango-quill-editorto your Python environmentRequires Python 3.7 or higher and Django 3.1 or higher.pipinstalldjango-quill-editorAdddjango_quilltoINSTALLED_APPSinsettings.py# settings.pyINSTALLED_APPS=['django.contrib.admin',...'django_quill',]Making ModelAddQuillFieldto theModel classyou want to use.App containing models.py must be added to INSTALLED_APPSAfter adding the app, you need to run makemigrations and migrate to create the DB table.# models.pyfromdjango.dbimportmodelsfromdjango_quill.fieldsimportQuillFieldclassQuillPost(models.Model):content=QuillField()Using in adminJust register the Model inadmin.pyof the app.fromdjango.contribimportadminfrom.modelsimportQuillPost@admin.register(QuillPost)classQuillPostAdmin(admin.ModelAdmin):passRunning the Live Demo project in localThe live demo is a deployment of the"playground"package, which is a django application within this library.After cloning or downloading the repository, you can try running the live demo locally.A Python virtual environment is required to run the project.# [Optional] We recommend that you start after creating a folder for your project.mkdir~/projectscdprojects# Clone repositorygitclonegit@github.com:LeeHanYeong/django-quill-editor.git# Go to the project directory and apply the virtual environmentcddjango-quill-editor# [apply venv]# Go to the playground packagecdplayground# Install requirementspipinstall-rrequirements.txt# Run migrate and runserverpythonmanage.pymigrate
pythonmanage.pyrunserverAfter the above operation, the live demo site works at localhost:8000.ContributingAs an open source project, we welcome contributions.
The code lives onGitHubDistribution tips (for owners)Installation# blackbrewinstallblack# pre-commitbrewinstallpre-commit
pre-commitinstallPyPI Releasepoetryinstall# Install PyPI distribution packagespythondeploy.pySphinx docsbrewinstallsphinx-doc# macOSLocalcd docs
make html
# ...
# The HTML pages are in _build/html.

cd _build/html
python -m http.server 3001docker-compose up (in local)docker-compose-fdocker-compose-local.ymlup--build--force-recreate--remove-orphans
Package: django-quiz-app
===============Django quiz app===============This is a configurable quiz app for Django.Current features----------------* Question order randomisation* Storing of quiz results under each user* Previous quiz scores can be viewed on category page* Correct answers can be shown after each question or all at once at the end* Logged in users can return to an incomplete quiz to finish it and non-logged in users can complete a quiz if their session persists* The quiz can be limited to one attempt per user* Questions can be given a category* Success rate for each category can be monitored on a progress page* Explanation for each question result can be given* Pass marks can be set* Multiple choice question type* True/False question type* Essay question type* Custom message displayed for those that pass or fail a quiz* Custom permission (view_sittings) added, allowing users with that permission to view quiz results from users* A marking page which lists completed quizzes, can be filtered by quiz or user, and is used to mark essay questionsRequirements------------django-model-utils 2.0.3It was developed using Django 1.6.5Installation------------git clone https://github.com/tomwalker/django_quiz.gitpip install -r requirements.txtAdd 'quiz', 'multichoice', 'true_false', and 'essay' to your 'INSTALLED_APPS' setting.INSTALLED_APPS = (...'quiz','multichoice','true_false',...)Add the following to your projects 'urls.py' file, substituting 'q'for whatever you want the quiz base url to be.urlpatterns = patterns('',...url(r'^q/', include('quiz.urls')),...)MIT License (MIT) Copyright (c) 2012 - 2014 Dr Tom WalkerPermission is hereby granted, free of charge, to any person obtaining acopy of this software and associated documentation files (the“Software”), to deal in the Software without restriction, includingwithout limitation the rights to use, copy, modify, merge, publish,distribute, sublicense, and/or sell copies of the Software, and topermit persons to whom the Software is furnished to do so, subject tothe following conditions:The above copyright notice and this permission notice shall be includedin all copies or substantial portions of the Software.THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESSOR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OFMERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANYCLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THESOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Package: django-quiz-management
django-quiz-managementA Django app that makes the use of quiz management and easy to handle!django-quiz-management is a quiz management to use of create quiz and there question answer and to boost your website.Downloadingdjango-quiz-management is available on The Python Package Index (PyPI). You can simply usepipto install it:$pipinstalldjango-quiz-managementDependencyWe use django nested admin package to make better view and create quiz along with question and answer in django adminInstalling1 - Addnested_admininside INSTALLED_APPS in settings.py:
2 - Addquiz_managementinside INSTALLED_APPS in settings.py:INSTALLED_APPS=[...'nested_admin','quiz_management',]3 - Run the migrations:$pythonmanage.pymakemigrations
$pythonmanage.pymigrateAnd that's it! django-quiz-management should appear in your admin asQuiz Managements.Documentationhttps://github.com/krishnaansh/django-quiz-management/blob/master/docs/README.mdDownloadhttps://github.com/krishnaansh/django-quiz-management/releases/download/v1.1/v1.1.zip