Saravanan666/pypi-org huggingface dataset:
Package: django-erp-framework
Django ERP FrameworkA light-weight, effective, Django based framework to create various business applications, resource planing and management systems.Offers a ready made platform where you can start to create data entry pages and attach various reports to them.FeaturesA Reporting Engine that can generate grouped reports and/or time series and/or crosstab from any model in your apps.Charting capabilities to represent the data in the reports.Widget system to create dashboards and display bits of the reports results and/or its charts on any page you want.Customizable and easily extensible.Django Jazzmin admin theme integration ready to use.Python 3.8 / 3.9 / 3.10 , Django 3.2 +Installation$pipinstalldjango-erp-frameworkOR$pipinstall-egit+https://github.com/RamezIssac/django-erp-framework.git#egg=django-erp-framework@developCheck out thegetting startedon Read The Docs.DemoYou can checkout a demo applicationhere.Code is available onGithub.DocumentationAvailable onRead The DocsPlease Proceed to the tutorialCreate a sales application Part 1Reporting EngineThe reporting engine of this framework is released as a separate packagedjango-slick-reporting.Testing and contributionTo run the test suite, first, create and activate a virtual environment. Then
clone the repo, install the test requirements and run the tests:# 1. Clone and install requirements
$ git clone git+git@github.com:ra-systems/django-erp-framework.git
$ cd tests
$ pip install -e ..
$ pip install -r requirements.txt

# 2. Set the test database connection details in the environment
$ export DATABASE_NAME=<database name>
$ export DATABASE_USER=<database user>
$ export DATABASE_PASSWORD=<database password if any>

# 3. Run the tests
$ ./runtests.py
# And for Coverage report
$ coverage run --include=../* runtests.py [-k]
$ coverage htmlFor more information on contributing, we honorDjango’s guidelines.
Package: django-erroneous
============django-erroneous============View all Django errors from right within the administration console.Erroneous traps Django's in-built exception signal, captures the traceback . which would be the same beautiful exception page that Django displays when debugging is enabled . and saves it to the database so you can view it later.It's quite similar to django-sentry from the folks at Disqus but a more lightweight, no-frills, error-logging system for Django. Credits to David Cramer over at Disqus for the initial django-db-log which is the work this is based upon.If there's a feature that you're missing and you'd like added, please create an issue on the project page at Github or create the fix yourself and send me a pull request. Adding a few small features here and there are okay but this is in no way aimed to encompass all the functionality of a full-blown error-logging stack like Sentry.Features--------* A simple user interface for browsing error records in the database.Installation------------Start with Django 1.3 or higher; erroneous is intended for use with the new loggingconfiguration first available in that version.To install, simply run::pip install django-erroneousConfiguration-------------1. Add ``erroneous`` to your ``INSTALLED_APPS`` setting.2. Run ``manage.py migrate`` to create the database tables, or if you're reallylogging to a second database and have disabled South migrations for erroneous,run ``manage.py syncdb``.There isn't much else than that to get it up and running.Future------* support for logging to other sinks: message queues, non-relational databases.
Package: django-error-pages
Django Error Pages==================Django Error Pages extends Django to allow you to raise and handle any type ofHTTP error, such as 400, and 403.It behaves just like the default Django 404 and 500 error pages, which render404.html and 500.html respectively inside your apps template folder, but displaysome information in DEBUG mode.It will catch all Django error codes and return an error page.It is very flexible, and covers a wide range of error codes:400-418, 422-426,500-505, 507, 509, 510Configurability & Extendibility-------------------------------Django Error Pages is very easy to use!How easy it is to raise a 403 forbidden:```pythonfrom django.shortcuts import render_to_responsefrom error_pages.http import Http403def homepage(request):if user is unauthorized:raise Http403return render_to_response('index.html')```And of course, it'll render a 403.html template for you if DEBUG mode is off.Also, I don't think Django handles some certain error pages, such as 400, 403,(which shows some default error, but isn't overridable). So we now is includedthe ability to render your Django template error pages directly from Apache!It will render just as if Django was rendering a 404 page. Just place thecorresponding 400.html page into the template folder in your app, and add thisrule to your Apache configuration. You can do this with ANY error code you want,just like you can raise any error code you want; why should anyone be restricted? :)```apacheconfErrorDocument 400 /__errorpage__/400```Configuring & Setting up------------------------* Add it to your middleware```pythonMIDDLEWARE_CLASSES = (...'error_pages.middleware.ErrorPageMiddleware',)```* And add the URL configuration to your root URL's```pythonfrom django.conf.urls.defaults import patterns, urlurlpatterns = patterns('',...url(r'^__errorpage__/(?P<code>\d+)$', 'error_pages.views.display_error'),)```Installing----------* Download django-error-pages from https://github.com/Roejames12/django-error-pages/tarball/master* Or `pip install django-error-pages`* `pip install django-error-pages==dev` for the absolute bleeding edge.
Package: django-error-report
django-error-reportView all Django Error detail in Django Admin.Error-report save Django error traceback and details which would be the
same beautiful exception page that Django displays when debugging is
enabled and saves it to the database so you can view it later.It’s simple alternative to django-sentry which is a paid option to see
error detail.You can create issues for feature you want in django-error-report in
future.FeaturesA simple user interface for browsing error records in the database.RequirementsPython 2.7, 3.6Django > 1.7InstallationTo install, simply run:pip install django-error-reportAdderror_reportto yourINSTALLED_APPSsetting.Add below in yoururls.pyfileurl(r'^error/', include('error_report.urls'))Adderror_report.middleware.ExceptionProcessorin your middlewaresRunmanage.py migrateto create the database tables.ConfigurationRequired settings for Django-error-report should be added in settings.py
file like thisERROR_DETAIL_SETTINGS = {
    "CONFIGURATION_OPTION": VALUE
}Available configuration options are below - ERROR_DETAIL_ENABLE:ERROR_DETAIL_ENABLE: Should Log error detail or not (True/False)ERROR_DETAIL_HEIGHT: Height of Iframe in admin (in pixels)
Package: django-error-report-2
django-error-report-2Maintained fork ofdjango-error-report. Original authormhsiddiquiView all Django Error detail in Django Admin.Error-report save Django error traceback and details which would be the
same beautiful exception page that Django displays when debugging is
enabled and saves it to the database so you can view it later.It’s simple alternative to django-sentry which is a paid option to see
error detail.You can create issues for feature you want in django-error-report in
future.FeaturesA simple user interface for browsing error records in the database.RequirementsPython 2.7, 3.6Django > 1.7InstallationTo install, simply run:pip install django-error-reportAdderror_reportto yourINSTALLED_APPSsetting.Add below in yoururls.pyfileurl(r'^error/', include('error_report.urls'))Adderror_report.middleware.ExceptionProcessorin your middlewaresRunmanage.py migrateto create the database tables.ConfigurationRequired settings for Django-error-report should be added in settings.py
file like thisERROR_DETAIL_SETTINGS = {
    "CONFIGURATION_OPTION": VALUE
}Available configuration options are below - ERROR_DETAIL_ENABLE:ERROR_DETAIL_ENABLE: Should Log error detail or not (True/False)ERROR_DETAIL_HEIGHT: Height of Iframe in admin (in pixels)
Package: django-errors
django-errorsGitHubTestCheck Demo ProjectBrowser the demo app on-line onHerokuCheck the demo repo onGitHubRequirementsPython 3.8+ supported.Django 3.2+ supported.SetupInstall frompip:pipinstalldjango-errorsmodifysettings.pyby adding the app toINSTALLED_APPS:INSTALLED_APPS=[# ..."django_errors",# ...]Finally, modify your projecturls.pywith handlers for all errors:# ...other imports...fromdjango_errorsimportviewsaserrors_viewsurlpatterns=[# ...other urls...]handler400=errors_views.custom_400""" Handle 400 error """handler403=errors_views.custom_403""" Handle 403 error """handler404=errors_views.custom_404""" Handle 404 error """handler500=errors_views.custom_500""" Handle 500 error """Run Example Projectgitclone--depth=50--branch=django-errorshttps://github.com/DLRSP/example.gitDLRSP/examplecdDLRSP/example
pythonmanage.pyrunserverNow browser the app @http://127.0.0.1:8000
Package: django-errorstack
A Django reusable application for logging errors to theErrorStackservice.InstallationInstall from PyPI witheasy_installorpip:pip install django-errorstackor get thein-development version:pip install django-errorstack==tipDependenciesdjango-errorstackrequiresDjango1.0 or later.UsageTo usedjango-errorstackin your Django project:Add'errorstack'to yourINSTALLED_APPSsetting.Set theERRORSTACK_STACK_KEYsetting.Adderrorstack.middleware.ErrorStackMiddlewareto the end
of yourMIDDLEWARE_CLASSESsetting.WhenDEBUGis False, all unhandled view exceptions will be logged
to ErrorStack. Error handling will otherwise proceed as it would
otherwise:django-errorstackdoes not disable or modify Django’s
usual error handling.Logging errors manuallyYou may want to log some errors to ErrorStack in your own code,
without raising an unhandled exception or displaying a 500 page to
your user.django-errorstackuses a named logger from the Python standard
libraryloggingmodule. The name of the logger is defined by theERRORSTACK_LOGGER_NAMEsetting (defaults to “errorstack”). Assuming
you don’t change the setting, you could log errors yourself like this:import logging

logger = logging.getLogger("errorstack")

try:
    #... some code that raises an exception
except:
    logger.error("Something bad happpened.", exc_info=True)This logger only sends errors or critical errors (not warnings or info
or debug messages) to ErrorStack.Attaching the ErrorStack handler to your own loggerYour application may already use the stdlibloggingmodule with
your own named loggers. If you want to attach the ErrorStack logger
handler to your own loggers, you can do the following:import logging

from errorstack.handlers import errorstack_handler

logger = logging.getLogger("my_logger")
logger.addHandler(errorstack_handler)Again, this handler only listens for errors or critical errors.SettingsERRORSTACK_STACK_KEYThe key of the error stack you want to send errors to. This option is
required.ERRORSTACK_CATCH_404LogHttp404exceptions to ErrorStack if this isTrue.Falseby default.ERRORSTACK_LOGGER_NAMEThe logger name to use. Defaults to “errorstack”.CHANGEStip (unreleased)0.1 (2009.12.16)Initial release.TODO
Package: django_errortemplates
Simple and generic404.htmland500.htmltemplates for django. The
error messages are styled with the bootstrap hero-unit style.Issues/contributeReport any issues at thegithub project page, and feel free
to add your own guides/experiences to the wiki, and to contribute changes using
pull requests.Install$ pip install django_errortemplatesSetupAdd'errortemplates'and'django.contrib.staticfiles'toINSTALLED_APPS.Try it outStart your server with:python manage.py runserver --insecureand navigate to a non-existing url or an url that raises an exception. Note that we use--insecure
Package: django-error-views
Verbose error views with minimal context and integration with SentryFree software: GNU Affero General Public License v3Documentation:https://django-error-views.readthedocs.io.FeaturesPending :DDemoTo run an example project for this django reusable app, click the button below and start a demo serwer on HerokuQuickstartInstall Django Error Views:pip install django-error-viewsAdd it to yourINSTALLED_APPS:INSTALLED_APPS=(...'django_error_views.apps.DjangoErrorViewsConfig',...)Add Django Error Views’s URL patterns:importdjango_error_views.urlsurlpatterns=[...url(r'^',include(django_error_views.urls)),...]Running TestsDoes the code actually work?$ pipenv install --dev
$ pipenv shell
$ toxWe recommend usingpipenvbut a legacy approach to creating virtualenv and installing requirements should also work.
Please installrequirements/development.txtto setup virtual env for testing and development.CreditsThis package was created withCookiecutterand thewooyek/cookiecutter-django-appproject template.History0.2.4 (2018-03-20)First release on PyPI.
Package: django-esay-account
=====django-esay-account=====django-esay-account is a simple Django app for accounts handle login & SingUp & logout and User Profil towQuick start-----------1. Add "django-esay-account" to your INSTALLED_APPS setting like this::INSTALLED_APPS = [...'crispy_forms','account',]add this line for the crispy_fromsCRISPY_TEMPLATE_PACK = 'bootstrap3'2. Include the account URLconf in your project urls.py like this::url(r'^', include('account.urls')),3. add this 6 lines at the bottom in the settings files to handel the password reset.EMAIL_BACKEND ='django.core.mail.backends.console.EmailBackend'DEFAULT_FROM_EMAIL = 'example@example.com'EMAIL_HOST_USER = ''EMAIL_HOST_PASSWORD = ''EMAIL_USE_TLS = FalseEMAIL_PORT = 1025andMEDIA_URL = '/media/'4. Run `python manage.py migrate` to create the django-esay-account models.5. Start the development server and visit http://127.0.0.1:8000/admin/to create a django-esay-account (you'll need the Admin app enabled).6. Visit http://127.0.0.1:8000/login/ to test the  django-esay-account.
Package: django-esi
django-esiDjango app for easy access to the EVE Swagger Interface (ESI)OverviewDjango-esi is a Django app that provides an interface for easy access to the EVE Swagger Interface (ESI), the official API for the gameEVE Online.It is build uponBravado- a python client library for Swagger 2.0 services.Django-esi adds the following main functionalities to a Django site:Dynamically generated client for interacting with public and private ESI endpointsSupport for adding EVE SSO to authenticate characters and retrieve tokensControl over which ESI endpoint versions are usedHistory of this appThis app is a fork fromadarnauth-esi. Since this app is an important component of theAlliance Authsystem and Adarnof - the original author - was no longer able to maintain it the AA dev team has decided in December 2019 to take over maintenance and further developing for this app within the Alliance Auth project.DocumentationFor all details on how to install and use django-esi please see thedocumentation.
Package: django-eskiz-sms
Djangodan EskizUz yordamida SMS yuborish uchun eng mukammal paketPaketni pip install django-eskiz-sms deb o’rnatib,
asosiy appni settings.py ida INSTALLED_APPS ga eskiz_sms deb qo’shing.Makemigration va migratedan keyin django adminga o’ting.
U yerda EskizSMS degan modelga EskizUZ emailingiz va kabinetdan olgan parolingizni kiriting.So’ngra asosiy urls.py ga eskiz_sms.urls ni include qiling, bu sms browserda forma orqali sms
yuborib sinab ko’rish uchun. Xavfsizlik yuzasidan keyin uni uzib qo’ying.
Bu faqat test uchun. Paketni asli quyidagi yo’l bilan ishlatasiz:Odatiy ishlatish uchun istalgan joyda from eskiz_sms.views import send_sms yoki boshqa
yo’l bilan send_sms() degan metodni chaqirib ishlating. Qolgan ishlarni o’zi bajaradi.
Shuningdek admin panelda SMSLog orqali jo’natilgan SMSlar statistikasini ko’rib tursangiz bo’ladi.Yordam kerak bo’lsa Telegram:https://t.me/a1ie9Ishlatish uchun batafsil qo’llanma:https://docs.tijorat.org/django-eskiz-sms
Package: django-esm
Django ESMNextGen JavaScript ESM module support for Django.Highlightseasy transitionsmart cache bustingno more bundlingnative ESM supportlocal vendoring with npmSetupInstall the package and add it to yourINSTALLED_APPSsetting:pipinstalldjango-esm# settings.pyINSTALLED_APPS=[# …'django_esm',]Next, add a new staticfiles finder to yourSTATICFILES_FINDERSsetting:# settings.pySTATICFILES_FINDERS=[# Django's default finders"django.contrib.staticfiles.finders.FileSystemFinder","django.contrib.staticfiles.finders.AppDirectoriesFinder",# django-esm finder"django_esm.finders.ESMFinder",]You will also need to expose yournode_modulesdirectory to Django's
staticfiles finder. You may runnpm ci --omit=devprior to runningcollectstaticto avoid exposing yourdevDependenciespublicly.# settings.pyfrompathlibimportPath# add BASE_DIR (if not already present)BASE_DIR=Path(__file__).resolve().parent.parentSTATICFILES_DIRS=[# …BASE_DIR/"node_modules",]Finally, add the import map to your base template:<!-- base.html --><!DOCTYPE html>{% load esm %}<htmllang="en"><head><scripttype="importmap">{%importmap%}</script></head></html>That's it!
Don't forget to runnpm installandpython manage.py collectstatic.UsageYou can now import JavaScript modules in your Django templates:<!-- index.html -->{% block content %}<scripttype="module">import"htmx.org"htmx.logAll()</script>{% endblock %}Private modulesYou can also import private modules from your Django app:<!-- index.html -->{% block content %}<scripttype="module">import"#myapp/js/my-module.js"</script>{% endblock %}To import a private module, prefix the module name with#.
You need to define your private modules in yourpackage.jsonfile:{"imports":{"#myapp/script":"./myapp/static/js/script.js",// You may use trailing stars to import all files in a directory."#myapp/*":"./myapp/static/js/*"}}Testing (with Jest)You can use thedjango_esmpackage to test your JavaScript modules with Jest.
Jest v27.4 and upwards will honorimportsin yourpackage.jsonfile.Before v27.4 that, you can try to use a custommoduleNameMapper, like so:// jest.config.jsmodule.exports={// …moduleNameMapper:{'^#(.*)$':'<rootDir>/staticfiles/js/$1'// @todo: remove this with Jest >=29.4},}How it worksDjango ESM works via native JavaScript module support in modern browsers.
It uses theimport mapto map module names to their location on the server.Here is an example import map:{"imports":{"htmx.org":"/static/htmx.org/dist/htmx.min.js"}}
Package: django-essence
Simple project with base common resources for almost any Django project.InstallationThe installation is performed by using pip:pip install django-essenceTo enabledjango-essencein a Django project it’s needed to add it toINSTALLED_APPSin the project settings file:INSTALLED_APPS = [
    ...
    'django_essence',
    ...
]ResourcesThe current implementation ofdjango-essenceoffers only common base abstract models
listed below:TimestampedModel: model with attributes (fields) useful for audit
purposes. Fields:created_atupdated_atEssenceModel: model inherited fromTimestampedModelwith anUUIDField. Fields:idcreated_atupdated_atEssencePersistentModel: model inherited fromEssenceModelwith “soft delete”
feature. Fields:idcreated_atupdated_atdeletedEssenceSlugModel: model inherited fromEssenceModelwith a enhancedslugfield.
Fields:idcreated_atupdated_atslugAll models are available importing from:from django_essence.models import *Running tests (development)First install development dependencies with:make installThan run tests with:pytest
Package: django-esutils
Django ESUtils==============Common and easy way to manage ES backend in django based on elasticutils andelasticsearch-py.Hacking-------In order to hack on django-esutils, you'll need to set at least an Elasticsearchinstance available from your machine.You can install it manually or more simply, use a docker container like this::docker run --net host dockerfile/elasticsearchand then you can browse your ES server at: http://127.0.0.1:9200/Configuration~~~~~~~~~~~~~add a :file:`local_settings.py` file in your :file:`demo/demo_esutils` directory,with these settings:.. code-block:: pythonES_URLS = ['http://127.0.0.1:9200',](or change it to fit your ES target configuration)Running tests~~~~~~~~~~~~~Now that your ES instance is ready, and your database connection set, simply runthe tests using tox, preferrably in a virtualenv::mkvirtualenv TOXpip install toxtox
Package: django-es-utils
Elasticsearch UtilitiesElasticsearch utilities for Django projects to analyze queries, create documents, sync data and connect to ES.Required configurationsAdd the following configurations to Django project settings:ES_SYNC_FEATURE(Required:Boolean)ELASTICSEARCH_HOST(Required:String)ELASTICSEARCH_USERNAME(Optional:String)ELASTICSEARCH_PASSWORD(Optional:String)Syncing data with ElasticsearchSteps to index a Django model into Elasticsearch:1- create a new file inside any Django app calledes_indices.pyand insert this code into it with your modifications:fromes_utils.analyzersimportarabic_analyzerfromes_utils.documentimportESDocumentfromelasticsearch_dslimport(connections,Document,Text,Completion)classProgramIndex(ESDocument):"""This class is used to map the programs with Elasticsearch index."""classIndex:name='programs'# the fields you want to index with their typesid=Text()# support autocomplete for this fieldname_en=Text(fields={'completion':Completion()})# add arabic analyzer to this fieldabout_ar=Text(analyzer=arabic_analyzer)about_en=Text()# nested objectcategory=Object(properties={'name_en':Text(),'name_ar':Text()})# ...# ...2- Add theindexingfunction to your model inmodels.pyfile:fromcms.djangoapps.program.es_indicesimportProgramIndexfromes_utils.helpersimportes_indexingclassProgram(models.Model):name_en=models.CharField(max_length=255)about_en=models.CharField(max_length=255)....# It's optional to add 'async_' arg.@es_indexingdefindexing(self,async_=True):attrs=dict(meta={'id':self.id},metadata={'filters':{'type':self.program_type,'status':self.status},'sorting':{'name':self.name_en,'type':self.program_type,'start_date':self.start}},id=self.id,slug=self.slug,name_en=self.name_en,type=self.program_type,about_en=self.about_en,# nested dictcategory=dict(name_en=self.category.name_en,name_ar=self.category.name_ar),)returnProgramIndex,attrs3- Add apost_saveandpost_deletesignals and connect them with the model:fromcms.djangoapps.program.modelsimportProgramfromcms.djangoapps.programimportes_indicesfromdjango.db.models.signalsimportpost_save,post_deletefromelasticsearch_dslimportSearchfromes_utils.connectionimportconnectionfromes_utils.helpersimportdelete_es_documentdefindex_program(sender,instance,created,**kwargs):ifinstance.can_index():instance.indexing(new=created,async_=True)elifnotcreated:index_name=es_indices.ProgramIndex._index._namedelete_es_document(document.id,index_name,async_=True)defdelete_program(sender,instance,**kwargs):index_name=es_indices.ProgramIndex._index._namedelete_es_document(instance.id,index_name,async_=True)forcls_nameinsettings.ES_SYNC_MODELS:Cls=getattr(models,cls_name)signals.post_save.connect(index_program,sender=Cls)signals.post_delete.connect(delete_program,sender=Cls)CompatibilityDjango >= 1.8.Python3.
Package: django_esv
ADjango Inlinesstyle inline and a template tag to work with theESV Bible API.Right now all they do is return the (x)html snippet provided by the ESV API and
provide clean ways to tweak the options.Template tag:{% load esv %}
{% passage reference [headings on] [audio off] [footnotes on] %}Where reference is a string that the ESV can use as a query, or an context
var that resolves to such a string.Examples:{% passage "Genesis 1:1" %}
{% passage "rom 3" %}
{% passage "1 tim 3-4" footnotes on %}Inline:{{ passage reference [headings=on] [audio=off] [footnotes=on] }}Examples:{{ passage John 1 }}
{{ passage John 2:1-3:18 footnotes=on }}
{{ passage jhn 2 matt 3 }}Configurationdjango_esv has a single optional setting. Which controls where and how
httplib2 stores it’s http cache. It defaults to:ESV_HTTP_CACHE = '/tmp/esv_http_cache'WARNING!The ESV client doesn’t yet do any caching besides standard HTTP caching.
You’ll want to do output caching or wait for a real cache solution in django_esv.DependenciesDjangohttplib2The inlines depend onDjango Inlines