Saravanan666/pypi-org huggingface dataset:
Package: django-simple-metatags
The django application allows to add title, keywords and description meta tags to site’s pages.FeaturesAttaching meta tags to model instancesAttaching meta tags to URL pathsCachingIntegration with the django-modeltranslation applicationInstallationpipinstalldjango-simple-metatagsConfigurationAdd ‘metatags’ to your INSTALLED_APPS:INSTALLED_APPS=(# ...'metatags',)Run the migrate management command:pythonmanage.pymigratemetatagsCustomize model admin classes:To be able to attach meta tags to a model instance you should slightly adjust a model admin class.The first way by adding theMetaTagInlineclass in inlines sequence:frommetatags.adminimportMetaTagInlineclassCustomModelAdmin(admin.ModelAdmin):# ...inlines=(MetaTagInline,)The second way by usingMetaTagAbleMixin:frommetatags.adminimportMetaTagAbleMixinclassCustomModelAdmin(MetaTagAbleMixin,admin.ModelAdmin):# ...The third and way by usingMetaTagAbleModelAdmin:frommetatags.adminimportMetaTagAbleModelAdminclassCustomModelAdmin(MetaTagAbleModelAdmin):# ...WarningMeta tags can be attached only to models that has auto-incrementing or positive integer primary key.NoteAlso django-simple-metatags application has an own model admin class that allows to attach meta tags to URL
paths.Load the metatags template library and add the include_metatags template tag in template.Add the include_metatags template tag with the model_instance argument to use meta tags attached to a model instance.{% load metatags %}<head><metahttp-equiv="content-type"content="text/html; charset=utf-8"/>{% include_metatags object default_title='Foo' default_keywords='Foo, bar, baz' %}</head>NoteThe model_instance attribute is just an instance of arbitrary model like User, FlatPage, etc. with attached via
Django’s admin meta tags. A variable than contains a model instance must be included in the template context.Add the include_metatags without the model_instance argument to use meta tags attached to an URL path.{% load metatags %}<head><metahttp-equiv="content-type"content="text/html; charset=utf-8"/>{% include_metatags default_title='Foo' default_keywords='Foo, bar, baz' %}</head>Arguments of include_metatags template tagAll arguments are optional.model_instance- A model instance with attached meta tags. Defaults toNone.default_title- A default title of page. Defaults to‘’.default_keywords- Default keywords of page. Defaults to‘’.default_description- Default description of page. Defaults to‘’.CachingSince version 2.0.0 application gained caching support. See settings section for more details.SettingsMETATAGS_CACHE_ENABLED- Enables meta tags caching to minimize database access. Defaults toFalse.NoteDjango’s caching system must be configured.METATAGS_CACHE_ALIAS- A name of cache backend used by meta tags caching feature. Defaults todefault.METATAGS_CACHE_TIMEOUT- Timeout in seconds to use for meta tags caching. If value set up toNonecached meta tags never expire. Defaults toNone.NoteValue of0causes meta tags to immediately expire.Management commandresetmetatagscache- Removes all cached meta tags.
Package: django-simple-mixins
What is it?django-simple-mixins is a simple Django App that contains some Mixins to use for Django’s Class Based Views.InstallationYou can do any of the following to installdjango-simple-mixinsRunpip installdjango-simple-mixins.Runeasy_installdjango-simple-mixins.Download or “git clone” the package and runsetup.py.Download or “git clone” the package and addsimplemixinsto your PYTHONPATH.UsageFor example if you’d like to use theCacheMixin:from django.views.generic import ListView

from simplemixins.mixins import CacheMixin

class ArticleListView(CacheMixin, ListView):
    cache_timeout = 60 * 15     # 900 – that is, 15 minutes multiplied by 60 seconds per minute.
    model = ArticleRequirementsDjango>=1.5
Package: django-simple-multilingual-survey
==========================Simple Multilingual Survey==========================Simple Multilingual Survey is a simple Django app to conduct Web-based survey.For each survey and question, visitors can choose between a fixed number of choices.Quick start-----------1. Add "multilingual_survey" to your INSTALLED_APPS settings like this:INSTALLED_APPS = (...'multilingual_survey',)2. Include the multilingual survey URLconf in your project urls.py like this::url(r'^survey/', include('multilingual_survey.urls', namespace='survey')),3. Run `python manage.py migrate` to create the survey models.4. Start the development server and visit http://127.0.0.1:8000/admin/to create a survey, questions and choices (you'll need the Admin app enabled).5. Visit http://127.0.0.1:8000/survey/slug-of-the-suvey/ to answer the survey.
Package: django-simple-notification
installpipinstalldjango-simple-notificationUsage1. create notification eventsfromnotifications.handlersimportsend_messagesend_message('Mahmoud Liked your post',user,'post_like')Explain# function interfacesend_message(message:str,user:User,type:str)# logic behind itmessage:thetextmessagetobesenttotheuseruser:aninstanceofUsermodel(theonewhowillrecievethenotification)type:isanotificationtagortype(youshouldcreatedifrrenttypesinyoursystemfordifferentevents)2.fetch notifications using REST APIsnotifications/all/:GET : get all the notificationsnotifications/mark/:PUT : mark all notifications as readnotifications/unread/:GET: get all unread notifications3.how the client side recieve the message from the server via websocketconfigrationNote: make sure that django channels is up and running and also you django serves under ASGI
check thisurlto configure django channels in your projectinsettings.pyINSTALLED_APPS=[...'channels',# django channels needs to be installed'notifications',# our package...]SIMPLE_NOTIFICATION_SETTINGS={'receive_handler_path':'custom_module.custom_py_file.custom_receive_handler',}inurls.pypath('api/v1/notifications/',include('notifications.urls')),inasgi.pyfromnotificationsimportroutingos.environ.setdefault('DJANGO_SETTINGS_MODULE','demo_project.settings')application=ProtocolTypeRouter({'http':get_asgi_application(),'websocket':AuthMiddlewareStack(URLRouter(routing.websocket_urlpatterns)),})run make migrate:pythonmanage.pymigrate
Package: django-simple-notifications
A app package for simple notifications for djangoQuickstartInstall django-notifications:pip install django-simple-notificationsAdd it to yourINSTALLED_APPS:INSTALLED_APPS=(...'simple_notifications.apps.DjNotificationsConfig',...)Add django-simple-notifications’s URL patterns:fromsimple_notificationsimporturlsassimple_notifications_urlsurlpatterns=[...url(r'^',include(simple_notifications_urls)),...]Add django-simple-notifications’s to the contexts processors:TEMPLATES=[{...'OPTIONS':{'context_processors':[..."simple_notifications.context_processors.check_user_show_notification"],},},]Add to the templates or base html:{%include"simple_notifications/alert.html"%}FeaturesTODORunning TestsTODOCreditsTools used in rendering this package:Cookiecuttercookiecutter-djangopackageHistory0.1.1 (2018-06-19)Bug fix0.1.0 (2018-06-05)First release on PyPI.
Package: django-simple-open-graph
django-simple-open-graphDjango package for simplicity embed open graph (og:) layout in templates for different objectsProblemIf you use many different objects and you need embed open-graph (e.g. fb: for facebook) layout for all pages in site.SolutionThis package help you!
﻿█▄▄ ███ █▄▄ █▄█▄█ █▄█ ▀█▀InstallationYou can install from PyPI:$ pip install django-simple-open-graph==0.1And addsimple_open_graphin yourINSTALLED_APPS.Example Of UsageAdd og namespace in your base template:<html prefix="og: http://ogp.me/ns#">or for facebook:<html xmlns:fb="http://ogp.me/ns/fb#" lang="en">And add block in base template:<head>
    ...
    {% block extra_head %}{% endblock %}
    ...
</head>Aaand! You can use this package in different templates:{% load simple_open_graph %}

{% block extra_head %}
    {% thumbnail object.user.image 150x150 as uimage %} <!-- as example for use easy_thumbnails package -->
    {% opengraph_meta "url=object.get_absolute_url, title=object.title, type='website', image=uimage.url" %}
{% endblock %}This tag converted in meta html properties:<meta property="og:url" content="/users/1">
<meta property="og:image" content="/media/thumbnails/users/person1.jpg.150x150_q85.jpg">
<meta property="og:type" content="website">
<meta property="og:title" content="Profile: user #1">Excellent!Useful LinksThe Open Graph protocolFacebook DebuggerChanges0.3 (2012-09-28)fix absolute urls0.2 (2012-09-19)fix mistake in readme (installation)fix VariableDoesNotExist error (for resolve not existing keys)0.1 (2012-09-12)Initial release.
Package: django-simple-options
Simple app to add configuration options to a Django project.Quick start1Install using pip:$ pip install django-simple-options2Add “options” to your INSTALLED_APPS settings like this:INSTALLED_APPS += ('options',)Settings optionsUseSIMPLE_OPTIONS_CONFIGURATION_DEFAULTto set the default options:SIMPLE_OPTIONS_CONFIGURATION_DEFAULT = {
    "sold_out": {
        "value": 0,
        "type": INT,
        "public_name": "Sets tickets as sold out"
    },
}
Package: django-simple-pages
django-simple-pagesallows you to store HTML documents in models, which can
be served automatically without the need for hard-coded URL patterns.Example use cases include:Serving a static website.Handling redirects for relocated resources.Verifying site ownership for Google Search Console.Quick-startInstallpip installdjango-simple-pages.Addsimple_pagestoINSTALLED_APPS.Addsimple_pages.middleware.PageFallbackMiddlewaretoMIDDLEWARE.Runpython manage.py migrate simple_pages.UsageSimply navigate to/adminand create a newPageobject. APageconsists of the following attributes:title:The title of the page. This is rendered in the<title>tag
iftemplate_nameis set tosimple_pages/default.html.access_url:The URL to access this page. All URLs should start with a
leading slash.redirect_url: The URL to redirect to. If set,contentwill not be
rendered.enabled: When set to True, this page is active. Setting this value to
False means that you will see a 404 if you navigate to the page’saccess_url.template_name: The path to the template used to rendercontent.
Supported values include:simple_pages/default.html: Renders a<head>containing a<title>tag, and a<body>containing the page’scontent.simple_pages/raw.html: Renders the page’scontentonly.Note:Boldattributes are required.ChangelogVersionDescription0.3Added fade.html template.0.2.1Bump version to include all new documentation.0.2Admin detail view uses HTML code editor, rather than a
plain textarea.0.1.1Fixes incorrect help_text on Page.template_name.0.1Initial version.
Package: django-simple-pagination
Django Simple Paginationis a simple Django app to for digg-style pagination with little effort.Documentationisavaliable online, or in the docs
directory of the project.Quick startInstall ‘Django-Simple-Pagination’ using the following command:pip install django-simple-paginationAddsimple_paginationto your INSTALLED_APPS setting like this:INSTALLED_APPS = [
    ...
    'simple_pagination',
]In templates use{% load paginate %}to load all pagination template tagsIn templates use{% paginate no_of_records entities %}to get pagination objects.Here no_of_records means no of objects to display in a page and entities means the list of objectsIn templates use{% show_pageitems %}to get digg-style page links.Questions, Comments, etc?We welcome your feedback and support, raisegithub ticketif you want to report a bug. Need new features?Contact us hereVisit our Django web development pageHere
Package: django-simple-permissions
AuthorGiovabal <giovabal@gmail.com>Supported python versionsPython 2.6, 2.7, 3.3, 3.4, 3.5Supported django versionsDjango 1.2 - 1.9A fork and semplification of [django-permission](https://github.com/lambdalisue/django-permission/), by Alisue
Package: django-simple-plausible
Django Simple PlausibleA dead simple package to add Plausible Analytics html tag to your HTML. Tested with Python 2.7 and 3.8. Tested with Django 1.11 and 3.2.UsageInstall package:pip install django_simple_plausibleAdddjango_simple_plausibleto yourINSTALLED_APPSin settings.pyADDPLAUSIBLE_SITESandPLAUSIBLE_SCRIPT_URLkeys and values to your settings.py. Or enter the corresponding values as template tag parameters, as shown below....

PLAUSIBLE_SITES = "example.com"
PLAUSIBLE_SCRIPT_URL = "https://example.com/js/plausible.js"

...add the following template tags to your site html:{% load plausible %}
{% plausible %}Configuring detailsPLAUSIBLE_SITES can be a comma separated list without spaces, if you want to use that feature of PlausiblePLAUSIBLE_SITES = "example.com,yoursite.com"Systemwide settings can be overridden giving the template tag some optional parameters:{% plausible plausible_sites="mysite.com" script_url="https://mysite.com/plausible.js" %}
Package: django-simple-poll
Simple Django poll application.Installation------------```pip install django-simple-poll```Install latest from github:```pip install -e git+https://github.com/applecat/django-simple-poll.git#egg=django-simple-poll```Requirements------------Django 1.10+, Python 2.7, 3.4+Usage-----1. Add 'poll' application in the ``INSTALLED_APPS`` settings:```INSTALLED_APPS = (...'poll',)```2. Add the poll's url to your urls.py.```urlpatterns = [...url(r'^poll/', include('poll.urls')),]```3. Run ```python manage.py migrate```4. Go to site's admin area and create a new poll:![82721122-13db-11e7-905a-b90019b0fbde](https://cloud.githubusercontent.com/assets/390483/24417739/393a782a-13f2-11e7-8c09-fd6d0cf228f0.png)5. Add this tags in your template file to show the poll:```{% load poll_tags %}...{% poll %}```6. Check if jQuery is already included on the page. If don't — add it:```<script src="https://code.jquery.com/jquery-3.2.1.min.js"></script>```7. Make vote, see the results:![2017-03-28 17 17 10](https://cloud.githubusercontent.com/assets/390483/24410357/8973a134-13db-11e7-9788-94fe3462d1ce.png)![2017-03-28 17 17 05](https://cloud.githubusercontent.com/assets/390483/24410353/870887e8-13db-11e7-81b6-b5a721696e32.png)Customization-------------Of course, you can (and probably, should) customize Simple Poll's templates. You can simply do this by overriding `base.html`, `poll.html` and `result.html` in `templates/poll` directory.
Package: django-simple-polls
Standart App from tutorial Django 2.2.Polls is a simple Django app to conduct Web-based polls. For each
question, visitors can choose between a fixed number of answers.Detailed documentation is in the “docs” directory.Quick startAdd “polls” to your INSTALLED_APPS setting like this:INSTALLED_APPS = [
    ...
    'polls',
]Include the polls URLconf in your project urls.py like this:path('polls/', include('polls.urls')),Runpython manage.py migrateto create the polls models.Start the development server and visithttp://127.0.0.1:8000/admin/to create a poll (you’ll need the Admin app enabled).Visithttp://127.0.0.1:8000/polls/to participate in the poll.
Package: django-simple-profiler
Django simple profilerDjango simple profiler it is a useful tool for Django framework that allows you to profiling your views.Example of use:decorate your viewsuse as context managerRequires DEBUG=True in settings.py (!)https://github.com/Sobolev5/django-simple-profilerHow to install itTo install run:pip install django-simple-profilerexample.pyfromdjango_simple_profilerimportdjango_profiler# as decoratorfromdjango_simple_profilerimportdjango_profiler_full# as decorator with full queriesfromdjango_simple_profilerimportDjangoProfiler# as context manager@django_profilerdefget_countries(request):forcountryinCountry.objects.all():print(country)returnHttpResponse("OK")@django_profiler_fulldefget_countries(request):forcountryinCountry.objects.all():print(country)returnHttpResponse("OK")defget_countries(request):# simplewithDjangoProfiler()asdp:forcountryinCountry.objects.all():print(country)# full querieswithDjangoProfiler(full=True)asdp:forcountryinCountry.objects.all():print(country)# with labelwithDjangoProfiler(label="ActiveCountries")asdp:forcountryinCountry.objects.filter(active=True):print(country)# with label and full querieswithDjangoProfiler(label="ActiveCountries",full=True)asdp:forcountryinCountry.objects.filter(active=True):print(country)returnHttpResponse("OK")P.S.Try my free service for developersWorkhours.space.
It's time tracker with simple interface, powerful functionality such as automatic payroll calculation,
telegram bot timer, easy web2 and web3 auth and more. Enjoy.
Package: django-simple-proxy
django_simple_proxySimple Proxy for Python Django frameworkInstallationpip install django-simple-proxyThen adddjango_simple_proxytoINSTALLED_APPSUsageFirst, set Proxy in the database using the admin panel.Manually, withrequestslibrary.import requests

from django_simple_proxy.tools import random_proxy

proxy_url = random_proxy()
proxies = {'http': proxy_url, 'https': proxy_url}
response = requests.get(url, proxies=proxies)Or usingget_request/post_request:from django_simple_proxy.tools import get_request

response = get_request(url)
Package: django-simple-publish-model
django-simple-publish-modelDjango application provides simple publish/unpublish model and admin.Installpip install django-simple-publish-modelUsagepro/settings.pyINSTALLED_APPS = [
    ...
    'django_fastadmin',
    'django_simple_publish_model',
    ...
]app/models.pyReleasesv0.1.0 2020/10/27First release.Take from django_fastadmin.v0.1.2 2021/04/08Add actions.v0.1.3 2023/09/14Doc update.v0.1.4 2023/09/22Fix ugettext problem.
Package: django-simple-pwa
PWA is a simple Django app to develope and deploy a Progressive Web Application.Detailed documentation is in the “docs” directory.Quick startAdd “pwa” to your INSTALLED_APPS setting like this:INSTALLED_APPS = [
    ...
    'pwa',
]Include the pwa URLconf in your project urls.py like this:path('', include('pwa.urls')),Runpython manage.py collectstaticto get the PWA static files.Load pwa & its meta files in index HTML file like as:{% load pwa %}
{% pwa_meta_data %}
{% pwa_meta_script %}Start the development server on HTTPS or localhost to see installable app.github:https://github.com/nimaes80/django-simple-pwadocuments:https://django-simple-pwa.readthedocs.io/fa/latest/pypi:https://pypi.org/project/django-simple-pwa/
Package: django-simple-queue
Django simple queueIt is a very simple app which uses database for managing the task queue.Installationpip install django-simple-queueSet upAdddjango_simple_queueto INSTALLED_APPS in settings.pyAdd the following to urls.py in the main project directory.path('django_simple_queue/', include('django_simple_queue.urls')),Apply the database migrationsUsageStart the worker process as follows:python manage.py task_workerUsefrom django_simple_queue.utils import create_taskfor creating new tasks.
e.g.create_task(
    task="full_path_of_function",
    args={"arg1": 1, "arg2": 2} # Should be a dict object
)
Package: django-simple-ratings
a simple, extensible rating system.dependencies:django-generic-aggregation:http://github.com/coleifer/django-generic-aggregationWith a little bit morealso, a playground for different stuff i’ve been reading about inprogramming collective intelligence, by toby segaran.this stuff lives in utils.py and is there if you want to experiment (or
contribute!).Getting startedyou’d like to add ratings to some model:from django.db import models
from ratings.models import Ratings

class Food(models.Model):
    name = models.CharField(max_length=50)

    ratings = Ratings()now, you can:# add ratings to things
>>> apple.ratings.rate(user=john, score=1)
<RatedItem: apple rated 1 by john>

>>> apple.ratings.rate(user=jane, score=5)
<RatedItem: apple rated 5 by jane>

# get interesting aggregate data
>>> apple.ratings.all()
[<RatedItem: apple rated 1 by john>, <RatedItem: apple rated 5 by jane>]

>>> apple.ratings.cumulative_score()
6

>>> apple.ratings.average_score()
3.0

# order things by their rating
>>> Food.ratings.order_by_rating()
[<Food: apple>, <Food: orange>]Use GFKs, FKs, whateverBy default, whenever you add Ratings() to your model it uses the RatedItem model
which has a GFK on it.  Suppose you are only rating one thing, or would like to
have an explicit database constraint – that’s no problem.  You can provide a
custom RatedItem model with a ForeignKey instead of a GFK.  Here’s the example
from the tests:class BeverageRating(RatedItemBase):
    content_object = models.ForeignKey('Beverage')


class Beverage(models.Model):
    name = models.CharField(max_length=50)

    ratings = Ratings(BeverageRating)

    def __unicode__(self):
        return self.nameThe API is exactly the same.
Package: django-simple-redis-admin
[![Build Status](https://travis-ci.org/nicholasserra/django-simple-redis-admin.svg?branch=travis)](https://travis-ci.org/nicholasserra/django-simple-redis-admin)django-simple-redis-admin=========`django-simple-redis-admin` is an addition to your Django admin panel that allows you to view and delete your Redis keys.Requirements------------* Django >= 1.8 <= 1.10* A Django redis cache backend. I recommend [django-redis-cache](https://github.com/sebleier/django-redis-cache)Installation------------`django-simple-redis-admin` can be installed via pip.```pip install django-simple-redis-admin```Then just add `redis_admin` to your `INSTALLED_APPS`.Why simple?-----------This package does not use models, so no database tables need to be created. Just add to INSTALLED_APPS and go.Users must have is_superuser == True to view the Redis admin. No django admin logs are created with this package.To Do-----* Editing keys* Better representation for Redis sets
Package: django-simple-registration
This fork fixes compatibility with Django 1.5 and also provides default templates.This is a fairly simple user-registration application for Django,designed to make allowing user signups as painless as possible. Itrequires a functional installation of Django 1.4 or newer, but has noother dependencies.For installation instructions, see the file "INSTALL" in thisdirectory; for instructions on how to use this application, and onwhat it provides, see the file "quickstart.rst" in the "docs/"directory. Full documentation is also `available onlinehttps://django-registration.readthedocs.org/`_
Package: django-simple-saml
Django Simple SAMLDjango app to manage SAML Identity ProvidersVersion supportThis app support Django 3.2+ and Python 3.8+.BackgroundThis library builds on top ofsocial-auth-app-djangoandpython3-saml, which together handle the heavy lifting of a SAML
authentication flow. It assumes that you are building a service that
will act as the Service Provider (SP) in the flow, and that you will be
integrating with a number of external Identity Providers (IdP) for user
authentication.The core change to those libraries that this package adds is a newSAMLAuthbackend calledSimpleSAMLAuththat reads in IdP data from a
model (i.e. the database) rather than using the settings config dictSOCIAL_AUTH_SAML_ENABLED_IDPS.The reason for this is to make it easy to update / test new IdPs on a
live environment without having to deploy. If you are running a platform
that offers SSO to clients as a feature, having to embed their IdP
details in the settings (which also requires a redeployment) isn't a
practical option.The IdP data is input via the Django admin site.SettingsThis package relies on the existingpython-social-authsettings. See
their documentation for details, or refer to thedemo.settings.basemodule for an example.ConfigurationClick this button to deploy to Heroku:You must supply three SAML settings that should be available from your
test IdP provider. If you have a Google Workspace account, that can be
used - seehttps://admin.google.com/ac/security/ssocertfor details.Local install & setupIf you are having problems installingxmlseclocally, try this:https://github.com/xmlsec/python-xmlsec/issues/254DISCLAIMERThe demo app demonstrate SSO using SAML2.0, which means it'sdestined(but not designed) to be used in security-conscious enterprise
environments. It is ademonstrationonly - it should NOT BE TRUSTED,
and you do so at YOUR OWN RISK.Do not deploy the demo into a secure environment, and do not connect
it to a real IdP.