Saravanan666/pypi-org huggingface dataset:
Package: django-static-echarts
django-static-echartsDjango application contain echarts static files.Installpip install django-static-echartsLincenseAll resource files of echarts are unzip from apache-echarts-X.Y.Z-src.zip which download fromhttps://echarts.apache.orgwithout any changes.All resource files of echarts obey echarts License, see details athttps://www.apache.org/licenses/.We don't guarantee the latest echarts version.Usagepro/settings.pyINSTALLED_APPS = [
        ...
        "django_static_echarts",
        ...
    ]app1/chart1.html{% load staticfiles %}

    {% block script %}
        <script src="{% static "echarts/echarts.min.js" %}"></script>
        <script src="{% static "echarts/theme/vintage.js" %}"></script>
        <script src="{% static "echarts/map/js/china.js" %}"></script>
    {% endblock %}About releasesThe first number is our release number.The other three numbers are the same with ECHARTS's release version.Releasev3.8.4First release.v4.0.4.1Upgrade echarts to 4.0.4.v4.0.4.2Doc update.v5.4.3.2Upgrade echarts to 5.4.3.
Package: django-staticfiles
This is a Django app that provides helpers for serving static files.Django developers mostly concern themselves with the dynamic parts of web
applications – the views and templates that render new for each request. But
web applications have other parts: the static media files (images, CSS,
Javascript, etc.) that are needed to render a complete web page.For small projects, this isn’t a big deal, because you can just keep the media
somewhere your web server can find it. However, in bigger projects – especially
those comprised of multiple apps – dealing with the multiple sets of static
files provided by each application starts to get tricky.That’s whatstaticfilesis for:Collecting static files from each of your Django apps (and any other
place you specify) into a single location that can easily be served in
production.The main website for django-staticfiles isgithub.com/jezdez/django-staticfileswhere you can also file tickets.Notedjango-staticfiles is now part of Django (since 1.3) asdjango.contrib.staticfiles.The django-staticfiles 0.3.X series will only receive security and data los
bug fixes after the release of django-staticfiles 1.0. Any Django 1.2.X
project using django-staticfiles 0.3.X and lower should be upgraded to use
either Django >= 1.3’s staticfiles app or django-staticfiles >= 1.0 to
profit from the new features and stability.You may want to chose to use django-staticfiles instead of Django’s own
staticfiles app since any new feature (additionally to those backported
from Django) will be released first in django-staticfiles.InstallationUse your favorite Python packaging tool to installstaticfilesfromPyPI, e.g.:pip install django-staticfilesYou can also install thein-development versionof django-staticfiles
withpip installdjango-staticfiles==dev.Added"staticfiles"to yourINSTALLED_APPSsetting:INSTALLED_APPS = [
    # ...
    "staticfiles",
]Set yourSTATIC_URLsetting to the URL that handles serving
static files:STATIC_URL = "/static/"In development mode (whenDEBUG = True) therunservercommand will
automatically serve static files:python manage.py runserverOnce you are ready to deploy all static files of your site in a central
directory (STATIC_ROOT) to be served by a real webserver (e.g.Apache,Cherokee,Lighttpd,Nginxetc.), use thecollectstaticmanagement
command:python manage.py collectstaticSee the webserver’s documentation for descriptions how to setup serving
the deployment directory (STATIC_ROOT).(optional) In case you use Django’s admin app, make sure theADMIN_MEDIA_PREFIXsetting is set correctly to a subpath ofSTATIC_URL:ADMIN_MEDIA_PREFIX = STATIC_URL + "admin/"
Package: django-staticfiles-bootstrap
Easily include twitter bootstrap in your django appsInstallationpip install django-staticfiles-bootstrapMake sure your django project is configured to use staticfiles, then add this to your INSTALLED_APPSINSTALLED_APPS += [‘django-staticfiles-bootstrap’,]UsageYou can use this in two different ways in your templates### STATIC_URL<link href=”{{ STATIC_URL }}bootstrap/css/bootstrap.css” rel=”stylesheet”>
<script src=”{{ STATIC_URL }}bootstrap/js/bootstrap.js”></script>### static template tag{% load static from staticfiles %}
<link href=”{% static “bootstrap/css/bootstrap.min.css” %}” rel=”stylesheet”>PluginsIf you want to use the JavaScript plugins, you will need jQuery. For that, I suggest django-staticfiles-jquery.Code prettifying requires Google code prettify. For that, I suggest django-staticfiles-google-code-prettify.
Package: django-staticfiles-downloader
django-staticfiles-downloaderprovidesstaticfiles_downloader.DownloaderFinder,
an extension ofdjango.contrib.staticfiles, which allows you to specify static files
with urls and optionaly checksum in your Django application or Django project settings.
This is particularly useful, when using third-party static files, if you don’t want to
either include the files in your project nor depend on CDN in runtime.The static files are collected withpython manage.py collectstatic.Installationpipinstalldjango-staticfiles-downloaderConfigurationAddstaticfiles_downloader.DownloaderFindertosettings.STATICFILES_FINDERS:STATICFILES_FINDERS=['django.contrib.staticfiles.finders.FileSystemFinder','django.contrib.staticfiles.finders.AppDirectoriesFinder','staticfiles_downloader.DownloaderFinder',]Define static files urls in your Django application# your_app/__init__.pystaticfiles_urls={# use only url'my_app/js/jquery-3.2.1.min.js':'https://code.jquery.com/jquery-3.2.1.min.js',# or use url and checksum'my_app/js/jquery-2.2.4.min.js':('https://code.jquery.com/jquery-2.2.4.min.js','sha384','rY/jv8mMhqDabXSo+UCggqKtdmBfd3qC2/KvyTDNQ6PcUJXaxK1tMepoQda4g5vB',),}Define static files urls in your Django project settings# your_project/settings.pySTATICFILES_URLS={# use only url'js/jquery-3.2.1.min.js':'https://code.jquery.com/jquery-3.2.1.min.js',# or use url and checksum'js/jquery-2.2.4.min.js':('https://code.jquery.com/jquery-2.2.4.min.js','sha384','rY/jv8mMhqDabXSo+UCggqKtdmBfd3qC2/KvyTDNQ6PcUJXaxK1tMepoQda4g5vB',),}
Package: django-staticfiles-fitvidsjs
FitVids.js meets Django staticfilesUsageThis application is meant to be used withdjango-staticfiles.  Make sure
that staticfiles setup and configured, then install this application usingpip:pip install django-staticfiles-fitvidsjsFinally, make sure thatfitvidsjsis listed in yourINSTALLED_APPS.  You
can use this oneliner to add it as well:INSTALLED_APPS += ['fitvidsjs', ]BuildFitVids.jscontains only the uncompressed version of the code in its Git
repository.  No further tools are necessary to build it.  Seesupport/build.pyfor more information on how data is transferred from the
submodule to the Python package.
Package: django-staticfiles-fontawesome
Masonry meets Django staticfilesUsageThis application is meant to be used withdjango-staticfiles.  Make sure
that staticfiles setup and configured, then install this application usingpip:pip install django-staticfiles-masonryFinally, make sure thatmasonryis listed in yourINSTALLED_APPS.  You
can use this oneliner to add it as well:INSTALLED_APPS += ['masonry', ]BuildMasonrypackages pre-built versions of the code in its Git repository.  No
further tools are necessary to build it.  Seesupport/build.pyfor more
information on how data is transferred from the submodule to the Python
package.
Package: django-staticfiles-google-code-prettify
Easily include google-code-prettify in your django appsInstallationInstall this package using pippip install django-staticfiles-google-code-prettifyMake sure your django project is configured to use staticfiles, then add this to your INSTALLED_APPPSINSTALLED_APPS += [‘django-staticfiles-google-code-prettify’,]UsageYou can use this in two different ways in your templates.### STATIC_URL<link href=”{{ STATIC_URL }}google-code-prettify/css/prettify.css” type=”text/css” rel=”stylesheet” />
<script type=”text/javascript” src=”{{ STATIC_URL }}google-code-prettify/js/prettify.js”></script>### static template tag{% load static from staticfiles %}
<link href=”{% static “google-code-prettify/css/prettify.css” %}” type=”text/css” rel=”stylesheet” />
<script type=”text/javascript” src=”{% static “google-code-prettify/js/prettify.js” %}”></script>
Package: django-staticfiles-isotope
Isotope meets Django staticfilesUsageThis application is meant to be used withdjango-staticfiles.  Make sure
that staticfiles setup and configured, then install this application usingpip:pip install django-staticfiles-isotopeFinally, make sure thatisotopeis listed in yourINSTALLED_APPS.  You
can use this oneliner to add it as well:INSTALLED_APPS += ['isotope', ]BuildIsotopepackages pre-built versions of the code in its Git repository.  No
further tools are necessary to build it.  Seesupport/build.pyfor more
information on how data is transferred from the submodule to the Python
package.LicenseIsotope is licensed under acustom license.  Please visit their site to see
whether you qualify for a free license.
Package: django-staticfiles-jquery
Introducing jQuery to Django!UsageThis application is meant to be used withdjango-staticfiles.  Make sure
that staticfiles setup and configured, then install this application usingpip:pip install django-staticfiles-jqueryFinally, make sure thatjqueryis listed in yourINSTALLED_APPS.  You
can use this oneliner to add it as well:INSTALLED_APPS += ['jquery', ]BuildTo build this, you need to have the jQuerybuild tool chainconfigured.
Seesupport/build.pyfor more information on how data is transferred from the submodule to the Python package.
Package: django-staticfiles-lessjs
Less.js meets Django staticfilesUsageThis application is meant to be used withdjango-staticfiles.  Make sure
that staticfiles setup and configured, then install this application usingpip:pip install django-staticfiles-lessjsFinally, make sure thatlessjsis listed in yourINSTALLED_APPS.  You
can use this oneliner to add it as well:INSTALLED_APPS += ['lessjs', ]BuildLess.jspackages pre-built versions of the code in its Git repository.
No further tools are necessary to build it.
Package: django-staticfiles-masonry
Masonry meets Django staticfilesUsageThis application is meant to be used withdjango-staticfiles.  Make sure
that staticfiles setup and configured, then install this application usingpip:pip install django-staticfiles-masonryFinally, make sure thatmasonryis listed in yourINSTALLED_APPS.  You
can use this oneliner to add it as well:INSTALLED_APPS += ['masonry', ]BuildMasonrypackages pre-built versions of the code in its Git repository.
No further tools are necessary to build it.
Package: django-staticfiles-moment
Moment.js meets Django staticfilesUsageThis application is meant to be used withdjango-staticfiles.  Make sure
that staticfiles setup and configured, then install this application usingpip:pip install django-staticfiles-momentFinally, make sure thatmomentis listed in yourINSTALLED_APPS.  You
can use this oneliner to add it as well:INSTALLED_APPS += ['moment', ]BuildMoment.jsships with a pre-built version in each tag.  No build step is
required, so there are no additional requirements other than runningpython support/build.py.
Package: django-staticfiles-noimport
Django Staticfiles Noimportdjango-staticfiles-import exists to allow Django'scollectstaticmanagement command to run with the
bare minimum of environment variables so it can be
run inside adocker buildstep such that the produced
container is self-contained.This approach allows typical runtime initialization to
verify all required runtime environment variables are
defined and provides an alternative entrypoint for just
thecollectstaticandfindstaticcommands.Specifically, this project allows for Django apps
withstatic/directories that expect you to use the
enabled-by-defaultAppDirectoriesFinder.Requirements & ConstraintsUtilizing this package requires accepting a handful of
constraints that are acceptable in our environment:Static assets will be served at the same path in all
environments (i.e.STATIC_URLdoesn't vary per
environment.)Django "apps" may not manipulate any static
file handling behaviors during app initialization.INSTALLED_APPSmust reference app names as strings,
as opposed to importing anAppConfigdirectly.SetupEnsure you have anos.environ-agnostic settings module.This may be achieved by creating a simplesettings/apps.pymodule that is imported from your primary settings with glob syntax like:from .apps import *and asettings/static.pythat imports it as well.Somewhere in that settings chain you must defineSECRET_KEYwhich is the one required non-staticfiles related setting.Use the providedstaticfiles_noimport.finders.AppDirectoriesNoImportFinderin yourSTATICFILES_FINDERSsettings. (See included example.)Usecollectstaticandfindstaticdirectly without using the typicalmanage.pyentrypoint. You'll need to inject your static-specific settings (e.g.,DJANGO_SETTINGS_MODULE=settings.static) for things to work as expected.Example Usage# settings/apps.pyINSTALLED_APPS=("django.contrib.auth","django.contrib.contenttypes","django.contrib.admin",......"yourappone","yourapptwo",)# settings/static.pyfrom.appsimport*STATIC_ROOT="/static/foobar/"STATIC_URL="/static/foobar/"STATICFILES_DIRS=("/some/resolved/path/static",)STATICFILES_FINDERS=("django.contrib.staticfiles.finders.FileSystemFinder","staticfiles_noimport.finders.AppDirectoriesNoImportFinder")STATICFILES_STORAGE="django.contrib.staticfiles.storage.ManifestStaticFilesStorage"Running collectstatic:$DJANGO_SETTINGS_MODULE=myproject.settings.staticcollectstatic
Package: django-staticfilesplus
A tiny library that adds asset pre-processor support to Django’scontrib.staticfiles.The bundledcontrib.staticfilesdoes most of what I want from an asset manager, but not
quite all. Rather than replace it entirely with another asset manager, I wrote this little
hack to add the missing piece. Now assets that need pre-processing (like LESS stylesheets,
or Sprocketized JS files) get compiled dynamically in development and then written out as
static files for serving in production.Features:Seamleess integration withcontrib.staticfiles: Continue to use thestatictemplate tag andcollectstaticcommand as normal.Ships with support for LESS stylesheets and Sprockets-like JavaScript concatenation and
minification.Very simple API for defining new pre-processors.Not a single line of my code needs to run in production: once you’ve runcollectstatic, its work is done.Read the documentation:http://django-staticfilesplus.evans.io
Package: django-staticfiles-select2
Introducingselect2to Django!UsageThis application is meant to be used withdjango-staticfiles.  Make sure
that staticfiles setup and configured, then install this application usingpip:pip install django-staticfiles-select2Finally, make sure thatselect2is listed in yourINSTALLED_APPS.  You
can use this oneliner to add it as well:INSTALLED_APPS += ['staticfiles_select2', ]Then in your template code you can do this:<link rel="stylesheet" href="{{ STATIC_URL }}staticfiles_select2/select2/select2.css">and:<script type="text/javascript" src="{{ STATIC_URL }}staticfiles_select2/select2/select2.min.js"></script>InspirationMost part of this project are stolen fromdjango-staticfiles-jquery.
Package: django-staticfiles-typeaheadjs
typeahead.js meets Django staticfilesUsageThis application is meant to be used withdjango-staticfiles.  Make sure
that staticfiles setup and configured, then install this application usingpip:pip install django-staticfiles-typeaheadjsFinally, make sure thattypeaheadjsis listed in yourINSTALLED_APPS.  You
can use this oneliner to add it as well:INSTALLED_APPS += ['typeaheadjs', ]Buildtypeahead.jsusesGruntto build and minify the JavaScript.  You need to
follow the instructions invendor/typeahead.js/README.mdfor setting up your
build environment, then runpython support/build.pyto update the Django
application.  Seesupport/build.pyfor more information on how data is
transferred from the submodule to the Python package.
Package: django-staticfiles-webpack
# django-staticfiles-webpackSimple StaticFilesStorage that can be used together with the assets-webpack-plugin to include hashed files.## WhyWebpack comes with an option to hash static files for long term caching so that generated files look like:- Main.76def765eff56.js (entry point)- Bundle.1.689ef7cbade76.js (loaded on demand)- Bundle.2.873426ef56a5e.js (loaded on demand)Bundle files are usually a result of code splitting. Webpack keeps track of the filename changes for you, however theentry point files cannot be managed by Webpack easily when they need to be included in your Django templates.When the [assets-webpack-plugin](https://github.com/sporto/assets-webpack-plugin) is added to the webpack configuration, then a json file is created which maps entry pointsto generated file names.This json file is read by the custom django staticfiles storage class to resolve the url for the entry point.## Webpack ConfigurationInstall the assets plugin with `npm install --save-dev assets-webpack-plugin`and include it in the plugins section of `webpack.conf.js`:```javascriptAssetsPlugin = require('assets-webpack-plugin');var entry = ['.src/app/App.js']module.exports = {output =  {path: __dirname,filename: 'App.[name].[hash].js',chunkFilename: "App.[id].[chunkhash].js",publicPath: '/static/'};plugins: [new AssetsPlugin() // writes webpack-assets.json file that can be read in by custom django storage class],module:{loaders: [{test: /\.js?$/, exclude: /node_modules/, loader: 'babel-loader'},//your other loaders ...]}```When a build is completed, a `webpack-assets.json` file should be in the directory with a content like this:```javascript{"main":{"js":"App.main.7ebdf0b55c648ba41cc1.js"}}```Note that the entry point has been called 'main' as there was no name specified.When multiple entry points are defined in a dict, then each key is reflected in the assets.json.See the webpack [docs](https://webpack.github.io/docs/multiple-entry-points.html).## Django Configuration### STATICFILES_STORAGEName of the storage class: `webpack.storage.WebpackHashStorage`### WEBPACK_ASSETS_FILEA path pointing to the generated webpack-assets.json file. E.g. `"path-to-your/webpack-assets.json"`## Need something more sophisticated?Maybe https://github.com/owais/django-webpack-loader suits your needs.
Package: django-static-fontawesome
django-static-fontawesomeDjango application contain font-awesome static filesInstallpip install django-static-fontawesomeFontawesome LicenseAll resource files of static/fontawesome are unzip from fontawesome-free-xx.xx.xx-web.zip which download fromhttps://fontawesome.comwithout any changes.All resource files of static/fontawesome obey Font Awesome License, see details athttps://fontawesome.com/license.We don't guarantee the latest fontawesome version.Settingspro/settings.pyINSTALLED_APPS=[..."django_static_fontawesome",...]Use static filespage.html{%loadstaticfiles%}{%blockstyle%}<linkrel="stylesheet"type="text/css"href="{% static "fontawesome/css/all.min.css" %}"/>{%endblock%}<iclass="fas fa-home"></i>HomeAbout releasesThe first three number is the same with fontawesome project's version.The fourth number is our release number, it's optional.Releasesv6.4.2.1Setup changes.v6.4.0.0Upgrade fontawesome to v6.4.0.v5.15.4.0Upgrade fontawesome to v5.15.4.v5.14.0.0No depends on django.Turn to the package as a pure static wrapper package.v5.12.1.4Fix setup problem, make description render on pypi.v5.12.1.3Fix setup.py.v5.12.1.1App rename to django_static_fontawesome.v5.12.1Upgrade fontawesome static files to version 5.12.1.Add demo page.v5.10.2Use fontawesome 5.10.2.v5.0.8.1Use fontawesome 5.0.8.v5.0.2First release.
Package: django-staticgen
Push your django powered site to Amazon S3.WORK IN PROGRESS // NOT PRODUCTION READY.DemoLive Site:http://staticgen-demo.herokuapp.comStatic Site:http://staticgen-demo.s3-website-us-west-2.amazonaws.comSource code for demo:http://github.com/mishbahr/staticgen-demoQuickstartInstalldjango-staticgenfrom PyPi:pip install django-staticgenAddstaticgentoINSTALLED_APPS:INSTALLED_APPS = (
    ...
    'staticgen',
    ...
)Migrate database:python manage.py migrateTo publish your site on Amazon S3, you’ll need to setup an AWS S3 bucket to host the website. Add the following details to your projectssettings.pymodule:AWS_ACCESS_KEY_ID = 'AKIAIOSFODNN7EXAMPLE'
AWS_SECRET_ACCESS_KEY = 'wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY'
AWS_STORAGE_BUCKET_NAME = 'staticgen-bucket'Finally, publishing your site to S3 is as simple as:python manage.py staticgen_publishCeleryThis project requirescelery>=3.1to be properly installed and configured.For more information on using Celery with Django.See:http://docs.celeryproject.org/en/latest/django/first-steps-with-django.htmlTodoCache ControlGzip CompressionCloudFront distribution/invalidation
Package: django-static-html5shiv
django-static-html5shivDjango application contain html5shiv static files.Installpip install django-static-html5shivAbout static resources of html5shivWe get all static resources of html5shiv fromhttps://github.com/aFarkas/html5shiv/releaseswithout any changes.The license about all the static resources of html5shiv obey html5shiv's license.We don't guarantee the latest html5shiv version.SettingsINSTALLED_APPS = [
    ...
    "django_static_html5shiv",
    ...
]Use static resource{% load staticfiles %}

<script src="{% static "html5shiv/html5shiv.min.js" %}"></script>
<script src="{% static "html5shiv/html5shiv-printshiv.min.js" %}"></script>About package versiondjango-static-html5shiv Uses version number like v3.7.3.1.The first three numbers are the version number of html5shiv.the fourth number is our release number.Releasesv3.7.3.3 2020/09/02No depends on django.Turn to the package as a pure static wrapper package.v3.7.3.2 2020/03/09Use python standard package structure.Use markdown for README.md.v3.7.3.1 2018/03/28First release.
Package: django-statici18n
OverviewWhen dealing with internationalization in JavaScript code, Django provides
theJSONCatalog viewwhich sends out a JavaScript code library with
functions that mimic the gettext interface, plus an array of translation
strings.At first glance, it works well and everything is fine. But, becauseJSONCatalog viewis generating JavaScript catalog dynamically on each
and every request, it’sadding an overheadthat can be an issue with
site growth.That’s whatdjango-statici18nis for:Collecting JavaScript catalogs from each of your Django apps (and any
other place you specify) into a single location that can easily be
served in production.The main website fordjango-statici18nisgithub.com/zyegfryed/django-statici18nwhere you can also file tickets.Supported Django Versionsdjango-statici18nworks with all the Django versions officially
supported by the Django project. At this time of writing, these are the
3.2 (LTS), 4.1, 4.2 series.InstallationUse your favorite Python packaging tool to installdjango-statici18nfromPyPI, e.g.:pip install django-statici18nAdd'statici18n'to yourINSTALLED_APPSsetting:INSTALLED_APPS = [
    # ...
    'statici18n',
]Once you havetranslatedandcompiledyour messages, use thecompilejsi18nmanagement command:python manage.py compilejsi18nAdd thedjango.core.context_processors.i18ncontext processor to thecontext_processorssection for your backend in theTEMPLATESsetting - it should have already been set by Django:TEMPLATES = [
  {
    # ...
    'OPTIONS': {
      'context_processors': {
        # ...
        'django.template.context_processors.i18n',
      },
    },
  },
]Edit your template(s) and replace thedynamically generated scriptby the
statically generated one:<scriptsrc="{{STATIC_URL}}jsi18n/{{LANGUAGE_CODE}}/djangojs.js"></script>NoteBy default, the generated catalogs are stored toSTATIC_ROOT/jsi18n.
You can modify the output path and more options by tweakingdjango-statici18nsettings.(Optional)The following step assumes you’re usingdjango.contrib.staticfiles.Edit your template(s) and use the provided template tag:{%loadstatici18n%}<scriptsrc="{%statici18nLANGUAGE_CODE%}"></script>Or inline the JavaScript directly in your template:{%loadstatici18n%}<script>{%inlinei18nLANGUAGE_CODE%}</script>