Saravanan666/pypi-org huggingface dataset:
Package: django-pit-survey
PIT AppDjango app with web forms to assist with the collection of data for Point-in-Time (PIT) counts for the Annual Homeless Assessment Report (AHAR) sent to the U.S. Congress. You can view these annual reports at:https://www.hudexchange.info/homelessness-assistance/aharExamples PDFs of the forms:Intervew:https://files.hudexchange.info/resources/documents/Model-Interview-Based-Unsheltered-Night-of-Count-PIT-Survey.pdfObservation:https://files.hudexchange.info/resources/documents/Model-Observation-Based-Unsheltered-Night-of-Count-PIT-Survey.pdfRunning LocallyRun using run.sh to set upStart locally by going tohttp://127.0.0.1:8000/Set up an account and submit surveysFor this production deployment, a newly registered user is automatically made an Admin which gives access to the Django Admin Dashboard.  When deployed at a volunteer event, this automation can be turned off.  This is how the system is designed to work, with newly registered users automatically being placed into the "Unapproved Users" group.  In this deployment however, your registration will make you an Admin, granting access to all features available in the system.ContributionsJustin CalmaTo be filled inTimothy CrowleyLogin & RegistrationUsers propogate to Admin dashboardRecognize user group on loginImplement different user flows based on groupUser groupingsCustom permissions for each groupProcess for admin to easily move users to different groupsZoe FrongilloFront end UI designForms submission handling (observation, survey, individuals)Backend management for saving multiple objects and their inter-dependencies within object modelsForms front end displayForms generatedSection survey to dynamically require certain sections based on the selections (i.e. Only clients that were
veterans need to fill out the VHS section, and only clients over 18 need to fill out the over 18 section)Redirect detail page to query the just submitted form object(s) to display to user the information they just submitted;
created functions to make the information readable to the userAdd individuals to forms more dynamically: the forms query individual form objects based on which user logged inExpanded user registration forms and added "Profile" page based on user logged inAdded a user "History" page that allows users to see all forms they have submitted by category in table formatEdwin FuquenSetup local testing and PyPi deployment.Optimized pages to be responsive on mobile screens.Performance tweaks to reduce page load times.Number of bug fixes and UI tweaks/enhancements.Removed duplicative fields on forms and computed them on the backend.Fixed a few login and regisration bugs.Improved the navbar to have highlights on hover.Added flow from home page, to registration, to login to forms.Edin SabanovicInitial setup of postgres db that was scrappedData ModelCharts/Admin Dashboard
Package: django-pivot2
django-pivot is a wrapper around numpy, pandas and django-pandas letting
you easily manipulate pivot tables on your queryset.Installpip install django-pivot2Modify your model(s) to usedjango_pandas.managers.DataFrameManagerordjango_pandas.managers.DataFrameQuerySet:class LongTimeSeries(models.Model):
  date_ix = models.DateTimeField()
  series_name = models.CharField(max_length=100)
  value = models.FloatField()

  objects = DataFrameManager()UsageThis app basicaly gives APIs to request a pivot table. Everything is not automatic
and developer must always declare:The possible valuesThe possible rows and columnsAnd for a end-user the API will askValuesRowsColumnsAggregation functionsApplied functionFormatAs class-based viewA mixin is available to compose you own pivot. It has the following behavior:
- Display a form to collect parameters of pivot table
- Display pivot table as HTML if valid input is given
- Download data as file with format given in formExample:from django_filters.views import FilterView
from django_pivot.views import PivotView
from myapp import models

class LongTimeSeriesPivotView(PivotView, FilterView):
    template_name = "pivot.html
    model = models.LongTimeSeries

    values_choices = ['date_ix', 'value']
    rows_choices = cols_choices = ['serie_name', 'date_ix', 'value']PivotViewis compatible with Django’sListView, django-filters’FilterViewor any kind of view with the same behavior.With graphene-djangoComing soonWith graphene-django-extrasExample of schema.py:from graphene_django import DjangoObjectType
from django_pivot.contrib.graphene_django_extras import PivotField
from myapp import models

class LongTimeSeriesType(DjangoObjectType):
    class Meta:
        model = models.LongTimeSeries

class Query:
    pivot_long_time_series = PivotField(
        LongTimeSeriesType,
        filterset_class=filtersets.LongTimeSeriesFilter,
        values_choices=['date_ix', 'value'],
        rows_choices=['serie_name', 'date_ix', 'value'],
        cols_choices=['serie_name', 'date_ix', 'value'],
    )Example of request:query {
  pivot_long_time_series (values: ["value"], rows: ["serie_name"], cols: ["value"], aggfuncs: ["mean"])
}As GraphQL is supposed to return JSON only and pandas JSON format is ..hum… weird,
we convert pivot_table into CSV and after into a list of list, so fully compatible.With Django REST FrameworkComing soon
Package: django-piwik
A simple app to add the Piwik JS tracking code to your template.RequirementsDjangoInstallationUsing PyPI you can simply type into a terminal:pip install django-piwikoreasy_install django-piwikConfigurationAddpiwikto the list ofINSTALLED_APPSin yoursettings.pyfile.AlsoPIWIK_SITE_ID(e.g.1) andPIWIK_URL(e.g.'http://piwik.example.com/', please don’t forget the trailing slash!) are required.In the template, put{% load piwik_tags %}to the top and add{% tracking_code %}before the</body>tag.That’s it. Happy tracking!AuthorCopyright 2013 Raphael Jasjukaitis <webmaster@raphaa.de>Released under the BSD license.
Package: django-pixels
=============================django-pixels=============================Tracking pixels made easyFeatures----------* Built-in view to serve a pixel response* Compose pixel tracking urls with different type IDs* Route tracking requests to functions using type IDsImplementation Notes with Short Examples----------Install django-pixels::pip install django-pixelsMount pixel tracking URL patterns:.. code-block:: pythonurlpatterns = [...url(r'^tracker/', include('django_pixels.urls', namespace="pixels")),...]Get the general pixel tracking url (This serves a transparent pixel as the response):.. code-block:: pythonfrom django.core.urlresolvers import reversetracking_url = reverse('pixels:pixel') # given you have mounted django_pixels urls with namespace='pixels'Get the tracking url with no-content(204) response (This serves an empty response with code 204):.. code-block:: pythonfrom django.core.urlresolvers import reversetracking_url = reverse('pixels:pixel-204') # given you have mounted django_pixels urls with namespace='pixels'Generate a pixel tracking url with type 1:.. code-block:: pythonfrom django_pixels import utilsutils.compose_pixel_url(tracking_url, 1)Write a function to handle tracking calls with type 1:.. code-block:: pythondef track_emails(request):# handle tracking with the passed HttpRequest instanceRegister the function to handle tracking calls with type 1:.. code-block:: pythonfrom django_pixels import handlershandlers.register(1, track_emails)Or mark a function to handle tracking calls with type 2:.. code-block:: pythonfrom django_pixels import handlers@handlers.track(type_id=2)def track_emails(request):# handle tracking with the passed HttpRequest instanceSettings----------* PIXELS_TYPE_PARAMETER_NAME - Change the parameter name used for tracking typeCredits-------Tools used in rendering this package:*  Cookiecutter_*  `cookiecutter-djangopackage`_.. _Cookiecutter: https://github.com/audreyr/cookiecutter.. _`cookiecutter-djangopackage`: https://github.com/pydanny/cookiecutter-djangopackageHistory-------0.1 (2016-12-10)++++++++++++++++++* First release on PyPI.
Package: django-pj-core
Misc utilities for DjangoDocumentationThe full documentation is athttps://django-pj-core.readthedocs.org(someday, not yet).QuickstartInstall django-pj-core:pip install django-pj-coreThen use it in a template:{% load pjcore_tags %}

<span class="{{ value | colorize_percentage }}" ... </span>CSS:span.negative {
  color: #CC3333;
}

span.positive {
  color: #88FF88;
}Will return stringred(negativevalueorgreen(positivevalue)Cookiecutter Tools Used in Making This Packagecookiecuttercookiecutter-djangopackageHistory0.1.0 (2015-08-31)First release on PyPI.
Package: django-placeholdit
A fully featured drop-in replacement ofplacehold.itfor DjangoFeaturesEverythingplacehold.itdoesIdentical URL structureImproved font rendition and vertical text alignmentInstallationYou can pip install the app from PyPi (recommended):$ pip install django-placeholditor GitHub:$ pip install git+git://github.com/stevelacey/django-placeholdit.git#egg=DjangoPlaceholditAdd django_placeholdit to your INSTALLED_APPS in settings.py:INSTALLED_APPS = (
    # ...
    'django_placeholdit',
)Add the routes into your urls.py, feel free to customise the prefix or namespace, no trailing slash:urlpatterns = patterns(
    # ...
    url(r'^placeholders', include('django_placeholdit.urls', namespace='placeholdit')),
)ConfigurationThe following options can be configured in your settings.py:PLACEHOLDIT_CACHE_SECONDS# Number of seconds to cache placeholders. Defaults to86400 * 7(a week)UsageIn templates:<img src="{% url 'placeholdit:placeholder' width=160 %}">
<img src="{% url 'placeholdit:placeholder' width=240 height=160 text='Custom dimensions' %}">
<img src="{% url 'placeholdit:placeholder' width=160 text='Custom text!' %}">
<img src="{% url 'placeholdit:placeholder' width=160 background='F77A00' color='fff' text='Custom colors!' %}">
<img src="{% url 'placeholdit:placeholder' width=240 height=80 background='fbd206' color='fff' text='Automatically' %}">
<img src="{% url 'placeholdit:placeholder' width=240 height=80 background='fbd206' color='fff' text='scaled!' %}">
<img src="{% url 'placeholdit:placeholder' width=160 background='93C663' color='3F740E' text='gif/jpeg/png' format='jpg' %}">Resulting in:<img src="http://example.com/placeholders/160">
<img src="http://example.com/placeholders/240x160&text=Custom%20dimensions">
<img src="http://example.com/placeholders/160&text=Custom%20text%21">
<img src="http://example.com/placeholders/160/F77A00/fff&text=Custom%20colors%21">
<img src="http://example.com/placeholders/240x80/fbd206/fff&text=Automatically">
<img src="http://example.com/placeholders/240x80/fbd206/fff&text=scaled%21">
<img src="http://example.com/placeholders/160.jpg/93C663/3F740E&text=gif/jpeg/png">ContributingFeel free tofork django-placeholditon GitHub! I’d love to see your pull requests.
Package: django-plainpasswordhasher
Dummy (plain text) password hashing for Django… for use in tests!Speed up tests!Cryptography is greedy. When you run tests, you usually do not care about
password security, but you care about performances. Using dummy password
hashing speeds up tests!Installdjango-plainpasswordhasherwith your favorite installer.
Here is an example using pip:pipinstalldjango-plainpasswordhasherThen configure your test settings:PASSWORD_HASHERS=('django_plainpasswordhasher.PlainPasswordHasher',)Except explicit password hashing testsIn most cases, using a dummy password hasher will do the job.
But you may write some tests that require real password hashing. In such a
case, let’s override settings!fromdjango.confimportglobal_settings# Django default settings...# You may use your project's# default settings instead.fromdjango.testimportTestCasefromdjango.test.utilsimportoverride_settings@override_settings(PASSWORD_HASHERS=global_settings.PASSWORD_HASHERS)classCryptographyTestCase(TestCase):"""Tests that require real cryptography."""ResourcesPyPI page:https://pypi.python.org/pypi/django-plainpasswordhasherCode repository:https://github.com/novapost/django-plainpasswordhasherBugtracker:https://github.com/novapost/django-plainpasswordhasher/issuesContinuous integration:https://travis-ci.org/novapost/django-plainpasswordhasherReferencesOriginal blog postDjango 1.5 documentation about getting faster testsDiscussion about password hashers & testing in Django issues
Package: django-plaintext-password
django-plaintext-passwordA Django password hasher to store passwords in plaintext."Should I use this in production?"Oh definitely not. Storing passwords in plaintext is a veryverybad thing. Django's defaults are incredibly secure and should be used unless you have a good reason not to.For more on why using this in production is a terrible idea, check outHow to store passwords.When running deployment checks, this will throw a "CRITICAL" error if in use.Installation and usagepip install django-plaintext-passwordThen addplaintext_password.PlaintextPasswordHashertoPASSWORD_HASHERSinsettings.py. To ensure it's used by default, make it the first or only item.How does it work?By default, Django will store the passwordpassword123in a format similar to:pbkdf2_sha256$216000$gd57n4OWJrXh$Xs/TqhwJICOxsLONGlKXorjuWccooiuJmJOUaxbwcOQ=This is good for security as the password has been both salted and hashed before being saved into the database, making it almost impossible to retrieve the original password. This library however, stores the password as-is:plaintext$$password123This makes searching by password possible, as well as comparing users passwords and allowing you to email users their passwords if they forget them - neat!In addition to storing the values directly in the database for easy retrieval, the comparison is done simply with==, rather than usingsecrets.compare_digest.Why?Well, why not?Although in all seriousness, If as part of your tests you're creating a large number of users, or just a couple users but you've got a lot of tests, you can get quite a performance improvement by simplifying the password hasher.Unfortunately due to a limitation (and feature) with Django, it's not possible to store just the value directly, it must be prefixed with the algorithm.
Package: django-planetscale
Django PlanetScaleA Django database backend for PlanetScaleGitHub:https://github.com/birdcar/django-planetscalePyPI:https://pypi.org/project/django-planetscale/Free software: GPL-3.0-onlyFeaturesEnables you to use PlanetScale with your Django appAvoids you having to rewrite your model code to set the kwargdb_constraint=Falseon every relationship you model.Subclasses the existing MySQL database backend using the documented process, ensuring compatibility with all versions of Django.CreditsThis package was created withCookiecutterand thewaynerv/cookiecutter-pypackageproject template.
Package: django-planout-experiments
A Django application that uses Facebook’s Planout library to manage product experiments and track outcomesDocumentationThe full documentation is athttps://django-planout-experiments.readthedocs.io.QuickstartInstall django-planout-experiments:pip install django-planout-experimentsAdd it to yourINSTALLED_APPS:INSTALLED_APPS=(...'planout_experiments.apps.PlanoutExperimentsConfig',...)Add django-planout-experiments’s URL patterns:fromplanout_experimentsimporturlsasplanout_experiments_urlsurlpatterns=[...url(r'^experiments/',include(planout_experiments_urls)),...]FeaturesAllows creation of Experiment model with admin definable GoalsIncludes models for tracking events that take place related to users under testAllows designing experimental groups using Facebook’s Planout Library[1][1]https://facebook.github.io/planout/Running TestsDoes the code actually work?source <YOURVIRTUALENV>/bin/activate
(myenv) $ pip install tox
(myenv) $ toxCreditsTools used in rendering this package:Cookiecuttercookiecutter-djangopackageHistory0.1.0 (2019-02-06)First release on PyPI.
Package: django-plans
Django-plans is a pluggable app for managing pricing plans with quotas and accounts expiration.Features currently supported:Multiple plans,Support for user custom plans.Flexible model for parametrizing plans (quota).Customizable billing periods (plan pricing),Order total calculation using customizable taxation policy (e.g. in EU calculating VAT based on seller/buyer countries and VIES)Invoicing,Account expiratons + E-mail remainders.Documentation:https://django-plans.readthedocs.org/Master branch: Support for Django +2.2, support for Python +3.6LicenseDjango Plans is licensed and distributed under MIT licesne..
Package: django-plans-payments
Almost automatic integration betweendjango-plansanddjango-payments.
This will add payment buttons to the order page and automatically confirm theOrderafter the payment.DocumentationThe full documentation is athttps://django-plans-payments.readthedocs.io.QuickstartInstall and configuredjango-plansanddjango-paymentsapps.
Capture mode is not yet supported, soPAYMENT_VARINANTSwith'capture': Falsewill not get confirmed.Install Django plans payments:pip install django-plans-paymentsAdd it to yourINSTALLED_APPS, before theplans:INSTALLED_APPS=(...'related_admin','plans_payments','plans',...)Add Djangoplans_paymentsto the URL patterns:urlpatterns=[...url(r'^plans-payments',include('plans_payments.urls')),...]Setdjango-planssettings and set model to:PAYMENT_MODEL='plans_payments.Payment'Customer IP addressCustomer IP address is stored in Payment model and used for some payment providers (i.e. PayU).
For security reasonsdjango-plans-paymentsdoes acquire the IP only fromrequestREMOTE_ADDRparameter.
If you are behind proxy, you will need to setup some mechanism to populate this variable fromHTTP_X_FORWARDED_FORparameter.
The suggested solution is to usedjango-httpforwardedforordjango-xffapplication for that.Running TestsDoes the code actually work?source <YOURVIRTUALENV>/bin/activate
(myenv) $ pip install tox
(myenv) $ toxCreditsTools used in rendering this package:Cookiecuttercookiecutter-djangopackageHistory1.2.2 (2023-12-20)add change_reason for django-simple-history1.2.1 (2023-12-19)specify sender=Payment for change_payment_status receiver1.2.0 (2023-10-16)bugfix release (fix prevoius bad release)1.1.3 (2023-10-15)add some indexes to Payment model1.1.2 (2023-03-29)reword Payment description to ommit word “Subscribtion” which might raise warnings for banks/card providers1.1.1 (2023-01-27)correction release, include wheel update, correctly rebase to master1.1.0 (2023-01-27)Fix transaction fee double counting1.0.1 (2022-12-09)Fix migrations1.0.0 (2022-12-08)Recurring payments functionality0.2.0 (2018-08-05)Payment process without capturing should workAutomatic buttons generation0.1.0 (2018-07-23)First release on PyPI.
Package: django-plantains
[![PyPI Version](https://img.shields.io/pypi/v/django-plantains.svg)](https://pypi.python.org/pypi/django-plantains)[![PyPI Python](https://img.shields.io/pypi/pyversions/django-plantains.svg)](https://pypi.python.org/pypi/django-plantains)[![PyPI Status](https://img.shields.io/pypi/status/django-plantains.svg)](https://pypi.python.org/pypi/django-plantains)[![PyPI License](https://img.shields.io/pypi/l/django-plantains.svg)](https://pypi.python.org/pypi/django-plantains)# Django PlantainsDjango plantains creates the ability to persist the association of a MailChimp account to an AuthUser account in Django. Leveraging the Django framework this can facitate authentication and persisted storage of Oauth metadata for later retrieval and usage.# RequirementsDjango plantains was built and tested for:* Django: 1.8* Python: 2.7# InstallationUse pip to install into a virtualenv:```shellpip install django-plantains```In `settings` configuration file add the following:```pythonINSTALLED_APPS = (...'plantains',)```Include the application URLconf in your project urls.py:```pythonurl(r'^plantains/', include('plantains.urls')),```Using a MailChimp registered app, set your client_id and client_secret in your `settings` configuration as well:```pythonMAILCHIMP_CLIENT_ID = '123456789'MAILCHIMP_CLIENT_SECRET = 'a1b2c3d4e5f6789'# Optional parameters# DefaultsMAILCHIMP_SUCCESS_REDIRECT_URL = '/'# These are in case MailChimp decides# to change it's endpointsMAILCHIMP_AUTHORIZATION_URL = 'https://login.mailchimp.com/oauth2/authorize'MAILCHIMP_ACCESS_TOKEN_URL = 'https://login.mailchimp.com/oauth2/token'```Use the authentication url to begin the Oauth process in your Django templates.```html<a href="{% url 'mailchimp_auth' %}">Feelin Chimpy</a>```Once the authentication is complete you can find your access_token in the `mailchimp_user` table.## How to ContributeDjango-plantains is willing and open to accept all contributions. Take a fork and make a pull-request. If you feel like becoming an active maintainer, please get in touch in becoming a project contributor.
Package: django-plausible
django-plausibleDjango module to provide easyPlausibleintegration, withWagtailsupport.Installationpip install django-plausibleThen simply addplausibletoINSTALLED_APPS.Usagedjango-plausibleprovides aplausibletemplate tag, which can be used to output the requiredscript tagfor Plausible.{% load plausible %}

{% plausible %}Will result in:<scriptdeferdata-domain="example.com"src="https://plausible.io/js/plausible.js"></script>ConfigurationConfiguration can be changed either insettings.py, or when calling theplausibletemplate tag:PLAUSIBLE_DOMAIN: The domain Plausible is running on (defaults toplausible.io)PLAUSIBLE_SCRIPT_NAME: The name of the script to use (defaults toplausible.js). Seescript extensionsfor available options.These settings will affect all calls to theplausibletemplate tag. To override it at call time, you can also pass them into the template tag:{% plausible plausible_domain="my-plausible.com" script_name="plausible.hash.js" %}By default, the domain (data-domain) used will be based on the request's hostname (usingrequest.get_host()). To override this, passsite_domainto the template tag.If the"compat" scriptis used,django-plausiblewill automatically add the requiredidto thescripttag. It is excluded by default to help hide Plausible's presence.Usage with WagtailAdditionally,django-plausibleprovides an (optional) deep integration withWagtail, allowing configuration through the Wagtail admin. To enable this, additionally addplausible.contrib.wagtailtoINSTALLED_APPS.Configuration is done through the "Plausible Analytics"setting:site_domain: the value fordata-domain. If left blank (the default), the request's hostname will be used (as above),notthe site hostname.plausible_domain: The domain Plausible is running on (as above)script_name: The name of the script to use (as above)To access the template tag, loadplausible_wagtail, rather thanplausible. The template tag itself is stillplausible. Note that unlike the Django variant, the Wagtail template tag doesn't allow options to be passed.{% load plausible_wagtail %}

{% plausible %}
Package: django-player
django-player (Django Presentation Layer) is a presentation framework to
develop websites, setting focus on UI layer. It’s not a CMS, you only present
data extracted from other CMS’s, but controlling the layout and how present the
information to the user.InstallingInstall package from pypi:$ easy_install django-playerCreate a new website project:$ create-website mywebsiteThis create amywebsitedirectory in your working directory, which is a
usual Django project.You have to define the DATABASES settings in the projectsettings.pyfile.Create data models:$ python manage.py syncdb --migrateRun development server:$ python manage.py runserverAnd finally, open the browser and go tohttp://localhost:8000/Usage(( to complete ))DemoThere are several demo sites availables running a django-player instance:devel1.demo.django-player.yaco.es: this is the first demo site.devel2.demo.django-player.yaco.es: this is a second demo site.pre.demo.django-player.yaco.es: this is the preproduction site.demo.django-player.yaco.es: this is the production site.0.1.0-beta8Some requirements fixes.0.1.0-alphaInitial version