DEV Community: Joaquin Guardado

Learn To Setup Python 3 As A Default On your Mac

Joaquin Guardado — Sat, 26 Sep 2020 06:34:25 +0000

Minimum requirements

Command Line tools or Xcode $ xcode-select --instal
Homebrew $ ruby -e "$(curl -fsSL [https://raw.githubusercontent.com/Homebrew/install/master/install](https://raw.githubusercontent.com/Homebrew/install/master/install))"

Python3

At the time of this writing your Macbook ships with an out of date version of Python, version 2.7 which was officially deprecated on Januray 1st, 2020. This means you need to update it to version 3 before building any new projects in your local development environment.

WARNING: Python 2.7 is not recommended.
This version is included in macOS for compatibility with legacy software.
Future versions of macOS will not include Python 2.7.
Instead, it is recommended that you transition to using 'python3' from within Terminal.

Python 2.7.16 (default, Jul  5 2020, 02:24:03)
[GCC 4.2.1 Compatible Apple LLVM 11.0.3 (clang-1103.0.29.21) (-macos10.15-objc- on darwin
Type "help", "copyright", "credits" or "license" for more information.

My preferred method of achieving this is to use Homebrew a very popular MacOs package manager. This will allow you to switch between Python3 and Python 2 in case you still need it. Please make sure you have it installed before continuing.

Open your terminal and run the following.

$ brew install python

To look at where it is installed run this command to get a similar output.

$ which python3
/usr/local/bin/python3

If you wish to be able to run a command with just python instead of python3 create an alias in your .zshrc. Copy the python3 installation path from above and run the following command.

$ echo "alias python=/usr/local/bin/python3" >> ~/.zshrc

Close your terminal and open it back up. Now if you run the command python you should get the following.

$ python --version
Python 3.8.5

Now if you need Python 2 to work on some older projects run it like this.

$ python2

Aslo If at any time you would like to set Python 2 as default on your Mac again just remove or comment out the alias in your .zshrc with vim or any editor you like.

$ vi ~/.zshrc

Edit your .zshrc and comment out the alias.

#alias python=/usr/local/bin/python3

Pip

Finally don't forget to update pip to pip3. The pip command is the default package manager for Python packages and although the default version of python on your system was updated pip is still running on the old version. To fix that create another alias for pip3. This will ensure the packages installed via pip are compatible with the new default version of Python.

First find the location of pip3.

$ which pip3
/usr/local/bin/pip3

Now create the new alias.

$ echo "alias pip=/usr/local/bin/pip3" >> ~/.zshrc

Close your terminal to reset it and run the pip command.

$ which pip
pip: aliased to /usr/local/bin/pip3

That's it! as always if you have any questions, comments or concerns feel free to reach out to me on Twitter.

Best.

Organize Your Github Like A Pro With This Python Script

Joaquin Guardado — Wed, 09 Sep 2020 11:41:06 +0000

What? Why?

You and I use GitHub every day and if you are anything like me very often come across an interesting repo, quickly fork it and save it for playing with it at some point later in the future, sometimes distant future :)

My GitHub started looking a little too cluttered with these Repos so I decided to do some cleaning. Yes, you could use the browser to point, click, copy, and paste every single repo you want to transfer out of your main account into another one to keep to interesting Repos safe and maintain your main account looking professional, but I find that very time consuming and just plainly bad use of the time we could instead use for twitting and be on our way to becoming social media influencers.

How? Here is what we need to get started

We'll use the GitHub API to automate this task 🤖, Python with a virtual environment for our script and the requests library to talk to the API.

First head out to GitHub and generate a personal access token from the developer settings page. On this page, click Generate a new token, give your token a name and select the scopes you need. I selected all the repo scopes because I'm planning on extending this utility. Here are the docs for a more detailed dive into scopes.

Copy the token and test quickly test it out with curl.

~ $ GITHUB_TOKEN="access_token"
~ $ curl -H "Authorization: token $GITHUB_TOKEN" https://api.github.com/gists

If it worked you should receive a similar repose with a list of all your public Gists.

[
 {
    "url": "https://api.github.com/gists/4d5ab8adff9fc8b4cdf7d8e9dfa442c7",
    "forks_url": "https://api.github.com/gists/4d5ab8adff9fc8b4cdf7d8e9dfa442c7/forks",
    "commits_url": "https://api.github.com/gists/4d5ab8adff9fc8b4cdf7d8e9dfa442c7/commits",
    "id": "4d5ab8adff9fc8b4cdf7d8e9dfa442c7",
    "node_id": "MDQ6R2lzdDRkNWFiOGFkZmY5ZmM4YjRjZGY3ZDhlOWRmYTQ0MmM3",
    "git_pull_url": "https://gist.github.com/4d5ab8adff9fc8b4cdf7d8e9dfa442c7.git",
    "git_push_url": "https://gist.github.com/4d5ab8adff9fc8b4cdf7d8e9dfa442c7.git",
    "html_url": "https://gist.github.com/4d5ab8adff9fc8b4cdf7d8e9dfa442c7",
    "files": {
      "views.py": {
        "filename": "views.py",
        "type": "application/x-python",
        "language": "Python",
        "raw_url": "https://gist.githubusercontent.com/jqn/4d5ab8adff9fc8b4cdf7d8e9dfa442c7/raw/7acabeae8db34dcae72fbb1dbb002557a70632ef/views.py",
        "size": 347
      }
    },
...
]

The second thing we need is a Virtual Environment. If you are a beginner or just unsure on how to do this please give this a read Learn How To Get Started With Flask It's geared towards getting you started with Flask but it goes over how to configure a local Python development environment.

I use virtualenvwrapper

$ mkdir ~/www/automation
$ cd ~/www/automation
$ mkvirtualenv automation_hacks
(automation) $ automation

Now with a Virtual Environment ready let's get the coding started.

Create a new Python script and install the required packages. Inside the automation directory run the following commands.

$ touch github_hacks.py
$ pip install requests
$ pip freeze > requirements.txt

This is the current directory structure

automation
├── github_hacks.py
└── requirements.txt

And with VSCode

$ code github_hacks.py

VSCode is not required for this step so feel free to use your favorite text editor.

And now "The code"

import requests
import sys
from pprint import pprint
import json

token = "access_token"
owner = sys.argv[1]
repo = sys.argv[2]
new_owner = sys.argv[3]


query_url = f"https://api.github.com/repos/{owner}/{repo}/transfer"

headers = {'Authorization': f'token {token}',
           'Accept': 'application/vnd.github.v3+json'}
params = {
    'new_owner': new_owner,
}

r = requests.post(query_url, headers=headers, data=json.dumps(params))

pprint(r.json())

Finally, we can run it like this:

$ python github_hacks.py owner repo new_owner

If you go back to your GitHub the repo was transferred to the new owner.

Currently, this script takes a single Repo at the time but it can be expanded to take multiple Repos and transfer them to another owner/organization.

This works best when transferring to an organization you own. If transferring to a new owner the owner has to accept the transfer first.

I did tryout PyGithub but currently, it doesn't have the transfer repo feature. There are also other ready to use libraries listed in the Github API docs but most of them are outdated as of the writing of this article.

Questions? Problems? Don't hesitate to reach out on Twitter or comment below.

Resources

Github Developer - Scopes

Github Rest API

requests

f-string Formatting in Python

Deploy A Flask App On AWS EC2

Joaquin Guardado — Mon, 31 Aug 2020 07:55:03 +0000

Flask is a web framework for python, meaning that it provides a simple interface for dynamically generating responses to web requests. Let’s start by launching a Flask server on an Amazon Web Services EC2 instance.

1. Starting up an EC2 instance

1. Launch an EC2 instance.

Log in to the AWS console here
Select EC2 from AWS services.
Click on Launch Instance.
Select the Ubuntu Server 16.04 LTS (HVM), SSD Volume Type — ami-43a15f3e instead of the Amazon Linux. The exact versions may change with time.
Click on Review and Launch.
Configure the security groups as shown below. This setting allows access to port 80 (HTTP) from anywhere, and ssh access only from any IP address.

2. Setting up the instance

Now that we’ve connected to the instance, it’s time to install some of the programs we’ll need.

1. Connect to the instance using ssh from the Terminal.
$ ssh -i "yourapp.pem" ubuntu@yourapppublicinstance.compute-1.amazonaws.com

2. Install the apache webserver and mod_wsgi.

$ sudo apt-get update
$ sudo apt-get install apache2
$ sudo apt-get install libapache2-mod-wsgi

If you point your browser at your instance’s public DNS name you should see the Apache server’s “It works!” page.

3. Install Flask using the pip tool (which also needs to be installed).

$ sudo apt-get install python-pip
$ sudo pip install flask

4. Create a directory for our Flask app.

We’ll create a directory in our home directory to work in, and link to it from the site-root defined in apache’s configuration /var/www/html by default, see /etc/apache2/sites-enabled/000-default.conf for the current value).

$ mkdir ~/flaskapp
$ sudo ln -sT ~/flaskapp /var/www/html/flaskapp

To verify our operation is working, create a simple index.html file.

$ cd ~/flaskapp
$ echo "Hello World" > index.html

You should now see “Hello World” displayed if you navigate to (your instance public DNS)/flaskapp in your browser.

3. Running a simple Flask app

1. Create an app.
We’ll use the simple “Hello world” example from the Flask documentation. Put the following content in a file named flaskapp.py:

from flask import Flask
app = Flask(__name__)
@app.route('/')
def hello_world():
  return 'Hello from Flask!'
if __name__ == '__main__':
  app.run()

2. Create a .wsgi file to load the app.
Put the following content in a file named flaskapp.wsgi:

#flaskapp.wsgi
import sys
sys.path.insert(0, '/var/www/html/flaskapp')

from flaskapp import app as application

3. Enable mod_wsgi.

The apache server displays HTML pages by default but to serve dynamic content from a Flask app we’ll have to make a few changes. In the apache configuration file located at /etc/apache2/sites-enabled/000-default.conf, add the following block just after the DocumentRoot /var/www/html line:

WSGIDaemonProcess flaskapp threads=5
WSGIScriptAlias / /var/www/html/flaskapp/flaskapp.wsgi

<Directory flaskapp>
    WSGIProcessGroup flaskapp
    WSGIApplicationGroup %{GLOBAL}
    Order deny,allow
    Allow from all
</Directory>

4. Restart the webserver.

Use this command to restart the server with the new configuration

$ sudo service apache2 restart

5. Test configuration.

If you navigate your browser to your EC2 instance’s public DNS again, you should see the text returned by the hello_world function of our app, “Hello from Flask!”

Our server is now running and ready to crunch some data (if something isn’t working, try checking the log file in /var/log/apache2/error.log.

4. Have Flask app do work.

Now that we have a server ready to do work we’ll set up a simple service to provide letter counts from an input string.
1. Collect information from the url.
Flask allows us to route requests to functions based on the url requested. We can also get input from the url to pass into the function. Add the following to flaskapp.py:

# flaskapp.py
@app.route('/countme/<input_str>')
def count_me(input_str):
    return input_str

This count_me() function will return anything after the countme/ portion of the url. Restart the webserver to see it in action:

$ sudo service apache2 restart

2. Process information
Let’s make our count_me() function a little more interesting. Modify flaskapp.py like so:

# flaskapp.py
from collections import Counter
...
@app.route('/countme/<input_str>')
def count_me(input_str):
    input_counter = Counter(input_str)
    response = []
    for letter, count in input_counter.most_common():
        response.append('"{}": {}'.format(letter, count))
    return '<br>'.join(response)

Restart the server and view the results:

$ sudo service apache2 restart

Note that it is bad practice to format HTML responses inside these functions, templates should generally be used instead.
The entire count_me() function could be written in one logical line:

return '<br>'.join('"{}": {}'.format(let, cnt)
                   for let, cnt in Counter(in_str).most_common())

If the application throws any errors the error log can help you debug.

$ sudo tail -f /var/log/apache2/error.log

If you enjoyed this tutorial, please give me some likes. Happy coding!