Saravanan666/pypi-org huggingface dataset:
Package: django-email-analytics
Django Email Analytics adds Google Analytics tracking to emails sent
with Django. It provides a wrapper for Django’s standard email backends.Installation and SetupInstall with pip:pip install django-email-analyticsThen set the email backend in the settings.py file.EMAIL_BACKEND = 'emailanalytics.backends.AnalyticsEmailBackend'SetEMAIL_ANALYTICS_BACKENDto the value you previously used forEMAIL_BACKEND. Or ifEMAIL_BACKENDwas unset, you can leaveEMAIL_ANALYTICS_BACKENDunset as well. This will chain the email
backends so that django-email-analytics will use your original backend
to send messages.OptionsBy default, URLs will be replaced only when the mimetype is text/html
and the URL occurs within ahrefattribute.SetEMAIL_ANALYTICS_REPLACE_TXTtoTrueif you would like to
also replace urls occuring in text emails.Tracking detailsIf a URL already contains tracking parameters, they are left unchanged.Otherwise, URLs are tagged with the following parameters:utm_sourceis set to the subject of the emailutm_mediumis set toemailutm_campaignis set towebappSee here for adescription of the tracking
parameters.
Package: django-email-bandit
Build Statusmaster:develop:A Django email backend for hijacking email sending in a staging/test environment. It extends
the default SMTP backend to intercept outgoing emails and instead send them
to a single email address that you specify. It does not intercept emails going to the site admins
(as defined by theADMINSsetting) so it will not interfere with 500 error emails.You can also configure the hijacked emails to be logged through standard Python
logging. Mixin classes are provided to use the same hijack logic for any existing
email backend such asdjango-ses.RequirementsPython 3Django >= 2.2 (supported versions)InstallationTo install django-email-bandit via pip:pip install django-email-banditAdd django-email-bandit to your installed apps:INSTALLED_APPS = (
    ...
    'bandit',
    ...
)For your test environment you should enable the backend:EMAIL_BACKEND = 'bandit.backends.smtp.HijackSMTPBackend'and set the email which will receive all of the emails:BANDIT_EMAIL = 'bandit@example.com'or even multiple addresses:BANDIT_EMAIL = ['bandit@example.com', 'accomplice@example.com']It’s also possible to whitelist certain email addresses and domains:BANDIT_WHITELIST = [
    'iloveemail@example.com',  # Just this specific email address
    'example.net'   # All email addresses @example.net
]DocumentationFull project documentation is onRead the Docs.Maintainer InformationWe use Github Actions to lint (using pre-commit, black, isort, and flake8),
test (using tox and tox-gh-actions), calculate coverage (using coverage), and build
documentation (using sphinx).We have a local script to do these actions locally, namedmaintain.sh:$ ./maintain.shA Github Action workflow also builds and pushes a new package to PyPI whenever a new
Release is created in Github. This uses a project-specific PyPI token, as described in
thePyPI documentation here. That token has been
saved in thePYPI_PASSWORDsettings for this repo, but has not been saved anywhere
else so if it is needed for any reason, the current one should be deleted and a new one
generated.As always, be sure to bump the version inbandit/__init__.pybefore creating a
Release, so that the proper version gets pushed to PyPI.Questions or Issues?If you have questions, issues or requests for improvements please let us know onGithub.Development sponsored byCaktus Consulting Group, LLC.
Package: django-email-blacklist
Python class to detect fake email providers. Checks each email against a blacklist of ~890 domains used by various disposable email services. Tested in production with Django. This package requires Python 3, for Python 2.7 supportsee here.InstallationInstall it usingpipand add it to  your Django INSTALLED_APPS:$ pip install django-email-blacklistCreate a folder in your templates directory and download the example email blacklist:$ wget https://raw.github.com/zeioth/django-email-blacklist/master/disposable_email_domains.txtAdd this to to yoursettings.py:DISPOSABLE_EMAIL_DOMAINS = "/path_to_your/disposable_email_domains.txt"UsageTo use the checker in your own scripts:>>> from django_email_blacklist import DisposableEmailChecker

>>> email_checker = DisposableEmailChecker()
>>> email_checker.is_disposable("foo@guerrillamail.com")
TrueCreditsThis is a fork from DisposableEmailChecker by aaronbassett, maintained by Zeioth.
Package: django-email-certify
Project Descriptionemail_verificationis a django package that verifies a user's email on registration.An email is sent to registered users to verify their email before login.All users that are not verified after 24hrs will be automatically deleted from the database.Installationpip install django-email-certifySetupAfter a successful installation, you will need to setup your django project to use the package. Follow the steps below to do that.First, we need to addemail_verificationto our project'sINSTALLED_APPS# settings.py

INSTALLED_APPS = [
    # ...other apps
    "email_verification.apps.EmailVerificationConfig",
]

EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
EMAIL_HOST = "smtp.gmail.com"
EMAIL_PORT = 465
EMAIL_HOST_USER = "your_email_user"
EMAIL_HOST_PASSWORD = "your_email_password"
EMAIL_USE_SSL = True
DEFAULT_FROM_EMAIL = "Default<no_reply@domain.com>"

LOGIN_URL = "" # ensure to set thisNext, we will add the url configuration for our package.# urls.py

urlpatterns = [
    # ...other urls
    path("verify-email/", include("email_verification.urls")),
]python manage.py migrateNext, we'll need to handle inactive user deletion for our project. To do that, we will be adding some configuration to ourwsgi.pyfile# wsgi.py

from threading import Thread

application = get_wsgi_application() # already in code

# this should come after the get_wsgi_application() object
from email_verification.views import delete_inactive_users

t = Thread(target=delete_inactive_users)
t.start()That's all for the configurations. Next up, we will be using verifying our users using a django form# views.py

from email_verification.views import VerifyEmail

def signup(request):
    form = RegisterForm() # create your form class
    if request.method == "POST":
        form = RegisterForm(request.POST)
        if form.is_valid():
            VerifyEmail(request, form)

            return redirect("redirect_url")
    
    return render(request, "register.html", {"form": form})
Package: django-email-change
django-email-changeAuthor:George NotarasDevelopment Web Site:django-email-change projectSource Code Repository:django-email-change source codeDocumentation:django-email-change documentationDownloads:django-email-change releasesdjango-email-change adds support for email address change and confirmation.Licensed under theApache License version 2.0. More licensing information
exists in thelicensesection.Warning: This project is not production ready! Testing is required.FeaturesProvides the users of a Django project with the ability to change their
account’s email address.Verification of the new email address.DocumentationApart from thedjango-email-change Online Documentation, more information about the
installation, configuration and usage of this application may be available
at the project’swiki.DonationsThis software is released as free-software and provided to you at no cost. However,
a significant amount of time and effort has gone into developing this software
and writing this documentation. So, the production of this software has not
been free from cost. It is highly recommended that, if you use this softwarein production, you should consider making a donation.To make a donation, please visit the CodeTRAXdonations pagewhich contains
aPayPaldonatebutton.Thank you for considering making a donation to django-email-change.Bugs and feature requestsIn case you run into any problems while using this application or think that
a new feature should be implemented, it is highly recommended yousubmita new
report about it at the project’sissue tracker.Using theissue trackeris the recommended way to notify the authors about
bugs or make feature requests. Also, before submitting a new report, please
make sure you have read thenew issue guidelines.SupportCodeTRAX does not provide support for django-email-change.You can still get community support at theCommunity Support Forums:LicenseCopyright 2010 George Notaras <gnot [at] g-loaded.eu>Licensed under theApache License, Version 2.0(the “License”);
you may not use this file except in compliance with the License.Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an “AS IS” BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.A copy of the License exists in the product distribution; theLICENSEfile.
For copyright and other important notes regarding this release please read
theNOTICEfile.
Package: django-email-changer
# Django Email ChangerDjango app to securely change a user’s email. This app will email your user at the new email with an activation URL. Once they click the link in the email, the new email will be put into their user account.## SettingsDjango Email Changer has some custom settings it looks for.###EMAIL_CHANGE_NOTIFICATION_SUBJECTThe subject of email change notifications.Default:“Email Change Activation”###EMAIL_CHANGE_NOTIFICATION_EMAIL_TEMPLATEThe template for email change notifications.Default:“django_email_changer/email_change_notification.txt”###EMAIL_CHANGE_NOTIFICATION_FROMWho is the email change notification from.Default:“no-reply@example.com”###EMAIL_CHANGE_ACTIVATION_SUCCESS_URLWhen a user activates their email, we’ll redirect to this URL so you can execute your code.Default:“/user-email-changed”###EMAIL_CHANGE_SUCCESS_URLAfter a successfully submitting a new email, the user is forwarded to this URL.Default:“/new-email-activation-sent”###CHANGE_EMAIL_CODE_EXPIRY_TIMEA dictionary of arguments fordatetime.timedelta. If modification is more thanCHANGE_EMAIL_CODE_EXPIRY_TIMEdays/hours/minutes/etc old then the modification will not be applied.Default:{“days”: 3}
Package: django-email-confirmation
This simple app is for cases where you don’t want to require an email
address to signup on your website but you do still want to ask for an
email address and be able to confirm it for use in optional parts of
your website.A user can have zero or more email addresses linked to them. The user
does not have to provide an email address on signup but, if they do,
they are emailed with a link they must click on to confirm that the
email address is theirs. A confirmation email can be resent at any
time.What’s on the trunk here should be usable but I welcome feedback on how
to make it better. The source contains a working project that shows all
the features of the app as well as providing useful code for your own
project (although Pinax is a more comprehensive example of how to use
django-email-confirmation).This code is based in part on django-registration and is essentially
a replacement for it where your requirements are different.
Package: django-email-confirm-la
Copyright (c) 2014 VintaPermission 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.Description: UNKNOWN
Keywords: django,email,mail,confirm,confirmation,content type
Platform: UNKNOWN
Classifier: Development Status :: 4 - Beta
Classifier: Environment :: Web Environment
Classifier: Framework :: Django
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.5
Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: 3.7
Classifier: Programming Language :: Python :: 3.8
Classifier: Topic :: Communications :: Email
Classifier: Topic :: Internet
Classifier: Topic :: Software Development :: Libraries
Classifier: Topic :: Software Development :: Libraries :: Python Modules
Classifier: Topic :: Utilities
Package: django-emaildeliverability
EmaildeliverabilityA Django app that help monitoring systems to ensure that emails reach their intended destination.InstallationUse the package manager pip to install Emaildeliverability.pip install django-emaildeliverabilityQuick startSet the following variables in your settings.py (replace the values with your own):EMAIL_DELIVERABILITY = {
    'USER': 'email@example.com',
    'PASSWORD': 'mysecretpassword',
    'SERVER': 'mail.example.com' # Imap server,
    'TIMEOUT': 45 # Optional. Time, in seconds, during which the app will try to verify that the email has reached its destination
    'INTERVAL': 5 # Optional. Retry interval
}Add "emaildeliverability" to your INSTALLED_APPS setting like this:INSTALLED_APPS = [
        ...,
        "emaildeliverability",
    ]Include the emaildeliverability URLconf in your project urls.py like this:path("emaildeliverability/", include("emaildeliverability.urls")),Point your prefered monitoring tool tohttp://localhost:8000/emaildeliverability/check(replace localhost:8000 with your host:port). The request will return the text 'OK' and a status of 200 if the email reached the destination mailbox before TIMEOUT seconds, or 'KO' and a status of 400 otherwise.
Package: django-email-disposable-checker
===============================
django-disposable-email-checkerDjango package to detect between ~890 & ~8,600 domains used by disposable email services.
You can validate any email against our internal list of ~890 domains used by
disposable email services. Optionally you can also check each domain against
theBlock-Disposable-Email.comAPI,
covering ~8,600 domains.This code was initially developed at:https://github.com/aaronbassett/DisposableEmailCheckerHowever PyPI ownership has been transferred tohttps://github.com/jheld/DisposableEmailCheckerand as such
all future contributions are expected to be made to the new github repo.SetupInstall the disposable email checker from PyPIpip install django-disposable-email-checkerThe disposable email checker comes with a list of ~890 emails. If you would like
to provide your own email list create a function which returns a list of domains
to block.fromdisposable_email_checker.emailsimportemail_domain_loaderdefcustom_email_domain_loader():# Anyone still using AOL will be too much of a customer service burdenreturn["aol.com",]+email_domain_loader()Then add the complete path including function name to your settingsDEC_LOADER="my.package.custom_email_domain_loader"If you would like to use theBDEintegration add your API key to your Django settingsBDEA_APIKEY="abcnotarealkey123"optionally you can configure the BDE API timeout in seconds (default 5)BDEA_TIMEOUT=2A default error message can be set globally for the validation checking (this is optional and if
left blank it will default to_('Blocked email provider.')):BDEA_MESSAGE='<blocked email message>'Adding to your modelsOnce you have completed setup add theDisposableEmailFieldto your models.fromdjango.dbimportmodelsfromdisposable_email_checker.fieldsimportDisposableEmailFieldclassMyModel(models.Model):email=DisposableEmailField()TheDisposableEmailFieldhas a few optional argumentswhitelist- A list of emails which will always be allowed. Defaults
to[]message- The error message used by ValidationError if validation
fails. Defaults to_('Blocked email provider.')code- The error code used by ValidationError if validation fails.
Defaults to "invalid".Using the validatorIf you want to use the validator by itselffromdjango.core.exceptionsimportValidationErrorfromdisposable_email_checker.validatorsimportvalidate_disposable_emailemail="emailaddress@readmetest.com"# replace with your own valuetry:validate_disposable_email(email)exceptValidationError:pass
Package: django-emailer
# django-emailerTemplate based email sending with SMTP connection management. Use this alongwith your transactional email sending provider.## InstallGet ready for a long process.$ pip install django-emailerAdd `'emailer'` to your `INSTALLED_APPS` setting then migrate/syncemailer models into the database.$ python manage.py syncdbDone.## How to useYou now have two new entities to play with: `ConnectionProfile` and`EmailTemplate`. Reach them through Django's admin to configure new SMTPconnections to use and set up your email templates as such:* `Name`: uppercase, underscode-separated words, **invariable** name todefine your template.* `Connection profile`: the STMP connection profile you created.* `Base template name`: set a different one of yours if you need a fancyemail template. Otherwise, `email/default.html` is just fine.* `Subject`: your email subject. Accepts Django context dictionary.* `Content`: you email body. Will be rendered into the `{{ content }}`template variable. Accepts Django context dictionary, of course.emailer has a very simple API, usable as follows:from emailer.models import EmailTemplateemail = EmailTemplate.get('YOUR_EMAIL_TEMPLATE_NAME').render(to='recipient@example.com',context={'customer_name': 'John Doe',})email.send()Note that the `context` argument will be used for both the subject andcontent of your email.**Protip**: Load your email templates into a fixture to ease the deployprocess. You may also need to have them dumped into test fixtures if you[hopefully] write unit tests to your application.
Package: django-email-foundation
django-email-foundationPackage that helps you build email templates easier in your projects.DescriptionIt's a Django package that helps you to build email templates for your email engine sender (we recommend you to usedjango-yubin).
It uses thezurb foundation for emailstemplates andnodepackages such asinkyorpanini.django-yubinzurb foundation for emailsThis gives you some commands and functionality to integratezurb foundation for emailsin your Django project.install_requires: A command for install the required node packages, such asinky,panini,gulp, etc., in your project.create_basic_structure: It creates in your project an essential folder tree which contains the basic layout and folders
such aspages,helpersandpartials, used by panini_.email_builder: Run agulpprocess to watch your source templates, build and move to your target email folder. It compiles
the sources using panini_ and inky_ for the best compatibility with the major email clients.Also, it gives you a Django view to preview the build templates and use a custom fixed context for each one, useful for your
designers that may edit the layouts.paniniinkyDocumentationPlease read the full documentation atreadthedocs
Package: django-email-gateway
django-email-gateway:Introduction:A Simple Django app to easily send emails, receive inbound emails from users with different email vendors like AWS SES, Sendgrid, Mailgun.Django email gatewayis used for sending mails from your verified domains. It can be used to send emails from different email vendors like (AWS SES, Sendgrid, MailGun). Using this app, we can easily use different email vendors to verified, non-verified users.Installation ProcedureUsepipto install easily with one step:$ pip install django-email-gatewayPull the code fromgithubusing the following command:git clone git://github.com/micropyramid/django-email-gateway.git

cd django-email-gateway

python setup.py installConfigurationAfter installing/cloning the django app, add the following details in settings file to setup your email vendor for verified & non-verified users:MAIL_SENDER='AMAZON'|'SENDGRID'|'MAILGUN'INACTIVE_MAIL_SENDER='AMAZON'|'SENDGRID'|'MAILGUN'If you’re usingAmazonas a email vendor, add the following settings with their values:AWS_ACCESS_KEY_ID="Your AWS Access Key"AWS_SECRET_ACCESS_KEY="Your AWS Secret Key"If you’re usingSendgridas a email vendor, add the following settings with their values:SG_USER="Your Sendgrid Username"SG_PWD="Your Sendgrid Password"If you’re usingMailgunas a email vendor, add the following settings with their values:MGUN_API_URL="Your MailGun Api Url"MGUN_API_KEY="Your MailGun Api Key"How It Works?Sending Emails:You can easily send emails to verified and non-verified users from different email vendors like AWS SES, Sendgrid, Mailgun.
Withsending_mailfunction, you can send custom emails to users. By default, it’ll send emails from sendgrid. Based on user verification, it will send emails to users from the specified email vendor.Receiving Email:You can easily get the receving emails from different vendors like sendgrid, aws ses, mailgun, by configuring and veririfying your website records in the specified email vendors like SES.Now It supports only ses for receiving emails, we’ll release a version to support sendgrid, mailgun.How To Use:Add these settings to send & receive emails from different vendors.Sending email:sending_mail(subject, email_template_name, context, from_email, to_email, verified)Receiving emails:from django_email_gateway.receiving_mail import sns_notification
subject, from_mail, to_mail, hash_code, mail_content = sns_notification(request.body)It will process your message content, will return the email subject, from mail, to email(abc@yourdomain.com), hashcode(abc), mail content.Visit our Django web development pageHereWe welcome your feedback and support, raisegithub ticketif you want to report a bug. Need new features?Contact us here
Package: django-email-hijacker
NoteFor the latest source, discussions, etc., please visit theGitHub repositoryDjango Email HijackerDjango Email Hijacker lets you send emails via your favourite email backend but sends them to a specified email address instead of the intended recipients.It allows you to send emails via a real backend from a development or staging environment without worrying that an actual user might get sent unintended emails.Installationpip install django-email-hijackerIn your development or stagingsettings.py:EMAIL_BACKEND = "email_hijacker.backends.hijacker.EmailBackend"

HIJACKER_EMAIL_ADDRESS = "hijacker@example.org"
HIJACKER_EMAIL_BACKEND = "your.real.EmailBackend"NoteDjango Email Hijacker usesDjango Pods.It allows for prefix style settings:HIJACKER_EMAIL_ADDRESS = "hijacker@example.org"
HIJACKER_EMAIL_BACKEND = "your.real.EmailBackend"Or dictionary style settings:HIJACKER = {
    "EMAIL_ADDRESS": "hijacker@example.org",
    "EMAIL_BACKEND": "your.real.EmailBackend"
}Running TeststoxContributionsAll contributions and comments are welcome.Change Logv0.3.2Fix #2: exclude tests packagev0.3.1Switch to Semantic VersioningFix issue with parse_requirements for newer versions of pip (>=6.0.0)v0.3Use Django Pods for settingsv0.2Unit tests now use Django 1.7 final instead of RC1v0.1Initial