增强现实AR>> cli_with_python>> 返回
项目作者： Alexmhack

项目描述 ：
command line intergration with python
高级语言： Python
项目地址: git://github.com/Alexmhack/cli_with_python.git
创建时间： 2018-09-03T05:24:23Z
项目社区：https://github.com/Alexmhack/cli_with_python
开源协议：
下载


cli_with_python

command line intergration with python

In this tutorial we will be continuing where we left off in previous tutorial series

If you haven’t started from there be sure to complete that tutorial first

So far we have made our command line app work with simple commands like

USAGE

  1. .../python_intermediate> python integrate --help
  2. .../python_intermediate> python integrate -h
  3. .../python_intermediate> python integrate view -id 1
  4. .../python_intermediate> python integrate view --user_id 10
  5. .../python_intermediate> python integrate message -id 1

In this tutorial we will be advancing our command line app.

Installation

Just clone the repository and you can all the above commands, add more data in data.csv
file and create your own commands by adding or editing code in __main__.py file.

Advancing Project

Create a new folder inside integrate folder and name it utils , copy paste the
__init__.py file in the utils fodler which makes utils a python module.

Now copy the templates.py file from python_intermediate/python_emailing and paste
it inside the utils folder.

Project Tree

  1. C:.
  2. └───integrate
  3.     ├───python_csv
  4.     ├───templates
  5.     ├───utils
  6.     │   └───__pycache__
  7.     └───__pycache__

integrate folder

  1. C:.
  2. ├───python_csv
  3. ├───templates
  4. ├───utils
  5. │   └───__pycache__
  6. └───__pycache__

Now we will move some of the code from templates.py into __main__.py

templates.py

  1. import os
  3. def get_template_path(path):
  4.     file_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), path)
  5.     if not os.path.isfile(file_path):
  6.         raise Exception(f"{file_path} is not a valid template path...")
  7.     return file_path
  10. def get_template(path):
  11.     file_path = get_template_path(path)
  12.     return open(file_path).read()
  15. def render_context(template_string, context):
  16.     return template_string.format(**context)
  1. __main__.py
  3. from utils.templates import get_template, render_context
  4. ...
  6. if args.type == "view":
  7.     if args.user_id:
  8.         print(find_user(user_id=args.user_id))
  9.     if args.email:
  10.         print(find_user(user_email=args.email))
  11. else:
  12.     print("sending message")
  13.     template = get_template(r'templates\email_message.txt')
  14.     template_html = get_template(r'templates\email_message.html')
  16.     context = {
  17.         'name': 'Pranav',
  18.         'date': '15th Aug, 18',
  19.         'total': 599
  20.     }
  22.     print(render_context(template, context))
  23.     print(render_context(template_html, context))
  24.     print("sending message...")

This will only give us one more functionality of priting the message that exists inside
the templates templates\email_message.txt and templates\email_message.html

Oh yes, where does these two templates come from, we have on more copy paste work left.
Copy the whole templates folder from python_intermediate and paste it in
integrate

We have made some changes in templates.py file.

  1. def get_template_path(path):
  2.     file_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), path)
  3.     ...

The file path argument that function takes looks into the integrate folder, you can print
the file_path to check. We achieve this using two os.path.dirname, first one
takes us back one folder and second tells to take from this current folder and then we join
the paths.

  1. .../cli_with_python> python integrate message
  3. # RESULT
  4. sending message
  5. Hi Pranav!
  6. Thank you for your purchase on 15th Aug, 18.
  7. We hope you are excited about using it.
  8. Just as a reminder the purchase total was $599.
  9. Have a greate one!
  11. Team Alexmhack
  12. <!DOCTYPE html>
  13. <html>
  14. <head>
  15.         <title>Alexmhack Email Message</title>
  16. </head>
  17. <body>
  18.         <h1>Hi Pranav!</h1>
  19.         <p>
  20.                 Thank you for your purchase on 15th Aug, 18.
  21.                 We hope you are excited about using it.
  22.                 Just as a reminder the purchase total was $599.
  23.                 Have a greate one!
  24.         </p>
  25.         <p>Team Django</p>
  26. </body>
  27. </html>
  28. sending message...

As expected the contents of the file inside the templates gets printed.

Now we will be reducing some workload from __main__.py file and moving the code
to the data_class.py and creating a class there with our functions as methods of the
class.

Check the data_class.py file to understand what I mean.

Sending emails

Now that we have our template ready but it still lacks few things like rendering context
from the actual data.csv file as well as the date column is missing in our file
so for that I have written code using pieces of code from files in python_csv folder
in inserting_data.py which simply inserts the data.

Inside data_class.py file we have made some changes with message_user function
in the UserManager class.

  1. class UserManager:
  3.     def message_user(self, user_id=None, user_email=None):
  4.         user = self.get_user_data(user_id=user_id, user_email=user_email)
  5.         if isinstance(user, dict):
  6.             template = get_template(r'templates\email_message.txt')
  7.             template_html = get_template(r'templates\email_message.html')
  9.             context = user
  10.             print(render_context(template, context))
  11.             print(render_context(template_html, context))
  12.         return None

Instead of passing the dict with key value pairs representing data, we just pass in the
user variable which is actually the returned value received from calling get_user_data
method with the user_id and user_email.

Since our function get_user_data returns dict objects as well as strings for error we
don’t wanna be inserting that in our context so we used a simple logic of checking if
the user is a dict object then executing further code

  1.     if isinstance(user, dict):
  2.         ...

That’s it now we can run commands

cmd

  1. .../cli_with_python> python integrate message -id 1
  3. sending message
  4. Hi Hopper!
  5. Thank you for your purchase on 2018-09-03 18:56:01.
  6. We hope you are excited about using it.
  7. Just as a reminder the purchase total was $269.
  8. Have a greate one!
  10. Team Django
  11. <!DOCTYPE html>
  12. <html>
  13. <head>
  14.         <title>Django Email Message</title>
  15. </head>
  16. <body>
  17.         <h1>Hi Hopper!</h1>
  18.         <p>
  19.                 Thank you for your purchase on 2018-09-03 18:56:01.
  20.                 We hope you are excited about using it.
  21.                 Just as a reminder the purchase total was $269.
  22.                 Have a greate one!
  23.         </p>
  24.         <p>Team Django</p>
  25. </body>
  26. </html>

As you can see we have all the information of our user with id 1 rendered in the
template and the email is ready to be sent to the user at the email address.

NOTE: The user data we have used is fake with fake email addresses so you can use
your data and actually see the email being sent using actual email addresses.

For sending email we will be using the same code we used in the html_format_email.py
file. So copy paste the imports and email credentials from that file into 

  2. Create a new method named ```render_message(self, user_data)``` in which we are going to
  3. do all the rendering stuff and in the message_user method we will send email
  5. **data_class.py**

class UserManager:

  1. def render_message(self, user_data):
  2.     template = get_template(r'templates\email_message.txt')
  3.     template_html = get_template(r'templates\email_message.html')
  5.     if isinstance(user_data, dict):
  6.         context = user_data
  7.         plain = render_context(template, context)
  8.         html = render_context(template_html, context)
  9.         return (plain, html)
  10.     return (None, None)
  2. So basically we moved all our rendering code into this method.
  4. Now for sending email we have 
  6. **data_class.py**

…
def messageuser(self, user_id=None, user_email=None, all_users=False):
user = self.get_user_data(user_id=user_id, user_email=user_email)
if isinstance(user, dict):
plain, html_ = self.render_message(user)
email = user.get(“email”, username)
to_list.append(email)

  1.         try:
  2.             email_conn = SMTP(host, port)
  3.             email_conn.ehlo()
  4.             email_conn.starttls()
  6.             message = MIMEMultipart("alternative")
  7.             message['Subject'] = "Hello there"
  8.             message['From'] = 'Python Developer'
  9.             message['To'] = email
  11.             part_1 = MIMEText(plain_, 'plain')
  12.             part_2 = MIMEText(html_, 'html')
  14.             message.attach(part_1)
  15.             message.attach(part_2)
  17.             email_conn.login(username, password)
  18.             email_conn.sendmail(from_email, to_list, message.as_string())
  19.             return f"EMAIL SENT TO {email}"
  20.         except SMTPException as e:
  21.             print(e)
  22.         finally:
  23.             email_conn.quit()
  25.     return None
  2. So we get the user details by caling ```get_user_data(user_id, user_email)``` on the
  3. user_id we received from ```__main__.py``` file where we call this class method passing
  4. in the user_id from the arguments provided in command prompt
  6. Then we do all the same stuff for sending email then at last we return the string 
  7. containing email else we ```return None

Very simple and nicely called methods for completing the task.

Sending emails to all users

In __main__.py file we create another argument named --all_users which
does not take any argument and we do that using action="store_true" attribute

main.py

  1. parser.add_argument(
  2.     "-all",
  3.     "--all_users",
  4.     action="store_true",
  5.     help="sends message to all the users"
  6. )

Now we check if args contains -all or --all_users argument by

  1. elif args.type == "message":
  2.     if args.all_users:
  3.         print("SENDING EMAILS...")
  4.         print(UserManager().message_all())
  5.     else:
  6.         print("SENDING EMAILS...")
  7.         print(UserManager().message_user(user_id=args.user_id, user_email=args.email))

If yes then we call message_all() class method which simply opens the csvfile and
iterates over all the rows and sends emails by calling the 

  2. **data_class.py**

…
def message_all(self):
with open(FILE_PATH) as csvfile:
reader = csv.DictReader(csvfile)
for row in reader:
row_id = int(row.get(“id”))
print(self.message_user(user_id=row_id))
```

We all print the returned message from function call

One more thing that is missing from our email sending command line app is that we don’t
have a tally which tells that which users are already been mailed, we have a field defined
for this purpose remember the sent field which is currently set to False.

What we will be doing now is editing that field to True if email has been sent and checking
the next time before sending emails that we don’t send email to users with True set as
sent field.