Saravanan666/pypi-org huggingface dataset:
Package: django-start-automate
Django-StartPrepare a new Django project quickly and automatically and more wonderful things that save you time By django startInstallationpipinstalldjango-start-automateUsage:main.py[OPTIONS]PROJECT_NAMEAPP_NAMEPrepareanewDjangoprojectquicklyandautomaticallyand,morewonderfulthingsthatsaveyoutimeBydjangostart

Options:-n,--name<LAMBDA>CustomEnvironmentName-v,--virtualenvInstallEnvironmentIsDeprecated-u,--url-pathTEXTSetCustomURLPathforyourApp--helpShowthismessageandexit.Success Install 🎊Deprecated Options-v, --virtualenvOption is deprecatedBuild First Django Projectdjango-startproject_nameapp_nameOptions-n or -nameto set custom environment name-u or --url-pathto set custom view url for your appdjango-version CommandUsage:django-version[OPTIONS]Displaycurrentversio,
checknewupdateandupdatedjango-start

Options:--update/--check-updateTEXT--helpShowthismessageandexit.New-u or --url-pathset custom view url for your appdjango-versionDisplay django-start versiondjango-version --check-updateCheck New Update Availabledjango-version --updateupdate django-startWelcome to contribute ❤PyPi🧑‍💻
Package: django-startcbv
InstallationAdd django-startcbv==0.1 to requirements.txt, then just:pip install -r requirements.txtUsageCreate a base.html template in templates/base.html.  It should contain a title and a content block, like this:<html>
<head>
<title>
{% block title %}{% endblock %}
</title>

<body>
{% block content %}{% endblock %}
</body>
</html>Add the “startcbv” app to INSTALLED_APPS in settings.py:INSTALLED_APPS = (
    ...
    'startcbv',
)For all of the following steps, replace “things” with the name of the app that you wish to create:python manage.py startcbv thingsIf you’re done using startcbv, you can remove it from INSTALLED_APPS now; otherwise, leave it in to create more class-based view apps.  Add your “things” app to INSTALLED_APPS in settings.py.:INSTALLED_APPS = (
    ...
    'things',
)Add your “things” app URL pattern to urls.py:url(r'^things/', include('things.urls')),Then:python manage.py syncdb
python manage.py runserverLicenseThis code is licensed under the MIT License.
Package: django-starterkit
# django-starterkit
## Build Status
[![Build Status](https://travis-ci.org/MikaSoftware/django-starterkit.svg?branch=master)](https://travis-ci.org/MikaSoftware/django-starterkit)
[![PyPI version fury.io](https://badge.fury.io/py/django-starterkit.svg)](https://pypi.python.org/pypi/django-starterkit)
[![Coverage Status](https://coveralls.io/repos/github/MikaSoftware/django-starterkit/badge.svg?branch=master)](https://coveralls.io/github/MikaSoftware/django-starterkit?branch=master)## About
Library with reusable code for every django project you work with, includes django rest framework.
Package: django-startproject
StartProject installs a script which allows the easy creation of a standard
Django project layout based on Lincoln Loop standards.Script usageAfter installing StartProject, simply run the following command (from within
the directory in where the new project directory should be created):django-startproject.py project_nameThe script will prompt for values to replace boilerplate variables with. These
variables allow for both the file contents and path names to be customized to
this specific project.Using a custom project templateIf you would prefer to use a custom project template than the one included in
this application, create your custom project template directory and call the
command script like this:django-startproject.py --template-dir=/your/custom/template project_nameSpecifying boilerplate variablesTwo optional files in the root of the project template directory are used to
determine the boilerplate variables:.startproject_boilerplateEach line should contain the boilerplate variable (and optionally, a
description of the variable, separated from the variable by white space)..startproject_defaultsEach line should contain a variable and the default value, separated by
whitespace. If the default value containsPROJECT, it is replaced with
the project name.See the files included in the project_template directory of StartProject for
an example.
Package: django-startproject-plus
Wrapper around Django’sstartprojectcommand. Supersets the command by adding an support for passing extra context when using thetemplatefunctionality.This command can be invoked with the same flags thatstartprojectsupports.Why?The template functionality on Django’sstartprojectcommand is great, but a template system without support for more context variables is not very helpful with more complex setups.This issue has been brought up to the django-devs mailing listhttps://code.djangoproject.com/ticket/18277InstallationThis package requires at least Django 1.5.x installed. Latest Django 1.8.x is supported.The package is available in pypi:pip install django-startproject-plusUsageThis is a drop in replacement for the django-admin.py startup, with anextra_contextflag:django-startproject.py myproject --extra_context='{"some": "json"}'TODOSupportdjango-admin.pystartapp.
Package: django-start-tool
UsageDetailed usage information can be found by typingdjango-start--helpExamplesCreate default project:$django-start# Is equivalent to$django-adminstartprojectconfig.Create project from template:$django-start\>-t/path/to/template# Is equivalent to$django-adminstartproject\>--template/path/to/template$django-start\>-thttps://github.com/<user>/<repository>/archive/main.zip# Is equivalent to$django-adminstartproject\>--templatehttps://github.com/<user>/<repository>/archive/main.zipAdd files to rendering (in addition to*-tpl):$django-start\>-t/path/to/template\>-r'*.env Procfile'# Is equivalent to$django-adminstartproject\>--template/path/to/template\>--extensionenv\>--nameProcfileExclude directories from rendering (in addition to.gitand__pycache__):$django-start\>-t/path/to/template\>-x'data logs'# Is equivalent to$django-adminstartproject\>--template/path/to/template\>--excludedata,logs
Package: django-stash-tag
Django Stash TagA Django template tag that allows for markup to be stashed and
dynamically appliedwithoutneeding to create a separate partial or
template tag file.InstallationInstall Django Stash Tag:pip install django-stash-tagAfter you've installed the tag, adddjango_stash_tagtoINSTALLED_APPSin yoursettings.pyfile:# settings.py

INSTALLED_APPS = (
    # …
    'django_stash_tag',
)Static UsageThestashtag can be used to store static markup for reuse further
down the template. Usingstash_applyyou can render the stashed
markup.First we load the tag and stash the markup with a name to stash it
under:{% load stash %}

{% stash 'static_heading' %}
  <h1>User: {{user.name}}</h1>
{% endstash %}We then apply the stash withstash_applyand provide the stash namestatic_headingas a tag argument:{% stash_apply 'static_heading' %}This would result in rendering (context.useris{'name': 'Ivan'}):<h1>User: Ivan</h1>Dynamic UsageIn most cases you probably need more dynamic control over the
paramaterization of the stashed markup. You can accomplish such
behavior through the use of template tag kwargs.Again we load the tag and stash the markup. This time the context
variables that are referenced within the stashed content are not
defined in the template's context:{% load stash %}

{% stash 'section_header' %}
  <header>
    <h3>{{title}} {{company}}</h2>
    <small>{{subtext}} {{company}}.</small>
  </header>
{% endstash %}We then apply the stash with additional template kwargs pertaining to
the context variables referenced in the stashed content
(context.companyset to{'name': 'GitHub'}):{% stash_apply 'section_header'
    title='About'
    subtext='We will take you back to when it all began at'
%}

{# further down in the template #}

{% stash_apply 'section_header'
    title='Apply for a Position at'
    subtext='Make software development a better experience at'
%}Which would then output:<header>
  <h3>About GitHub</h2>
  <small>We will take you back to when it all began at GitHub.</small>
</header>

<!-- further down in template --> 

<header>
  <h3>Apply for a Position at GitHub</h2>
  <small>Make software development a better experience at GitHub.</small>
</header>As demonstrted above you can usestash_applyas much as you
want once you've stashed the content in your template. You can use both
context variables already set on the template or dynamic variables set
though kwargs.
Package: django-state-choice-field
django_state_choice_fieldIt includes aStateChoiceFieldthat comes with reusableTextChoicesand validation for state changes. This feature enhances flexibility and data integrity.RequirementsPython 3.6+Django 2.2+InstallationTo set updjango_state_choice_field, you can easily install it with pip.$pipinstalldjango_state_choice_fieldExampleConsider a scenario where we have a model calledOrderthat includes the storage of the order's payment status. This payment status can fall into one of the following inPaymentStatus.It also defines the state transitions that are allowed for each state. For example, a payment status ofIN_PROGRESScan only be changed toFAILEDorCOMPLETED. This is done by defining the__states__attribute in thePaymentStatusclass which extendsStateEnum.fromdjango_state_choice_fieldimportStateChoiceField,StateEnumclassPaymentStatus(StateEnum):NOT_STARTED="not_started","Not Started"IN_PROGRESS="in_progress","In Progress"COMPLETED="completed","Completed"FAILED="failed","Failed"CANCELLED="cancelled","Cancelled"NOT_REQUIRED="not_required","Not Required"__states__={NOT_STARTED:(),IN_PROGRESS:(NOT_STARTED,FAILED),FAILED:(IN_PROGRESS,),COMPLETED:(IN_PROGRESS,NOT_REQUIRED),NOT_REQUIRED:(IN_PROGRESS,),CANCELLED:(NOT_STARTED,NOT_REQUIRED,FAILED,COMPLETED),}ModelOrdercan be defined as follows. Thepayment_statusfield is defined as aStateChoiceFieldwith thePaymentStatusenum class.fromdjango.dbimportmodelsclassOrders(models.Model):product_name=models.CharField(max_length=100)payment_status=StateChoiceField(PaymentStatus,default=PaymentStatus.NOT_STARTED,max_length=20)created_at=models.DateTimeField(auto_now_add=True)updated_at=models.DateTimeField(auto_now=True)Usage>>>order=Order.objects.create(product_name="Product 1")>>>order.payment_status
<PaymentStatus.NOT_STARTED:'not_started'>

>>>order.payment_status=PaymentStatus.IN_PROGRESS
>>>order.save()>>>order.payment_status
<PaymentStatus.IN_PROGRESS:'in_progress'># Now, if we try to change the payment status to CANCELLED, it will raise a InvalidTransitionError error.>>>order.payment_status=PaymentStatus.CANCELLED

django_state_choice_field.exceptions.InvalidTransitionError:[in_progress->cancelledisnotavalidtransitionforPaymentStatus']
Package: django-state-keeper
Django State KeeperDjango State Keeper is a Django app that allows you to create backups of your project's database, media files, and
selected directories. It provides the ability to restore your project's state from a backup and offers automatic backups
sent to a Telegram chat.FeaturesCreate backups as ZIP files containing selected project files and directories.Restore project state by uploading a backup ZIP file.Configure automatic backups sent to a Telegram chat.InstallationInstall the Django State Keeper library using pip:pipinstalldjango-state-keeperAdddjango_state_keeperto the INSTALLED_APPS list in your Django project's settings:INSTALLED_APPS=['django.contrib.admin','django.contrib.auth','django.contrib.contenttypes','django.contrib.sessions','django.contrib.messages','django.contrib.staticfiles','django_state_keeper']Include the Django State Keeper URL path in your project's urls.py file. Add the following line at the end of the
urls.py:urlpatterns+=[path('your-customized-path/',include('django_state_keeper.urls'))]Replace'your-customized-path/'with the desired URL path where you want to access the Django State Keeper app.Run migrations to create the necessary database tables:pythonmanage.pymigrateStart the Django development server:pythonmanage.pyrunserverAccess the Django State Keeper panel from Django admin site.How To UseYou can create a "Backup Packaging" instance to customize your packaging method, and then you can create and download
a backup by clicking on "Download" button.You can open the "Upload Backup" panel and upload a backup file to be injected immediately.You can create a "Auto Backup Sender Service" instance to receive backup files in telegram chat periodically.LicenseThis project is licensed under the MIT License. See the LICENSE file for details.
Package: django-static-ace-builds
django-static-ace-buildsDjango application contain ace-builds(Ajax.org Cloud9 Editor) static files. See details about the static resources athttps://ace.c9.io/.Installpip install django-static-ace-buildsUsagepro/settings.pyINSTALLED_APPS=[..."django_static_ace_builds",...]app/template/app/index.html{% load static %}<scriptsrc="{% static "ace-builds/ace.js"%}"></script>About releasesThe first three number is the same with ace-builds project's version.The fourth number is our release number, it's optional.Releasesv1.4.12.0 2020/08/31First release.v1.5.0.0 2023/09/12Upgrade to ace-build v1.5.0.
Package: django-static-adminlte
django-static-adminlteDjango application contain adminlte static files.Installpip install django-static-adminlteLicensesAll resource files of ADMINLTE are unzip from AdminLTE-x.x.x.tar.gz which download fromhttps://adminlte.io/without any changes.All resource files of ADMINLTE obey ADMINLTE License, see details athttps://github.com/ColorlibHQ/AdminLTE/blob/master/LICENSE.We don't guarantee the latest jQuery version.Usagepro/settings.pyINSTALLED_APPS=[..."django_static_fontawesome","django_static_ionicons","django_static_jquery3","django_static_bootstrap","django_static_adminlte",...]app/template/app/index.html{% load staticfiles %}

{% block style %}<linkrel="stylesheet"href="{% static "bootstrap/css/bootstrap.min.css"%}"><linkrel="stylesheet"href="{% static "fontawesome/css/all.min.css"%}"><linkrel="stylesheet"href="{% static "ionicons/css/ionicons.css"%}"><linkrel="stylesheet"href="{% static "adminlte/css/AdminLTE.min.css"%}"><linkrel="stylesheet"href="{% static "adminlte/css/skins/_all-skins.min.css"%}"><!--[if lt IE 9]><script src="{% static "html5shiv/html5shiv.min.js" %}"></script><script src="{% static "respond/respond.min.js" %}"></script><![endif]-->{% endblock %}

{% block script %}<scriptsrc="{% static "jquery/jquery.js"%}"></script><scriptsrc="{% static "bootstrap/js/bootstrap.min.js"%}"></script><scriptsrc="{% static "jquery-slimscroll/jquery.slimscroll.min.js"%}"></script><scriptsrc="{% static "fastclick/fastclick.js"%}"></script><scriptsrc="{% static "adminlte/js/adminlte.min.js"%}"></script><script>$(document).ready(function(){$('.sidebar-menu').tree()});</script>{% endblock %}About releasesThe first number is our release number.The other three numbers are the same with ADMINLTE's release version.Releases2.4.3First release.2.4.3.2Update.2.4.3.3Doc update.3.2.0.1Upgrade adminlte to 3.2.0.
Package: django-static-arrive
django-static-arriveDjango application contain arrive js files. And arrive js is absorbed in watching for DOM elements creation and removal.Installpipinstalldjango-static-arriveUsagepro/settings.pyINSTALLED_APPS = [
    ...
    "django_static_jquery3",
    "django_static_arrive",
    ...
]app/templates/demo.html{% load static %}

<script src="{% static "jquery3/jquery.js" %}"></script>
<script src="{% static "arrive/arrive.min.js" %}"></script>NoteDepends on jquery3.All js files are fromhttps://github.com/uzairfarooq/arrive.The first third release numbers are js's release version numbers.The fourth release number is our release number.Releasesv2.4.1.0First release.
Package: django-staticassets
Django Static AssetsAuthors:David Elias <stout.elias@gmail.com> and Joao Oliveira <joaoxsouls@gmail.com>Version:0.2.0django-staticassets is a django app to compile and bundle static assets.
It works together with django’s contrib staticfiles app. Heavly inspired by ruby’sSprockets.
It has the same directive processor to declare dependencies directly in asset source files.DocumentationDocumentation is on the excellentreadthedocs.org
Package: django-static-base
django-static-baseGitHubTestCheck Demo ProjectCheck the demo repo onGitHubRequirementsPython 3.8+ supported.Django 3.2+ supported.SetupInstall frompip:pipinstalldjango-static-baseAdd'static_base'to yourINSTALLED_APPSsetting.INSTALLED_APPS=[# ...other apps"static_base"]Add the following pre-requisites to yourbase.htmltemplate<html><head>...<linkrel="stylesheet"type="text/css"href="{% static 'base/css/bootstrap.css' %}">...</head><body>...<scripttype="text/javascript"src="{% static 'base/js/jquery.min.js' %}"></script><scripttype="text/javascript"src="{% static 'base/js/bootstrap.min.js' %}"></script><scripttype="text/javascript"src="{% static 'base/js/plugins/lazysizes.min.js' %}"async></script>...<scripttype="module"src="{% static 'base/js/plugins/instantpage.min.js' %}"defer></script></body></html>Add all your needed plugins or customization to yourbase.htmltemplate or sub-templates used by your project<html><head>...<linkrel="stylesheet"type="text/css"href="{% static 'base/css/plugins/jquery.smartmenus.bootstrap-4.css' %}">...<linkrel="stylesheet"type="text/css"href="{% static 'base/css/style-btn.css' %}"><linkrel="stylesheet"type="text/css"href="{% static 'base/css/color/blue.css' %}">...<linkrel="stylesheet"type="text/css"href="{% static 'base/css/custom.css' %}">...</head><body>...<scripttype="text/javascript"src="{% static 'base/js/jquery.min.js' %}"></script><scripttype="text/javascript"src="{% static 'base/js/bootstrap.min.js' %}"></script>...<scripttype="module"src="{% static 'base/js/plugins/instantpage.min.js' %}"defer></script></body></html>Run Example Projectgitclone--depth=50--branch=django-static-basehttps://github.com/DLRSP/example.gitDLRSP/examplecdDLRSP/example
pythonmanage.pyrunserverNow browser the app @http://127.0.0.1:8000
Package: django-staticblocks
staticblocks provides you with tools for content managers to easily
include flatpage content as a snippet in your templates while
retaining structured control over the templates themselves.The template designers will define page blocks in the templates.The content managers will choose which flatpage to use as the snippet
embedded in each page block.You must have ‘django.contrib.flatpages’ in your INSTALLED_APPS.To install, add ‘staticblocks’ to your INSTALLED_APPS and re-run syncdb.Using itCode to writeOn the template level, define your static blocks with arbitrary string labels
by passing the label into the scope of the included template snippet:{% with "index.html/firstpageblock" as blockname %}
  {% include 'staticblock/widgets/block.html' %}
{% endwith %}

{% with "index.html/secondpageblock" as blockname %}
  {% include 'staticblock/widgets/block.html' %}
{% endwith %}On the site, allowed users will now be able to associate that page block
with a flatpage, which will be pulled in as page content into that block.Permissions to assignAssign the following permisssions to your users and groups as desired:flatpages.add_flatpage
flatpages.change_flatpage
staticblocks.add_staticblock
staticblocks.change_staticblockTemplates to useYou can customize the layout of the pulled-in block by editing or forking
these templates:staticblock/templates/staticblock/widgets/block.html
staticblock/templates/staticblock/widgets/title.html
Package: django-staticblog
django-staticblog is amarkdown-based blog
system forDjangothat compiles to
static html.Requirementsdjango-staticblog requires:Python 2.6+Django 1.4+markdownhtml2textInstallationpip installdjango-staticblogorpython setup.py installafter checking out the code fromhttp://github.com/cgrice/django-staticblogAddstaticblogto yourINSTALLED_APPSsetting, and addurl(r'^preview/', include('staticblog.urls'))to yoururls.pyConfiguration OptionsSTATICBLOG_ROOT- root directory of your django projectSTATICBLOG_POST_DIRECTORY- full path to the directory which holds
your blog posts in markdown format. Defaults to yourSTATICBLOG_ROOT + '/posts'STATICBLOG_COMPILE_DIRECTORY- full path to the directory which will
hold compiled post and archive html pages. Defaults toMEDIA_ROOT + '/posts'STATICBLOG_STORAGE- Defines howstaticblogstores images
defined in blog posts. Defaults toDEFAULT_FILE_STORAGE.UsageTo start usingstaticblog, write some posts in yourSTATICBLOG_POST_DIRECTORY. These posts should be formatted inmarkdown. Post
filenames should contain alphanumeric characters and dashes only, and
end with.post. For examples, please see theexamplesfolder in
this repository.Each post can also contain metadata used for title tags and post
information. For example:Title: Look, I'm blogging!
Summary: A concise summary of a post
Author: John Doe
Date: 2009-08-05 11:25:53 GMTYou can include remotely hosted images in your posts - these will
automatically be downloaded and stored in the location defined bySTATICBLOG_STORAGE.To include local files, create a folder with the same name as your post
file, minus the.postextension. You can then add image files to
this folder, and reference them in your markdown like so:![Alt Text](post-name/image.jpg)Compiling PostsTo display your posts, you need to compile them. To do this,staticblogprovides a management command namedupdate_blog. By
defult, this command will process all new blog posts, handle their
images, and create a folder in yourSTATICBLOG_COMPILE_DIRECTORYwith the post name, with anindex.htmlfile containing the blog
post.update_blogalso creates a post listing, which it stores in anindex.htmlfile in yourSTATICBLOG_COMPILE_DIRECTORY.update_blogtakes two optional arguments:--all- process all blog posts regardless of whether they already
exist--name=POST,POST2- process a list of blog posts by post nameTemplatesstaticblogprovides two default templates -staticblog/post.htmlandstaticblog/archive.html. You can overwrite these in your own
template directory to integrate the posts with your site.Template Variablesstaticblog/post.htmlpost: a dict containing:content: blog content in html formattitledateauthorsummarystaticblog/archive.htmlposts: a list ofpostdicts as defined inpost.htmlaboveChangelog0.2.5 - 2012-10-16Bugfixes for setup.py0.2.4 - 2012-10-16URL for rendering posts is no longer hardcoded to ‘/preview’Added view to handle github post-receives and render blog
Package: django-static-bootstrap
django-static-bootstrapDjango application contain bootstrap static files.Installpipinstalldjango-static-bootstrapSettingsINSTALLED_APPS = [
    ...
    'django_static_bootstrap',
    ...
]Use static resource{% load staticfiles %}

<link rel="stylesheet" href="{% static "bootstrap/css/bootstrap.min.css" %}">
<script src="{% static "admin/js/vendor/jquery/jquery.js" %}"></script>
<script src="{% static "bootstrap/js/bootstrap.min.js" %}"></script>You can use django's jquery.js, but be careful about django's jquery.init.js. bootstrap/js/bootstrap.min.js must be loaded after jquery.js and before jquery.init.js.If you are not using django framework, you can try django-static-jquery3>=5.0.0 to get jquery.js.About releasesThe first three number is the same with bootstrap project's version.
The fourth number is our release number, it's optional.Releasesv3.3.7.1 2018/03/27First release.v4.4.1 2020/02/27Upgrade the resources to version 4.4.1.v4.4.1.2 2020/09/08No depends on django.v4.4.1.4 2023/09/15Doc update.v4.6.2.1 2023/09/16Upgrade to bootstrap v4.6.2.
Package: django-static-delivery
UsagePlease refer to theDocumentationto
learn how to usedjango-static-delivery. Basicly,static_deliveryprovides a
middleware to serve static files in - for example - Docker setups. The package uses
a middleware instead of a view to make sure we can bypass cookies.Requirementsdjango-static-delivery supports Python 3 only and requires at least Django 1.11.
No other dependencies are required.Prepare for developmentA Python 3.6 interpreter is required in addition to pipenv.$pipenvinstall--python3.6--dev$pipenvrunpipinstall-e.Now you’re ready to run the tests:$pipenvrunpy.test