Saravanan666/pypi-org huggingface dataset:
Package: django-pydash-app
pyDash - v1.4.6A reusable django app for monitoring your linux server.Supported Python versions:Python 2.x
Python 3.xRequirements:Django >= 1.5View Demouser: admin
pass: adminInstallationClone the repository to your pc and, assuming thatpipis installed,
run the following commands:python setup.py sdistpip installdist/django-pydash-app-*.tar.gzMake sure thatdjango.contrib.authis installed and working.Open your project’ssettings.pyand addpydashtoINSTALLED_APPS:INSTALLED_APPS = (
    'pydash',
)Open your project’surls.pyand include thepydashurls.urlpatterns = patterns('',
    (r'^pydash/', include('pydash.urls')),
)Make sureAppDirectoriesFinderis enabled in yourSTATICFILES_FINDERS:STATICFILES_FINDERS = (
    'django.contrib.staticfiles.finders.AppDirectoriesFinder',
)Before deploying to a live server, run the following command in order to
collect the static files stored in pydash’s directory:$ python manage.py collectstaticSettingsThere are 3 different refresh settings which are measured inmiliseconds:TIME_JS_REFRESH = 30000 #30 seconds
TIME_JS_REFRESH_LONG = 120000 #120 seconds
TIME_JS_REFRESH_NET = 2000 #2 secondsIf you wish to override the default settings, simply set those fields
with the new values in your application’ssettings.pyfile.The refresh settings for each table are as follows:Memory Usage - TIME_JS_REFRESH
Load Average - TIME_JS_REFRESH
CPU Usage - TIME_JS_REFRESH
Traffic Usage - TIME_JS_REFRESH_NET
Disk Reads/Writes - TIME_JS_REFRESH_NET
Uptime - TIME_JS_REFRESH_LONG
Disk Usage - TIME_JS_REFRESH_LONG
Online Users - TIME_JS_REFRESH_LONG
Processes - TIME_JS_REFRESH_LONG
Netstat - TIME_JS_REFRESH_LONGRemote data retrievalpyDash allows you to retrieve data remotely.Data is returned in JSON and can be easily retrieved as long as the user
agent has been authenticated by the web application.pyDash has a list of short URLs which you can use to retrieve the
specific data:/info/uptime/ - Uptime
/info/platform/hostname/ - Hostname
/info/platform/osname/ - OS Name
/info/platform/kernel/ - Kernel
/info/getcpus/cpucount/ - Number of CPU cores
/info/getcpus/cputype/ - Type/Name of CPU
/info/memory/ - Memory Usage
/info/cpuusage/ - CPU Usage in percentage(%), free and used
/info/getdisk/ - Disk Usage
/info/getusers/ - Online Users
/info/getips/ - IP Addresses
/info/gettraffic/ - Internet Traffic
/info/getdiskio/ - Disk Reads/Writes
/info/proc/ - Running Processes
/info/loadaverage/ - Load Average
/info/getnetstat/ - NetstatTo see the format of the JSON returned datasets or data you can access any of the URLs from your browser
ashttp://youpydaship/url, ex.http://demo.pydash.net/info/uptime/.OS SupportpyDash was tested and runs under the following OSes:-  Centos
-  Fedora
-  Ubuntu
-  Debian
-  Raspbian
-  Pidora
-  Arch LinuxIt might work under others, but it hasn’t been tested yet.ContributorsGeorge Zografos -george.p.zografos@gmail.comLicenseMITIssuesReport any issues/bugs athttps://github.com/k3oni/pydash-django-appCreditsDashboard Template,Bootstrap,Font Awesome
Package: django-pydenticon
Django PydenticonDjango Pydenticon is a Django application that provides an identicon
generator. The implementation uses Pydenticon library for generating the
identicons:https://github.com/azaghal/pydenticon/https://projects.majic.rs/pydenticonDjango Pydenticon comes with some pre-defined sane defaults for generating the
identicons, but is configurable, letting the user generate identicons with
custom parameters. Some parameters can be even overridden on case-by-case basis.LicenseDjango Pydenticon is released under terms ofBSD (3-Clause) License. See theLICENSEfile for more details.
Package: django-pyfs
A Django module which extends pyfilesystem2 with several methods to
make it convenient for web use. Specifically, it extends pyfilesystem2
with two methods:fs.get_url(filename, timeout=0)This will return a externally-usable URL to the resource. If
timeout>0, the URL may stop working after that period (in
seconds). Details are implementation-dependent. On Amazon S3, this is
a secure URL, which is only available for that period. For a static
filesystem, the URLs are unsecure and permanent.fs.expire(filename, seconds, days, expires=True)This allows us to create temporary objects. Our use-case was that we
wanted to generate visualizations to users which were .png images. The
lifetime of those images was a single web request, so we set them to
expire after a few minutes. Another use case was memoization.Note that expired files are not automatically removed. To remove them,
callexpire_objects(). In our system, we had a cron job do
this for a while. Celery, manual removals, etc. are all options.To configure a django-pyfs to use static files, set a parameter in
Django settings:DJFS = {'type' : 'osfs',
        'directory_root' : 'djpyfs/static/djpyfs',
        'url_root' : '/static/djpyfs'}Here,directory_rootis where the files go.url_rootis the URL
base of where your web server is configured to serve them from.To use files on S3, you needbotoinstalled. Then,DJFS = {'type' : 's3fs',
        'bucket' : 'my-bucket',
        'prefix' : '/pyfs/' }bucketis your S3 bucket.prefixis optional, and gives a base
within that bucket.To get your filesystem, call:def get_filesystem(namespace)Each module should pass a unique namespace. These will typically
correspond to subdirectories within the filesystem.The django-pyfs interface is designed as a generic (non-Django
specific) extension to pyfilesystem2. However, the specific
implementation is very Django-specific.Good next steps would be to:Allow Django storages to act as a back-end for pyfilesystemAllow django-pyfs to act as a back-end for Django storagesSupport more types of pyfilesystems (esp. in-memory would be nice)State: This code is tested and has worked well in a range of settings,
and is currently deployed on edx.org.
Package: django-pygmentify
Django Pygmentifyis aDjangotemplate tagapplication to highlight code withPygments.It is an alternative toDjango Pygments, which hasn’t been updated in several years.Package distributionCode repositoryDocumentationTestsInstall$pipinstalldjango-pygmentifyAdd tosettings.py.INSTALLED_APPS=[# ...'pygmentify',]Usage{%loadpygmentify_tags%}<link rel="stylesheet" href="{%pygmentify_css%}">{%pygmentify%}<pre class="python">
print('Hello, world!')
</pre>{%endpygmentify%}Result:<linkrel="stylesheet"href="/static/pygmentify/css/default.min.css"><divclass="highlight"><preclass="python"><span></span><spanclass="k">print</span><spanclass="p">(</span><spanclass="s2">&quot;Hello, world!&quot;</span><spanclass="p">)</span></pre></div>
Package: django-pygmento
django-pygmentoSyntax highlighter for django templates based on Pygments.Usage exampleInstall the package usingpipinstalldjango-pygmentoAddpygmentotoINSTALLED_APPSin your settings file.Loadpygmentotemplate tag{% load pygmento %}Include pygment css inheadusing thepygmento_csstemplate tag or manually generate it as describedhereand add it to static files.<head>{% pygmento_css %}</head>Usepygmentoas shown below# Single line code
{{ "print('hello')"|pygmento:"python" }}

# Multi-line code block in python
{% pygmentoblock "python" %}
class Dog:
    def __init__(self, name):
        self.name = name
        self.tricks = []    # creates a new empty list for each dog

    def add_trick(self, trick):
        self.tricks.append(trick)
{% endpygmentoblock %}

# Multi-line code block in html
{% pygmentoblock "html" %}
<!DOCTYPE html>
<html>
<body>
<h1>My Heading</h1>
<p>My paragraph.</p>
</body>
</html>
{% endpygmentoblock %}The above code will get rendered asAvailable stylesStyles can be set usingPYGMENTO_STYLEsetting.PYGMENTO_STYLE="default"See the list of available styles and how they lookhere.MetaApoorva Pandey –apoorvapandey365@gmail.comDistributed under the BSD license.https://github.com/apoorvaeternityContributingFork it (https://github.com/apoorvaeternity/django-pygmento/)Create your feature branch (git checkout -b feature/fooBar)Commit your changes (git commit -m 'Add some fooBar')Push to the branch (git push origin feature/fooBar)Create a new Pull Request
Package: django-pygments
descriptiondjango-pygments is a Django app that provides a template tag and two filters for doing syntax highlighting withPygments.dependenciesPygmentsinstallationadd django_pygments to your project directory and to INSTALLED_APPS in your settings.pyif you want to see the integrated demo page, add a urls.py entry and copy/link the media files in the proper dirusageenclose your code snippet in a pre tag with the non-standard "lang" attribute set to a supported language like this:<prelang="python">....</pre>see the view and demo template for examples on how to use the "pygmentify" and "pygmentify_inline" filters (the later is rather useful for RSS feeds) or the "pygment" tagWhile using the "pygment" template tag, you can pass keyword arguments that you would pass to Pygments HtmlFormatter class constructor by passing them as with keyword arguments along with the pygment tag. Look at demo template for examples. There is one caveat with this feature still. You can only pass Python values as argument values (like Strings wrapped within quotes or True or False boolean values, etc.). It doesn't support Django template/context variables as arguments yet.notesthe custom HTML formatter class displays each line as an ordered list element, thus implementing line numbering without interfering with copy/pastingto see a list of supported languages, look at the "lexer_names" variable in utils.pylicense3-clause BSDcreditsmain author - Ștefan Talpalarustefantalpalaru@yahoo.comsite -https://github.com/stefantalpalaru/django-pygments
Package: django-pygments-renderer
Provides functionality for syntax highlighting usingPygments.Installationdjango-pygments-renderer requires python 3.6 or later and Django 2.0 or later.$python3-mpipinstalldjango-pygments-rendererhttps://pypi.org/project/django-pygments-renderer/UsageINSTALLED_APPS+=['pygments_renderer',]{% load i18n %}
{% load pygmentize %}<html><head><title>{{ snippet.title}} - djangosnippets</title><style>{%pygments_css%}</style><!-- other header tags --></head><body><divclass="container"><h2class="title">{{ snippet.title }} by {{ snippet.created_by.username }}</h2><divclass="sourcecode">{{ snippet.code|pygmentize:"python3" }}</div><div>{{ snippet.description }}</div></div></body></html>Similar projectshttps://github.com/richardcornish/django-pygmentifyhttps://github.com/odeoncg/django-pygmentshttps://github.com/sniku/django-pygmentsDevelopmentlint:tox-eflake8orflake8test:tox-epy37orDJANGO_SETTINGS_MODULE=test_settings python-mdjango testLicenseThis software is licensed under the MIT License (SeeLICENSE).
Package: django-pygmy
django-pygmy is a little app that colorizes source codez in yourDjangotemplates.It usespygmentsfor prettify the codez.InstallationTo installdjango-pygmy, simply run:pip install django-pygmyThen add the app to yourINSTALLED_APPS:INSTALLED_APPS = (
    ...,
    'django_pygmy',
)UsageRender the awesomeness in your template:{% load pygmy %}

{% pygmy object.code %}It also takes the same options asHtmlFormatterclass:{% pygmy object.code nowrap='True' linenos='table' %}LexersBy defaultdjango-pygmytries to guess which lexer to use based on the provided code.If you wish you can define any lexer ofPygments lexerslike so:{% pygmy object.code lexer='python' %}DependenciesPython 2.6 - 3.3Django 1.3 - 1.5pygments >= 1.6
Package: django-pygwalker
django-pygwalkerThis utility creates user interfaces for visual analysis using PyGWalker in your django application. A PyGWalker page can be created from a Django queryset, a static csv file, or an uploaded csv file.For more information on PyGWalker see the github repo available here:https://github.com/Kanaries/pygwalkerCode QualityWorkflowDescriptionStatusBanditsecurity checksBlackcode formattingCodeQLsecurity analysisCoverallscode coverage statusIsortpython import orderingMypystatic type checkingPytestunit testingRadoncode complexity analysisRuffstatic code analysisSafetydependency scannerToxpython/django versions testingCode CoverageDashboard:https://coveralls.io/github/djangoaddicts/django-pygwalkerDocumentationFull documentation can be found onhttp://django-pygwalker.readthedocs.org.Documentation source files are available in the docs folder.Installationinstall via pip:pip install django-pygwalkeradd the following to your INSTALLED_APPS in settings.py:djangoaddicts.pygwalkerNOTE:adding djangoaddicts.pygwalker to INSTALLED_APPS is only required if you intend to use the built-in templates or the 'generic' PyGWalker view.to include the generic PyGWalker view (creates the PyGWalker page from an upload of a csv file) add the following to your project-level urls.py:path("pygwalker/",include("djangoaddicts.pygwalker.urls"),),FeaturesPygWalkerViewThe PygWalkerView renders a page containing PyGWalker html. This view takes a queryset parameter and includes all data in the queryset for visualizations. By default fields defined in the model will be included. To exclude fields or include additional fields (such as related fields), use the field_list parameter to specify exact fields desired for visualizations.A Bootstrap 5 template is included, but can be overwritten using the template_name parameter.Parametersfield_list:list of model fields to include (defaults to fields defined in the model)queryset:queryset providing data available to visualizationtheme:PyGWalker theme to use for pyg html (defaults to "media")title:title used on html rendertemplate_name:template used when rendering page; (defaults to pygwalker/bs5/pygwalker.html)Usage Examplesfromdjangoaddicts.pygwalker.viewsimportPygWalkerViewclassMyPygWalkerView(PygWalkerView):queryset=MyModel.objects.all()Explicitly Defined Fieldsfromdjangoaddicts.pygwalker.viewsimportPygWalkerViewclassMyPygWalkerView(PygWalkerView):queryset=MyModel.objects.all()title="MyModel Data Analysis"theme="light"field_list=["name","some_field","some_other__related_field","id","created_at","updated_at"]Custom TemplateCustom views/templates can be used to override the Bootstrap 5 templates provided by default view. Here is an example:fromdjangoaddicts.pygwalker.viewsimportPygWalkerViewclassMyPygWalkerView(PygWalkerView):queryset=MyModel.objects.all()template_name="my_custom_template.html"Licensedjango-pygwalker is licensed under the GNU-3 license (see the LICENSE file for details).https://github.com/djangoaddicts/django-pygwalker/blob/main/LICENSEContributingTo contribute to django-pygwalker, please seeContributing
Package: django-pylibmc-sasl
This package provides a memcached cache backend for Django usingpylibmc.  You want to use pylibmc
because it’s fast.This is a fork of thedjango-pylibmcpackage. These changes will eventually end up upstream.Requirementsdjango-pylibmc-sasl requires Django 1.3.  It was written and tested on Python 2.7.x.InstallationGet it frompypi:pip install django-pylibmc-saslUsageYour cache backend should look something like this:CACHES = {
    'default': {
        'BACKEND': 'django_pylibmc.memcached.PyLibMCCache',
        'LOCATION': 'localhost:11211',
        'TIMEOUT': 500,
        'BINARY': True,
        'OPTIONS': {  # Maps to pylibmc "behaviors"
            'tcp_nodelay': True,
            'ketama': True
        }
    }
}If you want to use the memcached binary protocol, set theBINARYkey’s
value toTrueas shown above.BINARYisFalseby default.If you want to controlpylibmc behaviors, use theOPTIONS.OPTIONSis an empty dict by default.Pylibmc supportscompressionand the
minimum size (in bytes) of values to compress can be set via the Django
settingPYLIBMC_MIN_COMPRESS_LEN.  The default is 0, which is disabled.CaveatsThis package breaks away from the current handling oftimeout=0in Django.
Django converts 0 into the default timeout, while django-pylibmc leaves it as
0.  memcached takes 0 to mean “infinite timeout.”  You can still passNoneto get the default timeout.
Package: django-pylibmc-threadsafe
Default django pylibmc cache backend don’t work correctly using multithread
uWSGI or celery worker.This package uses separate connection for each context (thread or async context)
and can be used as direct replacement ofdjango.core.cache.backends.memcached.PyLibMCCache.Installpipinstalldjango_pylibmc_threadsafeConfigurationThis package has only one additional option -ignore_excused to suppress all
exceptions (behavior used in olddjango.core.cache.backends.memcached.MemcachedCachebackend). All other
options are identical todjango.core.cache.backends.memcached.PyLibMCCache.Example configuration:CACHES={'default':{'BACKEND':'django_pylibmc_threadsafe.PyLibMCCache','LOCATION':'127.0.0.1:11211','KEY_PREFIX':'','OPTIONS':{'binary':True,'ignore_exc':True,'behaviors':{'ketama':True,}}},
Package: django-pymemcache
django-pymemcache is a Django cache backend that uses Pinterest’spymemcachelibrary as the backend.Installationpip install django-pymemcacheUsageSimply use it as any otherCache backend, e.g.CACHES={'default':{'BACKEND':'djpymemcache.backend.PyMemcacheCache','LOCATION':['127.0.0.1:11211',],'OPTIONS':{'serializer':<your_serializer>,'deserializer':<your_deserializer>,},},}Issueshttps://github.com/django-pymemcache/django-pymemcache/issues
Package: django-pymssql
Goalsdjango-pymssql is a Django database backend for Microsoft SQL Server that
works on non-Windows systems.It’s a small wrapper arounddjango-mssqlthat usespymssqlinstead of ADO to
connect to SQL Server.It should support the same versions of Python, Django and SQL Server asdjango-mssql.The original use case was to connect to SQL Server from a Django project
written in Python 3 and running on Linux.Statusdjango-pymssql 1.7almostpasses Django’s test suite with:Python 2.7 or 3.4Django 1.7.x + django-mssql 1.6.1 + pymssql 2.1.1Microsoft® SQL Server® 2012 ExpressUsagedjango-pymssql provides a Django database engine calledsqlserver_pymssql:DATABASES={'default':{'ENGINE':'sqlserver_pymssql','HOST':'...','NAME':'...','USER':'...','PASSWORD':'...',''OPTIONS':{# ...},},}Any parameter accepted bypymssql.connectcan be passed in OPTIONS.Alternativesdjango-sqlserveris a fork ofdjango-mssqlthat supportspython-tdsandpymssqlin addition to ADO on Windows. Unfortunately it has diverged and it
lags behinddjango-mssqlwhen it comes to supporting newer Django versions.django-pyodbcrelies onpyodbcto connect to SQL Server. It requires a
complex stack that doesn’t bring actual benefits. Besides it doesn’t appear
to be very mature nor actively maintained.HackingClone Django, pymssql, django-mssql and django-pymssql andpip install-e.each of them in a virtualenv.Create a Django tests settings file with the database engine set to'sqlserver_pymssql'and credentials for a testing SQL Server instance.Go the thetestssubdirectory in a clone of Django and execute./runtests.py--settings=test_pymssql.Licensedjango-pymssql is released under the MIT license, likedjango-mssql. See the
LICENSE file for details. Note thatpymssqlis released under the LGPL.Some database version checking code was borrowed fromdjango-sqlserverwhich
is also released under the MIT license..
Package: django-pynotify
Django PyNotifyGeneral purpose notification library for Django.Free software: MIT licenseDocumentation:https://django-pynotify.readthedocs.io.Supported Python versions: 3.7, 3.8, 3.9, 3.10, 3.11Supported Django versions: 3.1, 3.2FeaturesEasy integration into projectNotification templating and translationAsynchronous operationCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.5.5 (2023-01-03)Add support for Python 3.10 and 3.110.5.4 (2022-03-10)Migrate CI from Travis to Github ActionsFix lint errors0.5.3 (2022-03-01)Prevent duplicates ofNotificationTemplateobjects0.5.2 (2022-02-21)Allow handlers that are not paired with any signalReturn notifications created withnotifyhelper function0.5.1 (2022-01-20)UseJSONFieldinstead ofTextFieldfor JSON based fieldsAddextra_fieldstoBaseTemplateDrop Django 2.x support0.4.6 (2021-08-31)Addis_lockedfield toAdminNotificationTemplate0.4.5 (2021-01-21)Update dependencies0.4.4 (2021-01-15)Add support for Python 3.9Add support for Django 3Fix BS4 warning0.4.3 (2020-12-16)Fix translation file0.4.2 (2020-12-11)Addsend_pushflag toAdminNotificationTemplatemodelIgnore duplicit dispatcher classes inBaseHandler0.4.1 (2020-10-12)AddPYNOTIFY_STRIP_HTMLconfig option0.4.0 (2020-08-12)Removed support of Django 1.11, 2.0 and 2.1Fixed library requirements0.3.2 (2020-07-27)Addis_activeflag toAdminNotificationTemplatemodel0.3.1 (2020-06-12)Improve template variable checkingAdd new filterfilter_with_related_object0.3.0 (2020-04-19)Fix documentationChangePYNOTIFY_AUTOLOAD_APPStoPYNOTIFY_AUTOLOAD_MODULES, i.e. allow notification handlers to reside in
arbitrary module0.2.2 (2020-02-11)Use Django JSON encoder for encoding extra data0.2.1 (2020-02-11)Fix failed PyPi upload0.2.0 (2020-02-11)Add admin templatesLimit usage of related objects in templates and addPYNOTIFY_RELATED_OBJECTS_ALLOWED_ATTRIBUTESsettingShow placeholder text for deleted related objects0.1.7 (2020-01-20)Add support for Python 3.8 and Django 2.2Fix generating of translationsAllow unnamed related objects to be passed in a list0.1.6 (2019-04-16)AddPYNOTIFY_TEMPLATE_PREFIXconfig optionAdd methodsget_template_slug()andget_dispatcher_classes()toBaseHandlerAdd coveralls.io integration0.1.5 (2019-04-12)Add extra data toNotificationmodel0.1.4 (2019-04-08)Add_can_handle()method toBaseHandlerAddPYNOTIFY_ENABLEDsetting0.1.3 (2019-04-01)Addkwargsto Notification manager’screate()methodAddrealted_objects_dictproperty toNotificationmodel0.1.2 (2019-03-20)Remove automatic deploy to PyPi from Travis0.1.1 (2019-03-20)First release of the library
Package: django-pyodbc-lb
Database engine based on django-pyodbc-azure that overrides database connection.
IfOPTIONSdictionary containsload_balancerit must be an object withchoosemethod which returnds list of hosts.Example configuration:DATABASES = {
    'default': {
        'ENGINE': 'sql_server_lb',
        'NAME': 'database',
        'USER': 'user',
        'PASSWORD': 'password'
        'HOST': 'host',  # Not used
        'PORT': 1433,
        'COMMAND_TIMEOUT': 360,
        'CONN_MAX_AGE': 3600,  # Persistent connection limited to an hour
        'OPTIONS': {
            'load_balancer': LoadBalancer('database'),
            'driver': 'FreeTDS',
            'host_is_server': True,
            'extra_params': 'TDS_Version=7.3',
        }
    },
}
Package: django-pyowm
# Django PyOWMA Django ORM interface for PyOWM domain entities## Requirements- Django 1.10+- PyOWM 2.5+Python 2.7 is supported.** Please notice that the API can be unstable as this project is still in beta testing **## InstallInstall the library with `pip`:```shell$ pip install django_pyowm```Then add `django_pyowm` to the `INSTALLED_APPS` list into your Django project's `settings.py` file:```pythonINSTALLED_APPS = [...'django_pyowm'  # <---]```Finally generate tables by applying migrations:```shell$ python manage.py makemigrations django_pyowm$ python manage.py migrate```## FeaturesModels behave as all other Django models but they have a few usefulfunctions:-  `<Model_class>.from_entity(entity)` - creates a PyOWM model instancefrom the corresponding PyOWM domain object instance-  `<Model_instance>.to_entity(entity)` - turns the model instance tothe corresponding PyOWM domain object instance- `<Model_class>.save_all()` - persists the model instance along with all related objects## Quick usage examples```pythonfrom pyowm import OWMfrom django_pyowm import models# Get data an Observation from the APIowm = OWM(API_key='my_key')obs = owm.weather_at_place('London,UK')# Create a model instance from API responsem = models.Observation.from_entity(obs)# Save related objects and then the model itselfm.location.save()m.weather.save()m.save()# .. or save everything in one shotm.save_all()# From model instance to entityoriginal_obs = m.to_entity()```## TestingAll details about testing are [here](https://github.com/csparpa/django-pyowm/wiki/Testing)