Saravanan666/pypi-org huggingface dataset:
Package: django-crumbs
django-crumbsdjango-crumbs is a pluggable Django app for adding breadcrumbs to your project.InstallationInstall django-crumbs with pip:pip install django-crumbsAdd to your INSTALLED_APPS and run syncdb:INSTALLED_APPS = (
    ...,
    'crumbs',
)How It WorksIn each template, you’ll need to use the add_crumb template tag to append items to the trail:# basic crumb without a link
{% add_crumb 'People' %}
# crumb with link
{% add_crumb 'People' 'list_people' %}
# crumb with link and args
{% add_crumb person.name 'view_person' person.pk %}Note:no bread crumbs will be printed if only one call to add_crumb has been made.SetupIn your base.html template, add something along the lines of the following code:<div id="breadcrumbs">
    {% block breadcrumb %}
        {% load breadcrumb_tags %}
        {% add_crumb 'Home' 'home' %}
    {% endblock %}
    {% render_breadcrumbs %}
</div>Now in each extended child template, simply add a new crumb to the trail in the breadcrumb block:{% block breadcrumb %}
    {{ block.super }}
    {% load breadcrumb_tags %}
    {% add_crumb 'People' 'list_people' %}
{% endblock %}Examplebase.html:<div id="breadcrumbs">
    {% block breadcrumb %}
        {% load breadcrumb_tags %}
        {% add_crumb 'Home' 'home' %}
    {% endblock %}
    {% render_breadcrumbs %}
</div>person/list.html:{% extends "base.html" %}
{% block breadcrumb %}
    {{ block.super }}
    {% load breadcrumb_tags %}
    {% add_crumb 'People' 'list_people' %}
{% endblock %}person/view.html:{% extends "person/list.html" %}
{% block breadcrumb %}
    {{ block.super }}
    {% load breadcrumb_tags %}
    {% add_crumb person.name 'view_person' person.pk %}
{% endblock %}Development sponsored byCaktus Consulting Group, LLC.
Package: django-crwyoauth
django-crwyoauth简介django oauth 2.0 实现。运行环境Python2.7DjangoWorks on Linux, Mac OSX依赖包Django >= 1.10.3django-braces >= 1.9.0安装快速安装:pip install django-crwyoauthor
前往下载:https://pypi.python.org/pypi/django-crwyoauth/1.0.1/使用手册在这里:http://django-crwyoauth.readthedocs.io/zh_CN/1.0.1/修改日志2017-01-25更改crwyoauth_config表结构，添加site字段以适应多站点三方登录
Package: django-cryptocoin
Django-cryptocoin is a Django app to organize accepting bitcoin, litecoin, novacoin and other cryptocoins, which support JSON-RPC commands getnewaddress and getreceivedbyaddress.Quick StartInstall using pippip install django-cryptocoinAdd‘django-cryptocoin’,to INSTALLED_APPS in yoursettings.pyRunpython manage.py migrateSet settings similarly ashttps://github.com/quantum13/django-crypto-paid-chat/blob/master/cryptochat/settings_local.py-exampleAdd commandpython manage.py check_incomingsto cron with interval 1 minuteAdd relation to CryptoOrder to your order model:crypto_order = models.OneToOneField(CryptoOrder, related_name='order')Add handler to payment end signal (delivery digital content, sending email, etc):@receiver(after_pay_confirmation)
def after_pay(sender, **kwargs):
    passAfter sending form with order we need create instance of CryptoOrder and redirect to process view. Example:if form.is_valid():
    crypto_order = CryptoOrder(
        currency='btc',
        amount=0.1,#price
        date=timezone.now(),#time of invoice
        redirect_to=reverse('home')#view to redirect after payment
    )
    crypto_order.save()
    form.instance.crypto_order = crypto_order
    form.save()
    return redirect('cryptocoin-order-process', addr=crypto_order.addr)After confirmation of transaction sended signalafter_pay_confirmationwhich handler described above.Examplehttps://github.com/quantum13/django-crypto-paid-chatTested cryptocoinsBitcoinLitecoinNovacoinEmercoinOptionsCRYPTO_COINSDict with supported crypto currencies. Default:{
    'btc': 'Bitcoin',
    'ltc': 'Litecoin',
    'nvc': 'Novacoin',
}CONNECTION_STRINGConnection strings for JSON-RPC commands to coin clients. Default:{
    'btc': 'your_bitcoin_addr_to_send_btc',
    'ltc': 'your_litecoin_addr_to_send_ltc',
    'nvc': 'your_novacoin_addr_to_send_nvc',
}CONFIRMATIONSNetwork confirmations count for each crypto currency. Default:{
    'btc': 1,
    'ltc': 1,
    'nvc': 1,
}PROCESS_TEMPLATETemplate for process view. You can use own site template for this page. For example if you have base templatebase.htmlwith blockcontentyou can createprocess.htmlin your template folder and paste this code:{% extends 'base.html' %}

{% block content %}
    {% include 'django_cryptocoin/process.html' %}
{% endblock %}INVOICE_TIMEHow many seconds app will wait for payment. If you set big value, exchange rate to USD can change significantly. Default900seconds/GENERATED_ADDRESSES_ACCOUNTAccount for generated addresses in your wallet. Defaultdjango_cryptocoin.CURRENCY_PAIRSCurrency pairs for which will retrieved exchange rates from btc-e.com. To retrieve this rates run commandpython manage.py get_exchange_rates. Than you can get this rates with functionExchangeRate.get_exchange_rate(from_currency, to_currency). Default:['btc_usd', 'btc_rur', 'btc_eur', 'ltc_usd', 'ltc_rur', 'nvc_usd']DonateBTC: 1JrV8GW9HWRHWvJNQ14fExAkfgxawAY4oqLTC: LiHkeymborDtpqUh3ExYT9CXJkyucDH4CcNVC: 4U5F4GQin6QkTpbd5k9si3f4iSkn2o3v9x
Package: django-cryptocoins
=====CryptoCoins=====CryptoCoins is a simple Django app to keep an overview of your cryptocoins.Detailed documentation is in the "docs" directory.Quick start-----------1. Add "cryptocoins" to your INSTALLED_APPS setting like this::INSTALLED_APPS = [...'cryptocoins',]2. Include the polls URLconf in your project urls.py like this::url(r'^cryptocoins/', include('cryptocoins.urls')),3. Create the cryptocoins models::python manage.py migrate4. Run::python manage.py J1_Update_Coins --import-allto import all cryptocoins from coinmarketcap.com.As an alternative you can run::python manage.py J1_Update_Coins --import-only BTC,ETH,STORJto import only these cryptocoins5. Run::python manage.py J1_Update_Coinsor visit::http://127.0.0.1:8000/cryptocoins/coins/update_all/to update the prices of imported cyptocoins
Package: django-cryptocurrency-payment
Simple and flexible pluggable cryptocurrency payment app for django. Coins are spendable and reflect on HD wallet like ElectrumDocumentationThe full documentation is athttps://django-cryptocurrency-payment.readthedocs.io.QuickstartInstall Django Cryptocurrency Payment:pip install django-cryptocurrency-paymentAdd it to yourINSTALLED_APPS:INSTALLED_APPS=(...'cryptocurrency_payment.apps.CryptocurrencyPaymentConfig',...)CRYPTOCURRENCY_PAYMENT={"BITCOIN":{"CODE":"btc","BACKEND":"merchant_wallet.backends.btc.BitcoinBackend","FEE":0.00,"REFRESH_PRICE_AFTER_MINUTE":15,"REUSE_ADDRESS":False,"ACTIVE":True,"MASTER_PUBLIC_KEY":'PUT_YOUR_WALLET_MASTER_PUBLIC_KEY',"CANCEL_UNPAID_PAYMENT_HRS":24,"CREATE_NEW_UNDERPAID_PAYMENT":True,"IGNORE_UNDERPAYMENT_AMOUNT":10,"IGNORE_CONFIRMED_BALANCE_WITHOUT_SAVED_HASH_MINS":20,"BALANCE_CONFIRMATION_NUM":1,"ALLOW_ANONYMOUS_PAYMENT":True,"DERIVATION_PATH":"m/0",#please use deriavation path from your wallet"ADDRESS_TYPE":"p2wpkh"#specify address type you want to generate p2pkh p2sh p2wpkh p2wsh p2wpkh_in_p2sh},"LITECOIN":{"CODE":"LTC",........}}Add Django Cryptocurrency Payment’s URL patterns:fromcryptocurrency_paymentimporturlsascryptocurrency_payment_urlsurlpatterns=[...url(r'^',include(cryptocurrency_payment_urls)),#/payment/{pk}/...]Create payment with methodfromcryptocurrency_payment.modelsimportcreate_new_paymentpayment=create_new_payment(crypto='BITCOIN',#Cryptocurrency from your settingsfiat_amount=10,#Amount of item in fiatfiat_currency='USD',#Fiat currency used to convert to crypto amountpayment_title=None,#Title associated with paymentpayment_description=None,#Description associated with paymentrelated_object=None,#Generic linked object for this payment -> crypto_payments = GenericRelation(CryptoCurrencyPayment)user=None,#User of this payment for non-anonymous paymentparent_payment=None,#Associate with previous paymentaddress_index=None,# Use an address generated from a particular index for this payment e.g same address can always be used for a particular userreuse_address=None),#Used previously paid address for this paymentTasksRun these tasks periodically based on your preferred time using your favorite django task managercryptocurrency_payment.tasks.update_payment_statuscryptocurrency_payment.tasks.cancel_unpaid_paymentcryptocurrency_payment.tasks.refresh_payment_pricesFeaturesFlexible payment creation that can be linked to other django objectAutomatically update payment status from blockchainAuto update payment prices if payment is not paidAuto create child payment if payment is underpaidCancel unpaid payment after a period of timeAllow Anonymous paymentPluggable backend to support more cryptocurrencyRunning TestsDoes the code actually work?source <YOURVIRTUALENV>/bin/activate
(myenv) $ pip install tox
(myenv) $ toxCreditsTools used in rendering this package:Cookiecuttercookiecutter-djangopackageHistory0.1.0 (2020-03-21)First release on PyPI.
Package: django-crypto-extensions
DJANGO-CRYPTO-EXTENSIONS.. image::https://codecov.io/gh/DjangoCrypto/django-crypto-extensions/branch/main/graph/badge.svg?token=kSCQw7h9fi:target:https://codecov.io/gh/DjangoCrypto/django-crypto-extensions.. image::https://img.shields.io/pypi/v/django-crypto-extensions:target:https://pypi.org/project/django-crypto-extensions/1.0.0/:alt: PyPI.. image::https://img.shields.io/pypi/pyversions/django-crypto-extensions:alt: PyPI - Python Version.. image::https://readthedocs.org/projects/django-crypto-extensions/badge/?version=latest:target:https://django-crypto-extensions.readthedocs.io/en/latest/?badge=latest:alt: Documentation.. image::https://travis-ci.com/DjangoCrypto/django-crypto-extensions.svg?branch=main:target:https://travis-ci.com/DjangoCrypto/django-crypto-extensions:alt: Travis CIDocumentationFor more information on installation and configuration see the documentation at:https://django-crypto-extensions.readthedocs.io/
Package: django_cryptofield
This package provides database backed, encrypted fields for Django. The fields use database internal mechanisms to encrypt and verify strings completely inside the database. This functionality is interesting for use with passwords that are stored in a database as it allows the database to manage salting, hashing, and verification of the passwords.Support notesCurrently only PostgreSQL is supported as a database backend. I would be happy if someone with experience in MySQL or other databases that support encryption would provide hints or implementations for their favourite database.UsageUsingcryptofieldis easy:from django.db import models
import cryptofield

class ModelWithCrypto(models.Model):
    password = cryptofield.CryptoField()Keyword argumentsTheCryptoFieldclass supports the following keyword arguments:KeywordDescriptionValuesalgorithmThe hashing algorithm to usebf (default), md5, xdes, desRequirements (PostgreSQL)To use this package with PostgreSQL, make sure that the database in use has thepgcryptoextension activated. To do so, issue the following command to the desired database:CREATE EXTENSION IF NOT EXISTS pgcrypto;If no error occurs, theCryptoFieldclass can now be used with the database.
Package: django-cryptographic-fields
Django Cryptographic Fields===========================.. image:: https://circleci.com/gh/foundertherapy/django-cryptographic-fields.png:target: https://circleci.com/gh/foundertherapy/django-cryptographic-fieldsAbout-----``django-cryptographic-fields`` is set of fields that wrap standard Djangofields with encryption provided by the python cryptography library. Thesefields are much more compatible with a 12-factor design since they take theirencryption key from the settings file instead of a file on disk used by``keyczar``.While keyczar is an excellent tool to use for encryption, it's not compatiblewith Python 3, and it requires, for hosts like Heroku, that you either checkyour key file into your git repository for deployment, or implement manualpost-deployment processing to write the key stored in an environment variableinto a file that keyczar can read.Getting Started---------------$ pip install django-cryptographic-fieldsAdd "cryptographic_fields" to your INSTALLED_APPS setting like this:INSTALLED_APPS = (...'cryptographic_fields',)``django-cryptographic-fields`` expects the encryption key to be specifiedusing ``FIELD_ENCRYPTION_KEY`` in your project's ``settings.py`` file. Forexample, to load it from the local environment:import osFIELD_ENCRYPTION_KEY = os.environ.get('FIELD_ENCRYPTION_KEY', '')To use an encrypted field in a Django model, use one of the fields from the``cryptographic_fields`` module:from cryptographic_fields.fields import EncryptedCharFieldclass EncryptedFieldModel(models.Model):encrypted_char_field = EncryptedCharField(max_length=100)For fields that require ``max_length`` to be specified, the ``Encrypted``variants of those fields will automatically increase the size of the databasefield to hold the encrypted form of the content. For example, a 3 characterCharField will automatically specify a database field size of 100 characterswhen ``EncryptedCharField(max_length=3)`` is specified.Due to the nature of the encrypted data, filtering by values contained inencrypted fields won't work properly. Sorting is also not supported.Generating an Encryption Key----------------------------There is a Django management command ``generate_encryption_key`` providedwith the ``cryptographic_fields`` library. Use this command to generate a newencryption key to set as ``settings.FIELD_ENCRYPTION_KEY``../manage.py generate_encryption_keyRunning this command will print an encryption key to the terminal, which canbe configured in your environment or settings file.
Package: django-cryptography
A set of primitives for easily encrypting data in Django, wrapping
the PythonCryptographylibrary. Also provided is a drop in
replacement for Django’s own cryptographic primitives, usingCryptographyas the backend provider.Do not forget to read thedocumentation.Cryptography by exampleUsing symmetrical encryption to store sensitive data in the database.
Wrap the desired model field withencryptto easily
protect its contents.fromdjango.dbimportmodelsfromdjango_cryptography.fieldsimportencryptclassMyModel(models.Model):name=models.CharField(max_length=50)sensitive_data=encrypt(models.CharField(max_length=50))The data will now be automatically encrypted when saved to the
database.encryptuses an encryption that allows for
bi-directional data retrieval.RequirementsPython(3.6, 3.7, 3.8, 3.9, 3.10)Cryptography(2.0+)Django(2.2, 3.2, 4.0)Installationpip install django-cryptography
Package: django-cryptolock
Authenticatio using cryptocurrency wallets for Django projectsThis package provided a django app containing a set of utilities to make easier to
implement the BitId and Monero Cryptolock authentication “protocols”.Future releases might include other cryptocurrencies but for the being
(until we reach some stability) the focus will continue BTC and XMR.DISCLAIMER:This package is still in an early stage of development. It isn’t meant to be
used on any production scenario yet (in other words, only test projects for now).DocumentationThe full documentation is athttps://django-cryptolock.readthedocs.io.QuickstartInstall Django-Cryptolock:pip install django-cryptolockAdd it to yourINSTALLED_APPS:INSTALLED_APPS=(...'django_cryptolock.apps.DjangoCryptolockConfig',...)Migrate your database:python manage.py migrateAdd the following settings to your project for the Monero Backend:AUTHENTICATION_BACKENDS=["django_cryptolock.backends.MoneroAddressBackend",...]DJCL_MONERO_NETWORK="mainnet"DJCL_MONERO_WALLET_RPC_PROTOCOL="<http_or_https>"DJCL_MONERO_WALLET_RPC_HOST="<wallet_rpc_host>:<port>"DJCL_MONERO_WALLET_RPC_USER="<user>"DJCL_MONERO_WALLET_RPC_PASS="<password>"Add Django-Cryptolock’s URL patterns:fromdjango.conf.urlsimporturlurlpatterns=[...url(r"^auth/",include("django_cryptolock.urls",namespace="django_cryptolock")),...]More detailed information can be found in the documentation.CreditsTools used in rendering this package:Cookiecuttercookiecutter-djangopackageHistory0.1.0 (2020-03-31)Add validation for existing addresses on the signup formAdd rudimentary BitId supportRenamed the base auth views to generic names0.0.2 (2020-01-08)A defaulturls.pyis provided by the package so can work “out-of-the-box”.Default location for templates moved todjango_cryptolockfolder.Update quickstart guide.Update instructions to contribute to the project.AddDJCLnamespace to all related settings.MoneroAddressBackend is now executed when more parameters are added to theauthenticatefunction.0.0.1 (2019-11-25)First release on PyPI.
Package: django-crystal-big
This library bundlesEveraldo’s Crystal iconsfor direct consumption with Django
applications. Sizes available are 64x64 and 128x128. Look fordjango-crystal-smallfor
16x16, 22x22, 24x24, 32x32 and 48x48.  The icons are additionally crushed using
pngcrush, optipng and advpng.Very simple installation:Use Django 1.3 ordjango-staticfilesadddjango_crystal_bigtoINSTALLED_APPSrunmanage.py collectstaticshould pick up Crystal icons as well. They are
available under thecrystaldirectoryThe latest version can be installed viaPyPI:$ pip install django-crystal-bigor:$ easy_install django-crystal-bigThesource code repositoryandissue trackerare
maintained onGitHub.Note:This is only a handy Django-specific bundle of icons originally
crafted byEveraldo Coelhoand contributors.
These icons have been released under the LGPL, and so is this bundle.
Package: django-crystal-small
This library bundlesEveraldo’s Crystal iconsfor direct consumption with Django
applications. Sizes available are 16x16, 22x22, 24x24, 32x32 and 48x48. Look fordjango-crystal-bigfor
64x64 and 128x128. The icons are additionally crushed using pngcrush, optipng
and advpng.Very simple installation:Use Django 1.3 ordjango-staticfilesadddjango_crystal_smalltoINSTALLED_APPSrunmanage.py collectstaticshould pick up Crystal icons as well. They are
available under thecrystaldirectoryThe latest version can be installed viaPyPI:$ pip install django-crystal-smallor:$ easy_install django-crystal-smallThesource code repositoryandissue trackerare maintained onGitHub.Note:This is only a handy Django-specific bundle of icons originally
crafted byEveraldo Coelhoand contributors.
These icons have been released under the LGPL, and so is this bundle.
Package: django-cschedules
=====CSchedules=====Very simple calendar schedule.Quick start-----------1. Add "c_schedules" to your INSTALLED_APPS setting like this::INSTALLED_APPS = [...'django.contrib.admin','django.contrib.auth','django.contrib.messages','rest_framework', # include if you want use rest api'c_schedules',]if you want use rest_framework, execute pip install djangorestframework2. Include the c_schedules URLconf in your project urls.py like this::url(r'^cschedules/', include('c_schedules.urls')),3. settings params:USE_ONLY_REST_URLS: (default False)USE_WITH_REST_URLS: (default False)CS_USE_IN_ADMIN_PANEL: (default True)3. Run `python manage.py migrate` to create the c_schedules models.4. Start the development server and visit http://127.0.0.1:8000/admin/to create a c_schedules (you'll need the Admin app enabled).5. Visit http://127.0.0.1:8000/c_schedules/ to participate in the c_schedules.
Package: django-cs-models
Django Complex System ModelsA Django app that helps you creating models within a Complex System.LicenseSoftware licensed underMPL 2.0license.Installationpip install django-cs-modelsUsageTwo parameters have to be set in your settings. Here is an example:COMPLEX_APP_NAME='ecosystem'COMPLEX_STRUCTURE={'roots':[['Organization','Committee','Board','Cohort'],],'nodes':[['ProjectTeam'],['Resource'],['Member'],]}Roots are entities that contain nodes (a root cannot contain another root).
Nodes are entities contained by and containing other nodes.You can define roots and nodes at different levels, i.e. their position
in the hierarchy. These levels will tell if such entity can be
contained by such other entity.Now inecosystemapp:fromcsmodels.modelsimportabstract_modelclassCohort(abstract_model('Cohort')):your_model_fields_here=models.SomeField()classMeta:verbose_name=_('Cohort')verbose_name_plural=_('Cohorts')The cohort model will inherit many to many relationships to
project teams, resources and members from the abstract model.Of course, a change in the complex structure will change the models,
therefore migrations will be needed!First diagram shows the example above.Second diagram shows how links are created between entity depending on their
type (root or node) and their level. Letters (their names) are not important,
but numbers (their levels) are.Documentationhttps://github.com/Pawamoy/django-cs-models.wikiDevelopmentTo run all the tests:toxChangelog0.1.0 (2016-10-06)Alpha release on PyPI.
Package: django-csp-advanced
django-csp-advancedA powerfulContent-Security-Policy(CSP) middleware for Django. This CSP middleware supports
using a dictionary syntax for CSP, and using callables taking arguments(request, response)to fill in parts of the dictionary.For example, the followingsettings.pyconfiguration:ADVANCED_CSP={'block-all-mixed-content':True,'frame-src':['none'],'plugin-types':['application/pdf'],'report-uri':'/dev/null','sandbox':['allow-scripts'],'script-src':['self','https://dmoj.ca'],'style-src':lambdarequest,response:['self'],'upgrade-insecure-requests':False,}generates this CSP (order may differ based on dictionary hashing):style-src 'self'; script-src 'self' https://dmoj.ca; frame-src 'none'; plugin-types application/pdf; block-all-mixed-content; sandbox allow-scripts; report-uri /dev/nullAnother feature is the ability to augment or replace the CSP from views:defview(request):response=HttpResponse()response.csp={'script-src':['https://ajax.googleapis.com']}returnresponseThis will addhttps://ajax.googleapis.comto the list of origins listed forscript-srcto result in something like:...; script-src 'self' https://dmoj.ca https://ajax.googleapis.com; ...You can use'override': Trueto replace the CSP instead:defview(request):response=HttpResponse()response.csp={'script-src':['self'],'override':True}returnresponseThis will replace the CSP withscript-src 'self'.You can also setcsp_reporton the response to add entry to the report-only CSP.
Note that neithercsporcsp_reporthas any effect if their global version is disabled.
However,cspwill be used to populateContent-Security-Policy-Report-Onlyif there is
no enforced CSP policy configured, but there is a report-only policy.InstallationFirst, install the module with:$ pip install django-csp-advancedOr if you want the latest bleeding edge version:$ pip install -e git://github.com/quantum5/django-csp-advanced.gitThen, add'csp_advanced'toINSTALLED_APPSand'csp_advanced.middleware.AdvancedCSPMiddleware'to'MIDDLEWARE'or'MIDDLEWARE_CLASSES'dependingon your setup.Finally, use either a dictionary or a callable takingrequest, responseas eitherADVANCED_CSPorADVANCED_CSP_REPORT_ONLY.Examples:ADVANCED_CSP=lambdarequest,response:{'script-src':['self']}ADVANCED_CSP_REPORT_ONLY={'script-src':['self']}ADVANCED_CSP={'style-src':lambdarequest,response:['self']}You get the idea.