def post(self, request, *args, **kwargs):
if not settings.USE_MAILCHIMP:
return Response({
"status": "error",
"error": "Mailchimp is currently disabled."
})
new_user_data = {
'email_address': request.data['email'],
'status': 'subscribed',
'tags': ['newsletter']
}
mailchimp_client = MailChimp(settings.MAILCHIMP_API_KEY,
settings.MAILCHIMP_USERNAME)
# add the new user to the mailchimp list
try:
mailchimp_client.lists.members.create(settings.MAILCHIMP_LIST_ID,
new_user_data)
return Response({
"status": "success",
"request": str(new_user_data)
})
# TODO: Look into best practices for returning errors.
except ValueError as value_error:
return Response({"status": "error", "error": str(value_error)})
except Exception as e:
if e.args[0].get('title') == "Member Exists":
error_msg = "Email is already subscribed to newsletter."
else:
error_msg = "Unknown error. Please try again later."
return Response({"status": "error", "error": error_msg})
def list_campaigns(filter=None):
"""This function creates a campaign in MailChimp through their API.
:param attribute filter: an issuer internal indentifier.
:returns: Campaign object or list of campaigns."""
client = MailChimp(
mc_user=djangoSettings.MC_USER,
mc_api=djangoSettings.MC_API_KEY,
)
data = client.campaigns.all(get_all=True)['campaigns']
# A filter value has been sent, only return relevant rows
if filter:
output = []
for r in data:
row = {}
if str(filter) in r['settings']['title']:
row['settings'] = r['settings']
row['report_summary'] = r['report_summary']
row['report_summary']['emails_sent'] = r['emails_sent']
row['report_summary']['send_time'] = parser.parse(
r['send_time'])
output.append(row)
return output
else:
return data
def add_to_common_list_view(request):
"""Веб-сервис, добавляющий email в общий лист рассылки"""
email = request.GET.get('email')
if not email:
return JsonResponse({'success': False, 'message': 'Передайте email'})
mailchimp_client = MailChimp(
mc_api=settings.MAILCHIMP_API_KEY,
mc_user=settings.MAILCHIMP_USERNAME)
mailchimp_client.lists.members.create(settings.MAILCHIMP_COMMON_LIST_ID, {
'email_address': email,
'status': 'subscribed',
})
subscriber_hash = mailchimp_client \
.search_members \
.get(query=email
fields='exact_matches.members.id') \
.get('exact_matches').get('members')[0].get('id')
mailchimp_client.lists.members.tags.update(
list_id=settings.MAILCHIMP_COMMON_LIST_ID,
subscriber_hash=subscriber_hash,
data={'tags': [{'name': 'COMMON TAG', 'status': 'activate'}]})
CommonMailingList.objects.get_or_create(email=email)
return JsonResponse({'success': True})
def update_mailchimp(modeladmin, request, queryset):
valid_contacts = queryset.filter(email__isnull=False)
client = MailChimp(mc_api=settings.MAILCHIMP_API, mc_user=settings.MAILCHIMP_USER)
listas = client.lists.all(get_all=True, fields="lists.name,lists.id")
lista = listas['lists'][0]['id']
for p in valid_contacts:
user_hash = get_subscriber_hash(p.email)
contact = {
'email_address': p.email,
'status_if_new': 'subscribed',
'merge_fields': {
'FNAME': p.nome,
'LNAME': p.sobrenome,
'CITY' : p.cidade,
'STATE' : p.estado,
'ORG' : p.entidade.first().nome if p.entidade.first() else '',
'SENSIBLE' : '',
'EVENTS' : '',
'PHONE' : p.telefone,
'ADDRESS' : p.endereco,
'GENDER' : p.sexo.nome if p.sexo else '',
'AGE' : p.idade()
},
'tags' : [],
}
contact['merge_fields'] = return_empty(contact['merge_fields'])
resultado = client.lists.members.create_or_update(lista, user_hash, return_empty(contact))
modeladmin.message_user(request, '{} contatos atualizados.'.format(valid_contacts.count()))
def delete_user_from_mailchimp(email_address):
client = MailChimp(mc_user=settings.MAILCHIMP_USER, mc_api=settings.MAILCHIMP_API_KEY)
result = None
try:
result = client.search_members.get(query=email_address)
if result:
subscriber_hash = result.get('exact_matches', {}).get('members', [{}])[0].get('id', None)
except Exception as e:
logger.debug(e)
try:
client.lists.members.delete(
list_id=settings.MAILCHIMP_LIST_ID,
subscriber_hash=subscriber_hash,
)
except Exception as e:
logger.debug(e)
try:
client.lists.members.delete(
list_id=settings.MAILCHIMP_LIST_ID_HUNTERS,
subscriber_hash=subscriber_hash,
)
except Exception as e:
logger.debug(e)
try:
client.lists.members.delete(
list_id=settings.MAILCHIMP_LIST_ID_HUNTERS,
subscriber_hash=subscriber_hash,
)
except Exception as e:
logger.debug(e)
def setup_mailchimp_client():
user_name = 'anystring'
api_key = os.environ['MAILCHIMP_API_KEY']
headers = requests.utils.default_headers()
client = MailChimp(user_name, api_key, request_headers=headers)
print 'MailChimp client created'
return client
def push_new_users_to_mailchimp(key, new_users, list_id):
"""Push new users to MailChimp new user list."""
logging.info('Making an API call to MailChimp')
client = MailChimp('apikey', str(key).strip())
current_members = get_all_current_members_of_list(client, list_id)
logging.info('Pushing New Users to list: {0}'.format(list_id))
for email, full_name in new_users.iteritems():
if email not in current_members:
name_split = full_name.split()
try:
client.lists.members.create(
list_id, {
'email_address': email,
'status': 'subscribed',
'merge_fields': {
'FNAME': name_split[0],
'LNAME': name_split[-1],
},
})
except requests.exceptions.HTTPError as error:
if DEBUG:
logging.error('Error: {0}'.format(error))
pass
return
def verify_user(request, user_id, activation_nonce):
""" Verify email and assign api token """
user = get_object_or_404(CapUser, pk=user_id)
# This leaks a little info -- we reveal whether a user ID exists or not and whether it is verified or deactivated.
# This seems acceptable to provide better messages to legitimate users.
if user.email_verified:
return render(request, 'registration/verified.html')
if not user.is_active:
return render(
request, 'registration/verified.html',
{'error': 'This account is not active and cannot be verified.'})
error = None
mailing_list_message = "We have not signed you up for our newsletter, Lawvocado. Sign up any time from our homepage."
try:
user.authenticate_user(activation_nonce=activation_nonce)
except PermissionDenied:
error = mark_safe(
"This verification code is invalid or expired. <a href='%s'>Resend verification</a>?"
% reverse('resend-verification'))
else:
# user authenticated successfully
# update API limits for first X users per day
# users after this limit will have approved accounts, but we will have to go back manually to increase limits
site_limits = SiteLimits.add_values(daily_signups=1)
if site_limits.daily_signups < site_limits.daily_signup_limit:
user.total_case_allowance = user.case_allowance_remaining = settings.API_CASE_DAILY_ALLOWANCE
user.save()
# sign them up for the mailing list if they selected the mailing_list checkbox.
if settings.MAILCHIMP['api_key'] and user.mailing_list:
try:
mc_client = MailChimp(mc_api=settings.MAILCHIMP['api_key'],
mc_user=settings.MAILCHIMP['api_user'])
mc_client.lists.members.create(
settings.MAILCHIMP['id'], {
'email_address': user.email,
'merge_fields': {
'LNAME': user.first_name,
'FNAME': user.last_name
},
'status': 'subscribed'
})
mailing_list_message = "Also, thanks for signing up for our newsletter, Lawvocado."
except MailChimpError as e:
if e.args[0]['status'] == 400 and e.args[0][
'title'] == 'Member Exists':
mailing_list_message = "Also, thanks for your continued interest in our newsletter, " \
"Lawvocado. We'll keep you on our list."
else:
logger.exception(
"Error adding user email %s to mailing list" %
user.email)
return render(request, 'registration/verified.html', {
'error': error,
'mailing_list_message': mailing_list_message,
})
def mailchimp_subscribe(request: AuthHttpRequest):
user = request.user
if settings.TESTING or settings.DEBUG:
logger.warning(f"Not actually subscribing {user} since we're testing")
return
elif API_KEY is not None:
try:
client = MailChimp(mc_api=API_KEY, mc_user='******')
client.lists.members.create(
os.getenv('MAILCHIMP_LIST_ID'), {
'email_address': user.email,
'status': 'subscribed',
'merge_fields': {
'FNAME': user.first_name,
'LNAME': user.last_name,
}
})
messages.success(
request, "The email {user.email} is now listed as the " +
"contact point for OTIS announcements from Evan.")
except MailChimpError as e:
logger.error(f"Could not add {user.email} to MailChimp",
exc_info=e)
messages.warning(
request,
"The email {user.email} could not be added to MailChimp, maybe it's subscribed already?"
)
else:
raise Exception("No API KEY provided in production!")
def form_valid(self, form):
mailchimp_enabled = settings.MAILCHIMP_API_KEY and settings.MAILCHIMP_LIST_ID
dummy_key = 'a' * 32
client = MailChimp(mc_api=settings.MAILCHIMP_API_KEY or dummy_key,
timeout=5.0,
enabled=mailchimp_enabled)
data = form.cleaned_data.copy()
email = data.pop('email')
data = {k.upper(): v for k, v in data.items()}
try:
client.lists.members.create(
settings.MAILCHIMP_LIST_ID, {
'email_address': email,
'status': 'pending',
'merge_fields': data,
})
except Exception as e:
self.warning(e)
else:
if mailchimp_enabled:
self.success()
else:
self.warning(
Exception(
'Incorrect Mailchimp configuration: API_KEY: {}, LIST_ID: {}'
.format(
str(settings.MAILCHIMP_API_KEY),
str(settings.MAILCHIMP_LIST_ID),
)))
return super().form_valid(form)
def handle(self, *args, **options):
print("- match")
from marketing.models import Match
for match in Match.objects.all():
process_email(match.email, 'match')
get_size = 50
client = MailChimp(settings.MAILCHIMP_USER, settings.MAILCHIMP_API_KEY)
print('mailchimp')
for i in range(0, 90000):
members = client.lists.members.all(settings.MAILCHIMP_LIST_ID,
count=get_size,
offset=(i * get_size),
fields="members.email_address")
members = members['members']
if not len(members):
break
print(i)
for member in members:
email = member['email_address']
process_email(email, 'mailchimp')
#TODO: could sync back
#with client.lists.members.create(
print('/mailchimp')
print('local')
print("- dashboard_sub")
from dashboard.models import Subscription
for sub in Subscription.objects.all():
email = sub.email
process_email(email, 'dashboard_subscription')
print("- tip")
from dashboard.models import Tip
for tip in Tip.objects.all():
for email in tip.emails:
process_email(email, 'tip_usage')
print("- bounty")
from dashboard.models import Bounty
for b in Bounty.objects.all():
email_list = []
if b.bounty_owner_email:
email_list.append(b.bounty_owner_email)
if b.claimee_email:
email_list.append(b.claimee_email)
for email in email_list:
process_email(email, 'bounty_usage')
print("- tdi")
from tdi.models import WhitepaperAccess, WhitepaperAccessRequest
for wa in WhitepaperAccess.objects.all():
process_email(wa.email, 'whitepaperaccess')
for wa in WhitepaperAccessRequest.objects.all():
process_email(wa.email, 'whitepaperaccessrequest')
print('/local')
def get_client(subscription):
client = MailChimp(
mc_api=subscription.mc_api,
mc_user=subscription.mc_user,
timeout=30.0,
)
return client
def get(self, service=""):
# test MailChimp API
if service == "mailchimp":
try:
MAILCHIMP_API = os.environ.get('MAILCHIMP_API')
headers = requests.utils.default_headers()
client = MailChimp(mc_api=MAILCHIMP_API, timeout=60.0, request_headers=headers)
client.lists.all(get_all=True, fields="lists.id")
return {'status': 'OK'}, 200
except Exception as e:
log.error(str(e))
# test GA API
if service == "ga":
try:
# Define the auth scopes to request.
scope = 'https://www.googleapis.com/auth/analytics.readonly'
key_file_location = 'client_secrets.json'
# Authenticate and construct service.
service = get_service(api_name='analytics',
api_version='v3',
scopes=[scope],
key_file_location=key_file_location)
service.management().accounts().list().execute()
return {'status': 'OK'}, 200
except Exception as e:
log.error(str(e))
return {'status': 'ERROR'}, 500
def main():
# set all paths
path_to_apikey = '/home/ubuntu/.apikeys'
apikey_file = 'mailchimp-list.api'
mc_user_file = 'mailchimp-user'
path_to_lists = '/home/ubuntu/path/to/mailing-lists/updates'
path_to_id_dict = '/home/ubuntu/.apikeys/list_ids.pickle'
path_to_tag_dict = '/home/ubuntu/.apikeys/tag_ids.pickle'
# load keys and data
apikey = load_key(path_to_apikey, apikey_file)
mailchimp_user = load_key(path_to_apikey, mc_user_file)
lists_to_update = os.listdir(path_to_lists)
list_id_dict = load_pickle(path_to_id_dict)
tag_id_dict = load_pickle(path_to_tag_dict)
master_list_name = '<CLIENT> Master Contact List'
file_list_id = list_id_dict[master_list_name]
new_member_list = list_id_dict['<CLIENT> New Members']
# initialize mailchimp client
client = MailChimp(mc_api=apikey, mc_user=mailchimp_user)
# add all new members to mailchimp
for listfile in lists_to_update:
# get tag id instead of list id
# use one master list
segment_id = tag_id_dict[listfile]
list_to_add = os.path.join(path_to_lists, listfile)
print('---> Starting List:', listfile)
print('List ID:', file_list_id)
print('Tag ID:', segment_id)
add_to_mailchimp(list_to_add, file_list_id, segment_id, listfile,
new_member_list, client)
def post(self, request):
serializer = WaitlistSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
client = MailChimp(mc_api=MAILCHIMP_API_KEY, mc_user='******')
try:
client.lists.update_members(
list_id=MAILCHIMP_WAITLIST_ID,
data={
'members': [{
'email_address':
serializer.validated_data['email'],
'status':
'pending'
}]
})
total = client.lists.members.all(
MAILCHIMP_WAITLIST_ID,
status='subscribed',
get_all=True,
fields="members.email_address,members.id")
count = len(total['members'])
except requests.exceptions.RequestException as e:
raise APIException('Could not subscribe to waitlist')
return Response({'count': count})
def check_connection(self, logger: AirbyteLogger, config: Mapping[str, Any]) -> Tuple[bool, Any]:
try:
client = MailChimp(mc_api=config["apikey"], mc_user=config["username"])
client.ping.get()
return True, None
except Exception as e:
return False, repr(e)
class SubscribeView(FormView):
template_name = 'tonight/subscribe.html'
form_class = EmailForm
success_url = '/thanks/'
client = MailChimp(MAILCHIMP_USER, MAILCHIMP_API_KEY)
def subscribe(self, list_id, email):
self.client.lists.members.create(list_id, {
'email_address': email,
'status': 'subscribed',
})
def form_valid(self, form):
# https://github.com/charlesthk/python-mailchimp
data = form.cleaned_data
try:
if data['city'] == 'ALL':
self.subscribe('9219e7e784', data['email'])
elif data['city'] == 'HN':
self.subscribe('ebb54415a6', data['email'])
elif data['city'] == 'SG':
self.subscribe('ca0033027c', data['email'])
except Exception:
return HttpResponseRedirect('/subscribe/existed/')
return super(SubscribeView, self).form_valid(form)
def post(self, request):
serializer = WaitlistSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
client = MailChimp(mc_api=MAILCHIMP_API_KEY, mc_user='******')
try:
client.lists.update_members(
list_id=MAILCHIMP_WAITLIST_ID,
data={
'members': [{
'email_address':
serializer.validated_data['email'],
'status':
'pending'
}]
})
local_cache = cache
count = local_cache.get('waitlist_count')
if not count:
response = client.lists.members.all(MAILCHIMP_WAITLIST_ID,
status='subscribed',
count=0)
count = response['total_items']
local_cache.set('waitlist_count', count)
local_cache.incr('waitlist_count')
except requests.exceptions.RequestException as e:
raise APIException('Could not subscribe to waitlist')
return Response({'count': count})
def mailchimp_subscribe(request, email, first_name, last_name, organisation, job_title):
"""Subscribe `email` to newsletter.
Returns boolean indicating success
"""
del request.session["newsletter_email"]
email_hash = hashlib.md5(email.encode("utf8")).hexdigest()
data = {
"email_address": email,
"status": "subscribed",
"merge_fields": {
"FNAME": first_name,
"LNAME": last_name,
"MMERGE3": organisation,
"MMERGE4": job_title,
},
}
client = MailChimp(
mc_user=get_env_setting("MAILCHIMP_USER"),
mc_api=get_env_setting("MAILCHIMP_API_KEY"),
)
try:
client.lists.members.get(
list_id=settings.MAILCHIMP_LIST_ID, subscriber_hash=email_hash
)
return True
except MailChimpError:
try:
client.lists.members.create(list_id=settings.MAILCHIMP_LIST_ID, data=data)
return True
except MailChimpError:
# things like blacklisted emails, etc
logger.warn("Unable to subscribe %s to newsletter", email)
return False
def update_email_subscriptions(sender, instance, created, **kwargs):
if settings.DEBUG==False and not created:
client = MailChimp(mc_api=settings.MAILCHIMP_API_KEY, timeout=10.0)
email_hash = hashlib.md5(instance.user.email.lower().encode('utf-8')).hexdigest()
interests = {}
subscription_groups = SubscriptionGroup.objects.all();
for group in subscription_groups:
interests[group.group_id] = instance.subscription_groups.filter(group_id__iexact=group.group_id).exists()
client.lists.members.create_or_update(
list_id=settings.SPEAKER_LIST_ID,
subscriber_hash=email_hash,
data={
'email_address': instance.user.email,
'status': 'subscribed',
'status_if_new': 'pending',
'merge_fields': {
'FNAME': instance.first_name,
'LNAME': instance.last_name,
'IWOMAN': "Yes" if instance.woman else "No",
'IPOC': "Yes" if instance.poc else "No",
'ILGBTQA': "Yes" if instance.lgbtqa else "No",
'ITITLE': instance.position if instance.position else "undisclosed position",
'ICOMPANY': instance.organization if instance.organization else "undisclosed company",
'ICITY': instance.location.city if instance.location else "undisclosed location",
},
'interests': interests
}
)
def add_user_to_mailing_list(email: str) -> None:
"""
Adds the new user's email to our mailchimp list (which should trigger a
welcome email)
"""
try:
user = AuthUser.objects.get(email=email)
client = MailChimp(settings.MAILCHIMP_API_KEY,
mc_user=settings.MAILCHIMP_USERNAME)
res = client.lists.members.create(
settings.MAILCHIMP_LIST_ID,
{
"email_address": email,
"status": "subscribed",
"merge_fields": {
"FNAME": user.first_name,
"LNAME": user.last_name
},
},
)
logger.info("Added user to email list. Response: ", res)
except Exception as e:
logger.exception(
f"Exception while adding email {email} to mailing list.", e)
def form_valid(self, form):
# add to mailchimp
email = form.cleaned_data.get('email')
if settings.MAILCHIMP_ENABLE and email:
email_hash = hashlib.md5(email.lower().encode('utf-8')).hexdigest()
try:
mailchimp_client = MailChimp(
mc_api=settings.MAILCHIMP_API_KEY,
mc_user=settings.MAILCHIMP_USERNAME)
data = {
'email_address': email,
'status': 'subscribed',
'status_if_new': 'subscribed'
}
mailchimp_client.lists.members.create_or_update(
list_id=settings.MAILCHIMP_LIST_ID,
subscriber_hash=email_hash,
data=data)
except Exception as e:
pass
return super().form_valid(form)
def my_handler(event, context):
api_key = os.environ['API_KEY']
username = os.environ['USERNAME']
list_id = os.environ['LIST_ID']
client = MailChimp(mc_api=api_key, mc_user=username)
content_type = event['headers']['Content-Type']
email = parse_email(content_type, event['body'])
try:
lists = client.lists.all()
logger.info(lists)
members = client.lists.members.create(list_id, {
'email_address': email,
'status': 'subscribed'
})
except MailChimpError as e:
print(e)
return {
'statusCode': 400,
"header": {
"Content-Type": "application/json"
},
'body': str(e)
}
return {
'statusCode': 200,
"header": {
"Content-Type": "application/json"
}
'body': ''
}
def add_to_case_list_view(request):
"""Веб-сервис, добавляющий email в лист рассылки по конкретному делу"""
email = request.GET.get('email')
if not email:
return JsonResponse({'success': False, 'message': 'Передайте email'})
case_id = request.GET.get('case_id')
if not case_id:
return JsonResponse({'success': False, 'message': 'Передайте case_id'})
mailchimp_client = MailChimp(
mc_api=settings.MAILCHIMP_API_KEY,
mc_user=settings.MAILCHIMP_USERNAME)
mailchimp_client.lists.members.create(settings.MAILCHIMP_CASE_LIST_ID, {
'email_address': email,
'status': 'subscribed',
})
subscriber_hash = mailchimp_client \
.search_members \
.get(query=email
fields='exact_matches.members.id') \
.get('exact_matches').get('members')[0].get('id')
case = Case.objects.get(pk=case_id)
case_tag = f'Case {case.name}'
mailchimp_client.lists.members.tags.update(
list_id=settings.MAILCHIMP_CASE_LIST_ID,
subscriber_hash=subscriber_hash,
data={'tags': [{'name': case_tag, 'status': 'activate'}]})
CaseMailingList.objects.get_or_create(email=email)
return JsonResponse({'success': True})
def push_to_mailchimp():
print('- push_to_mailchimp')
client = MailChimp(settings.MAILCHIMP_API_KEY, settings.MAILCHIMP_USER)
created_after = timezone.now() - timezone.timedelta(hours=2)
eses_funder = EmailSubscriber.objects.filter(
active=True,
created_on__gt=created_after,
profile__persona_is_funder=True).order_by('-pk')
print("funder emails")
print("- {} emails".format(eses_funder.count()))
sync_mailchimp_list(eses_funder, settings.MAILCHIMP_LIST_ID_FUNDERS)
eses_hunter = EmailSubscriber.objects.filter(
active=True,
created_on__gt=created_after,
profile__persona_is_hunter=True).order_by('-pk')
print("hunter emails")
print("- {} emails".format(eses_hunter.count()))
sync_mailchimp_list(eses_hunter, settings.MAILCHIMP_LIST_ID_HUNTERS)
eses = EmailSubscriber.objects.filter(
active=True, created_on__gt=created_after).order_by('-pk')
print("all emails")
print("- {} emails".format(eses.count()))
sync_mailchimp_list(eses, settings.MAILCHIMP_LIST_ID)
print('/push_to_mailchimp')
def essense(request):
if request.method == 'GET':
cal = Calendar.objects.all()[:5]
side = Post.objects.filter(page='SB')
info = Post.objects.filter(page='CI')
post = Post.objects.filter(page='ES')
context = {
'post': post,
'title': '',
'side': side,
'info': info,
'cal': cal
}
#if get, show past newsletters
return render(request, 'Stevie/letterIndex.html', context)
elif request.method == 'POST':
emailer = request.POST.get('name')
email = request.POST.get('email')
client = MailChimp(mc_api=API_KEY)
client.lists.members.create(
LIST_ID, {
'email_address': email,
'status': 'subscribed',
'merge_fields': {
'FNAME': emailer,
},
})
return redirect('essense')
def reports_result(date_range, campaign_name_search): client = MailChimp(user_name, api_key) all_json_data = client.reports.all(get_all=True) all_reports = all_json_data['reports'] reports_in_daterange = all_reports#[0:50] # TODO: create new method find_index_for_date_range to handle a simple string date range input and provide the right index number for this filter matching_reports = [reports for reports in reports_in_daterange if campaign_name_search in reports["campaign_title"]] return matching_reports
def client(self) -> MailChimp:
"""
Get the MailChimp client
"""
return MailChimp(mc_user=settings.NEWSLETTER_USERNAME,
mc_secret=settings.NEWSLETTER_API_KEY,
request_headers=self.headers)
def get_client():
headers = default_headers()
headers['User-Agent'] = 'Digital Marketplace (marketplace.service.gov.au)'
client = MailChimp(getenv('MAILCHIMP_SECRET_API_KEY'),
getenv('MAILCHIMP_USERNAME'),
timeout=30.0,
request_headers=headers)
return client
def _get_mailchimp_client() -> MailChimp:
"""
Возвращает клиент API для работы с Mailchimp
"""
return MailChimp(
mc_api=settings.MAILCHIMP_API_KEY,
mc_user=settings.MAILCHIMP_USERNAME
)
