Saravanan666/pypi-org huggingface dataset:
Package: django-azure-ad-auth
Django Azure AD Auth======================*Django Azure AD Auth* allows you to authenticate through Azure Active Directory.Installation------------Run `pip install django-azure-ad-auth`Add the `AzureActiveDirectoryBackend` to your `AUTHENTICATION_BACKENDS` setting:```pythonAUTHENTICATION_BACKENDS = (...'azure_ad_auth.backends.AzureActiveDirectoryBackend',)```Settings--------###AAD_TENANT_IDThe Azure Tenant ID. It can be found in the URL of the Azure Management Portal.###AAD_CLIENT_IDThe Azure Application Client ID.###AAD_AUTHORITY**default:** `'https://login.microsoftonline.com'`The domain that is used for authorization, the federation metadata document, and loggin out.###AAD_SCOPE**default:** `'openid'`OAuth scope parameter.###AAD_RESPONSE_TYPE**default:** `'id_token'`Tells OAuth to return a JWT token in its response.###AAD_RESPONSE_MODE**default:** `'form_post'`Defines how the response parameters are returned. Valid choices are `fragment` or `form_post`.###AAD_USER_CREATION**default:** `True`Allow creation of new users after successful authentication.
Package: django-azure-ad-auth-redux
Django Azure AD Auth ReduxDjango Azure AD Authallows you to authenticate through Azure Active Directory.This fork has the following additional features:Add the specification of the decode algorithm per newer PyJWT requirements.Supports django > 3.2.18InstallationRunpip install django-azure-ad-auth-reduxAdd theAzureActiveDirectoryBackendto yourAUTHENTICATION_BACKENDSsetting:AUTHENTICATION_BACKENDS=(..."azure_ad_auth.backends.AzureActiveDirectoryBackend",)SettingsAAD_TENANT_IDThe Azure Tenant ID. It can be found in the URL of the Azure Management Portal.AAD_CLIENT_IDThe Azure Application Client ID.AAD_AUTHORITYdefault:"https://login.microsoftonline.com"The domain that is used for authorization, the federation metadata document, and logging out.AAD_SCOPEdefault:"openid"OAuth scope parameter.AAD_RESPONSE_TYPEdefault:"id_token"Tells OAuth to return a JWT token in its response.AAD_RESPONSE_MODEdefault:"form_post"Defines how the response parameters are returned. Valid choices arefragmentorform_post.AAD_USER_CREATIONdefault:TrueAllow creation of new users after successful authentication.AAD_USER_MAPPINGdefault:{}Map fields from the token to the user, to be used on creation.AAD_USER_STATIC_MAPPINGdefault:{}Map static values to user fields on creation.AAD_GROUP_MAPPINGdefault:{}Map group ids to group names for user permissions.
Package: django-azure-auth
Django Azure AuthA simple Django app for user authentication with Azure Active Directory.Descriptiondjango-azure-authis a Django app which wraps the greatMSALpackage to enable authentication against Microsoft's Azure Active Directory in Django projects.The app includeslogin,logoutandcallbackauthentication views, a decorator
to protect individual views, and middleware which allows the entire site to require user
authentication by default, with the ability to exempt specified views.This project is in no way affiliated with Microsoft.InstallationFrom PyPi:pipinstalldjango-azure-authConfigurationAzure setupRegister an app athttps://portal.azure.com/.Add a client secret and note it down.Add a redirect URI of the formathttps://<domain>/azure_auth/callback.SettingsAdd the following to yoursettings.py, replacing the variables in braces with the values
from your Azure app:AZURE_AUTH={"CLIENT_ID":"<client id>","CLIENT_SECRET":"<client secret>","REDIRECT_URI":"https://<domain>/azure_auth/callback","SCOPES":["User.Read"],"AUTHORITY":"https://login.microsoftonline.com/<tenant id>",# Or https://login.microsoftonline.com/common if multi-tenant"LOGOUT_URI":"https://<domain>/logout",# Optional"PUBLIC_URLS":["<public:view_name>",]# Optional, public views accessible by non-authenticated users"PUBLIC_PATHS":['/go/',],# Optional, public paths accessible by non-authenticated users}LOGIN_URL="/azure_auth/login"LOGIN_REDIRECT_URL="/"# Or any other endpointNote: You should obfuscate the credentials by using environment variables.Installed appsAdd the following to yourINSTALLED_APPS:INSTALLED_APPS=("...","azure_auth","...")Authentication backendConfigure the authentication backend:AUTHENTICATION_BACKENDS=("azure_auth.backends.AzureBackend",)URLsInclude the app's URLs in yoururlpatterns:fromdjango.urlsimportpath,includeurlpatterns=[path("azure_auth/",include("azure_auth.urls"),),]UsageDecoratorTo make user authentication a requirement for accessing an individual view, decorate the
view like so:fromazure_auth.decoratorsimportazure_auth_requiredfromdjango.shortcutsimportHttpResponse@azure_auth_requireddefprotected_view(request):returnHttpResponse("A view protected by the decorator")MiddlewareIf you want to protect your entire site by default, you can use the middleware by adding the
following to yoursettings.py:MIDDLEWARE=["...","azure_auth.middleware.AzureMiddleware","...",]Make sure you add the middleware after Django'ssessionandauthenticationmiddlewares so
that the request includes the session and user objects. Public URLs which need to be accessed by
non-authenticated users should be specified in thesettings.AZURE_AUTH["PUBLIC_URLS"], as
shown above.Planned developmentGroups managementCreditsThis app is heavily inspired by and builds on functionality inhttps://github.com/shubhamdipt/django-microsoft-authentication, with both feature
improvements and code assurance through testing.Credit also to:https://github.com/Azure-Samples/ms-identity-python-webapphttps://github.com/AzMoo/django-okta-auth
Package: django-azure-backup
Django Database BackupThis package can take postgres dump and able to upload data in azure cloud storage.Build Processopen the link.click here for steps.RequiredDjango Default Database Config.AZURE_ACCOUNT_NAME (Azure Storage Account Name).AZURE_CREDENTIAL (Azure Key).AZURE_CONTAINER (Azure Container Name).AZURE_BACKUP_FOLDER_NAME.Commandspython3 manage.py db-backup-listpython3 manage.py db-backuppython3 manage.py db-restore
Package: django-azure-communication-email
Django Azure Communication EmailA Django email backend for Azure Communication Email service.InstallationRun the following on your system:pip install django-azure-communication-emailThen, add these settings to your Djangosettings.py:EMAIL_BACKEND = 'django_azure_communication_email.EmailBackend'

AZURE_COMMUNICATION_CONNECTION_STRING = '...'
# OR
AZURE_KEY_CREDENTIAL = '...'
AZURE_COMMUNICATION_ENDPOINT = '...'If you prefer to use Azure Active Directory authentication, you can use the
followingsettings.pyinstead:EMAIL_BACKEND = 'django_azure_communication_email.EmailBackend'

AZURE_COMMUNICATION_ENDPOINT = '...'

# Note: make sure to set the following environment variables:
# AZURE_TENANT_ID, AZURE_CLIENT_ID, AZURE_CLIENT_SECRETNow, when you usedjango.core.mail.send_mail, Azure Communication Email
service will send the messages by default.Running TestsTo run the tests::python runtests.pyIf you want to debug the tests, just add this file as a python script to your IDE run configuration.Creating a ReleaseTo create a release:Runpoetry version {patch|minor|major}as explained inthe docs.
This will update the version inpyproject.toml.Commit that change and use git to tag that commit with a version that matches the patternv*.*.*.Push the tag and the commit (note some IDEs don't push tags by default).
Package: django_b2storage
A backblaze B2 storage system for djangoDescriptiondjango-b2storage is a storage system for django using the cloud serviceBackblaze B2.InstallationTo install django-b2storage:$pipinstalldjango_b2storageThen in your settings file, add the following:DEFAULT_FILE_STORAGE='django_b2storage.backblaze_b2.B2Storage'B2_ACCOUNT_ID='your_account_id'B2_APPLICATION_KEY='your_application_key'B2_BUCKET_NAME='your_bucket_name'B2_BUCKET_ID='your_bucket_id'And That’s It!!!You will now be able to refer to user uploaded files using:object_with_file.file.url()TutorialTo see this in action alongside withHeroku, see my tutorialhere
Package: django-b2t-accounts
This “Account” app is an authentication app based on Django’s built in
Authentication module and is an email authentication system.Quick startInstall dependencies:pip install -r requirements.txtAdd “account” to your INSTALLED_APPS setting like this:INSTALLED_APPS = [
    ...
    'account',
]Include the polls URLconf in your project urls.py like this:path('', include('account.urls')),
] + static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)

if settings.DEBUG:
    urlpatterns += static(settings.STATIC_URL, document_root=settings.STATIC_ROOT)Add to end of settings.py for static media:#ADD TO BOTTOM OF SETTINGS FILE

# Static File Handling Settings
STATIC_URL = '/static/'
STATICFILES_DIRS = [
    os.path.join(BASE_DIR, "static")
]
STATIC_ROOT = os.path.join(BASE_DIR, "static_cdn")

# Media file handling Settings
MEDIA_URL = '/media/'
MEDIA_ROOT = os.path.join(BASE_DIR, 'media_cdn')


# Auth Redirects
LOGIN_REDIRECT_URL = '/YOUR-URL'
LOGOUT_REDIRECT_URL = '/YOUR-URL'Migrate to create the account models.:python manage.py migrateStart the development server and visithttp://127.0.0.1:8000/admin/to create a new user (you’ll need the Admin app enabled).Visithttp://127.0.0.1:8000/to begin using the authentication app.
Package: django-bab-cms
=====bab CMS=====Light CMS Django app.Quick start-----------1. Add "bab_cms" to your INSTALLED_APPS setting like this::INSTALLED_APPS = [...'bab_core',]2. Include the cms URLconf in your project urls.py like this::path('core/', include('bab_core.urls')),3. Run `python manage.py migrate` to create the cms models.
Package: django-bab-core
=====bab CMS=====Light CMS Django app.Quick start-----------1. Add "bab_cms" to your INSTALLED_APPS setting like this::INSTALLED_APPS = [...'bab_cms',]2. Include the cms URLconf in your project urls.py like this::path('cms/', include('bab_cms.urls')),3. Run `python manage.py migrate` to create the cms models.4. Start the development server and visit http://127.0.0.1:8000/admin/to create posts and articles (you'll need the Admin app enabled).5. Visit http://127.0.0.1:8000/cms/ to participate in the CMS.
Package: django-babel-boilerplate
Django Babel PackageThis is a package to create a boilerplate of django and babel with a efficient method of file structureGET STARTEDUSAGEMake sure, you have installed node js, before proceeding to the documentation.In your terminal run the command..$ pip install django-babel-boilerplateTo create a project,$ django-babel [project_name]The file structure would look like[root-folder]settingsbase.pylocal.pyproduction.pystaging.py__init__.pyurls.pyviews.pywsgi.pystaticcommonjsscssdistcssimagesjshomejsscsssvgtemplatesindex.html.babelrc.gitignoremanage.pypackage.jsonrequirements-server.txtrequirements.txtTo install all the dependencies.$ npm installTo run just the server$ python manage.py runserveror$ npm start serverTo run babel, use$ npm start babelTo run the sass, use$ npm start scssTo run the server, babel and the sass all together, use$ npm startYour good to go..Happy Coding :)
Package: django-babeljs
# django-babeljs #A simple interface to babel.js: transpile your javascript template into a javascript tag.## install ##Just include `babeljs` into your `INSTALLED_APPS````#!pythonINSTALLED_APPS += [ "babeljs" ]```## templatetag ##Load the templatetag```#!html{% load babeljs %}```### babeljs ###Include the babeljs file(s) as `<scrip...></script>` tag(s).It is useful only for in browser transpilation (ie: no nodejs is installed), otherwise can be omitted```#!html{% babeljs %}```### babel ###load file.js, try to transpile it with babeljs and copy the result into the template (acts the same as the `include` tag)```#!html{% babel "file.js" %}```transpile a react jsx file```#!html{% babel "file.jsx" %}```## settings ##### BABELJS_BABEL ###Provide a custom babeljs script.### BABELJS_ROOT ###Where to find the babeljs script.### BABELJS_MINIFIED ###If use or not the minified version [default=not DEBUG].Useful only for default babeljs script.### BABELJS_CACHE_BACKEND ###Use a specific cache backend for compiled js [default="default"].### BABELJS_CACHE_TIMEOUT ###The number of seconds the transpiled code should be stored in the cache, 0 for never cache it, None for cache it forever [default=300].
Package: django-babel-transpiling
django-babel-transpilingBring babel to your django project, transpiling static .jsx files on the fly, without NodeJS require!Installpip install django-babel-transpilingStatic files transpiling configAddbabel_transpilingto your djangoINSTALLED_APPSAddbabel_transpiling.middlewares.StaticFilesTranspilingMiddlewareto your djangoMIDDLEWAREnote the order[
...
'babel_transpiling.middlewares.StaticFilesTranspilingMiddleware',
'whitenoise.middleware.WhiteNoiseMiddleware',
... 
]Config djangoSTATICFILES_STORAGE = 'babel_transpiling.storage.StaticFilesTranspilingStorage'Global OptionsDefault options is:{
    'transpiler': 'npm/@babel/standalone@7.12.15/babel.min.js',
    'extensions': ['.jsx'],
    'options': {
        'plugins': ['transform-import-cssm'],
        "presets": ["react"],
        "generatorOpts": {
            "jsescOption": {
                "minimal": True
            }
        }
    },
    'mimetypes': {
        '.jsx': 'application/javascript'
    },
    'setup': ['npm/babel-plugin-transform-import-cssm@1.0.0/index.standalone.js']
}You can customize by provideBABEL_TRANSPILINGin your django settings, for example, custom babel preset:BABEL_TRANSPILING = {
    'options': {
        "filename": "index.ts",
        "presets": ["typescript"]
    }
}Babel APIYou can control more by setsetupoption, for example, write custom plugin and register:$ cat path/to/setup.js

// Simple plugin that converts every identifier to "LOL"
function lolizer() {
  return {
    visitor: {
      Identifier(path) {
        path.node.name = 'LOL';
      }
    }
  }
}
Babel.registerPlugin('lolizer', lolizer);Then config options:BABEL_TRANSPILING = {
    'options': {
        'plugins': ['lolizer']
    },
    'setup': ['path/to/setup.js']
}Template SupportSometimes transpiling in your template file is more make sense than static file,
you can usetranspilingtag to do that.{% load babel_transpiling %}
...
<script>
    {% transpiling %}
      ReactDOM.render(<App/>, document.querySelector('#root'))
    {% endtranspiling %}
</script> 
...Template tag also support use custom transpiling option, for example, in context there exists atsoption:{% transpiling options=ts %}
  const anExampleVariable: string = "Hello World"
  console.log(anExampleVariable)
{% endtranspiling %}FAQStatic file not get transpiledif you use djangorunservercommand to run server and the settingDEBUG=True, please add--nostaticoption to commandI want use other storageyou should write your own storage to inheritStaticFilesTranspilingStorage
Package: django-babel-underscore
Implements a underscore extractor for django-babel.Free software: BSD licenseDocumentation:http://django-babel-underscore.readthedocs.org.FeaturesTODOHistory0.5.2 (2018-08-18)Adds support for Django 1.10 and 1.11.0.5.1 (2016-07-15)Fix release0.5.0 (2016-07-15)Remove support for Python 2.6 and Python 3.3Remove support for Django < 1.8Add support for Python 3.5Add support for Django 1.9Now requires markey 0.80.4.2 (2015-08-28)Update to markey 0.70.4.1 (2015-08-28)Fix release0.4.0 (2015-08-28)Add support for Django 1.80.3.0 (2015-03-15)Addedunderscoreentry_point for babel.extractors (#1)0.2.0 (2014-12-24)Fix dependency names.0.1.0 (2014-05-25)First release on PyPI.
Package: django-bab-project
=====bab CMS=====Light CMS Django app.Quick start-----------1. Add "bab_cms" to your INSTALLED_APPS setting like this::INSTALLED_APPS = [...'bab_cms',]2. Include the cms URLconf in your project urls.py like this::path('cms/', include('bab_cms.urls')),3. Run `python manage.py migrate` to create the cms models.4. Start the development server and visit http://127.0.0.1:8000/admin/to create posts and articles (you'll need the Admin app enabled).5. Visit http://127.0.0.1:8000/cms/ to participate in the CMS.
Package: django-babylon
Ok so I figured cache invalidation was a royal pain in the arse, and that one
of the current best ways is to cache infinitely and only invalidate when the
associated data is stale. But! How do we know when it is stale?Effectively the point of this project is to give you a way to formally define
caches with meta information such as other caches they depend on (so you can
do the “Russian Doll” style caching that 37 Signals went on about), models that
caches directly depend upon, other models that might invalidate the cache, and
other useful stuff.There are several other concepts that I thought up too, such as “hooks”.Of course I will expand the documentation because this project is blatantly
really useful for defining a decent caching scheme instead of shitting out some
half baked attempt that confuses people and gives everyone stale data all the
time.To-DoTemplate tags to access HTML templates.DocumentationTestsSorting out how best to trick fucking python-memcached into doing infinite
caching.
Package: django-backend-auth-api
BACKEND-AUTH-API is a app to manage your authentication backend api with integrated doc.Detailed documentation is in the “docs” directory.Quick startAdd “authapi” to your INSTALLED_APPS setting like this:INSTALLED_APPS = [
    ...
    'authapi',
]Include the authapi URLconf in your project urls.py like this:path('authapi/', include('authapi.urls')),Runpython manage.py migrateto create the authapi models.Start the development server and visithttp://127.0.0.1:8000/admin/to see docs (you’ll need the Admin app enabled).Visithttp://127.0.0.1:8000/authapi/to see all urls related to  a backend authentication.
Package: django-background-tasks
Django Background Task is a database-backed work queue for Django, loosely based aroundRuby’s DelayedJoblibrary. This project was adopted and adapted fromlilspikeydjango-background-task.To avoid conflicts on PyPI we renamed it to django-background-tasks (plural). For an easy upgrade from django-background-task to django-background-tasks, the internal module structure were left untouched.In Django Background Task, all tasks are implemented as functions (or any other callable).There are two parts to using background tasks:creating the task functions and registering them with the schedulersetup a cron task (or long running process) to execute the tasksDocsSeeRead the docs.Donationsdjango-background-tasksis free software. If you find it useful and would like to give back, please consider to make a donation usingBitcoinorPaypal. Thank you!
Package: django-background-tasks4
Django Background Task is a database-backed work queue for Django, loosely based aroundRuby’s DelayedJoblibrary. This project was adopted and adapted fromlilspikeydjango-background-task.To avoid conflicts on PyPI we renamed it to django-background-tasks (plural). For an easy upgrade from django-background-task to django-background-tasks, the internal module structure were left untouched.In Django Background Task, all tasks are implemented as functions (or any other callable).There are two parts to using background tasks:creating the task functions and registering them with the schedulersetup a cron task (or long running process) to execute the tasksDocsSeeRead the docs.Donationsdjango-background-tasksis free software. If you find it useful and would like to give back, please consider to make a donation usingBitcoinorPaypal. Thank you!
Package: django-background-tasks-doctocliq
Django Background Task is a database-backed work queue for Django, loosely based aroundRuby’s DelayedJoblibrary. This project was adopted and adapted fromlilspikeydjango-background-task.To avoid conflicts on PyPI we renamed it to django-background-tasks (plural). For an easy upgrade from django-background-task to django-background-tasks, the internal module structure were left untouched.In Django Background Task, all tasks are implemented as functions (or any other callable).There are two parts to using background tasks:creating the task functions and registering them with the schedulersetup a cron task (or long running process) to execute the tasksDocsSeeRead the docs.Donationsdjango-background-tasksis free software. If you find it useful and would like to give back, please consider to make a donation usingBitcoinorPaypal. Thank you!
Package: django-background-tasks-updated
Django Background Tasks UpdatedDjango Background Task is a database-backed work queue for Django, loosely based
aroundRuby's DelayedJoblibrary. This project was
adopted and adapted fromlilspikey'sdjango-background-task. This fork includes minor fixes to support Django 4.To avoid conflicts on PyPI we renamed it to django-background-tasks-updated (plural).DocsSeeRead the docsDonationsdjango-background-tasksis free software. If you find it useful and would like to give back, please consider making
a donation to the original author usingBitcoinorPayPal. Thank you!
Package: django-backlinks
Django Backlinks is a framework for adding backlink, such as
TrackBack <http://www.sixapart.com/pronet/docs/trackback_spec> and
Pingback <http://hixie.ch/specs/pingback/pingback> capabilities to Django
applications and projects built on the Django web framework
<http://www.djangoproject.com/>.For installation instructions, please read theINSTALLfile located in
this directory.For instructions on the usage of this application, please readoverview.txtlocated in thedocs/directory.
Package: django-backoffice-dashboard-alpha
Django Backoffice DashboardDjango Backoffice is an application Django to easier create backoffice dashboard integrated for your project.InstallationInstall django-backoffice using:pipinstalldjango-backoffice-dashboard-alphaAdddjbackofficeto yourINSTALLED_APPSsetting like thisINSTALLED_APPS=[# ... other apps'djbackoffice','sweetify',# djbackoffice need it'django_tables2'# djbackoffice need it]Runpython manage.py collectstaticto collect file static djbackoffice into project.Include urldjbackofficein your root urlfromdjbackoffice.coreimportbackoffice# .... other importurlpatterns=[path('admin/',admin.site.urls),.....path('backoffice/',backoffice.urls),]Accesshttp://127.0.0.1:8000/backoffice/login/to enter backoffice page.How to Usecreate filebackoffice.pyon your appThen writeSimple registerfromdjbackoffice.coreimportbackofficefromauthor.modelsimportAuthorbackoffice.register(Author)Advanced registerfromdjbackoffice.coreimportbackoffice,BackofficeOptionsfromdjbackoffice.decoratorsimportregisterfromauthor.modelsimportAuthor@register(Author)classAuthorOption(BackofficeOptions):# To select the fields that will appear in the index viewlist_display=('name','email','address','phone_number')# To select the field to be the search keysearch_fields=('name','email')# To select a form layoutform_column_style=2# To select CRUD mode. The default Read mode cannot be disabledcrud_mode='cru'# To set how much data appears in the index viewlist_per_page=50# To set the icon that appears on the menu# icon using https://icons.getbootstrap.comicon_menu="bi-door-open-fill"Thanks!https://github.com/zuramai/mazer: Mazer Dashboard TemplateFor Contributorclone projectsymlink app todemoln-s[path_project_djbackoffice][path_demo_djbackoffice]createenvdevelopmentactiveenventer directorydemonow, you can access all commandmanage.pyTODOPermission AccessCustom DashboardOrganize Sidebar MenuAdvance Filter
Package: django-backup2csv
Backup2CSV is a simple Django app that allow you to download and
restore your models content in a csv file.Quick startAdd “backup2csv” to your INSTALLED_APPS setting like this:INSTALLED_APPS = [
        ...
        'backups',
]Include the backup2csv URLconf in your project urls.py like this::…
from django.urls import includeurlpatterns = […
path(‘backup/’, include(‘backups.urls’, namespace=’bkups’)),
…]Start the development server and visithttp://127.0.0.1:8000/backup/to see the list of all apps and models you have.