Saravanan666/pypi-org huggingface dataset:
Package: django-rgd-imagery
Resonant GeoData ImageryA submodule of Resonant GeoData for storing imagery supporting annotations and spatial reference.InstallationFollow the instructions for the coredjango-rgdapp first, thenpip install --find-links https://girder.github.io/large_image_wheels django-rgd-imageryAdd this app to yourINSTALLED_APPSalong with the core RGD app:INSTALLED_APPS+=['django.contrib.gis','rgd','rgd_imagery',]ModelsThis app adds quite a few additional models on top of the core app for storing image dataManagement Commandsrgd_imagery_demo: populate the database with example image data (image sets, annotations, rasters, etc.).rgd_imagery_landsat_rgb_s3: populate the database with example raster data of the RGB bands of Landsat 8 imagery hosted on a public S3 bucket.Notable FeaturesSTAC Item ingest/export for raster imageryImage tile serving throughlarge_imageImage annotation supportCloud Optimized GeoTIFF conversion utilityExtract ROIs from imagery in pixel and world coordinates
Package: django-rholang-editor
# django_rholang_editor## Introduction[Rholang](https://developer.rchain.coop/) is a new language for writing smart contracts that run on the RChain virtual machine.You can find more in the [Rholang tutorial](https://developer.rchain.coop/tutorial)##UsageIf you want to use the django form way and post the text in the rholang-editor. You may use as below.```pythonfrom django.forms import Formfrom django_rholang_editor.fields import RholangTextFormFieldclass EditorForm(Form):rho = RholangTextFormField()```There is multiple way to configure the attrs of the `RholangTextFormField````pythonRholangTextFormField(default_text="",height="100px",width="100%",js_variable='editor')````ARGS`* default_textimplement the default text in the rholang text editor .* heightthe rholang editor widget height* widththe rholang editor widget width* js_variablethe js variable name of the rholang editor . You can call the `js_variable` after the editor in thehtml to figure others implement or other interactions with other components.## Install1. install using pip```bashpip install django-rholang-editor```2. Update `INSTALLED_APPS`:```pythonINSTALLED_APPS = (# ...'django_rholang_editor',)```
Package: django-riak-sessions
Installationpip install django-riak-sessionsConfigurationAddriak_sessionsto your installed appsAdd the session engine to your settings:SESSION_ENGINE = 'riak_sessions.backends.riak'Optional ConfigurationThere are a couple of optional configuration values. The default
values are as follows:import riak
RIAK_PORT = 8087
RIAK_HOST = '127.0.0.1'
RIAK_TRANSPORT_CLASS = riak.RiakPbcTransport
RIAK_BUCKET = 'django-riak-sessions'
RIAK_SESSION_KEY = 'session:%(session_key)s'
Package: django-rich
Extensions for usingRichwith Django.RequirementsPython 3.8 to 3.12 supported.Django 3.2 to 5.0 supported.Want to work smarter and faster?Check out my bookBoost Your Django DXwhich covers many ways to improve your development experience.
I wrote django-rich whilst working on the book!InstallationInstall withpip:python-mpipinstalldjango-richNone of django-rich’s features are activated by default.
Follow the documentation below to use them.Referencedjango_rich.management.RichCommandA subclass of Django’sBaseCommandclass that sets itsself.consoleto a RichConsole.
TheConsoleuses the command’sstdoutargument, which defaults tosys.stdout.
Colourization is enabled or disabled according to Django’s--no-colorand--force-colorflags.You can useself.consolelike so:fromdjango_rich.managementimportRichCommandclassCommand(RichCommand):defhandle(self,*args,**options):self.console.print("[bold red]Alert![/bold red]")You can customize the construction of theConsoleby overriding themake_rich_consoleclass attribute.
This should be a callable that returns aConsole, such as afunctools.partial.
For example, to disable the default-onmarkupandhighlightingflags:fromfunctoolsimportpartialfromdjango_rich.managementimportRichCommandfromrich.consoleimportConsoleclassCommand(RichCommand):make_rich_console=partial(Console,markup=False,highlight=False)defhandle(self,*args,**options):...django_rich.test.RichRunnerA subclass of Django’sDiscoverRunnerwith colourized outputs andnice traceback rendering.To use this class, point yourTEST_RUNNERsetting to it:TEST_RUNNER="django_rich.test.RichRunner"You can also use it as a base for further customization.
Since only output is modified, it should combine well with other classes.The test runner provides the following features:Output is colourized wherever possible.
This includes Rich’s defaulthighlightingwhich will format numbers, quoted strings, URL’s, and more.Failures and errors use Rich’straceback rendering.
This displays the source code and local values per frame.
Each frame also shows the filename and line number, and on many terminals you can click the link to jump to the file at that position.Output is also colourized when using the--debug-sqland--pdbflags.All other flags from Django’s DiscoverRunner continue to work in the normal way.Output Width on CIWhen tests run on your CI system, you might find the output a bit narrow for showing tracebacks correctly.
This is because Rich tries to autodetect the terminal dimensions, and if that fails, it will default to 80 characters wide.
You can override this default with theCOLUMNSenvironment variable (as per Python’sshutil.get_terminal_size()function):$COLUMNS=120./manage.pytest
Package: django-richcomments
Django RichcommentsDjango app extending the builtin comments framework for AJAX style commenting.django-richcommentswraps the Django’s comments frameworks existingrender_comment_listandrender_comment_formtemplate tags to make them behave AJAXy.ContentsDjango RichcommentsInstallationUsageAuthorsChangelog0.0.2 (2011-09-15)0.0.1 (2010-08-03)InstallationInstall or adddjango-richcommentsto your Python path.Configure Django’s comments framework as describedhere.Add richcomments url include to your project’surls.pyfile:(r'^richcomments/', include('richcomments.urls')),Ensuredjango-richcommentsstatic media is accessible, seemanaging static files.Usagedjango-richcommentssimply wraps the existingrender_comment_listandrender_comment_formtemplate tags to make them behave AJAXy. Thus when a comment is submitted it is done via Javascript and an existing comment list is update without a page reload. You would customize your comment listing and form HTML as per normal. From a code perspective commenting behaves exactly the same as it normally does, except that the form generated by therender_comment_formtag will be submitted via AJAX and comment lists generated by therender_comment_listwill be updated via AJAX after such a submit.For richcomments to be active on a page both thejQueryandjQuery form pluginJavascript libraries needs to be loaded. Both are included as part ofdjango-richcommentsstatic media and a shortcut template tag is provided for your convenience, i.e.:{% load richcomments %}

{% richcomments_static %}which renders the following (with a static path as configured in your settings):<script type="text/javascript" src="/static/richcomments/includes/jquery.min.js"></script>
<script type="text/javascript" src="/static/richcomments/includes/jquery.form.js"></script>To recap here’s a simple example illustrating how you can display a list of comments as well as a comment form for an object which will be submitted and updated via AJAX:{% load comments richcomments %}

<html>
    <head>
        {% richcomments_static %}
    </head>
    <body>
        {% render_comment_list for object %}
        {% render_comment_form for object %}
    </body>
</html>AuthorsPraekelt FoundationShaun SephtonChangelog0.0.2 (2011-09-15)Documentation, static media tag.0.0.1 (2010-08-03)Initial release
Package: django-richcontentblocks
=====django-richcontentblocks=====Very simple CMS-like content blocks for use in a django project.Features:1. Admin interface for creating/managing content blocks (including a rich text editor)2. Template tag for retrieving/displaying content block in a django project template. Django cache is leveraged, when possible, in loading content block.Inspiration and more full featured version: django-tinycontent_Installation------------Run: ``pip install django-richcontentblocks``Quick start-----------1. Follow configuration instructions for ckeditor_ (skip this step if ckeditor is already configured).2. Run migrations::manage.py migrate3. Add "richcontent" to your INSTALLED_APPS setting like this::INSTALLED_APPS = (...'richcontentblocks',)You should now have an admin tool with the ability to create rich content blocks.Usage in template------------------An example of loading a rich content block, with a key value of ``my-block`` in a template::{% load rich_content_block_tags %}<div>the content block will be in next div</div><div>{% rich_content_block 'my-block' %}</div>The first time a content block loads, it will be placed in cache. Subsequent loads of the content block will use the cached item.If an invalid content block key is used to when attempting to load a content object, an error message is displayed... _ckeditor: https://github.com/django-ckeditor/django-ckeditor.. _django-tinycontent: https://github.com/dominicrodger/django-tinycontent
Package: django-rich-logging
django-rich-loggingA prettier way to see Django requests while developing.📖 Complete documentation:https://django-rich-logging.readthedocs.io📦 Package located athttps://pypi.org/project/django-rich-logging/⭐ Featureslive-updating table of all requests while developingInstallationpoetry add django-rich-loggingORpip install django-rich-loggingConfiguration# settings.py# other settings hereLOGGING={"version":1,"disable_existing_loggers":False,"handlers":{"django_rich_logging":{"class":"django_rich_logging.logging.DjangoRequestHandler","level":"INFO",},},"loggers":{"django.server":{"handlers":["django_rich_logging"],"level":"INFO"},"django.request":{"level":"CRITICAL"},},}# other settings hereRead all of the documentation athttps://django-rich-logging.readthedocs.io.
Package: django-richmin
Django richmin (Rich Admin)Drop-in theme for django admin, that utilises AdminLTE 3 & Bootstrap 4 to make yo' admin look richyInstallationpip install django-richminFeaturesDrop-in admin skin, all configuration optionalCustomisable side menuCustomisable top menuCustomisable user menu4 different Change form templates (horizontal tabs, vertical tabs, carousel, collapsible)Bootstrap 4 modal (instead of the old popup window, optional)Search bar for any given model adminCustomisable UI (via Live UI changes, or custom CSS/JS)ResponsiveSelect2 drop-downsBootstrap 4 & AdminLTE UI componentsUsing the latestadminlte+bootstrapThanksThis was initially a Fork ofhttps://github.com/farridav/django-jazzminBased on AdminLTE 3:https://adminlte.io/Using Bootstrap 4:https://getbootstrap.com/Using Font Awesome 5:https://fontawesome.com/
Package: django-richtemplates
django-richtemplatesis a set of templates (surprise!), template tags,
media files providing presentation layer similar to what Richfaces library
offers for J2EE developers - not outstanding but still nice looking and
elegant.We wanted to have ability to prototypeDjangoprojects/applications
with some basic set of templates and thats whydjango-richtemplateswas created. We use it for our company’s intranet applications but it
can be also easily used for example projects in otherDjangopluggable
applications.InstallationRefer todocs/installation.rstfile.DocumentationDocumentation is available online athttp://packages.python.org/django-richtemplates/.Plain restructuredText
documents are located atdocs/directory. You may also buildhtmlversion by runningmake htmlatdocs/directory orpython setup.py build_sphinx.Bugs and issuesBug and issue tracker is located at bitbucket’s project pagehttp://bitbucket.org/lukaszb/django-richtemplates/. You may find sources
there as well.LicenseLicense should be included in LICENSE file.
Remember thatRichtemplatesmake use of some third part tools. Those tools
have their own licenses.Third part toolsjQuery-jqueryfamfamfam icons-famfamfam
Package: django-rickroll
A novel way of handling malicious requests within a Django application.InstallationInstall from PyPi (stable):pip install django-rickrollor Github (dev):pip install -e git://github.com/codeinthehole/django-rickroll.git#egg=django-rickrollAdd'rickroll'to yourINSTALLED_APPSand the following to yourMIDDLEWARE_CLASSES:'rickroll.middleware.HackingAttemptMiddleware'UsageWherever you detect a hacking attempt, raise aHackingAttemptexception
and the middleware will rickroll the offending user.For example, in yourviews.py:from rickroll.exceptions import HackingAttempt

def some_view(request):
    # ...
    if hacking_detected:
        raise HackingAttempt()then the user in question will get redirected tohttp://www.youtube.com/watch?v=dQw4w9WgXcQ.
The destination can be overridden using the settingRICKROLL_URL.DiscussionIf your site ever gets penetration tested, the testing company will likely manipulate
every request to your site where there are parameters being passed (query
parameters, POST params, cookies etc).  When you encounter a parameter which
should be an integer but has value../../../../../../etc/passwd, it’s not
always clear what the “right” response should be. I thought it would be funny
to rickroll.
Package: django-riemann
django-riemann==============Send logging information to a [Riemann][1] instance via Django's `LOGGING`directive.[1]: http://riemann.io/Installl--------```pip install django-riemann```Fields------```host:        the host name of the app that is sending the logsservice:     'django-logger'state:       log leveltime:        time of the log eventtags:        logger namedescription: traceback if available```Configuration-------------``` pythonRIEMANN_LOGGER_HOST = '127.0.0.1'RIEMANN_LOGGER_PORT = '5555'RIEMANN_LOGGER_TRANSPORT = 'udp'  # or 'tcp'LOGGING = {# ...'handlers': {'riemann': {'level': 'INFO','class': 'riemann.handler.RiemannHandler'}}}LOGGING['root']['handlers'].append('riemann')```License-------BSD, short and sweet
Package: django-rigger
Django Riggerrigger is a django toolset that provides a daily common toolRequirementsPython (3.5, 3.6, 3.7, 3.8)Django (2.1, 2.2, 3.0)Ihighly recommendand only officially support the latest patch release of each Python and Django series.InstallationInstall using pip...pip install django-riggerAdd 'rigger' to your INSTALLED_APPS setting.INSTALLED_APPS = [
    ...
    'rigger',
]
Package: django-right-to-left
SummaryA Django template loader that looks for an alternative right to left version of a template file if the activated language is a right to left language such as Arabic or Hebrew.This provides a clean and easy way to customise the markup in your templates without having to place conditional logic in your templates.The most common use case for this would be a Django website that supports both a left to right and right to left language, such as English and Arabic.ExampleSuppose you had the following Django template:# homepage.html
{% extends "layout.html" %}

{% block content %}
    <div id="main_content">...</div>
    <div id="side_promo">...</div>
{% endblock %}To swap the content around when the activated language is Arabic, an IF statement would have to be wrapped around the div tags. This may be a feasible solution for small templates but for most templates this will make the template very hard to read and messy.Using the django-right-to-left template loader makes this process a lot cleaner by allowing you to create an alternative template with the same name but with “_rtl” appended to the file name. In this example, a file called “homepage_rtl.html” will be picked up as the alternative.Now when a template is rendered, regardless of whether it is rendered by a Django view or by extending another template using the “extends” block or included using the “include” block, the django-right-to-left template loader will look to see if an alternative template suffixed with “_rtl” exists. If it doesn’t exist it will load the standard version of the template.InstallationYou can install django-right-to-left using pip:$ pip install django-right-to-leftor easy_install:$ easy_install django-right-to-leftInstructionsdjango-right-to-left works in exactly the same way as the Djangocached template loader.
The django-right-to-left template loader is a class-based loader that you configure with a list of other loaders that it should wrap.Simply wrap the template loaders defined in your settings file with the django-right-to-left-loader.For example, if you are currently using the filesystem loader and app_directories loader,
change theTEMPLATE_LOADERSsettings from:TEMPLATE_LOADERS = (
    'django.template.loaders.filesystem.Loader',
    'django.template.loaders.app_directories.Loader',
)to this:TEMPLATE_LOADERS = (
    ('rtl.loaders.Loader', (
        'django.template.loaders.filesystem.Loader',
        'django.template.loaders.app_directories.Loader',
    )),
)That’s all there is to it. All you have to do now is create your alternative templates, ensuring that the string “_rtl” is appended to the filename. So the alternative template for “homepage.html” will be “homepage_rtl.html”.Running the testsdjango-right-to-left has a small but extensive test suite. You can run the tests by running the
following commands, assuming you
havevirtualenvwrapperinstalled:$ git clone git@github.com:abbas123456/django-right-to-left.git
$ cd django-right-to-left
$ mkvirtualenv django-right-to-left
$ pip install -r requirements.txt
$ ./runtests.py
Package: django-rijkshuisstijl
Rijkshuisstijl boilerplate for Django.Version:0.1.7Source:https://github.com/maykinmedia/django-rijkshuisstijlKeywords:Django, rijkshuisstijlPythonVersion:3.6Contents1Features2Installation2.1Requirements2.2Install3Usage1FeaturesBasic rijkshuisstijl (Dutch government branding) layout including headers, footer, buttons, forms and more.Modular setup using inclusion tags.Responsive2Installation2.1RequirementsPython 3.6 or abovesetuptools 30.3.0 or aboveDjango 1.11 or above2.2InstallInstall from PyPI with pip:pipinstalldjango-rijkshuisstijlThen add “sitetree” and “rijkshuisstijl” to INSTALLED_APPS3UsageAdd CSS/JS/icons to your main template:{% load rijkshuisstijl %}<!DOCTYPE html><htmllang="nl"class="views"><head>{% meta_css %}
    {% meta_icons %}</head><bodyclass="view__body">{% meta_js %}</body>Then add the basic structure, supply the current urls for various urls (depending on your project):{% load rijkshuisstijl %}<!DOCTYPE html><htmllang="nl"class="views"><head>{% meta_css %}
    {% meta_icons %}</head><bodyclass="view__body">{% skiplink %}
    {% login_bar details_url='#' logout_url='#' login_url='#' registration_url='#' %}
    {% header %}
    {% navigation_bar details_url='#' logout_url='#' login_url='#' registration_url='#' %}<mainclass="view__content">{% skiplink_target %}</main>{% footer %}
    {% meta_js %}</body>See the documentation for further information about logos, navigation, forms and datagrids.
Package: django-riotjs-helper
A small, rudimentary helper app for RiotJS (https://riot.js.org) integration into django projects.QuickstartInstall Django RiotJS Helper:pip install django-riotjs-helperAdd it to yourINSTALLED_APPS:INSTALLED_APPS=(...'riotjs_helper',...)Add this to your base template (base.html):{% include 'riotjs_helper/riotjs_core.html' %}
{% block riot_tags %}
{% endblock riot_tags %}
{% include 'riotjs_helper/riotjs_mount.html' %}If you plan on using django rest framework you can switch riotjs_core.html to the more elaborate riotjs_setup.html:{% include 'riotjs_helper/riotjs_setup.html' %}This setup requires some additional libraries as well, allready included in the requirements.txt:djangorestframeworkdjango-filterdjango-rest-swaggerhttpieMarkdownpython-dateutilcoreapicoreapi-clicoreschemaAnd these has to be added to your INSTALLED_APPS, urls has to be updated etc.And then to create some tags:pythonmanage.pyriot_tag<appname><tag1-name><tag2-name>In the page you want to use your tag:{% block content %}
...<tag1-name></tag1-name>...<tag2-name></tag2-name>...
{% endblock %}

{% block riot_tags %}
{% include '<appname>/include/<tag1-name>_tag.html' %}
{% include '<appname>/include/<tag2-name>_tag.html' %}
{% endblock riot_tags %}If you need to add more context to your tags you can do that by editing the generated include files, for instance like so:{% load static %}<scriptsrc="{% static '<appname>/tags/<tag1-name>.tag' %}"type="riot/tag"></script><script>riot_context['<tag1-name>']={more_context_goes_here:{...somethingfancy...}};</script>If you want to look at some boilerplate/example code generate your tags with the –example-code option:pythonmanage.pyriot_tag<appname><tag1-name><tag2-name>--example-codeHistory0.1.0 (2018-09-23)First release on PyPI.
Package: django-ripozo
Integrates ripozo with django for fast, flexible
Hypermedia, HATEOAS, and other REST apis.Full django-ripozo documentationLooking for theripozo documentation?Supports Django 1.6, 1.7, and 1.8.python 2.6, 2.7, 3.3, 3.4, pypyNOTECurrently there arecompatibility issueswith Django 1.6, 1.7 and python 3.5.  There is currently a fix in progress.
However, two of our test environments will fail until the fix is deployed. All tests
pass otherwise.Minimal AppYou’ll need to instantiate the django project in
the standard manner.  If you aren’t sure how to
do this, check out the excellentdjango documentation.In your app you’ll need a resources.py file.fromripozoimportResourceBase,apimethodclassMyResource(ResourceBase):@apimethod(methods=['GET'])defsay_hello(cls,request):returncls(properties=dict(hello='world'))And in your urls.py filefromripozo.adaptersimportSirenAdapter,HalAdapterfrom.resourcesimportMyResourcedispatcher=DjangoDispatcher()dispatcher.register_resources(MyResource)dispatcher.register_adapters(SirenAdapter,HalAdapter)urlpatterns=dispatcher.url_patternsAnd just like that you have a fully functional application.Looking for a more extensive example?
Check out anexamplewith database interactions as well.
Package: django-ripple
Ripple Django is a base app for a Django-React-Bootstrap Framework that can be run in Google CloudQuick startAdd “rippledjango” to your INSTALLED_APPS setting like this:INSTALLED_APPS = [
    ...
    'ripple',
]Include the polls URLconf in your project urls.py like this:path('auth/', include('rippledjango.urls')),Runpython manage.py migrateto create the polls models.Start the development server and visithttp://127.0.0.1:8000/admin/to create a poll (you’ll need the Admin app enabled).Visithttp://127.0.0.1:8000/.
Package: django-ripple_api
============================================Python Ripple API and transaction management============================================Settings========* ``RIPPLE_ACCOUNT`` - account that acts as 'manager' and monitors incoming transactions* ``RIPPLE_SECRET`` - secret for 'manager' account* ``RIPPLE_API_DATA[0]['RIPPLE_API_URL']``* ``RIPPLE_API_DATA[0]['RIPPLE_API_USER']``* ``RIPPLE_API_DATA[0]['RIPPLE_API_PASSWORD']``* ``RIPPLE_TIMEOUT`` - timeout for django manamgement command calls* ``RIPPLE_TRANSACTION_MONITOR_MIN_LEDGER_INDEX`` - offset, ledger index to start transaction monitoring with,default is the beginning of timeExample Config::RIPPLE_API_DATA = [{'RIPPLE_API_URL': 'http://s_west.ripple.com:51234','RIPPLE_API_USER': '','RIPPLE_API_PASSWORD': '',}]  # You can specify multiple servers and ripple_api app will try them in order if one of servers#    returns errorSignals=======* ``ripple_api.signals.transaction_status_changed = Signal(providing_args=["old_status"])`` - sentwhen existing Transaction's status is changed* default django's post_save signal is useful to get new Transactions.. TODO:* docs on api usage* docs on management command
Package: django-river-ml
django-river-mlDjango models to deployriveronline machine learning.
This is a Django version ofchantillythat aims to use the
same overall design. We also includeexample clientsand a test application intests. We also are developing anAPI clientand early work on aspecificationthat can be extended to other
Python based servers intended for river.See the ⭐️Documentation⭐️ to get started!ContributorsWe use theall-contributorstool to generate a contributors graphic below.Vanessasaurus💻