Saravanan666/pypi-org huggingface dataset:
Package: django-makeconf
# django-makeconfMake config files from Django settings variables and templates.## InstallationFrom your Django app, install the module from pip:pip install django-makeconfThen make sure it's included in your `INSTALLED_APPS` section:INSTALLED_APPS = (...'makeconf',)## TemplatesCreate templates in the `templates/` directory of your app. For example, if you create `myapp/templates/makeconf/Dockerfile.tmpl`, you can generate `Dockerfile` in the root of your app by configuring `MAKECONF_MAP` in your settings file:MAKECONF_MAP = {'Dockerfile': 'makeconf/Dockerfile.tmpl',}This relies on Django's template finder, which is pretty flexible. It will scan all your apps for a template with the same path name. The `Dockerfile` will be generated using the `Dockerfile.tmpl`, and it will have access to the `settings` variable.## Elastic Beanstalk ModulesElastic Beanstalk configuration files can be declared using `MAKECONF_EB_MODULES`. Templates named `<module_name>.tmpl` can be referenced in a list by the module name. If you had a `newrelic` module and a `postgres` module that each configure your server with packages, files, etc., you can automatically turn the following format:MAKECONF_EB_MODULES = ['postgres', 'newrelic']Into additional `MAKECONF_MAP` entries like so:MAKECONF_MAP = {...'.ebextensions/01_postgres.config': 'postgres.tmpl','.ebextensions/02_newrelic.config': 'newrelic.tmpl',}If `MAKECONF_EB_MODULES` is set, `.ebextensions` will be erased with each build.## OptionsCurrently, there is one option which can be set using `MAKECONF_OPTIONS`:* `executable_extensions` - Files with extensions in this list will be created executable. Defaults to `['.sh']`.## UsageAssuming you have a `TIER` variable defined as `'qa'` in your settings file and the following template,FROM amazon/aws-eb-python:3.4.2-onbuild-3.5.1ADD uwsgi-start.sh /ENV DJANGO_SETTINGS_MODULE config.settings.{{ settings.TIER }}EXPOSE 8080you could runpython manage.py makeconfand `{{ settings.TIER }}` would be replaced with `qa` in the output file.## Template Tags* `environ` - The `environ` tag is used to get required variables from the shell environment:* To use it, first, load the `makeconf` template tags in your template:{% load makeconf %}* Then, use the tag in that template:{{'MY_ENVIRONMENT_VARIABLE'|environ}}## Shared TemplatesIf people use this, I could see shareable formats published for different services and needs. I'm currently using it to build Elastic Beanstalk and Docker configurations based on my Django settings, so I may end up publishing Django apps with names like `django-makeconf-elasticbeanstalk-configure-proxy`, or `django-makeconf-eb-docker-settings-module`, which would simply contain templates in their `templates/` directories (plus a `setup.py` and a `MANIFEST.in` that included the template files). You'd be able to pip install those templates and use them directly in your `MAKECONF_MAP`.Also, I'm totally open to contributions in that vein or pull requests / issues on this project.
Package: django-makemessages-xgettext
Authors:Resulto Developpement Web Inc.Version:0.1.1This project has one goal:Allow makemessages to receive additional parameters to pass to xgettext.Requirementsdjango-makemessages-xgettext works with Python 2.7 and 3.4. It requires Django 1.7+InstallationInstall with pippip install django-makemessages-xgettextThen add “django_makemessages_xgettext” to the INSTALLED_APPS list in settings.pyINSTALLED_APPS = [
    ...
    "django_makemessages_xgettext",
]UsageAs a way to generate .po files without the line number comment referenceJust use themakemessagesxgettextcommand instead of themakemessagescommand:python manage.py makemessagesxgettext -a --xgettext=--add-location=fileLicenseThis software is licensed under theNew BSD License. See theLICENSEfile
in the repository for the full license text.
Package: django-maker
'''This package provides tools for create app, models, serializer and CRUD.To use this package, you must first install it using pip:

```bash
pip install django_maker
```

## Usage

 # to create app 
 
    python manage.py createapp and follow the steps
    
 # to create models 
 
    python manage.py create_models and follow the steps
    
 # to create serializer 
 
    python manage.py create_serializer and follow the steps
    
 # to create create simple CRUD 
 
    python manage.py create_simple_CRUD 
                
```

...

'''
Package: django-makesuperuser
Installation$[sudo]pipinstalldjango-makesuperuserExamplesexample#1 - management command:settings.pyINSTALLED_APPS+=["django_makesuperuser"]$pythonmanage.pymakesuperuser--usernameadmin--passwordadmin
$pythonmanage.pymakesuperuser--usernameadmin--passwordadmin--emailfoo@foo.fooexample#2 - python module cli:$exportDJANGO_SETTINGS_MODULE=settings
$python-mdjango_makesuperuser"username""password"$python-mdjango_makesuperuser"username""password"foo@foo.fooreadme42.com
Package: djangomako
django-makoThe simple, elegant Django Mako library
Used base engine to create a template rendering class to be used like Django's TemplateView class. To understand how to use it, readCustom backends on django.The current implementation assumes all system templates are Mako Template. Thus, when you start a new template make sure that the template language is Mako not Django.If you want to use another template backend like Django Template Backend, just passusing='Django'in your FBV or addtemplate_engine = 'mako'in your CBV.Enjoy! This shouldn't be tricky any more.InstallationTo install the package as a requirement in your python environemnt just
dopip install djangomakoUsing the libraryAfter installing the package in your python environment, navigate to
your project'ssettings.pyand add the following lines in theTEMPLATESvariableTEMPLATES=[# ...{'BACKEND':'djangomako.backends.MakoBackend','NAME':'mako','DIRS':[os.path.join(BASE_DIR,'templates'),],},# ...]TheBACKENDvalue is from this library.TheNAMEis simply the template identifier.InDIRSyou're gonna include all the directories that have mako
templates.The order matters here, so if you want your project to
support only mako, you just need to remove the Django entry from the
templates, while if you need mako as a fallback only, then you need to
put it under the Django Template entry.Template VariablesI passed some template variables to the context if the request objects
exists:CSRF_TOKENandCSRF_INPUT${csrf_input}## {% csrf_token %} in Django templates.${csrf_token}## {{ csrf_token }} in Django templates.To access the request:${request}To include a static file url:${static('image.png')}## {% static "image.png" %} in Django templates.To reverse a url in the template:${url('home')}## {% url 'home' %} in Django templates.Detailed Examples?An example of how to use this library in Class-Based view and
Function-Based Views is insideniceappapp.Errors?To test how this engine handles errors, just run theserver and go to this path/mako.Detailed Explanation?You can find a detailed explanation of how I implemented this library
in my blog post namedIntegrating third-party templates' libraries with Django.LicenseThe MIT License (MIT)
Copyright (c) 2017-2019 Ahmed Jazzarme@ahmedjazzar.com
Package: django-mama-cas
MamaCAS is a DjangoCentral Authentication Service (CAS)single sign-on
and single logout server. It implements the CAS 1.0, 2.0 and 3.0 protocols,
including some of the optional features.CASis a single sign-on and single logout web protocol that allows a user
to access multiple applications after providing their credentials a single
time. It utilizes security tickets, unique text strings generated and
validated by the server, allowing applications to authenticate a user without
direct access to the user’s credentials (typically a user ID and password).The source code can be found atgithub.com/jbittel/django-mama-cas, and is
the preferred location for contributions, suggestions and bug reports.
Documentation is available atdjango-mama-cas.readthedocs.org.QuickstartDjango versions 2.2 to 3.1 are supported. It should work with Django >= 2.0 though.Install withpip:$ pip install django-mama-casAdd toINSTALLED_APPSand runmigrate:INSTALLED_APPS += ('mama_cas',)Include the URLs:urlpatterns += [url(r'', include('mama_cas.urls'))]See the fullinstallation instructionsfor details.UpgradeUpgrade withpip:$ pip install --upgrade django-mama-casBefore upgrading, see thechangelogfor any backward incompatible
changes or other important upgrade notes.ContributingContributions are welcome! The preferred process for changes is by submitting
GitHub pull requests. New code should follow bothPEP8and theDjango
coding style, generally respecting the style of the surrounding code. When
appropriate, pull requests should add or update tests, along with any
necessary documentation changes. With any substantial contribution, feel
free to add yourself as a contributor in the AUTHORS file.Development dependencies can be installed fromrequirements.txt.
Execute the test suite with:$ py.testYou can usetoxto run the tests against all supported versions of
Python and Django.
Package: django-management-audit
Audit your app’s management command calls with a single line of code. Logs command name and start/end timestamps on every run.QuickstartInstall django-south-central:pip install django-management-auditCreate database table for audit records:python manage.py syncdbUsageModify your manage.py file to import audit installer and run it:from management_audit import install

install(['your_app_name',])Optionally supply exclusion list of commands that you don’t want to audit:install(['your_app_name',], ['command_to_ignore',])When commands from your apps will be run,django-management-auditwill create a database record for each run which includes command’s name and start/end timestamps.TODOLog command parameters in addition to name and timestamps.Create admin UI to browse audit records.Add inclusion list as opposite to exlusion list (verify if that’s a use case at all)History0.1.0 (2014-01-01)First release on PyPI.
Package: django-management-auth
Django management authLogin to a Django application from a management command.Installationpip install django-management-authThen, addmanagement_authtoINSTALLED_APPS.Finally, add the required URLs:# urls.pyurlpatterns+=[path(".login-as",include("management_auth.urls"))]UsageAuthentication happens using a short-lived signed URL, generated from a management command../manage.py login_as <username>This will create a URL for<username>. By default, the URLs are valid for 60 seconds (configurable with--timeout).Fully-qualified URLsWhere possible, URLs, are displayed fully-qualified, such that they can be quickly clicked to log in.To specify manually, useMANAGEMENT_AUTH_BASE_URLFor Wagtail users,WAGTAILADMIN_BASE_URLis used to create the URL.Fordjango.contrib.sitesusers,SITE_IDis correctly consideredIf no base URL is found, a relative path is shown.Design considerationsTokens are only valid for a short amount of time, intended to prevent reuse / sharing.Tokens are signed URLs, rather than requiring a database table. This means the validation view is faster and more lightweight, and a database leak doesn't risk exposing sessions.Because tokens are signed, they can be used multiple times (however this is a bad idea)
Package: django-management-tools
Django Management ToolsCollection of tools to extend Django’s manage.py command.Free software: MIT licenseDocumentation:https://django-management-tools.readthedocs.io.Featurespython manage.py createadmin –user <username> –password <password> –email <emailaddress>username/password defaults to admin/admin
email default to nothingInstallationInstalldjango-management-toolsfrom pip$ pip install django-vault-helpersAdd the new packages to your installed apps.INSTALLED_APPS = [
    ...
    'managementtools',
    ...
]CreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2019-10-29)First release on PyPI.
Package: django-manage-newsletter
diddemo-newsletterDemo Newsletter is a Django app that manages your newsletter subscriptionsQuick start:Add "newsletter" to your INSTALLED_APPS setting like this.INSTALLED_APPS = [
...
'newsletter',
]Include the polls URLconf in your project urls.py like this.path('', include('newsletter.urls', namespace="news")),Run "python manage.py migrate" to create the NewsLetter models.Optional settings:NL_REDIRECT_HTMLDefailts to 'news/news_letter.html'. You can overwrite this settings by adding
NL_REDIRECT_HTML = 'your_html_location' to your settings.py file.UNSUBSCRIBE_DICTDefaults to {}. You can overwrite this setting by adding
UNSUBSCRIBE_DICT = {
"1": "Your first unsubscribe reason",
"2": "Your second unsubscribe reason",
"3": "Your third unsubscribe reason",
"4": "Your forth unsubscribe reason"
}, to your settings.py file.Note: "Not specified" will be used when KeyError is raised when processing an unsubscribe requestNote: More settings coming soonConfiguration:Main model: NewsLetter
Model form: NewsLetterForm - the form has an email field only
TemplateTag: {% nl_unsubscribe email=user_email reason=your_reason_key %}Code example:views.py:from django.views.generic.edit import FormView
 from newsletter.forms import NewsLetterForm

 class ExampleView(FormView):

 	template_name = "example.html"
 	form_class = NewsLetterForm
 	success_url = "/news-letter"

 	def form_valid(self, form):
 		form.save()
 		return super().form_valid(form)urls.py:from django.urls import path
 from . import views

 app_name = "your_app_name"

 urlpatterns = [
 	path("example", views.ExampleView.as_view(), name="example"),example.html:<form class="your-classes" id="newsletterform" method="POST">
   {% csrf_token %}
   <input type="email" class="your-classes" placeholder="Your email address.."  id="{{form.email.id_for_label}}" name="{{form.email.name}}">
   <button class="your-classes" type="submit">Subscribe</button>
 </form>Your email html:{% load news_tags %}...<a href="{% nl_unsubscribe email=email_address reason=reason_key %}">unsubscribe</a>...
Package: django-manage-reset-migrations
Installationpip install django-manage-reset-migrationsRelease 0.1UsageAdd django_manage_reset_migrations to INSTALLED_APPS./manage reset_migrationsIt will delete all the applied migrations from the disk and the db. Useful when migration files are too many and it slows down the computer. Reset migrations using this utility and run makemigration then fake all of them.Release 0.2UsageAdd django_manage_reset_migrations to INSTALLED_APPS./manage reset_migrationsThis will delete migrations for all apps from db and disk./manage reset_migrations –apps app1 app2 app3 …*This will delete migration for app1, app2, app3 only.As always pull requests are welcome :)
Package: django-managerie
django-managerie:lightbulb: Expose Django management commands as forms in the adminRequirementsDjango 3.2+ (this project tracks Django's end-of-life policy)Python 3.7+InstallationInstall the package as you would any Python package, then adddjango_managerieto yourINSTALLED_APPS.Automatic patchingThis is the easiest way to get up and running. You can have Managerie patch the admin site's dashboard view to include pseudo-models with the name "Commands" for all apps where management commands are available, and while it's at it, it'll also include URLs of its own.Hook up Managerie to your admin site (e.g. inurls.py, where you haveadmin.autodiscover()), like so:fromdjango.contribimportadminfromdjango_managerieimportManagerie# ...managerie=Managerie(admin_site=admin.site)managerie.patch()No patchingThis is likely safer (in the presence of slightly less tolerant 3rd party apps that mangle the admin, for instance), but you can't enjoy the luxury of the Commands buttons in the admin dashboard.fromdjango.contribimportadminfromdjango.conf.urlsimportinclude,urlfromdjango_managerieimportManagerie# ...managerie=Managerie(admin_site=admin.site)# ...urlpatterns=[# ...# ... url(r'^admin/', include(admin.site.urls)), ...url(r'^admin/',include(managerie.urls)),# Add this!]UsageIf you allowed Managerie to patch your admin, superusers can now seeCommands"objects" in the admin dashboard.
If you didn't patch the admin, you can access a list of all commands through/admin/managerie/(or wherever your
admin is mounted).If you click through to a command, you'll see the arguments of the command laid out as a form.
Fill the form, then hit "Execute Command", and you're done! :sparkles:Accessing the Django request from a managerie'd commandManagerie sets_managerie_requeston the command instance to the current Django request.
You can use it to access the request, for instance, to get the current user.TODOMoreargparseaction supportMultiple-argument support (nargs)
Package: django-manager-utils
django-manager-utilsAdditional utilities for Django model managers.InstallationTo install the latest release, type:pip install django-manager-utilsTo install the latest code directly from source, type:pip install git+git://github.com/ambitioninc/django-manager-utils.gitDocumentationFull documentation is available athttp://django-manager-utils.readthedocs.orgLicenseMIT License (see LICENSE)
Package: django-manifest
Django ManifestA kickstarter for Django Web Framework projects that supports both legacy frontend and javascript technolohies using REST API.Documentation:https://django-manifest.readthedocs.ioDemo:https://django-manifest.github.ioFeaturesUser registration & authentication.Password reset and email confirmation.Profile picture and settings.Future: Topic creation and branching.Future: User comments and rating.InstallationDownloadthe latest release, unzip file.AlternativelyRun in shell:$ pip install django-manifestSee setup instructions.DocumentationProject CreationFrontend Integration
Package: django-manifest-loader
Django Manifest LoaderReads a manifest file to import your assets into a Django template. Find
the URL for a single asset or the URLs for multiple assets by using
pattern matching against the file names. Path resolution handled using
Django's built-instaticfilesapp. Minimal configuraton,
cache-busting, split chunks.DocumentationAboutTurns this{% load manifest %}
<script src="{% manifest 'main.js' %}"></script>Into this<script src="/static/main.8f7705adfa281590b8dd.js"></script>Official documentationFor an in-depth look at this package, check outthis blog post hereQuick start blog postQuick reference:Manifest tag{% load manifest %}

<script src="{% manifest 'main.js' %}"></script>turns into<scriptsrc="/static/main.8f7705adfa281590b8dd.js"></script>Manifest match tag{% load manifest %}

{% manifest_match '*.js' '<script src="{match}"></script>' %}turns into<scriptsrc="/static/vendors~main.3ad032adfa281590f2a21.js"></script><scriptsrc="/static/main.8f7705adfa281590b8dd.js"></script>LicenseDjango Manifest Loader is distributed under the3-clause BSD license.
This is an open source license granting broad permissions to modify and redistribute the software.
Package: django-manifold
Manifold is aDjangoapplication
designed byACV Auctionsthat allows for
easy creation and serving of an RPC server through a WSGI interface
usingGunicorn ThriftandThriftpy.
Manifold usesApache Thriftto
standardize message transmission.It allows the Django project to define Thrift file locations and
services in the settings file. This then gives the power to define Python functions
to handle RPC calls, load the Thrift filesin memoryas a Python module,
serve an RPC WSGI server in both development and production, and serve a HTTP wrapper
around our RPC functions for frameworks and languages that don’t have RPC support.Table of ContentsCredits and MaintenanceThrift GuideUsage GuideContributing GuideLicenseCredits and MaintenanceManifold is built usingDjangoandThriftpy, and is maintained byACV Auctions.Thrift GuideFor an introduction and in-depth description of Thrift, we recommend
followingThrift: The Missing
Guide.Usage GuideView thedocumentationfor usage guides.Contributing GuideThis project is developed and maintained byACV
Auctions. We are always open to outside
contributers helping to making Manifold better. Please refer to
ourContribution Guideto make a change.LicenseManifold isApache 2.0 Licensed
Package: django-mantis-core
A wrapper around the Django Dingos application used by the Mantis
Cyber Threat Intelligence Management Framework. The rationale
for this wrapper is to provide a location for
code specific to cyber threat intelligence management that
is to be added to the underlying models. Such code should
not be added to Dingos, because Dingos is a generic framework.Please refer to the
documentation and developer guidelines ofDjango DingosandMANTIS.The full documentation of the Mantis core module is athttp://django-mantis-core.readthedocs.org/en/latest/AcknowledgmentsThe basic layout for this Django app with out-of-the-box configuration ofsetup.pyfor
easy build, submission to PyPi, etc., and Sphinx documentation tree was generated with Audrey Roy’s excellentCookiecutterand Daniel Greenfield’scookiecutter-djangopackagetemplate.History0.2.0 (2014-02-26)Added corresponding abstract model classes for
models introduced in DINGOS 0.2.0.0.1.0 (2013-12-19)Bump dependencies0.0.9 (2013-12-17)First release on PyPI.
Package: django-mantis-iodef-importer
An IODEF (v1.0) importer for the  Mantis Cyber Threat Intelligence Mgmt. Framework.DocumentationThe full documentation is athttp://mantis-iodef-importer.rtfd.org.QuickstartPlease refer to the Quickstart information of MANTIS, available athttp://django-mantis.rtfd.org.AcknowledgmentsThe basic layout for this Django app with out-of-the-box configuration ofsetup.pyfor
easy build, submission to PyPi, etc., and Sphinx documentation tree was generated with Audrey Roy’s excellentCookiecutterand Daniel Greenfield’scookiecutter-djangopackagetemplate.History0.1.0 (2013-12-19)Bugfixes; added documentation0.1.0 (2013-12-10)First release on PyPI.
Package: django-mantis-openioc-importer
A module implementing import of  OpenIOC indicator XML files for the Mantis Cyber Threat Intelligence Mgmt. Framework.DocumentationThe full documentation is athttp://django-mantis-openioc-importer.readthedocs.org.QuickstartPlease refer to the quickstart information of MANTIS, available athttp://django-mantis.readthedocs.org.Once you are set up with MANTIS, you can use the Djangomanage.pyto import
OpenIOC indicators into your system as follows:$ python manage.py mantis_openioc_import <xml-file>  <xml-file> ... [--settings=<path_to_your_django_settings_module]Here is the output of--helpformantis_openioc_import:Usage: manage.py mantis_openioc_import [options] xml-file xml-file ... (you can use wildcards)

Imports OpenIOC XML indicator files of specified paths into DINGO

Options:
  -v VERBOSITY, --verbosity=VERBOSITY
                        Verbosity level; 0=minimal output, 1=normal output, 2=verbose output, 3=very verbose output
  --settings=SETTINGS   The Python path to a settings module, e.g. "myproject.settings.main".
                        If this isn't provided, the DJANGO_SETTINGS_MODULE environment variable will be used.
  --pythonpath=PYTHONPATH
                        A directory to add to the Python path, e.g. "/home/djangoprojects/myproject".
  --traceback           Print traceback on exception
  -m MARKING_JSON, --marking_json=MARKING_JSON
                        File with json representation of information of marking to be associated with imports.
  -p PLACEHOLDER_FILLERS, --marking_pfill=PLACEHOLDER_FILLERS
                        Key-value pairs used to fill in placeholders in marking as described in marking file.
  -n IDENTIFIER_NS_URI, --id_namespace_uri=IDENTIFIER_NS_URI
                        URI of namespace used to qualify the identifiers of the created information objects.

  --version             show program's version number and exit
  -h, --help            show this help message and exitAcknowledgmentsThe basic layout for this Django app with out-of-the-box configuration ofsetup.pyfor
easy build, submission to PyPi, etc., and Sphinx documentation tree was generated with Audrey Roy’s excellentCookiecutterand Daniel Greenfield’scookiecutter-djangopackagetemplate.History0.2.0 (2014-01-26)Fixed bug in import of timestamp.0.1.1 (2013-12-19)Bugfixes: id-namespace was not properly treated.0.1.0 (2013-12-19)Bugfixes; added documentation0.0.9 (2013-12-19)First release on PyPI.