Saravanan666/pypi-org huggingface dataset:
Package: django-rss2rest
rss2rest========- Configure your feeds in the `settings` file- Turns RSS feeds into a RESTful API with the use of TastyPie and Feedparser (perfect for use with `backbone.js`)- Map feeds to Django models, few convenienve models are provided (see below)- Write your own mdels representing a feed item, you just need to provide a mapping from feed nodes to model fields- Harvest feeds using `./manage.py syncdb` command- Access your feeds direct via tastypie API resource![](https://secure.travis-ci.org/gump/rss2rest.png "Travis CI build status")Installation============Install via PIP:$ pip install django-rss2restAdd to your `INSTALLED_APPS` the following:INSTALLED_APPS = [...,'tastypie','rss2rest',]Define your feeds:RSS2REST_FEEDS = [{'feed': 'http://feedurl/','model': 'rss2rest.FeedItem'},]Add RESTful routing to your `urls.py`:from rss2rest.api import FeedItemResourcefeed_item_resource = FeedItemResource()urlpatterns += patterns('rss2rest',(r'^api/', include(feed_item_resource.urls)),)Usage=====Synchronise Feeds:./manage.py syncrss2restConsume feeds go to:http://127.0.0.1/rss2rest/api/<resource_name>Models for your feeds=====================In order for the feed to be exposed as a RESTful resource the feed must be mapped to a django model.`rss2rest` provides a few pre-defined models that fit some typical scenarios.**Generic feed item models:*** `FeedItem` - generic feed item* `VimeoFeedItem` - maps well to Vimeo Likes RSS feed* `FlickrFeedItem` - maps well to Flickr Likes RSS feed**Writing your own feed item model:*** Create your own model for the feed to provide custom mapping, etc* Simply extend the abstract `AbstractFeedItem` class present in the `rss2rest.models` file.* Put `MAPPING` dictionary as a class property and you're ready to go* Make sure you put your new model class name (as string in the format of `app.ModelName`) into the `RSS2REST_FEEDS`setting* If your model is pretty generic and maps to a public feed - make sure you submit it as a pull request withaccompanying tests to be included in the `rss2rest`**Generic tasty pie resources*** `FeedItemResource` - resource name: `feed_item`* `FlickrItemResource` - resource name: `flickr`* `VimeoItemResource` - resource name: `vimeo`**Custom resources*** You can build your custom resource as per [Tastypie's documentation](http://django-tastypie.readthedocs.org/en/latest/index.html)Contribute==========Set up in development mode:$ git clone git://github.com/gump/rss2rest.git$ cd rss2rest$ mkvirtualenv rss2rest$ python setup.py develop$ cd sandbox/$ cp local_settings_sample.py local_settings.py$ ./manage.py syncdb$ ./manage.py test rss2restPlanned development===================* More tests for all types of feeds* More generic feed item models to cater for other common use cases* `published` flag on abstract model to drive presence in the RESTful API (configurable with publish/unpublish flagusing django admin panel); way to define default behaviour using a setting* Defining your feeds in the database
Package: django-rsscloud
django-rsscloudIt turns your RSS feed into a rsscloud-enabled feed and it allows you
to connect post_save signal from one or more models to a ping function
that will be in charge of pinging the rsscloud server or schedule a
future ping. It also provides a management command to run periodically
in order to ping the rsscloud server if necessary. I’ve only
implemented the REST interface for the blog side.I’m testing it at my website:http://www.matagus.com.ar/You can check the RSS feed there.Any feedback is welcome.LICENSEdjango-rsscloud is released under New BSD license.
Package: django-rss-feeds
# Django Feeds[![Build Status](https://img.shields.io/github/actions/workflow/status/StuartMacKay/django-feeds/ci.yml?branch=master)](https://github.com/StuartMacKay/django-feeds/actions/workflows/ci.yml?query=branch%3Amaster)
[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)Django RSS is an aggregator for RSS and Atom feeds.## Features## Installation
Package: django-rss-link-view
Installation$[sudo]pipinstalldjango-rss-link-viewviews.pyfromdjango_rss_link_view.viewsimportRssLinkMixinclassMyView(RssLinkMixin,...):defget_atom_title(self):return'atom title'defget_atom_url(self):return'path/to/atom.xml'defget_rss_title(self):return'rss title'defget_rss_url(self):return'path/to/rss.xml'classMyView(RssLinkMixin,...):atom_title='atom title'atom_url='path/to/atom.xml'rss_title='rss title'rss_url='path/to/rss.xml'readme42.com
Package: django-rss-plugin
Simple plugin to show a a rss feed in your django cms site.FeaturesShow specified number of feeds in the page.You can choose to open the feed in current window or new window.Show any rss feed you specified, it can be your external rss url, or your internal rss relative url like ‘/myblog/rss’.The feed list would be cached for specified time long.You can choose the template of your RSS feed or use the defaultUsageInstallation:$ pip install django-rss-pluginAdd rssplugin to your INSTALLED_APPS in Django settings.py file, Like following:INSTALLED_APPS=(
      'rssplugin',
)Run south migrate to install plugin database:$ python manage.py migrate rsspluginIf no south, just run:$ python manage.py syncdbtemplate filterparsed_to_date:{% load rss_tags %}
{{ entry.published_parsed|parsed_to_date|timesince }}see rss.html for usage examples.Notice, both external link like ‘http：//example.com/rss’ and internal link like ‘/blog/rss’ are supported.Using custom templateUseCMS_RSS_PLUGIN_TEMPLATE = “path_to_your_template.html”in settings.py to set a custom template, default is rss/rss.html.Feed timeoutUseCMS_RSS_PLUGIN_FEEDPARSER_TIMEOUT = secondsin settings.py to set a custom socket timeout, default is 60Online ResourcesCode repository.Change History03/04/2015, Version 0.0.9Added socket timeout settings when fetching feed.01/01/2015, Version 0.0.8Added customized template support, thanks to Felix-neko contribution.2/13/2013, Version 0.0.7Fix a template bug.2/12/2013, Version 0.0.6New feature:Can specify both external link and internal path.2/11/2013, Version 0.0.5New features:If no entries found, show “no entries found”.2/8/2013, Version 0.0.4First stable release published to Pypi.
Package: django-rss-xml-parser
## Django rss/xml parser(django_rss_xml)This parse is intended for XML / RSS, which does not conform to the standard:https://tools.ietf.org/html/rfc5005Use https://pypi.python.org/pypi/feedparserfor standard RSS### installpip install django-rss_xml-parseradd to settings```pythonINSTALLED_APPS = [...'django_rss_xml',...]```### usage1) create mappers```pythonafisha = {"elements": "event","items_to": {"id__attr": "event_id", "title": "title", "text": "text"}}yandex = {"elements": "item","items_to": {"title": "title", "description": "text"}}kassir = {"elements": "item"}...```2) create models```pythonfrom django.db import modelsfrom django.utils.translation import ugettext as _from django.utils.timezone import nowclass Tags(models.Model):tag = models.CharField(max_length=50, verbose_name=_("Tag"))class RssModel(models.Model):event_id = models.IntegerField(verbose_name=_("event ID"), null=True)title = models.CharField(max_length=550, verbose_name=_("Title"), null=True)text = models.TextField(verbose_name=_("Description"), null=True)time = models.DateTimeField(verbose_name=_("Time and Date"), default=now, blank=True)tags = models.ForeignKey(Tags, on_delete=models.CASCADE, verbose_name=_('Tags'), null=True, blank=True)```3) add in view```pythonrss_rules = {"uri": 'rss/data/afisha.xml', "rule": afisha}ORrss_rules = {"uri": 'https://news.yandex.ru/auto.rss', "rule": yandex}```example:```pythonfrom django.views.generic import TemplateViewfrom .rss_mapper import kassir, afisha, yandexfrom django_rss_xml.rss_parser import RSSfrom .models import RssModelclass RSSView(TemplateView, RSS):template_name = "rss/rss.html"rss_rules = {"uri": 'rss/data/afisha.xml', "rule": afisha}def get_context_data(self, **kwargs):context = super(RSSView, self).get_context_data(**kwargs)context['rss_obj'] = self.rss_to_object()context['rss_m'] = self.rss_to_model(RssModel)return context```## Running tests```bashpython manage.py test django_rss_xml```
Package: django-rsync
=====Django-Rsync=====django-rsync is a simple deployment script using rsync for django projects.Detailed documentation is in the "docs" directory.Quick start-----------1. Add "django_rsync" to your INSTALLED_APPS setting like this::INSTALLED_APPS = (...'django_rsync',)2. Crate the config files for syncing in the folder you want with this format::upload.ini:[remote]user    = userhost    = host.orgport    = 22dir     = /path/to/folder/[rsync_conf]filter_file = ./reference/to/rsync/filter.txt/reference/to/rsync/filter.txt- media/- *.pyc- projectname/- */migrations3. Run `python manage.py update_remote uload.ini` to upload the changed files.4. If it is any change in *.py files restart the project in server.
Package: django-rsync-storage
=====RSYNC STORAGE=====django storage for distrubute files  via rsyncQuick start-----------1. Add "polls" to your INSTALLED_APPS setting like this::from rsync_storage import RSyncStorage2. In settings file specify ::RSYNC_HOSTS = [{'host': '172.17.0.2', 'media_root': '/opt/media/'}]* make sure thatn you have ssh connection to "host" for user run your django App* make sure you have celery worker started
Package: django-rszio
A Django wrapper forhttps://rsz.ioInstallationInstall via pip:pip install django-rszioUsageAdd toINSTALLED_APPSinsettings.py'rszio',Add the include to urlpatterns inurls.pyurlpatterns = [url(r'^media/',include('rszio.urls')),]Load the template tag into a template{% load rszio %}Use theimagetag.{% image 'path/to/image.jpg' width=100 rotate=10 %}Visit theRSZ.IO Docsfor all of the options.
Convert parameters to kwargs.OptionsPrevalidate if the image exists in the default file storageAdd tosettings.pyRSZIO_CHECK_EXISTS = TrueThe default isFalseCache Control headersIt is highly recommended that if you use this package your site should
be sitting behind a CDN. Not sure what this is, check outhttps://www.cloudflare.com/Add tosettings.pyTo set an expiration timeout use an integer in seconds. For example,
below the image is set to cache for an hour.RSZIO_CACHE_CONTROL = 3600This will outputCache-Controlmax-age=3600in the response header.The advanced optionAny string you pass that doesn’t convert to an int will be set in the
header.RSZIO_CACHE_CONTROL = "no-cache"This will outputCache-Controlno-cachein the response header.CaveatsKISSThe origional image must be accessable via a URL, so RSZ.IO can
access it. I usedjango-storageswith AWS S3 to serve my media.This is tested and used in production with Django 1.10 and 1.11 on
Python 3.5 and 3.6. But this should work on older versions of Django
and Python 2. Open an issue or pull request if not the case.VersioningThe package is following the Major.Minor.BugFix philosophy. So breaking
changes will increase the major number. New features will increase the
minor number.So it is safe to put this line in yourrequirements.txtAll new features, no breaking featuresdjango-rszio>=1.0.0,<2.0Just bugfixesdjango-rszio>=1.0.0,<1.1
Package: django-rt
Django-RTCurrent version:0.3.1 pre-alphaDjango-RT is a framework for implementing real-time APIs in Django web applications. This framework follows the traditional publish/subscribe methodology, using Redis as the pub/sub provider.Django-RT consists of two major components:Application API: This provides the necessary functionality to allow you to easily add a real-time API to your Django application.“Courier” HTTP server: A lightweight, asynchronous server designed solely to deliver real-time messages to web clients.WARNING: Django-RT is currently inpre-alphastages of development, and is not ready for public consumption. Expect major API changes and, potentially, security risks in pre-alpha releases. Use in production at your own risk!UsesWeb chatUser notificationsReal-time charts (server monitoring, stock tickers, etc)FeaturesSimple to integrate with any existing Django projectTrivial client-side JavaScript implementation with SSE (Server-Sent Events); no third-party libraries needed with modern browsers.Asynchronous server design to handle many long-running client connections from a single threadDecoupled server architecture allows for the use of blocking code (database access, cache access, etc) in callbacks, without compromising the operation of the delivery serverDeployable on existing Heroku apps, using uWSGIRequirementsDjango >= 1.7Python >= 3.4 (2.7+ support planned)A Redis server (TODO: minimum Redis version)DeploymentCourier serverThere are currently 2 production servers to choose from:aiohttp/asyncio (recommended): Python >= 3.4gevent WSGI: Python >= 3.4ProtocolsSSE (Server-Sent Events) is the only delivery protocol currently supported.LimitationsOnly one-way delivery is currently supported (server to client). Messages originating from the client should use a conventional AJAX request. This should be sufficient for the majority of applications.Real-time functionality can only be added to Django Class-Based Views (CBVs). Older function-style views are not supported.How it worksTODO
Package: django-rte
A rich-text-tinymce-widget with model field for Django.RequirementsDjango >= 1.3Installationpip install django-rteConfigurationFirst includertein yourINSTALLED_APPS:INSTALLED_APPS = (
    ...
    'rte',
    ...
)Now you can either go with the default base configuration or you can define your
own.  Either way you can always overwrite attributes by passing a config dict to
either the model field or the widget. If you want to set a different base
configuration you just need to place a new config file'rte/tiny.config.js'.Language is automatically detected for you, should you need to explicitly set a
different language you need to do this in the field or widget config dict and
not in the'rte/tine.config.js'file.ExamplesExample model usage:from rte import RTEField

class MyModel(models.Model):
    content = RTEField()Example Widget usage:from rte import TinyWidget

def MyForm(forms.Form):
    content = forms.TextField(widget=TinyWidget(config={'language': 'en'}))
Package: django-rt-logging
django-real-time loggingUseful and simple real-time logging middleware for django projects.https://github.com/Speccy-Rom/django-real-time-loggingHow to use itTo install run:pip install django-rt-loggingAdd the following lines at the end ofsettings.pyfile:INSTALLED_APPS=INSTALLED_APPS+('django-rt-logging',)MIDDLEWARE=(MIDDLEWARE+('django_watch.middleware.LoggingMiddleware',))Open your development console and see the result:""" START /my_project/posts/views.py => news_list: Line number 15 """kwargs:{'posts_id':'3'}request.GET:<QueryDict:{'published_at':['today']}>""" END /my_project/posts/views.py => news_list: Line number 15 """sqlqueriestime:0.13totaltime:4.23
Package: django-rules-light
This is a simple alternative to django-rules. Its core difference is that
it does not rely on models. Instead, it uses a registry which can be
modified at runtime.One of its goals is to enable developers of external apps to make rules,
depend on it, while allowing a project to override rules.Exampleyour_app/rules_light_registry.py:# Everybody can read a blog post (for now!):rules_light.registry['blog.post.read']=True# Require authentication to create a blog post, using a shortcut:rules_light.registry['blog.post.create']=rules_light.is_authenticated# But others shouldn't mess with my posts !defis_staff_or_mine(user,rule,obj):returnuser.is_stafforobj.author==userrules_light.registry['blog.post.update']=is_staff_or_minerules_light.registry['blog.post.delete']=is_staff_or_mineExampleyour_app/views.py:@rules_light.class_decoratorclassPostDetailView(generic.DetailView):model=Post@rules_light.class_decoratorclassPostCreateView(generic.CreateView):model=Post@rules_light.class_decoratorclassPostUpdateView(generic.UpdateView):model=Post@rules_light.class_decoratorclassPostDeleteView(generic.DeleteView):model=PostYou might want to read thetutorialfor
more.What’s the catch ?The catch is that this approach does not offer any feature to get secure
querysets.This means you have to:think about security when making querysets,overrideeventual external app ListViews,RequirementsPython 2.7+ (Python 3 supported)Django 1.8+Quick InstallInstall module:pip installdjango-rules-light,Add tosettings.INSTALLED_APPS:rules_light,Add insettings.MIDDLEWARE_CLASSES(orsettings.MIDDLEWAREfor Django 1.10+):rules_light.middleware.Middleware,You might want to read thetutorial.There is also a lot of documentation, from the core to the tools, including
pointers to debug, log and test your security.ContributingRun tests with thetoxcommand. Documented patches passing all
tests have a better chance to get merged in. Seecommunity guidelinesfor details.ResourcesTo ask questions or just get informed about package updates, you could
subscribe to the mailing list.Mailing list graciously hostedbyGoogleGit graciously hostedbyGitHub,Documentation graciously hostedbyRTFD,Package graciously hostedbyPyPi,Continuous integration graciously hostedbyTravis-ci
Package: django-runcommands
runcommands: execute system commands from urls.Authors: Mathieu Agopian andcontributorsLicence: BSDCompatibility: Django 1.4+, python2.7 and python3.3Project URL:https://github.com/magopian/django-runcommandsDocumentation:http://django-runcommands.rtfd.org/QuickstartInstall the application:pipinstalldjango-runcommandsAnd then add an entry for the runcommand’s view in your URLCONF, for each
command you wish to make accessible:# urls.pyfromruncommands.viewsimportRunCommandViewurlpatterns=patterns('',url(r'^hello-world/$',RunCommandView.as_view(command='echo Hello World')),)Your command output is now available at the url/hello-world/.HackingSetup your environment:git clone https://github.com/magopian/django-runcommands.git
cd django-runcommandsHack and run the tests usingToxto test
on all the supported python and Django versions:make testChangelog0.1 (2013-06-18)first version
Package: django-rundbg
django-rundbg=============Provides a lightweight development runserver on Werkzeug with aweb-based debugger with support for REST APIs.Features---------  Friendly for API debugging, like Django Rest Framework.-  Werkzeug `web-baseddebugger <http://werkzeug.pocoo.org/docs/0.11/debug/#using-the-debugger>`__:warning: Be very careful to keep this away from any production environment~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~Installation and Configuration------------------------------>From PyPI with pip::pip install django-rundbgIn your `developmentsettings <https://code.djangoproject.com/wiki/SplitSettings#Multiplesettingfilesimportingfromeachother>`__file add the following:::from yourproject.settings_general import INSTALLED_APPSINSTALLED_APPS = INSTALLED_APPS + ['django_rundbg',]DEBUG = TrueDEBUG_PROPAGATE_EXCEPTIONS = TrueQuickstart----------After installation and configuration, just run:::python manage.py rundbg --use-linkTo try out, just place an ``assert False`` statement whenever you wantto inspect your code and variables and this will show either at yourcurrent browser window or in the dev console... figure:: https://www.octobot.io/uploads/django-rundbg/chrome-dev-example.png:alt: Chrome Dev Console exampleChrome Dev Console exampleInvoking--------After installation and configuration, just run:::python manage.py rundbgSince it extends on Django's ``runserver`` you can pass on the sameparameters than to ``rundbg``:::python manage.py rundbg --no-reload 0.0.0.0:5678Additionally, it supports one additional parameter useful for debuggingXHR requests:::python manage.py rundbg --use-linkThis will show an very simple error 500 page, with a *link* to theWerkzeug Traceback and web-based interactive debugger that you can openin any browser window. The default behaviour for the Werkzeug debuggeris to serve the debugging page to the request that created theexception.Additionally, it supports the following parameters from``runserver_plus``: - ``--reloader-interval 2`` After how many secondsauto-reload should scan for updates in poller-mode. -``--keep-meta-shutdown`` Keep``request.META['werkzeug.server.shutdown']`` function which isautomatically removed because Django debug pages tries to call thefunction and unintentionally shuts down the Werkzeug server.*Werkzeug security PIN is disabled*.Credits-------This project is strongly based upon the work of others: - The `DjangoExtensions <https://github.com/django-extensions/django-extensions>`__``runserver_plus`` is a more comprehensive command than this one. - The`Werkzeug <http://werkzeug.pocoo.org/>`__ server. - `Anothertake <https://github.com/philippbosch/django-werkzeug-debugger-runserver>`__on the same challenge.Authors--------  Juan SaavedraWith :heart: from `Octobot <https://www.octobot.io>`__
Package: django-rundevserver
django-rundevserverA simpleDjangoaddon to provide a new management command which runs a
development server with custom host/port set in the applicationssettings.pyfile. You can also set the DEBUG variable here, allowing the default setting to
be False for production.InstallationInstall the addon using pip:pipinstalldjango-rundevserverOR, if you have forked this repository to your local machine, you can build the
package using the following steps:pipinstall-rrequirements.txt
pythonsetup.pysdist
pipinstalldist/django-rundevserver-0.3.tar.gzThis implies your Python and Pip commands are as above, substitute your own
versions if different.UsageAdd this app to your Django settings.py INSTALLED_APPS like any other:INSTALLED_APPS=[...'rundevserver',]Now, just userundevserverinstead ofrunserver:pythonmanage.pyrundevserverBy default, this will function exactly as the standardrunserverexcept itautomatically enables the DEBUG setting.In this way, you can leaveDEBUG=Falsein your mainsettings.pyfile so it is correct for production,
but during development or debugging it will be set to True.Configuration variables are set in the projectsettings.pyand current accepted
values are as below. If all of these are unspecified,rundevserverwill function
exactly asrunserver(except for the aforementioned DEBUG setting!):# Chose which port to listen to, defaults to 8000 if unspecifiedRDS_PORT=8001# Listen on all interfaces (ie 0.0.0.0) if true. Otherwise (or if unspecified),# it will use the standard 127.0.0.1.RDS_ALL_INTERFACES=True# Force DEBUG mode if True OR unspecified. If you dont want DEBUG set in# development for some reason, specifiy False hereRDS_DEBUG=TrueRDS_ALL_INTERFACESis very useful if you are developing on a remote machine
where the default runserver localhost would not let you connect.TodoAdd documentationAdd Tests
Package: django_rundirect
This is simple Django command to run a custom Python script(or a single
line of Python code) with Django settings loaded and environment setup.
So you need not put any Django settings related code in your script.To install this packagepip install django_rundirectTo integrate this package into a django project, add‘django_rundirect’to Django’s INSTALLED_APPS.Then you can run a python script as:python manage.py rundirect SCRIPT.pyYou may pass args and options to the custom script, for example:python manage.py rundirect SCRIPT.py some_arg --some_option=somevalueYou may run a single line of Python code, for example(like running
python -c):python manage.py runline "from django.contrib.auth.models import User;print User.objects.count()"Note that the sys.path will include the path of manage.py(or where you
run the python executable).
Package: django_runprocess
django_runprocessThis app allows you to run external applications along with therunservercommand. This is useful for example to run automatic compilation of your
sass/less files without having to manually runsass--watch.Installationpip install django_runprocessConfigurationAdd it to yourINSTALLED_APPS:INSTALLED_APPS = (
    ...
    'runprocess'
)Add the commands you want to be executed in theRUNPROCESS_PROCESSESsetting.  For example, to automatically runsass--watchalong withrunserver, use the following:SASS_DIR = os.path.join(STATIC_ROOT, 'sass')
CSS_DIR = os.path.join(STATIC_ROOT, 'css')

RUNPROCESS_PROCESSES = (
    ('sass', '--watch', '%s:%s' % (SASS_DIR, CSS_DIR)),
)