Saravanan666/pypi-org huggingface dataset:
Package: dj-cli
dj==**dj** is a command line tool that makes [Django][1] development *even* simpler. It provides shortcuts for most common [manage.py][2] commands.It uses [virtualenv][3] and [South][4] by default.Creating New Project--------------------$ dj new myproject/New python executable in myproject/bin/pythonInstalling Setuptools......$ cd myproject/$ ls -ltotal 0drwxr-xr-x  14 user  wheel  476 Nov 15 15:48 bindrwxr-xr-x   3 user  wheel  102 Nov 15 15:47 includedrwxr-xr-x   3 user  wheel  102 Nov 15 15:47 libdrwxr-xr-x   6 user  wheel  204 Nov 15 15:50 myprojectAdding New Applications-----------------------$ dj app exampleCreating migrations directory at '/../myproject/example/migrations'...Creating __init__.py in '/../myproject/example/migrations'...Created 0001_initial.py. You can now apply this migration with: ./manage.py migrate exampleRunning migrations for example:- Migrating forwards to 0001_initial.> example:0001_initial- Loading initial data for example.Installed 0 object(s) from 0 fixture(s)This will also update *settings.py* file.Schema Migration After Model Update-----------------------------------$ vim myproject/example/models.py$ dj sync example+ Added model example.PersonCreated 0002_auto__add_person.py. You can now apply this migration with: ./manage.py migrate exampleRunning migrations for example:- Migrating forwards to 0002_auto__add_person.> example:0002_auto__add_person- Loading initial data for example.Installed 0 object(s) from 0 fixture(s)Shell & Test Server-------------------$ dj shell$ dj runValidating models...0 errors foundNovember 15, 2013 - 14:10:00Django version 1.6, using settings 'myproject.settings'Starting development server at http://127.0.0.1:8000/Quit the server with CONTROL-C.Installing Packages Inside Virtual Environment----------------------------------------------$ dj install CeleryDownloading/unpacking Celery...Issues / To Do--------------* Using bash scripts inside Python, will fix that.* Argument parser needs to be replaced.* Deleting applications should be handled manually.Reporting Bugs, Submiting Pull/Feature Requests-----------------------------------------------Feel free to report any bugs, submit pull requests and ask for feature requests.[1]: https://www.djangoproject.com/[2]: https://docs.djangoproject.com/en/dev/ref/django-admin/[3]: http://virtualenv.org[4]: http://south.aeracode.org
Package: djcloudbridge
A reusable Django app that exposes a ReSTful Web API for interacting withCloudBridgeproviders. The structure of the API mirrors the organisation
of CloudBridge’s API and allows for creating, retrieving and updating
CloudBridge resources.DocumentationThe full documentation is athttps://djcloudbridge.readthedocs.io.QuickstartInstall djcloudbridge:pip install djcloudbridgeAdd it to yourINSTALLED_APPS:INSTALLED_APPS=(...'djcloudbridge.apps.DjangoCloudbridgeConfig',...)Add djcloudbridge’s URL patterns:fromdjcloudbridgeimporturlsasdjcloudbridge_urlsurlpatterns=[...url(r'^',include(djcloudbridge_urls)),...]And finally, the following settings are recommended in your settings.pyREST_FRAMEWORK={'PAGE_SIZE':50,'DEFAULT_PAGINATION_CLASS':'rest_framework.pagination.PageNumberPagination','DEFAULT_AUTHENTICATION_CLASSES':('rest_framework.authentication.SessionAuthentication','rest_framework.authentication.TokenAuthentication')}REST_AUTH_SERIALIZERS={'USER_DETAILS_SERIALIZER':'djcloudbridge.serializers.UserSerializer'}REST_SESSION_LOGIN=True# **Make sure to change** the value for ``FERNET_KEYS`` variable# because it is used to encrypt sensitive database fields.FERNET_KEYS=['new key for encrypting']Running the API LocallyYou can run a test server to browse the API endpoints locally. DJCloudBridge
is based on Python 3.6 and although it may work on older Python
versions, 3.6 is the only supported version. Use of virtualenv is also
highly advised.To get started, simply register the provider connection information under the
relevant cloud model (e.g. AWS, Azure, GCE, OpenStack) in Django Admin.
Then create a User Profile under the User Profile model. Finally, use the API
browser athttp://localhost:8000/cloudsto view the cloud you registered and
interact with cloud resources for that provider.Checkout djcloudbridge and create environment$mkdirdjcloudbridge&&cddjcloudbridge$virtualenv-ppython3.6venv--prompt"(djcloudbridge)"&&sourcevenv/bin/activate$gitclonehttps://github.com/cloudve/djcloudbridge.git$cddjcloudbridge$pipinstall-rrequirements.txt$pythonmanage.pymigrate$pythonmanage.pycreatesuperuser$pythonmanage.pyrunserverVisithttp://127.0.0.1:8000/admin/to define your cloud connection settings.Visithttp://127.0.0.1:8000/clouds/to explore the API.FeaturesTODORunning TestsDoes the code actually work?source <YOURVIRTUALENV>/bin/activate
(myenv) $ pip install tox
(myenv) $ toxCreditsTools used in rendering this package:Cookiecuttercookiecutter-djangopackageHistory0.1.0 (2017-10-04)First release on PyPI.0.2.0 (2017-11-15)Updated AWS cloud model to reflect cloudbridge changes.Minor bug fixes0.3.0 (2017-12-17)Moved azure resource group, storage account and vm_default_username to credentialsChanged status to beta
Package: dj-cloud-error
dj-cloud-error: Django Google Cloud Error ReportingReport exceptions from any Django site to Google Cloud Stackdriver Error ReportingFree software: MIT licenseFeaturesReport exceptions from any Django site to Google Cloud Stackdriver Error ReportingOptional dependency on django-ipware for logging of IP addressesQuickstartConfigure your app to user Google Cloud project:Enabled the Error Reporting api as perhttps://cloud.google.com/error-reporting/docs/setup/pythonSet up the required Google IAM credentials - eg set the environment variable GOOGLE_APPLICATION_CREDENTIALS
as the path to a service account JSON file, for an account that has the “Errors Writer” permission.Install the package:pip install dj_cloud_errorEnable the provided exception handler by settinghandler500in your Django project’s rooturls.py:# in myproject/urls.py
import dj_cloud_error

handler500 = dj_cloud_error.handler500Note:handler500is only used ifDEBUG = Falsein django settings.SettingsTo disable error reporting (eg in your CI/CD environment), add this to your django settings:# in myproject/settings/test.py
CLOUD_ERROR_REPORTING_DISABLED = TrueTo configure the name under which the errors appear in add this to your django settings:CLOUD_ERROR_REPORTING_SERVICE_NAME = "myservice"  # defaults to "python"Optional ExtrasIfdjango-ipwareis installed it’s used to log the client IP address, it can be installed as follows:pip install dj_cloud_error[ip]CreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2019-10-01)First release on PyPI.
Package: dj-cmd
Tired of typing long Django commands likepython manage.py runserver? Justpip install dj-cmdand thendj rfrom any project’s directory.Featuressaves typingautomatically locates Django’smanage.pyscript in the current or parent directoriesworks great with virtualenv, even on WindowsCommandsList of command aliases is a matter of personal taste, so go ahead and adjust
the config or fork the project and add yours to thealiases.pyfile.Predefined shortcuts include:rorrun- runserverany validmanage.pycommandConfig fileCommand aliases can be specified in a config file.If a.djcmdor.dj.iniconfig file is present in the user’s home directory
or in themanage.pybase directory, it is used to populate the list
of command aliases.Exampleof the.djcmdconfig file:[commands]
r=runserver
rp=runserver_plus

sh=shell
sp=shell_plus
dbs=dbshell

cs=collectstatic --noinput

m=migrate
mm=makemigrations
sm=showmigrations

cleanpyc=clean_pycPut it in your home or in themanage.pybase directory of your project.Licensedj-cmdis released under the BSD license.Other ResourcesGitHub repository -https://github.com/nigma/dj-cmdPyPi Package site -http://pypi.python.org/pypi/dj-cmdSample config file -https://github.com/nigma/dj-cmd/blob/master/.djcmdCommercial SupportThis app, and many others, have been created aten.ig.maweb & mobile development.Want to create a cutting edge web or mobile app or need help with setting up backend architecture?
Just drop us a note aten@ig.maand we will guide you from idea
to a final product.
Package: djcms-blog
# Simple Django BlogSimple Django Blog app using Markdown* Free software: MIT license* Documentation: https://djcms-blog.readthedocs.io.## Features* Works on pure Django* Markdown blog post format* Built-in template* Multiple languages support* SEO tags supported to customize## Usage### InstallAdd the following apps to your INSTALLED_APPS in `settings.py````INSTALLED_APPS += ['django.contrib.sitemaps','dj_markdown','simplemde','django.contrib.humanize','djcms_blog',]```Add `django.middleware.locale.LocaleMiddleware` to MIDDLEWARE```MIDDLEWARE += ['django.middleware.locale.LocaleMiddleware',]```Define default language and supported languages.```LANGUAGE_CODE = 'en'LANGUAGES = [('es', 'ES'),('en', 'EN'),]```Update your `urls.py` adding blog urls.```from django.conf.urls.i18n import i18n_patternsfrom django.contrib.sitemaps.views import sitemapfrom djcms_blog.sitemaps import PostsSitemapsitemaps = {'blog': PostsSitemap,}urlpatterns = [url(r'^admin/', admin.site.urls),url(r'^sitemap\.xml$', sitemap, {'sitemaps': sitemaps}, name='sitemap'),]urlpatterns += i18n_patterns(url(r'^', include('djcms_blog.urls')),)```## ConfigurationYou can define the following blog settings in your settings.**DEFAULT_BLOG_ID** Define the default blog id to be used in the urls and links.**DEFAULT_URL** URL to open the blog**BLOG_TITLE** HTML title**ROOT_TITLE** Title for links**DJCMS_BLOG_CACHE_TIME** Cache time used in public views.**MARKDOWN_CODE_CSS_THEME** Code theme for markdown code in the blog.**DEFAULT_COVER_IMAGE** Cover image used in blog**DEFAULT_NAVBAR_IMAGE** Image used as icon in navigation### ExampleIn `settings.py````# Blog configDJCMS_BLOG_CACHE_TIME = 0DEFAULT_BLOG_ID = 1```## ContributingInstall dev dependencies```pip install -r requirements_dev.txt```Run tests```pytest . --cov=. --cov-report=term-missing```Static Analysis```flake8 .```## CreditsThis package was created with **Cookiecutter** and the `audreyr/cookiecutter-pypackage` project template.# History0.1.0 (2018-06-05)------------------* First release on PyPI.0.2.4 (2019-03-03)------------------* Fix issue at blogs with slugs eg."test-blog".* Added support to custom nav image.
Package: djcms-blog-plugin
# DjangoCMS Blog plugin![image](https://img.shields.io/pypi/v/djangocms_blog_plugin.svg%0A%20%20%20%20%20:target:%20https://pypi.python.org/pypi/djangocms_blog_plugin)![image](https://img.shields.io/travis/carlosmart626/djangocms_blog_plugin.svg%0A%20%20%20%20%20:target:%20https://travis-ci.org/carlosmart626/djangocms_blog_plugin)![image](https://readthedocs.org/projects/djangocms-blog-plugin/badge/?version=latest%0A%20%20%20%20%20:target:%20https://djangocms-blog-plugin.readthedocs.io/en/latest/?badge=latest%0A%20%20%20%20%20:alt:%20Documentation%20Status)![image](https://pyup.io/repos/github/carlosmart626/djangocms_blog_plugin/shield.svg%0A%20%20:target:%20https://pyup.io/repos/github/carlosmart626/djangocms_blog_plugin/%0A%20%20:alt:%20Updates)DjangoCMS Blog plugin is a plugin enabled for DjangoCMS to add a feed of your posts created in [djcms_blog](https://github.com/CarlosMart626/djcms_blog) in any page.-   Free software: MIT license-   Documentation: <https://djangocms-blog-plugin.readthedocs.io>.## Features* Support DjangoCMS* Can define a Blog to display* Can define how many entries to display## InstallationInstall using pip```pip install djcms_blog_plugin```Add to installed apps:```INSTALLED_APPS = (`# Your django apps'cms', # required django cms'djcms_blog', # required djcms_blog'djcms_blog_plugin',```## Settings```DJCMS_BLOG_ID = 1 # Defines the Main blog idDJCMS_BLOG_ENTRIES_NUMBER # Define the number of entries to display in the widget```## ContributingInstall dev dependencies```pip install -r requirements_dev.txt```Run tests```pytest . --cov=. --cov-report=term-missing# virtualenvpython -m pytest . --cov=. --cov-report=term-missing```=======History=======0.1.0 (2018-09-08)------------------* First release on PyPI.0.1.3 (2019-03-03)------------------* Update author image updated in djcms_blog.
Package: djcms-custom-menu
Django CMS Custom MenuAn extension for Django CMS that allows you to create multiple menus like Wordpress. This is compatible for Python 3.6, Django 2.1.9, django-cms 3.6.0Replaces Previous VersionsThis replaces the previous versions by Ryan Bagwell and Rogerio Carrasqueira which are no longer actively updatedOriginally forked from:https://github.com/rgcarrasqueira/django-cms-named-menushttps://github.com/ryanbagwell/django-cms-named-menushttps://github.com/mcldev/djangocms-named-menusInstallationInstall with pippip install djcms-custom-menuAdddjcms_custom_menuto INSTALLED_APPSRun migrationspython manage.py migrateUsageAfter installation, place the{% show_djcms_custom_menu 'YourMenuName' 0 100 100 100 "snippets/cms_named_menu.html" %}template tag where you want your menu to appear... code::{% load djcms_custom_menu_tags %}{% show_djcms_custom_menu 'Header Menu' 0 100 100 100 "snippets/cms_named_menu.html" %}Next, create your menu in the admin area using the drag and drop interface.Drag or add button click to add items as menu items:.. image:: ui1.pngYou can also add external website links as menu item.Add button click to add external website link as menu items:.. image:: ui2.pngSettingsThe following settings can be changed by adding to your project's settings.py file:Override the default cache duration for DJCMS Custom Menu, default = 0 seconds.. code::DJCMS_CUSTOM_MENU_CACHE_DURATION = 3600Set the application namespaces that can be used with DJCMS Custom Menus as a list, default is CMS pages only - as the page id will not be unique for other applications e.g. Aldryn NewsBlog etc. default = ['CMSMenu',].. code::DJCMS_CUSTOM_MENU_NAMESPACES = ['CMSMenu',]or to allow all namespaces:.. code::DJCMS_CUSTOM_MENU_NAMESPACES = NoneN.B.: Just feel free to contact for any query and helpAbdullah Al Arafat |imbipul9@gmail.com| +8801712192445
Package: djcommon
The Django Common (djcommon) project is a set of project independent reusable features easy to use while
developing with the Django Framework -https://www.djangoproject.com/.FeaturesCurrently, the following features have been gathered and are working in Django 1.3+modelsTimeStampedModel (adds date_created and date_modified)fieldsMultiSelectField (for selecting multiple choices=)viewsserver_error (500 error handler with RequestContext)adminEnhancedModelAdmin (keeping filter states after edits)EnhancedInline (implements VerboseManyToManyRawIdWidget on m2m fields when name in raw_id_fields)middlewareSSLMiddlewareRestrictedAccessMiddlewareStripWhitespaceMiddlewarehelpersget_setting (shortcut for getattr(settings, ‘SITE_ID’))uniqify_listcontainsauthEmailBackend (authenticate user by email address or username)formsEnhancedFormEnhancedModelForm (combined_fields)widgetsDiggPaginatorWidgetadmin.VerboseManyToManyRawIdWidgettemplateget_available_templatesget_template_choicesCachedNodeContextUpdatingNodeCachedContextUpdatingNodetemplatetagscommonfilters: cleartags, cut, replace, nowhitespace, cleanwhitespace, startswith, endswithdevelopmentfilters: attributes, attributes_formatted, getattributetemplatesforms/as_div.htmlemailsend_email_with_template (including an handy directory structure for templates)pdfcontent_to_pdfcontent_to_responserender_to_pdfxmlfast_iterTODOadminEnhancedInline with Nested inline functionIf you have ideas for other features please let me know.Installationpip install djcommonAdddjcommonto your INSTALLED_APPS if you want to use templates and templatetagsTODOs and BUGSSee:http://github.com/baskoopmans/djcommon/issues
Package: djcompiler
DjCompilerDjCompiler is a python package that compiles the django project to a C language project which gives more performance and more security since the original code is hidden.CompatibilityPython:3.83.93.103.11Installationpip install djcompilerUsagerundjcompiler helpto see available commands.rundjcompiler compileto compile the django project.rundjcompiler buildfileto generate a config file.rundjcompiler buildpyto generate a python script that compiles the project when run.Future Features
Package: dj-config-url
This simple Django utility allows you to utilize12factorinspired
environment variables to configure your Django application.This project has been forked from kennethreitz’dj-database-urland is fully
compatible with it, so you can use this utility as a drop-in replacement.Supported configurationSupport currently exists for the following database engines: PostgreSQL,
PostGIS, MySQL, MySQL (GIS) and SQLite.You can also configure yourCACHESconfiguration for the backends supported
by the Django core: Database, dummy, file based, local memory as well as both
Memcached backends.InstallationInstallation is simple:$ pip install dj-config-urlUsageConfigure your database insettings.pyfromDATABASE_URL:DATABASES = {'default': dj_config_url.config()}Parse an arbitrary Database URL:DATABASES = {'default': dj_config_url.parse('postgres://...')}Configure your cache backend:CACHES = {'default': dj_config_url.parse('memcache://...')}Use a custom cache backend class:CACHES = {'default': dj_config_url.parse('memcache://127.0.0.1:123?password=s3cr3t', 'redis_cache.cache.RedisCache')}Database examplesEngineDjango BackendURLPostgreSQLdjango.db.backends.postgresql_psycopg2postgres://USER:PASSWORD@HOST:PORT/NAMEPostGISdjango.contrib.gis.db.backends.postgispostgis://USER:PASSWORD@HOST:PORT/NAMEMySQLdjango.db.backends.mysqlmysql://USER:PASSWORD@HOST:PORT/NAMEMySQL (GIS)django.contrib.gis.db.backends.mysqlmysqlgis://USER:PASSWORD@HOST:PORT/NAMESQLitedjango.db.backends.sqlite3sqlite:///PATH[1][1]SQLite connects to file based databases. The same URL format is used, omitting
the hostname, and using the “file” portion as the filename of the database.
This has the effect of four slashes being present for an absolute file path:sqlite:////full/path/to/your/database/file.sqlite.Cache examplesBackendDjango BackendURLDatabasedjango.core.cache.backends.db.DatabaseCachedbcache://table_nameDummydjango.core.cache.backends.dummy.DummyCachedummycache://File baseddjango.core.cache.backends.filebased.FileBasedCachefilecache:///path/to/cacheLocal Memorydjango.core.cache.backends.locmem.LocMemCachelocmemcache://[optionalname]Memcacheddjango.core.cache.backends.memcached.MemcachedCachememcache://IP:PORT[,IP:PORT,...]PyLibMCdjango.core.cache.backends.memcached.PyLibMCCachepymemcache://IP:PORT[,IP:PORT,...]You may specify options for the cache backends as query parameters in the url, e.g.:CACHES = {
    'default': dj_config_url.parse('filecache:///var/tmp/django_cache?timeout=60&max_entries=1000&cull_frequency=2'),
}This will be equivalent of writing this in yoursettings.py:CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache',
        'LOCATION': '/var/tmp/django_cache',
        'TIMEOUT': 60,
        'OPTIONS': {
            'MAX_ENTRIES': 1000,
            'CULL_FREQUENCY': 2,
        }
    }
}
Package: dj-contentmodel
Boilerplate for taxonomies, content collections, and content models using django-mptt and django-taggit.FeaturesDrag and drop construction of taxonomies.Arbitrary relationships among groups, taxonomies, collections, content, and attachments.Templates for displaying taxonomies with and without collections’ contents.Documentationdj-content model is just boilerplate for django-mptt and django-taggit.
It defines a hierarchical structure with arbitrary relationships via collections.
The Quickstart example is a sufficient starting point for many projects.
Each abstract class provided by dj-contentmodel is a descendant of django.db.models, so
extend them as you would a Django model. The Group and Taxonomy classes are also
descendants of django-mptt’s MPTTModel class and can be extended accordingly.
Additional examples dj-contentmodel’s abstract classes are available athttps://dj-contentmodel.readthedocs.org.QuickstartFirst, install dj-contentmodel:pip install dj-contentmodelThen, import the abstract base classes.:from dj_contentmodel.models import Taxonomy, Collection, Content, AttachmentNext, subclass the imported classes to create taxonomies and content models as needed.
The following example is of a minimum configuration.
The names of defined classes are arbitrary, but the relationships among classes are not.class Sitemap(Taxonomy):
    """Main navigation"""
    collections = models.ManyToManyField('Bucket', blank=True)
    class Meta:
        verbose_name = "Category"
        verbose_name_plural = "Categories"
    ...

class Bucket(Collection):
    """Arbitrary collections to group content."""
    contents = models.ManyToManyField('Page', blank=True)
    ...

class Page(Content):
    ...

class Report(Attachment):
    parents = models.ManyToManyField('Page', blank=True)
    ...Finally, register your models with the admin.from django.contrib import admin
from mptt.admin import DraggableMPTTAdmin

admin.site.register(
    Sitemap,
    DraggableMPTTAdmin,
    list_display=(
        'tree_actions',
        'indented_title',),
    list_display_links=(
        'indented_title',),)
admin.site.register(Bucket)
admin.site.register(Page)
admin.site.register(Report)Without a migration, it may be necessary to create the tables.:python manage.py migrate --run-syncdbRunning TestsDoes the code actually work? For now I have my fingers crossed.
Later iterations will be test driven and include integration and performance testing.source <YOURVIRTUALENV>/bin/activate
(myenv) $ pip install -r requirements_test.txt
(myenv) $ python runtests.pyCreditsTools used in rendering this package:Cookiecuttercookiecutter-djangopackagedjango-mpttdjango-taggitpip-toolsHistory0.1.0 (2016-06-07)First release on PyPI.
Package: dj-core
dj-coreA self-contained and extensible django environment.The default configuration makes use of the following optional packages:django-anymail[mailgun]django-debug-toolbardjango-debug-toolbar-line-profilerdjango-minimal-userdjango-storagesThe default configuration also configures the following, but does not require them:django-extensionsdjango-cors-headerscelery[redis]Disabling optional packages:Override the following environment variables:django-anymail:DJCORE_EMAIL_BACKENDdjango-debug-toolbar[-line-profiler]:DJCORE_USE_DJDTdjango-minimal-user:DJCORE_AUTH_USER_MODELdjango-storages:DJCORE_DEFAULT_FILE_STORAGE,DJCORE_STATICFILES_STORAGE
Package: djcorecap
djcorecapCore app for Django projects that provides essential functions, tags, and
enhanced Bootstrap-friendly templates.Free software: MIT licenseFeaturesCustom base template that plays nicely with Bootstrap (and themes)Custom allauth templates that play nicely with Bootstrap (and themes)Paginator template snippet ready for inclusion in other templatesConvenience functions to support Bokeh plotsTemplate tags for auto-setting links to active and formatting percentagesBootstrap test pageInstallationAdd djcorecap to your INSTALLED_APPS in settings.
Ensure that it comes before all other third party apps to enable
template overrides, etc.If you plan to use the app’s base template
as your project’s base template, replace base.html in
project/templates/ with a file containing the following:{%extends'djcorecap/base.html'%}If you plan to use djcorecap’s version of the allauth templates, delete
the account/ folder (if exists) from project/templates/.History0.1.0 (2018-03-24)First release1.0.0 (2020-04-10)First PyPI production release