This is Python Bytes, Python headlines and news deliver directly to your earbuds: episode 9, recorded on Tuesday, January 17th. In this episode we discuss walking with async coroutines, diving deep into requests, and a universe of options (for AIs).

#1 (Brian): Python Asynchronous I/O Walkthrough


In July, there was an open source book published called 500 Lines or Less.
One of the chapters was called A Web Crawler With asyncio Coroutines, written by A. Jesse Jiryu Davis and Guido van Rossum. It explains async networking, showing how non-blocking sockets work and how Python 3’s coroutines improve asynchronous network programs.
As mentioned recently on A. Jesse Jiryu Davis’s blog emptysqua.re, the chapter may be difficult for a novice or intermediate developer to follow.
This month, Philip Guo, an Assistant Professor at UC San Diego, has released an 8 part video series, 90 minutes total, so on the order of 10 minutes each, that walks through the article, including some coding examples that he walks through.
Since async is something that takes a while to get your head around, I appreciate the multi-sensory education experience. Listening to Philip talk about it, watching him walk through the code and talk about the article, and having the article as a reference, is super helpful.
Talk Python #22: CPython Internals and Learning Python with pythontutor.com
Talk Python #69: Write an Excellent Programming Blog


#2 (Michael): 4 likely future twists for Python
by Serdar Yegulalp


Python 2.x may live on


Python 2.x might also get a continued lease on life if independent developers decide to keep the branch going on their own.
At least one such effort exists -- Naftali Harris's "Python 2.8" project, which backports improvements and bug fixes from Python 3 into the Python 2.x branch.
it makes sense to make the 3.x leap, but it's likely we'll see a lot of keep-the-2.x-flame-alive efforts

Requirements.txt may be replaced with something better


Pipfile has been proposed as a possible replacement by the folks at the Python Packaging Authority, which is "the working group that maintains many of the relevant projects in Python packaging."
Pipfile will be superior to requirements.txt file in a number of ways:
1. TOML syntax for declaring all types of Python dependencies.
2. One Pipfile (as opposed to multiple requirements.txt files).
3. Existing requirements files tend to proliferate into multiple files - e.g. dev-requirements.txt, test-requirements.txt, etc. - but a Pipfile will allow seamlessly specifying groups of dependencies in one place.
4. This will be surfaced as only two built-in groups (default & development). (see note below)
5. Fully specified (and deterministic) environments in the form of Pipfile.freeze. A deployed application can then be completely redeployed with the same exact versions of all recursive dependencies, by referencing the Pipfile.freeze file.
Example pipfile:

[[source]]
url = 'https://pypi.org/'
verify_ssl = true

[requires]
python_version = '2.7'

[packages]
requests = { extras = ['socks'] }
Django = '>1.10'
pinax = { git = 'git://github.com/pinax/pinax.git', ref = '1.4', editable = true }

[dev-packages]
nose = '*'

Python could get more enterprise editions


As the language has gained traction across the board, it's also appearing in versions aimed specifically at solving enterprise-grade problems.
Intel, for instance, elected to repackage the Anaconda science-and-math distribution of Python after outfitting it with extensions that give it a speed boost, albeit only on Intel processors.
Anaconda is itself produced by Continuum Analytics, no stranger to enterprise data-analysis needs.

Python's new software repository system could lead to enterprise-friendly Python package management

One possibility being floated in this vein is the concept of an enterprise-grade package index for Python, as discussed by Cristian Medina of Nimble Storage:
Businesses always have a need for an on-premises, secure, encrypte