Saravanan666/pypi-org huggingface dataset:
Package: django-debug-informer
django-debug-informerThe Django Debug Informer is a simple application that helps you to display various debug information about the Django project.Installation$ pip install django-debug-informerAnd adddebug_informerto yourINSTALLED_APPSsetting:INSTALLED_APPS = [
    # ...
    'debug_informer',
]AddDebugInformerHeadersMiddlewareto yourMIDDLEWARESsetting:MIDDLEWARES = [
    # ...
    'debug_informer.middleware.DebugInformerHeadersMiddleware',
]Include the application urls into your project root urlconf:urlpatterns = [
    # ...
    path('djdi/', include('debug_informer.urls', namespace='djdi')),
]Enjoy!UsageTo get Python version:$ http :8000/djdi/versions/python/
HTTP/1.1 200 OK
Content-Length: 132
Content-Type: application/json
Date: Sun, 29 Apr 2018 16:53:05 GMT
Server: WSGIServer/0.2 CPython/3.6.5
X-DI-Backend-Host: bat-book.local
X-DI-Backend-Pid: 60817
X-DI-Backend-Start-At: 2018-04-29T16:52:56.380979+00:00
X-Frame-Options: SAMEORIGIN

{
    "name": "Python",
    "version": "3.6.5 (default, Mar 30 2018, 06:41:53) \n[GCC 4.2.1 Compatible Apple LLVM 9.0.0 (clang-900.0.39.2)]"
}To get list of installed packages:➔ http :8000/djdi/versions/packages/
HTTP/1.1 200 OK
Content-Length: 284
Content-Type: application/json
Date: Sun, 29 Apr 2018 16:54:52 GMT
Server: WSGIServer/0.2 CPython/3.6.5
X-DI-Backend-Host: bat-book.local
X-DI-Backend-Pid: 60817
X-DI-Backend-Start-At: 2018-04-29T16:52:56.380979+00:00
X-Frame-Options: SAMEORIGIN

{
    "list": [
        {
            "name": "wheel",
            "version": "0.31.0"
        },
        {
            "name": "setuptools",
            "version": "39.1.0"
        },
        {
            "name": "pytz",
            "version": "2018.4"
        },
        {
            "name": "pip",
            "version": "10.0.1"
        },
        {
            "name": "Django",
            "version": "2.0.4"
        },
        {
            "name": "django-debug-informer",
            "version": "0.3.1.dev0"
        }
    ],
    "total": 6
}To get specified package:$ http :8000/djdi/versions/packages/Django/
HTTP/1.1 200 OK
Content-Length: 38
Content-Type: application/json
Date: Sun, 29 Apr 2018 16:56:26 GMT
Server: WSGIServer/0.2 CPython/3.6.5
X-DI-Backend-Host: bat-book.local
X-DI-Backend-Pid: 60817
X-DI-Backend-Start-At: 2018-04-29T16:52:56.380979+00:00
X-Frame-Options: SAMEORIGIN

{
    "name": "Django",
    "version": "2.0.4"
}Testing and lintingFor testing and linting installtox:$ pip install tox...and run:$ toxLicensedjango-debug-informeris licensed under the MIT license. See the license file for details.
Package: django-debug-logging
Django Debug Logging is a “plugin” for theDjango Debug Toolbarthat allows
users to log the debug toolbar statistics to the database during a site crawl.
This allows users to create performance testing plans to exercise the site, and
then review and aggregate the results afterwards to identify performance
problems.It also provides a basic UI for browsing the details that have been logged to
the database and reviewing aggregated information about test runs.  The UI
borrows a lot from the custom Sphinx theme by the Read the Docs team, and the
Sentry project from Disqus.The overall goal is to use this tool to monitor performance statistics over
time, so that you can see trends and spikes in the number of queries, cache
misses, cpu time, etc., and identify where in the app the problems are coming
from. It is not intended as a load testing tool, so features like concurrency
and warmup periods will not be part of the initial focus.ScreenshotsThe main Debug Logging frontend view:A test run:A log record:To DoWe welcome contributions!  Here are some of our main priorities for continued
development:Add a –repeat option to the log_urls command so that the urls can be run
through multiple times.Write more complex performance tests that use TestCase classes and log each
request from the Django test client.Graph the aggregated stats of the runs.Take more inspiration from Sentry and group hits on the same urls within the
same run together, showing aggregated and individual stats.
Package: 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.InstallationInstall and configureDjango Debug ToolbarInstall Django Debug Panel:pipinstalldjango-debug-panelAdddebug_panelto yourINSTALLED_APPSsetting:INSTALLED_APPS=(# ...'debug_panel',)Replace the Django Debug Toolbar middleware with the Django Debug Panel one. Replace:MIDDLEWARE_CLASSES=(...'debug_toolbar.middleware.DebugToolbarMiddleware',...)with:MIDDLEWARE_CLASSES=(...'debug_panel.middleware.DebugPanelMiddleware',...)(Optional) Configure your cache.
All the debug data of a request are stored into the cache backenddebug-panelif available. Otherwise, thedefaultbackend is used, and finally if no caches are
defined it will fallback to a local memory cache.
You might want to configure thedebug-panelcache in yoursettings:CACHES={'default':{'BACKEND':'django.core.cache.backends.memcached.MemcachedCache','LOCATION':'127.0.0.1:11211',},# this cache backend will be used by django-debug-panel'debug-panel':{'BACKEND':'django.core.cache.backends.filebased.FileBasedCache','LOCATION':'/var/tmp/debug-panel-cache','OPTIONS':{'MAX_ENTRIES':200}}}Install the Chrome extensionDjango Debug Panel
Package: django-debug-permissions
# Django Debug Permissions
Get a list of all user permissions available in the systemThis app adds a single manage.py command that lists all user permissions available in the system.## Supported versions
Haven’t tested it with earlier version, but the app works for sure with:Django: 1.11Python: 3.4+## InstallationInstall using PIP:pip install django-debug-permissionsAdddebug_permissionsto INSTALLED_APPS:INSTALLED_APPS += [‘debug_permissions’]## Usage
Runpython manage.py get_all_permissionsand you should get a list of all permissions similar to:` account.add_emailaddress account.add_emailconfirmation account.change_emailaddress account.change_emailconfirmation account.delete_emailaddress account.delete_emailconfirmation auth.add_group auth.add_permission auth.change_group auth.change_permission auth.delete_group auth.delete_permission ... sessions.add_session sessions.change_session sessions.delete_session sites.add_site sites.change_site sites.delete_site users.add_user users.change_user users.delete_user `## Contributors
Tim Kamanin (tim@timonweb.com,http://timonweb.com)## Cross-promotion:
Checkout these modules if you:
* are tired of locating manage.py and typingpython manage.pyeverytime - Django-manage.py-anywhere (https://github.com/timonweb/Django-manage.py-anywhere) will be your saviour;
* want to download database and media dumps via Django admin - Django Database Backup UI (https://github.com/timonweb/django-dbbackup-ui) will help you;
Package: django-debug-queries
This package provides a simple context manager for Django applications
that will output the SQL queries caused by a block of code to standard
output.(To pre-empt a common question: Django Debug Toolbar lets you see the
queries caused by HTTP requests to your application, but often I want to
track down the queries that are used in a management command or some
other context than making requests in your browser; theshow_queriescontext manager in this package helps in those other situations.)WarningPlease be aware that DEBUG will be set to True
throughout the block (and restored to its previous
value afterwards), so this shouldn’t be used in
production, for example.If you have sqlparse installed, then the SQL will be pretty-printed to
make them easier to read, so I’d recommend that you also do:pip install sqlparseExamplefrom django_debug_queries import show_queries

...

    with show_queries():
        people = list(Person.objects.filter(date_of_birth__gt="2000-01-01") \
            .values('id', 'legal_name'))
        sessions = list(ParliamentarySession.objects.all())This might output the following to standard output:--===--
Number of queries: 2
  Query 0 (taking 0.003):
    SELECT "core_person"."id",
           "core_person"."legal_name"
    FROM "core_person"
    WHERE "core_person"."date_of_birth" > '2000-01-01'
    ORDER BY "core_person"."sort_name" ASC
  Query 1 (taking 0.005):
    SELECT "core_parliamentarysession"."id",
           "core_parliamentarysession"."created",
           "core_parliamentarysession"."updated",
           "core_parliamentarysession"."start_date",
           "core_parliamentarysession"."end_date",
           "core_parliamentarysession"."house_id",
           "core_parliamentarysession"."position_title_id",
           "core_parliamentarysession"."mapit_generation",
           "core_parliamentarysession"."name",
           "core_parliamentarysession"."slug"
    FROM "core_parliamentarysession"
    ORDER BY "core_parliamentarysession"."start_date" ASC
End of query output.Other optionsLong query strings can take a long time to pretty-print using sqlparse,
so by default SQL that is longer that 2048 characters is not formatted;
you can adjust that limit with the optionalsqlparse_character_limitparameter, e.g.:with show_queries(sqlparse_character_limit=8192):
    ...If you are using multiple databases in your Django application, you can
tell this to use a particular database with the optionaldb_aliasparameter, e.g.with show_queries(db_alias='my_other_db'):
    ...
Package: 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 4.1.0. It works on
Django ≥ 3.2.4.The Debug Toolbar does not currently supportDjango’s asynchronous views.Documentation, including installation and configuration instructions, is
available athttps://django-debug-toolbar.readthedocs.io/.The Django Debug Toolbar is released under the BSD license, like Django
itself. If you like it, please consider contributing!The Django Debug Toolbar was originally created by Rob Hudson <rob@cogit8.org>
in August 2008 and was further developed by manycontributors.
Package: django-debug-toolbar-alchemy
Django Debug Toolbar panel for SQLAlchemy.Free software: MIT licenseGitHub:https://github.com/miki725/django-debug-toolbar-alchemyOverviewThis package completely mimics default Django Debug Toolbar SQL panel
(internally its actually subclassed) but instead of displaying queries done
via Django ORM, SQLAlchemy generated queries are displayed.
Rest of the functionality is the same.InstallingFirst install:$ pip install django-debug-toolbar-alchemyThen in your settings:# settings.py
DEBUG_TOOLBAR_PANELS = [
    # other panels
    'debug_toolbar_alchemy.panels.sql.SQLPanel',
    # other panels
]In order to support multiple DB databases, alias getter callable
must be specified in settings:# settings.py
DEBUG_TOOLBAR_CONFIG = {
    'ALCHEMY_DB_ALIASES': '<dot patht to alias getter>',
}Alias getter must return a dictionary of aliases as keys and
SQLAlchemy engines as values.
If your application uses global session,
you can get the engine from session instances:from myapp.db import session, session_slave

def alchemy_dbs():
    return {
        'default': session.bind,
        'slave': session_slave.bind,
    }History0.1.5 (2018-09-04)Fixed whenmultiparamsare name synonyms inUPDATEstatements.Added support forsimilarqueries added in debug toolbar baseSQLPanel.0.1.4 (2018-09-04)Added template to be included indistpackage.0.1.3 (2018-09-03)Added a way to runSELECTandEXPLAINto queries in debug toolbar.
Tested insqlite,postgresqlandoracle.0.1.2 (2018-08-30)Fix bug by attaching SQLAlchemy events at most once.
Otherwise in some cases when multiple threads are used,
event handlersdequewould be mutated while
other SQLAlchemy events are running since
event handling is not thread-safe in SQA.0.1.1 (2018-07-13)Fix bug which did not correctly track plain string clauses.0.1.0 (2017-10-04)First release on PyPI.CreditsDevelopment LeadMiroslav Shubernetskiy -https://github.com/miki725ContributorsNone yet. Why not be the first?LicenseThe MIT License (MIT)

Copyright (c) 2017, Miroslav Shubernetskiy

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
Package: django-debug-toolbar-autoreload
django-debug-toolbar-autoreloadTHIS MODULE IS NO LONGER MAINTAINEDI decided to stop the development on this project since there are now more
mature solutions to the same problem. I personally prefer to usegulpto
observe files for changes and to start a livereload server that can be used
with your browser’s livereload plugin.Here is an examplegulpfile.jsthat does nearly the same as the
autoreload feature of this package:var gulp = require('gulp'),
    livereload = require('gulp-livereload'),
    watch = require('gulp-watch');

var watchPaths = [
    'templates/**.html',
    'static/**.js',
    'static/**.css',
];

gulp.task('watch', function() {
    gulp.src(watchPaths)
        .pipe(watch())
        .pipe(livereload());
});If you still have interest in this project and want to maintain it, just
drop me a message and we can discuss the details.This package contains an extra panel for the excellentdjango-debug-toolbar.The purpose is to automatically reload the page if a template that was used to
render the current page is changed. It is for your browser what therunserver’s auto-reload feature is for your python code.Watch this screencast for a short introduction:http://www.youtube.com/watch?v=zQSoJF70if4InstallPut thedebug_toolbar_autoreloadsource folder in yourPYTHONPATH.Add'debug_toolbar_autoreload'to yourINSTALLED_APPSsettings.Add'debug_toolbar_autoreload.AutoreloadPanel'to yourDEBUG_TOOLBAR_PANELS.This means your settings file should look something like:INSTALLED_APPS = (
    # ... other apps ...
    'debug_toolbar',
    'debug_toolbar_autoreload',
)

DEBUG_TOOLBAR_PANELS = (
    # default panels
    'debug_toolbar.panels.version.VersionDebugPanel',
    'debug_toolbar.panels.timer.TimerDebugPanel',
    'debug_toolbar.panels.settings_vars.SettingsVarsDebugPanel',
    'debug_toolbar.panels.headers.HeaderDebugPanel',
    'debug_toolbar.panels.profiling.ProfilingDebugPanel',
    'debug_toolbar.panels.request_vars.RequestVarsDebugPanel',
    'debug_toolbar.panels.sql.SQLDebugPanel',
    'debug_toolbar.panels.template.TemplateDebugPanel',
    'debug_toolbar.panels.cache.CacheDebugPanel',
    'debug_toolbar.panels.signals.SignalDebugPanel',
    'debug_toolbar.panels.logger.LoggingPanel',

    # autoreload panel
    'debug_toolbar_autoreload.AutoreloadPanel',
)Requirements:Django 1.4 or higher is required since we need a
multithreaded development server.ContributeDownload and setup the project:git clone https://github.com/gregmuellegger/django-debug-toolbar-autoreload.git
cd django-debug-toolbar-autoreload
virtualenv .
source bin/activate
pip install -r requirements/development.txt
python manage.py syncdb
python manage.py runserverOpen one of the demo pages fromhttp://localhost:8000/in your browser.HackSend a pull requestChangelog0.2.0Don’t reload the whole page if only a css file was changed. Instead load CSS
in place.Adding CHANGES.rst to MANIFEST.in which caused errors during install.0.1.1Try to detect if development server wants to shutdown. Before this change
was the server still running in the background and didn’t allow you to
restart it again.0.1.0Initial release.
Package: django-debug-toolbar-django-info
Django-Info is a panel forDjango Debug Toolbarto display these informations:UrlPatternsInfo:List all urls: “module / function name”, “url name”, “url / regex”DatabaseInfo:backend informationapp/model infoexisting database table namesMost source code parts are from:PyLucid ‘show internals’ plugin.screenshotsUrlPatternsInfo:DatabaseInfo:Template Tags/Filters Information:installInstall via pip, e.g.:$ pip install django-debug-toolbar-django-infoAdd to yoursettings.py, e.g.:# http://django-debug-toolbar.readthedocs.org/en/latest/configuration.html#debug-toolbar-panels
DEBUG_TOOLBAR_PANELS = [
    ...
    'django_info_panel.panels.database.DatabaseInfo',
    'django_info_panel.panels.urlpatterns.UrlPatternsInfo',
    'django_info_panel.panels.template.TemplateInfo',
]

INSTALLED_APPS = [
    ...
    'django_info_panel'
]compatibilityTested in these combination:django-infodjango-debug-toolbarDjangov0.3.0v1.4v1.8v0.1.0-v0.2.0v1.2.2v1.7.4changelog08.07.2016 - v0.3.0:Update for Django 1.810.02.2015 - v0.2.0:Add “Template Tags/Filters Information” with a list of all registered template tags/filtersv0.1.0 - 02.02.2015:First releasedonationFlattr this!SendBitcoinsto1823RZ5Md1Q2X5aSXRC5LRPcYdveCiVX6FlinksForumhttp://forum.pylucid.org/IRC#pylucid on freenode.netGithubhttps://github.com/jedie/django-debug-toolbar-django-infoPyPihttp://www.python.org/pypi/django-debug-toolbar-django-info
Package: django-debug-toolbar-extra
ContentsDjango Debug Toolbar ExtraRequerimentsInstallationDevelopment0.0.2 (2012-08-09)0.0.1 (2011-08-23)Django Debug Toolbar ExtraRequerimentsDjango Debug ToolbarInstallationAfter install Django Debug Toolbar add in your settings:DEBUG_TOOLBAR_PANELS = (
    ...

    'debug_toolbar_extra.panels.PrintTemplateNamePanel',

    ...
)DevelopmentYou can get the last bleeding edge version of django debug toolbar extra by doing a checkout
of its subversion repository:svn cohttp://svnpub.yaco.es/djangoapps/debug_toolbar_extra/trunk/0.0.2 (2012-08-09)Works in Django 1.4Documentation0.0.1 (2011-08-23)Initial version
Package: django-debug-toolbar-force
Showdjango-debug-toolbarin non- or partial-HTML views.PrerequisitesPython 3.7, 3.8, 3.9, 3.10 and 3.11.Django 2.2, 3.0, 3.1, 3.2, 4.0 and 4.1.django-debug-toolbar 1.5 (may work on earlier versions as well, although
not guaranteed).DocumentationDocumentation is available onRead the Docs.InstallationInstall latest stable version from PyPI:pipinstalldjango-debug-toolbar-forceor latest stable version from GitHub:pipinstallhttps://github.com/barseghyanartur/django-debug-toolbar-force/archive/stable.tar.gzAdddebug_toolbar_force.middleware.ForceDebugToolbarMiddlewaretoMIDDLEWARE(orMIDDLEWARE_CLASSESfor older versions of Django)
of the your projects’ Django settings (you would
typically do that in your dev settings only).MIDDLEWARE+=('debug_toolbar.middleware.DebugToolbarMiddleware','debug_toolbar_force.middleware.ForceDebugToolbarMiddleware',)UsageIn your browser, visit a non-HTML view and append?debug-toolbarat the
end.GET http://localhost:8000/foo/json-view/?debug-toolbarTestingSimply type:pytest-vvvor use tox:toxor use tox to check specific env:tox-epy310LicenseGPL-2.0-only OR LGPL-2.1-or-laterSupportFor any security issues contact me at the e-mail given in theAuthorsection.For overall issues, go toGitHub.AuthorArtur Barseghyan <artur.barseghyan@gmail.com>
Package: django-debug-toolbar-http-client
# debug-toolbar-http-clientA django debug toolbar panel which records http requests made by app. It's simple base on [vcrpy](https://github.com/kevin1024/vcrpy) which will decompress “gzip” and “deflate” response bodies before recording![alt tag](https://github.com/hoffer2github/debug-toolbar-http-client/blob/master/sample.png)##Usage###. Install and configure [Django Debug Toolbar](https://github.com/django-debug-toolbar/django-debug-toolbar)###. Install Django Debug Toolbar HTTP Client Panel:```pip install django-debug-toolbar-http-client```###. Add ``http_client_panel`` to your ``INSTALLED_APPS`` setting:```INSTALLED_APPS = (# ...'http_client_panel',)```###. Add HTTP Client Panel to Django Debug Toolbar middleware:```MIDDLEWARE_CLASSES = (...'http_client_panel.panels.HttpClient.HttpClientPanel',...)```
Package: django-debug-toolbar-line-profiler
TheDjango Debug Toolbaris 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.This package provides a panel that incorporates output fromline_profilerThe stock line_profiler is only compatible with the 2.x branch of python
but a patched version for Python 3 can be installed with:pip install cython
pip install -e hg+https://bitbucket.org/kmike/line_profiler@7999f21#egg=line_profiler(cf.http://stackoverflow.com/questions/6273139/profiling-by-line-with-python-3)This panel will only function with django_debug_toolbar>=1.0, before that it’s functionality
was contained in the debug_toolbar.panels.profiling.ProfilingPanel.This Django Debug Toolbar panel is released under the BSD license, like Django
and the Django Debug Toolbar. If you like it, please consider contributing!The Django Debug Toolbar was originally created by Rob Hudson
in August 2008 and was further developed by many contributors.InstallationTo install the line_profiler panel, first install this package withpip installdjango-debug-toolbar-line-profiler, then add debug_toolbar_line_profiler to the INSTALLED_APPS:INSTALLED_APPS = (
    ...
    'debug_toolbar_line_profiler',
)and add the panel to DEBUG_TOOLBAR_PANELS:DEBUG_TOOLBAR_PANELS = (
    ...
    'debug_toolbar_line_profiler.panel.ProfilingPanel',
)ConfigurationBy default, the panel will profile your view function. If you use class based views
the panel will profile all functions on the class that don’t start with _. If you
want additional code to be profiled, add the @profile_additional decorator like so:from debug_toolbar_line_profiler import profile_additional
from boto.s3.connection import S3Connection

...

@profile_additional(S3Connection.make_request)
def your_view_code(*args, **kwargs):
    ...SignalsThere is also a signal (debug_toolbar_line_profiler.signals.profiler_setup) that
you can attach to for integrating class based views like django rest framework.Here is an example:from rest_framework.viewsets import ViewSet
from rest_framework.response import Response
from debug_toolbar_line_profiler import signals


class AViewSet(ViewSet):
    def list(self, request):
        return Response([])

    def retrieve(self, request, pk=None):
        return Response({})


def register_profile_views(sender, profiler, **kwargs):
    profiler.add_function(AViewSet.list)
    profiler.add_function(AViewSet.retrieve)


signals.profiler_setup.connect(register_profile_views,
                               dispatch_uid='register_profile_views')