Modern responsive template for the Django admin interface with improved functionality. We are proud to announce completely new Jet. Please check out Live Demo
Django JET
Modern template for Django admin interface with improved functionality
Attention! NEW JET
We are proud to announce completely new Jet. Please check out Live Demo.
Developing of new features for Django Jet will be frozen, only critical bugs will be fixed.
Django JET has two kinds of licenses: open-source (AGPLv3) and commercial. Please note that using AGPLv3
code in your programs make them AGPL compatible too. So if you don't want to comply with that we can provide you a commercial
license (visit Home page). The commercial license is designed for using Django JET in commercial products
and applications without the provisions of the AGPLv3.
A Django app that creates automatic web UIs for Python scripts.
Wooey is a simple web interface to run command line Python scripts. Think of it as an easy way to get your scripts up on the web for routine data analysis, file processing, or anything else.
Wooey was envisioned as a system to allow data analysts to be able to easily:
1. Autodocument workflows for data analysis
(simple model saving).
2. Enable fellow co-workers with no command line
experience to utilize python scripts.
3. Enable the easy wrapping of any program in simple
python instead of having to use language specific
to existing tools such as Galaxy.
For installation and other instructions, check out our documentation or give Wooey a test drive at our demo-server!
Set of widgets to build dashboards for Django projects
Welcome to django-controlcenter!
Get all your project models on one single page with charts and whistles.
Attention!
Unfortunately, I have no time to add new features.
Please make PR if you need one:
branch from master
provide tests
add docs
update changelog
That's it.
Rationale
Django-admin is a great tool to control your project activity: new orders, comments, replies, users, feedback -- everything is here. The only struggle is to switch between all those pages constantly just to check them out for new entries.
With django-controlcenter you can have all of your models on one single page and build beautiful charts with Chartist.js. Actually they don't even have to be a django models, get your data from wherever you want: RDBMS, NOSQL, text file or even from an external web-page, it doesn't matter.
Quickstart
Install django-controlcenter:
pip install -U django-controlcenter
Create a dashboard file with unlimited number of widgets…
Integrated set of Django applications addressing authentication, registration, account management as well as 3rd party (social) account authentication.
Welcome to django-allauth!
Integrated set of Django applications addressing authentication
registration, account management as well as 3rd party (social) account
authentication.
Most existing Django apps that address the problem of social
authentication unfortunately focus only on one dimension - the social.
Most developers end up integrating another app in order to support authentication
flows that are locally generated.
This approach creates a development gap between local and social
authentication flows. It has remained an issue in spite of numerous common
scenarios that both require. For example, an email address passed along by an
OpenID provider may not be verified. Therefore, prior to hooking up
an OpenID account to a local account the email address must be
verified. This essentially is one of many use cases that mandate email
verification…
Your Django app exposes a web API you want to protect with OAuth2 authentication,
You need to implement an OAuth2 authorization server to provide tokens management for your infrastructure,
Django OAuth Toolkit can help you providing out of the box all the endpoints, data and logic needed to add OAuth2
capabilities to your Django projects. Django OAuth Toolkit makes extensive use of the excellent
OAuthLib, so that everything is
rfc-compliant.
Reporting security issues
Please report any security issues to the JazzBand security team at <security@jazzband.co>. Do not file an issue on the tracker.
This app makes it extremely easy to build Django powered SPA's (Single Page App) or Mobile apps exposing all registration and authentication related functionality as CBV's (Class Base View) and REST (JSON)
REST implementation of Django authentication system.
djoser
REST implementation of Django authentication
system. djoser library provides a set of Django Rest Framework
views to handle basic actions such as registration, login, logout, password
reset and account activation. It works with
custom user model.
Instead of reusing Django code (e.g. PasswordResetForm), we reimplemented
few things to fit better into Single Page App
architecture.
authentik is an open-source Identity Provider that emphasizes flexibility and versatility, with support for a wide set of protocols.
Our enterprise offer can also be used as a self-hosted replacement for large-scale deployments of Okta/Auth0, Entra ID, Ping Identity, or other legacy IdPs for employees and B2B2C use.
Installation
For small/test setups it is recommended to use Docker Compose; refer to the documentation.
For bigger setups, there is a Helm Chart here. This is documented here.
Your organization uses authentik? We'd love to add your logo to the readme and our website! Email us @ hello@goauthentik.io or open a GitHub Issue/PR! For more information on how to contribute to authentik, please refer to our CONTRIBUTING.md file.
Complete Two-Factor Authentication for Django providing the easiest integration into most Django projects.
Django Two-Factor Authentication
Complete Two-Factor Authentication for Django. Built on top of the one-time
password framework django-otp and Django's built-in authentication framework
django.contrib.auth for providing the easiest integration into most Django
projects. Inspired by the user experience of Google's Two-Step Authentication
allowing users to authenticate through call, text messages (SMS), by using a
token generator app like Google Authenticator or a YubiKey hardware token
generator (optional).
If you run into problems, please file an issue on GitHub, or contribute to the
project by forking the repository and sending some pull requests. The package
is translated into English, Dutch and other languages. Please contribute your
own language using Transifex.
Test drive this app through the example app. It demos most features except
the Twilio integration. The example also includes django-user-sessions for
providing Django sessions with a foreign key to the user. Although the package
is optional, it improves account…
Drop-in API endpoints for handling authentication securely in Django Rest Framework. Works especially well
with SPAs (e.g., React, Vue, Angular), and Mobile applications.
Requirements
Django 3, 4 and 5 (See Unit Test Coverage in CI)
Python >= 3.8
Quick Setup
Install package
pip install dj-rest-auth
Add dj_rest_auth app to INSTALLED_APPS in your django settings.py:
Install required modules with pip install -r dj_rest_auth/tests/requirements.pip
To run the tests within a virtualenv, run python runtests.py from the repository directory
The easiest way to run test coverage is with coverage,
which runs the tests against all supported Django installs. To run the test coverage
within a virtualenv, run coverage…
Simple yet powerful authorization / authentication client library for Python web applications.
Authomatic
Authomatic
is a framework agnostic library
for Python web applications
with a minimalistic but powerful interface
which simplifies authentication of users
by third party providers like Facebook or Twitter
through standards like OAuth and OpenID.
Authomatic was migrated from a private project of Peter Hudec to a community-managed project.
Many thanks to Peter Hudec for all his hard work for creating and maintaining authomatic!
We are now a small team of volunteers, not paid for the work here.
Any help is appreciated!
Features
Loosely coupled.
Tiny but powerful interface.
The python-openid library is the only optional dependency.
Framework agnostic thanks to adapters
Out of the box support for Django, Flask, Pyramid and Webapp2.
Ready to accommodate future authorization/authentication protocols.
A Django content management system focused on flexibility and user experience
Wagtail is an open source content management system built on Django, with a strong community and commercial support. It's focused on user experience, and offers precise control for designers and developers.
🔥 Features
A fast, attractive interface for authors
Complete control over front-end design and structure
Scales to millions of pages and thousands of editors
Fast out of the box, cache-friendly when you need it
Content API for 'headless' sites with decoupled front-end
Runs on a Raspberry Pi or a multi-datacenter cloud platform
StreamField encourages flexible content without compromising structure
Powerful, integrated search, using Elasticsearch or PostgreSQL
The easy-to-use and developer-friendly enterprise CMS powered by Django
django CMS
Open source enterprise content management system based on the Django framework and backed by the non-profit django CMS Association (Sponsor us!).
Contribute to this project and win rewards
Because django CMS is a community-driven project, we welcome everyone to get involved in the project. Become part of a fantastic community and help us make django CMS the best open source CMS in the world.
Attention!
Please use the develop-4 branch as the target for pull requests for on-going development.
Security fixes will be backported to older branches by the core team as appropriate.
Features
hierarchical pages
extensive built-in support for multilingual websites
multi-site support
draft/publish workflows
version control
a sophisticated publishing architecture, that's also usable in your own applications
frontend content editing
a hierarchical content structure for nested plugins
an extensible navigation system that your own applications can hook into
django Filer is a file management application for django that makes
handling of files and images a breeze.
Note
This project is endorsed by the django CMS Association
That means that it is officially accepted by the dCA as being in line with our roadmap vision and development/plugin policy
Join us on Slack.
Contribute to this project and win rewards
Because this is a an open-source project, we welcome everyone to
get involved in the project and
receive a reward for their contribution.
Become part of a fantastic community and help us make django CMS the best CMS in the world.
We'll be delighted to receive your
feedback in the form of issues and pull requests. Before submitting your
pull request, please review our contribution guidelines.
We're grateful to all contributors who have helped create and maintain this package
Contributors are listed at the contributors…
The portal is primarily a django based application, and to set it up we require to have
python environment with django and other project dependencies installed. Though one can
work with the project without an virtual environment, it is recommended to use one so
as to avoid conflicts with other projects.
Make sure that you have Python 3, python-3-devel, gcc, virtualenv, and pip installed.
Clone the repository
$ git clone https://github.com/amfoss/cms.git
$ cd cms
Create a python 3 virtualenv, and activate the environment.
$ virtualenv -p python3 .
$ source bin/activate
Install the project dependencies from requirements.txt
$ pip install -r requirements.txt
You have now successfully set up the project on your environment. If you encounter any problems during installation, you…
Django page CMS is based around a placeholders concept. Placeholder is a special template tag that
you use in your page templates. Every time you add a placeholder in your template such field
dynamically appears in the page admin interface.
Each page can have a different template with different placeholders.
A configurable set of panels that display various debug information about the current request/response.
Django Debug Toolbar
The Django Debug Toolbar is a configurable set of panels that display various
debug information about the current request/response and when clicked, display
more details about the panel's content.
Here's a screenshot of the toolbar in action:
In addition to the built-in panels, a number of third-party panels are
contributed by the community.
The current stable version of the Debug Toolbar is 5.0.0-alpha. It works on
Django ≥ 4.2.0.
django-devserver has some optional dependancies, which we highly recommend installing.
pip install sqlparse -- pretty SQL formatting
pip install werkzeug -- interactive debugger
pip install guppy -- tracks memory usage (required for MemoryUseModule)
pip install line_profiler -- does line-by-line profiling (required for LineProfilerModule)
You will need to include devserver in your INSTALLED_APPS:
INSTALLED_APPS = (
...
'devserver',
)
If you're using django.contrib.staticfiles or any other apps with management
command runserver, make sure to put devserverabove any of them (or below
for Django<1.7). Otherwise …
django-debug-toolbar in WebKit DevTools. Works fine with background Ajax requests and non-HTML responses.
Django Debug Panel
Django Debug Toolbar inside WebKit DevTools. Works fine with background AJAX requests and non-HTML responses
Great for single-page applications and other AJAX intensive web applications.
(Optional) Configure your cache
All the debug data of a request are stored into the cache backend debug-panel
if available. Otherwise, the default backend is used, and finally if no caches are
defined it will fallback to a local memory cache.
You might want to configure the debug-panel cache in your settings:
A django-debug-toolbar panel that displays template rendering times for your Django application
Template-Timings
Template-timings is a panel for Django Debug Toolbar that gives an in-dept breakdown of the time it takes to render your Django templates (including templates included via {% extends %} and {% include %}).
Template-timings supports Django 1.11 and below, Django 2.0 and above do not work at the moment.
Install
Install via pip (pip install django-debug-toolbar-template-timings) then add 'template_timings_panel.panels.TemplateTimings.TemplateTimings' to your DEBUG_TOOLBAR_PANELS setting, and add 'template_timings_panel' to your INSTALLED_APPS:
In my experience this panel adds about 10% overhead. The panel uses the standard SQLPanel that ships with debug-toolbar to handle the SQL timings, so if you disable that the overhead will decrease and you can still see the render times.
Oscar is an e-commerce framework for Django designed for building domain-driven
sites. It is structured such that any part of the core functionality can be
customised to suit the needs of your project. This allows a wide range of
e-commerce requirements to be handled, from large-scale B2C sites to complex B2B
sites rich in domain-specific business logic.
Build the database model out of the product's properties – not vice versa
Most e-commerce systems are shipped with a predefined database model for products. But products can
vary a lot, and it simply is impossible to create a model which fits for all of them. This is
esspecially true for products with a hierarchy of variants. In many popular e-commerce platforms
you either have far too many attributes per product, and/or the really required attributes are
missing.
In django-SHOP implementations, the product models reflect their pysical properties making it
possible to create complete and deep hierarchies of variations, but without having to fiddle with
unneeded properties. It furthermore avoids the need for an
Entity Attribute Value Model, which
is considered a database…
Shuup is International Registered Trademark & Property of Shuup Commerce Inc.,
Business ID: BC1126729,
Business Address: 1500 West Georgia Suite 1300, Vancouver, BC, V6G-2Z6, Canada.
CLA
Contributor License Agreement is required for any contribution to this
project. Agreement is signed as a part of pull request process. See
the CLA.rst file distributed with Shuup.
License
Shuup is published under Open Software License version 3.0 (OSL-3.0).
See the LICENSE file distributed with Shuup.
Some external libraries and contributions bundled with Shuup may be
published under other compatible licenses. For these, please
refer to VENDOR-LICENSES.md file in the source code tree or the licenses
included within each package.
Chat
We have a Gitter chat room for Shuup. Come chat with us!
We're going to take you step-by-step to build a modern, fully open-source, eCommerce web application using Python, Django, Bootstrap, Javascript, and more.
eCommerce
This course will teach you step-by-step to build a eCommerce site from scratch. We'll be using open-source software to create each aspect of a fully functioning eCommerce business.
learn how to build, test and deploy a Django application
Course Introduction
The Django E-commerce Tutorial Series is designed for students who wants to learn the Django Framework by building an e-commerce application. This course is a great way to start learning Python and the Django Framework. We start from a beginners level slowly moving into more advanced topics. I have tried to design this course to be modular so that you could also focus in on particular subjects, tutorials or aspects of Django should…
Have a look at the sandbox site as this is a sample Oscar project
integrated with both PayPal options. See the contributing guide within the
docs for instructions on how to set up the sandbox locally.
The best way to have DRY Django forms. The app provides a tag and filter that lets you quickly render forms in a div format while providing an enormous amount of capability to configure and control the rendered HTML.
django-crispy-forms
The best way to have Django DRY forms. Build programmatic reusable layouts out of components, having full control of the rendered HTML without writing HTML in templates. All this without breaking the standard way of doing things in Django, so it plays nice with any other form application.
django-crispy-forms supports Django 4.2+ with Python 3.8+.
A filter named |crispy that will render elegant div based forms. Think of it as the built-in methods: as_table, as_ul and as_p. You cannot tune up the output, but it is easy to start using it.
A tag named {% crispy %} that will render a form based on your configuration and specific layout setup. This gives you amazing power without much hassle, helping you save tons of time.
Django-crispy-forms supports several frontend frameworks, such as Twitter Bootstrap…
This package allows you to quickly filter or group "chained" models by adding a custom foreign key or many to many field to your models. This will use an AJAX query to load only the applicable chained objects.
Works with Django version 3.2 to 5.0.
Warning: The AJAX endpoint enforces no permissions by default. This means that any model with a chained field will be world readable. If you would like more control over this permission, the django-autocomplete-light package is a great, high-quality package that enables the same functionality with permission checks.
Documentation
For more information on installation and configuration see the documentation at:
Alternatively, you can install download or clone this repo and call pip install -e ..
Add to INSTALLED_APPS in your settings.py:
INSTALLED_APPS= (
# ..."bootstrap4",
# ...
)
In your templates, load the bootstrap4 library and use the bootstrap_* tags. See example below.
Example template
{%loadbootstrap4 %}{# Display a form #}
<formaction="/url/to/submit/"method="post"class="form">
{%csrf_token%}{%bootstrap_formform%}{%buttons%}
<buttontype="submit"class
This repository includes Dockerfile and docker-compose.yml files so you can easily setup and start to experiment with django-bootstrap-modal-forms running inside of a container on your local machine. Any changes you…
A Django reusable app providing the ability for admin users to create
their own forms within the admin interface, drawing from a range of
field widgets such as regular text fields, drop-down lists and file
uploads. Options are also provided for controlling who gets sent email
notifications when a form is submitted. All form entries are made
available in the admin via filterable reporting with CSV/XLS export.
Form builder:
Data reporting:
HTML5 Features
The following HTML5 form features are supported.
placeholder attributes
required attributes
email fields
date fields
datetime fields
number fields
url fields
Installation
The easiest way to install django-forms-builder is directly from PyPi
using pip by running the command below:
$ pip install -U django-forms-builder
Otherwise you can download django-forms-builder and install it directly
from source:
$ python setup.py install
Once installed you can configure your project to use
django-forms-builder with the following…
Django's "formtools" is a set of high-level abstractions for Django forms
Currently for form previews and multi-step forms.
This code used to live in Django proper -- in django.contrib.formtools
-- but was separated into a standalone package in Django 1.8 to keep the
framework's core clean.
A package that allows you to serialize django forms, including fields and widgets into Python
dictionary for easy conversion into JSON and expose over API
Please go through my djangocon US 2012 talk
to understand the problem sphere, motivations, challenges and implementation of Remote Forms
Sample Implementation
If you don't mind digging around a little bit to learn about different the components that might be
necessary for an implementation of django-remote-forms, check out
django Remote Admin django-remote-admin
Mongodbforms supports all the fields that have a simple representation in Django's formfields (IntField, TextField, etc). In addition it also supports ListFields and MapFields.
File fields
Mongodbforms handles file uploads just like the normal Django forms. Uploaded files are stored in GridFS using the mongoengine fields. Because GridFS has no directories and stores files in a flat space an uploaded file whose name already exists gets a unique filename with the form <filename>_<unique_number>.<extension>.
Container fields
For container fields like ListFields and MapFields a very simple widget is used. The widget renders the container content in the appropriate field plus one empty field. This is mainly done to not introduce any Javascript dependencies, the backend code will happily handle any kind of dynamic form, as long…
GeoDjango provides geospatial extensions to the Django web dev framework
Django is a high-level Python Web framework that encourages rapid development
and clean, pragmatic design
All documentation is in the "docs" directory and online at
http://www.djangoproject.com/documentation/. If you're just getting started
here's how we recommend you read the docs
* First, read docs/install.txt for instructions on installing Django.
* Next, work through the tutorials in order (docs/tutorial01.txt,
docs/tutorial02.txt, etc.).
* If you want to set up an actual deployment server, read docs/modpython.txt
for instructions on running Django under mod_python.
* The rest of the documentation is of the reference-manual variety.
Read it -- and the FAQ -- as you run into problems.
Docs are updated rigorously. If you find any problems in the docs, or think they
should be clarified in any way, please take 30 seconds to fill out a ticket
here:
http://code.djangoproject.com/newticket
To get more help:
* Join the #django channel on irc.freenode.net. Lots of helpful people
IP Address Location | IP Lookup | IP Geolocation API
The ipapi Python library provides convenient access to the IP address location service from applications written in the Python language. It makes it easy to harness the potential of the IP geolocation API.
This setting determines which day of the week your calendar begins on if your locale doesn’t already set it. Default is 0, which is Sunday.
OCCURRENCE_CANCEL_REDIRECT
This setting controls the behavior of :func:`Views.get_next_url`. If set, all calendar modifications will redirect here (unless there is a `next` set in the…
-----
About
-----
**django-future** is a Django application for scheduling jobs on specified
times
**django-future** allows you to schedule invocation of callables at a given
time. The job queue is stored in the database and can be managed through the
admin interface. Queued jobs are run by invoking an external django management
command
-----
Usage
-----
You need to have **django-future** installed. A recent version should be
available from PyPI.
To schedule jobs from your code, use the ``schedule_job`` function::
>>> from django_future import schedule_job
>>> import datetime
>>> schedule_job(datetime.datetime(2010, 10, 10),
... 'myproject.myapp.handlers.dosomething')
------------
Running jobs
------------
Scheduled jobs will not start automagically. The job queue must regularly
be processed by invoking the Django management command
``runscheduledjobs``. You will probably want to run this command regularly,
perhaps in a cron job, to ensure that scheduled jobs are run in a timely
manner.
When the job processor is started, it
Make sure you have Django-RQ up and running before you do anything
This app is just a simple admin plugin to manage your scheduled tasks and management commands.
Install the package with pip install django-rq-jobs
Add django_rq_jobs to INSTALLED_APPS in settings.py:
INSTALLED_APPS= (
# other apps"django_rq",
"django_rq_jobs",
)
Add RQ_JOBS_MODULE in settings.py.
A string or a tuple of strings designating all modules where you keep your jobs. Anything marked with the Django RQ's @job decorator
will show up in the admin.
# A singe module:RQ_JOBS_MODULE='myapp.tasks'# or with multiple modules:RQ_JOBS_MODULE= (
'myapp.tasks',
'anotherapp.tasks',
)
Run python manage.py migrate to create the job model.
Open your Django admin and find the RQ Jobs scheduled job section and schedule something.
Generate generic activity streams from the actions on your site. Users can follow any actors' activities for personalized streams.
Django Activity Stream
What is Django Activity Stream?
Django Activity Stream is a way of creating activities generated by the actions on your site.
It is designed for generating and displaying streams of interesting actions and can handle following and unfollowing of different activity sources.
For example, it could be used to emulate the Github dashboard in which a user sees changes to projects they are watching and the actions of users they are following.
Action events are categorized by four main components.
Actor. The object that performed the activity.
Verb. The verb phrase that identifies the action of the activity.
Action Object. (Optional) The object linked to the action itself.
Target. (Optional) The object to which the activity was performed.
Actor, Action Object and Target are GenericForeignKeys to any arbitrary Django object and so can represent any Django model in your project
An action…
An app for creating news feeds (also known as activity streams) for users,
notifying them of activity happening around your site. Optimised for speed,
pluggability and simplicity.
News feed items are stored as a string and a timestamp. You can't store any
additional metadata about the stream items, such as generic foreign keys to and
Actor or a Target. You just store the item content as plain text (or HTML).
If you need links to other objects, just insert an <a> tag.
DEPRECATED
PLEASE NOTE:This repository is no longer actively maintained or regularly used by DabApps and therefore should be considered deprecated. Please find alternative packages for your needs or feel free to create and maintain your own fork.
Create a virtual environment. Activate it. Make sure it is in the same directory as the cloned repo.
# for linux users
python -m venv <env-name>
source venv/bin/activate
Install all requirements.
pip install -r requirements.txt
In settings.py inside Indus, replace email settings with your email address and password to allow email verification. Remember to remove these when committing to github.
EMAIL_HOST_USER = os.environ.get('EMAIL_HOST_USER') # relpace with your email
EMAIL_HOST_PASSWORD = os.environ.get('EMAIL_HOST_PASSWORD') # replace with email password
Inside the project folder, create migrations for the apps users and feeds
A news recommendation system uses RSS news feeds in major Sri Lankan news sources and suggests them to users based on user's interests and the location.
Location-based-news-reccomendation
Our problem is that now a days people getting various news feeds and for them they act like garbage
Because most of them are useless for users. So it is better if we can arrange news feed according to users preference and categorize them
So in arranging it is better to organize based on location or user related feeds. So as a result we decide to create user friendly system without wasting their valuable time and their related areas, locations.
In this project we are trying to get users preferences about their news choices and as a result of hectic life pattern of people we are going to recommend our users what they only wish to watch. Another feature of this is that this is according to location. So technologies we are wishing to use are ML, NLP, Web Crowling etc
when publisher upload some articles into their system…
Translates Django models using a registration approach.
Modeltranslation
The modeltranslation application is used to translate dynamic content of
existing Django models to an arbitrary number of languages without having to
change the original model classes. It uses a registration approach (comparable
to Django's admin app) to be able to add translations to existing or new
projects and is fully integrated into the Django admin backend.
The advantage of a registration approach is the ability to add translations to
models on a per-app basis. You can use the same app in different projects,
may they use translations or not, and you never have to touch the original
model class.
Features
Add translations without changing existing models or views
Translation fields are stored in the same table (no expensive joins)
Supports inherited models (abstract and multi-table inheritance)
Django-ORM-Standalone Template - Use the power of Django's database functionality in regular python scripts.
Django ORM Standalone
Use the database components of Django without having to use the rest of Django (i.e. running a web server)! 🎉 A typical use case for using this template would be if you are writing a python script and you would like the database functionality provided by Django, but have no need for the request/response functionalty of a client/server web application that Django also provides.
With this project template you can write regular python scripts and use Django's excellent ORM functionality with the database backend of your choice. This makes it convienient for Djangonauts to write database driven python applications with the familiar and well polished Django ORM. Enjoy.
⚙️ Requirements
Last tested successfully with Python 3.10.4 and Django 5.0.6
Create venv and pip install django to import the required modules.
Awesome Django authorization, without the database
rules
rules is a tiny but powerful app providing object-level permissions to
Django, without requiring a database. At its core, it is a generic framework
for building rule-based systems, similar to decision trees. It can also be
used as a standalone library in other contexts and frameworks.
Features
rules has got you covered. rules is:
Documented, tested, reliable and easy to use.
Versatile. Decorate callables to build complex graphs of predicates
Predicates can be any type of callable -- simple functions, lambdas,
methods, callable class objects, partial functions, decorated functions,
anything really.
A good Django citizen. Seamless integration with Django views,
templates and the Admin for testing for object-level permissions.
Efficient and smart. No need to mess around with a database to figure
out whether John really wrote that book.
Simple. Dive in the code. You'll need 10 minutes to figure out…
django-role-permissions is a django app for role based permissions. It's built on top of django contrib.auth user Group and Permission functionalities and it does not add any other models to your project.
django-role-permissions supports Django versions from 1.5 until the latest.
This packages uses tox to run tests on multiple evironments, please make sure they are passing before submitting a pull request.
To run tests, install tox and run it in the command line from this project's folder:
Django REST Framework API Key is a library for allowing server-side clients to safely use your API. These clients are typically third-party backends and services (i.e. machines) which do not have a user account but still need to interact with your API in a secure way.
Features
✌️ Simple to use: create, view and revoke API keys via the admin site, or use built-in helpers to create API keys programmatically.
🔒 As secure as possible: API keys are treated with the same level of care as user passwords. They are only visible at creation and hashed before storing in the database.
🎨 Customizable: satisfy specific business requirements by building your own customized API key models, permission classes and admin panels.
Rules based permissions for the Django Rest Framework
dry-rest-permissions
Overview
Rules based permissions for the Django Rest Framework.
This framework is a perfect fit for apps that have many tables and relationships between them. It provides a framework that allows you to define, for each action or groups of actions, what users have permission for based on existing data in your database.
What does DRY Rest Permissions provide?
A framework for defining global and object level permissions per action.
Support for broadly defining permissions by grouping actions into safe and unsafe types.
Support for defining only global (table level) permissions or only object (row level) permissions.
Support for custom list and detail actions.
A serializer field that will return permissions for an object to your client app. This is DRY and works with your existing permission definitions.
A framework for limiting list requests based on permissions
A Django app that provides generic per-object-permissions for Django's auth app and helpers to create custom permission checks.
django-authority
This is a Django app for per-object-permissions that includes a bunch of
helpers to create custom permission checks.
The main website for django-authority is
django-authority.readthedocs.org. You can also install the
in-development version of django-authority with
pip install django-authority==dev or easy_install django-authority==dev.
Example
To get the example project running do:
Bootstrap the environment by running in a virtualenv:
REST framework is a collaboratively funded project. If you use
REST framework commercially we strongly encourage you to invest in its
continued development by signing up for a paid plan.
The initial aim is to provide a single full-time position on REST framework
Every single sign-up makes a significant impact towards making that possible.
RESTful Websocket APIs with Django Rest Framework and Channels
Channels API
Channels API exposes a RESTful Streaming API over WebSockets using
channels. It provides a ResourceBinding which is comparable to Django
Rest Framework's ModelViewSet. It is based on DRF serializer
classes.
It requires Python 2.7 or 3.x, Channels <=1.1.8.1, Django <=1.11, and Django Rest Framework 3.x
The API builds on top of channels' WebsocketBinding class. It works by having
the client send a stream and payload parameters. This allows
us to route messages to different streams (or resources) for a particular
action. So POST /user would have a message that looks like the following
Haystack provides modular search for Django. It features a unified, familiar
API that allows you to plug in different search backends (such as Solr,
Elasticsearch, Whoosh, Xapian, etc.) without having to modify your code.
Haystack is BSD licensed, plays nicely with third-party app without needing to
modify the source and supports advanced features like faceting, More Like This,
highlighting, spatial search and spelling suggestions.
Advanced search language for Django, with auto-completion. Supports logical
operators, parenthesis, table joins, and works with any Django model. Tested on
Python 2.7, 3.6 - 3.12, Django 1.8 - 5.0. The auto-completion feature has been
tested in Chrome, Firefox, Safari, IE9+.
Bug reports, bug fixes, and new features are always welcome. Please raise issues on the
django-watson github repository, and submit
pull requests for any new code.
You can run the test suite yourself from within a virtual environment with the following
commands.
A transparent layer for full-text search using Sphinx and Django
This project is no longer maintained
This is a layer that functions much like the Django ORM does except it works on top of the Sphinx (http://www.sphinxsearch.com) full-text search engine.
Please Note: You will need to create your own sphinx indexes and install sphinx on your server to use this app.
There will no longer be release packages available. Please use SVN to checkout the latest trunk version, as it should always be stable and current.
Installation
To install the latest stable version:
sudo easy_install django-sphinx
To install the latest development version (updated quite often):
git clone git://github.com/dcramer/django-sphinx.git
cd django-sphinx
sudo python setup.py install
Note: You will need to install the sphinxapi.py package into your Python Path or use one of the included versions. To use the included version, you must specify the following in your settings.py file:
Provides a set of tools for managing Search Engine Optimisation (SEO) for Django sites.
================
Django SEO tools
================
This is a set of SEO tools for Django.
It allows you to associate metadata with:
* absolute paths
* model instances
* model classes
* views
Metadata can be edited in the admin in a centralised place, but also alongside any associated models.
This is however a framework, not an app. You therefore have
complete control over the data you store.
Here is an example of a definition::
from rollyourown import seo
class BasicMetadata(seo.Metadata):
title = seo.Tag(max_length=68, head=True)
keywords = seo.KeywordTag()
description = seo.MetaTag(max_length=155)
heading = seo.Tag(name="h1")
subheading = seo.Tag(name="h2")
extra = seo.Raw(head=True)
# Adding some fields for facebook (opengraph)
og_title = seo.MetaTag(name="og:title", populate_from="title", verbose_name="facebook title")
og_description = seo.MetaTag(name="og:description", populate_from="description", verbose_name='facebook description')
As you can see it is very flexible, but there is much more than this simple example.
The full documentation can be read online at http://django-seo.readthedocs.org/.
Simple wrapper around elasticsearch-py to index/search a django Model.
django_elasticsearch is a wrapper around py-elasticsearch that automates the indexation and search of django models. Note: if your elasticsearch documents/mappings are not close to django models, this package is probably not for you.
As stated in the python elasticsearch module documentation:
There are two branches for development - master and 0.4. Master branch is used to track all the changes for Elasticsearch 1.0 and beyond whereas 0.4 tracks Elasticsearch 0.90.
Releases with major version 1 (1.X.Y) are to be used with Elasticsearch 1.* and later, 0.4 releases are meant to work with Elasticsearch 0.90.*.
django_elasticsearch has only been tested with Elasticsearch 1.3.9 and it's corresponding python interface version 1.2.0, but since the API hasn't change i'm quite positive that newer…
Since version 0.5, the HaystackSearchApphook is not registered automatically
anymore. If you want do use the default app hook provided by django-cms-search,
add this (e.g. in models.py):
from cms_search.cms_app import HaystackSearchApphook
apphook_pool.register(HaystackSearchApphook)
If present, it is supposed to be a list/tuple of django apps for Jenkins to run
Tests, reports, and coverage are generated only for the apps from this list.
JENKINS_TASKS
List of Jenkins reporters executed by ./manage.py jenkins command.
Default value:
JENKINS_TASKS = ()
JENKINS_TEST_RUNNER
The name of the class to use for starting the test suite for jenkins command
Class…
django-nose provides all the goodness of nose in your Django tests, like:
Testing just your apps by default, not all the standard ones that happen to
be in INSTALLED_APPS
Running the tests in one or more specific modules (or apps, or classes, or
folders, or just running a specific test)
Obviating the need to import all your tests into tests/__init__.py
This not only saves busy-work but also eliminates the possibility of
accidentally shadowing test classes.
Useful additions to Django's default TestCase from REVSYS
Rationale
Let's face it, writing tests isn't always fun. Part of the reason for
that is all of the boilerplate you end up writing. django-test-plus is
an attempt to cut down on some of that when writing Django tests. We
guarantee it will increase the time before you get carpal tunnel by at
least 3 weeks!
If you would like to get started testing your Django apps or improve how your
team is testing we offer TestStart
to help your team dramatically improve your productivity.
This app aims to provide a simple way of loading masses of randomly generated
test data into your development database. You can use a management command to
load test data through command line.
It is named autofixture because it is based on django's fixtures. Without
autofixture you add test data through the admin to see how the non-static
pages on your site look. You export data by using dumpdata to
send it to your colleagues or to preserve it before you make a manage.py
reset app and so on. As your site grows in complexity the process of adding
and re-adding data becomes more and more annoying.
This is where autofixtures will help!
Requirements
We require and support Django 1.4 to 1.9
Installation
You must make the autofixture package available on your python path
Either drop it into your project directory or install it from the python
package index…
It also requires 'django.contrib.humanize' to be in INSTALLED_APPS.
Usage
The example project is a good place to get started and have a play.
Results are stored in redis and displayed in the Django admin. The key
components of this framework are: the experiments, alternatives and
goals.
Configuration
Before you can start configuring django-experiments, you must ensure
you have a redis server up and…
-green.svg){kind=icon}
