파이썬 subprocess - paisseon subprocess

Processes and the Operating System

Whenever you use a computer, you’ll always be interacting with programs. A process is the operating system’s abstraction of a running program. So, using a computer always involve processes. Start menus, app bars, command-line interpreters, text editors, browsers, and more—every application comprises one or more processes.

A typical operating system will report hundreds or even thousands of running processes, which you’ll get to explore shortly. However, central processing units (CPUs) typically only have a handful of cores, which means that they can only run a handful of instructions simultaneously. So, you may wonder how thousands of processes can appear to run at the same time.

In short, the operating system is a marvelous multitasker—as it has to be. The CPU is the brain of a computer, but it operates at the nanosecond timescale. Most other components of a computer are far slower than the CPU. For instance, a magnetic hard disk read takes thousands of times longer than a typical CPU operation.

If a process needs to write something to the hard drive, or wait for a response from a remote server, then the CPU would sit idle most of the time. Multitasking keeps the CPU busy.

Part of what makes the operating system so great at multitasking is that it’s fantastically organized too. The operating system keeps track of processes in a process table or process control block. In this table, you’ll find the process’s file handles, security context, references to its address spaces, and more.

The process table allows the operating system to abandon a particular process at will, because it has all the information it needs to come back and continue with the process at a later time. A process may be interrupted many thousands of times during execution, but the operating system always finds the exact point where it left off upon returning.

An operating system doesn’t boot up with thousands of processes, though. Many of the processes you’re familiar with are started by you. In the next section, you’ll look into the lifetime of a process.

Process Lifetime

Think of how you might start a Python application from the command line. This is an instance of your command-line process starting a Python process:

The process that starts another process is referred to as the parent, and the new process is referred to as the child. The parent and child processes run mostly independently. Sometimes the child inherits specific resources or contexts from the parent.

As you learned in Processes and the Operating System, information about processes is kept in a table. Each process keeps track of its parents, which allows the process hierarchy to be represented as a tree. You’ll be exploring your system’s process tree in the next section.

Note: The precise mechanism for creating processes differs depending on the operating system. For a brief overview, the Wikipedia article on process management has a short section on process creation.

For more details about the Windows mechanism, check out the win32 API documentation page on creating processes

On UNIX-based systems, processes are typically created by using

>>> import shlex
>>> shlex.split("python timer.py 5")
['python', 'timer.py', '5']

>>> subprocess.run(shlex.split("python timer.py 5"))
Starting timer of 5 seconds
.....Done!
CompletedProcess(args=['python', 'timer.py', '5'], returncode=0)

>>> import shlex
>>> shlex.split("python timer.py 5")
['python', 'timer.py', '5']

>>> subprocess.run(shlex.split("python timer.py 5"))
Starting timer of 5 seconds
.....Done!
CompletedProcess(args=['python', 'timer.py', '5'], returncode=0)

The parent-child relationship between a process and its subprocess isn’t always the same. Sometimes the two processes will share specific resources, like inputs and outputs, but sometimes they won’t. Sometimes child processes live longer than the parent. A child outliving the parent can lead to orphaned or zombie processes, though more discussion about those is outside the scope of this tutorial.

When a process has finished running, it’ll usually end. Every process, on exit, should return an integer. This integer is referred to as the return code or exit status. Zero is synonymous with success, while any other value is considered a failure. Different integers can be used to indicate the reason why a process has failed.

In the same way that you can return a value from a function in Python, the operating system expects an integer return value from a process once it exits. This is why the canonical C

>>> shlex.split("echo 'Hello, World!'")
['echo', 'Hello, World!']

// minimal_program.c

int main(){
    return 0;
}

This example shows a minimal amount of C code necessary for the file to compile with

>>> shlex.split("echo 'Hello, World!'")
['echo', 'Hello, World!']

>>> shlex.split("echo 'Hello, World!'")
['echo', 'Hello, World!']

So, what processes are running on your system right now? In the next section, you’ll explore some of the tools that you can use to take a peek at your system’s process tree. Being able to see what processes are running and how they’re structured will come in handy when visualizing how the

$ python timer.py 5

Active Processes on Your System

You may be curious to see what processes are running on your system right now. To do that, you can use platform-specific utilities to track them:

• Windows
• Linux + macOS

There are many tools available for Windows, but one which is easy to get set up, is fast, and will show you the process tree without much effort is Process Hacker.

You can install Process Hacker by going to the downloads page or with Chocolatey:

PS> choco install processhacker

Open the application, and you should immediately see the process tree.

One of the native commands that you can use with PowerShell is

>>> shlex.split("echo 'Hello, World!'")
['echo', 'Hello, World!']

>>> shlex.split("echo 'Hello, World!'")
['echo', 'Hello, World!']

The official Microsoft version of Process Hacker is part of the Sysinternals utilities, namely Process Monitor and Process Explorer. You also get PsList, which is a command-line utility similar to

>>> shlex.split("echo 'Hello, World!'")
['echo', 'Hello, World!']

PS> choco install sysinternals

You can also use the more basic, but classic, Task Manager—accessible by pressing Win+X and selecting the Task Manager.

For UNIX-based systems, there are many command-line utilities to choose from:

• >>> shlex.split("echo 'Hello, World!'")
  ['echo', 'Hello, World!']
  

  7: The classic process and resource monitor, often installed by default. Once it’s running, to see the tree view, also called the forest view, press Shift+V. The forest view may not work on the default macOS

  >>> shlex.split("echo 'Hello, World!'")
  ['echo', 'Hello, World!']
  

  7.

• >>> shlex.split("echo 'Hello, World!'")
  ['echo', 'Hello, World!']
  

  9: More advanced and user-friendly version of

  >>> shlex.split("echo 'Hello, World!'")
  ['echo', 'Hello, World!']
  

  7.

• >>> subprocess.run(["notepad"])
  CompletedProcess(args=['notepad'], returncode=0)
  

  1: Another version of

  >>> shlex.split("echo 'Hello, World!'")
  ['echo', 'Hello, World!']
  

  7 with more information, but more technical.

• >>> subprocess.run(["notepad"])
  CompletedProcess(args=['notepad'], returncode=0)
  

  3: A Python implementation of

  >>> shlex.split("echo 'Hello, World!'")
  ['echo', 'Hello, World!']
  

  7 with nice visuals.

• >>> shlex.split("echo 'Hello, World!'")
  ['echo', 'Hello, World!']
  

  6: A utility specifically to explore the process tree.

On macOS, you also have the Activity Monitor application in your utilities. In the View menu, if you select All Processes, Hierarchically, you should be able to see your process tree.

You can also explore the Python psutil library, which allows you to retrieve running process information on both Windows and UNIX-based systems.

One universal attribute of process tracking across systems is that each process has a process identification number, or PID, which is a unique integer to identify the process within the context of the operating system. You’ll see this number on most of the utilities listed above.

Along with the PID, it’s typical to see the resource usage, such as CPU percentage and amount of RAM that a particular process is using. This is the information that you look for if a program is hogging all your resources.

The resource utilization of processes can be useful for developing or debugging scripts that use the

$ python timer.py 5

You now have a bird’s-eye view of processes. You’ll deepen your mental model throughout the tutorial, but now it’s time to see how to start your own processes with the Python

$ python timer.py 5

The Timer Example

To come to grips with the Python

$ python timer.py 5

# timer.py

from argparse import ArgumentParser
from time import sleep

parser = ArgumentParser()
parser.add_argument("time", type=int)
args = parser.parse_args()
print(f"Starting timer of {args.time} seconds")
for _ in range(args.time):
    print(".", end="", flush=True)
    sleep(1)
print("Done!")

The timer program uses

PS> choco install processhacker

PS> choco install processhacker

It’s not much, but the key is that it serves as a cross-platform process that runs for a few seconds and which you can easily tinker with. You’ll be calling it with

$ python timer.py 5

Note: Calling Python programs with the Python

$ python timer.py 5

The main reason you’ll be using Python programs for most of the examples in this tutorial is that they’re cross-platform, and you most likely already have Python installed!

You may be tempted to think that starting a new process could be a neat way to achieve concurrency, but that’s not the intended use case for the

$ python timer.py 5

The

$ python timer.py 5

$ python timer.py 5

Okay, ready to get stuck in! Once you have the

PS> choco install processhacker

$ python timer.py 5

>>>

>>> import subprocess
>>> subprocess.run(["python", "timer.py", "5"])
Starting timer of 5 seconds
.....Done!
CompletedProcess(args=['python', 'timer.py', '5'], returncode=0)

With this code, you should’ve seen the animation playing right in the REPL. You imported

$ python timer.py 5

>>> subprocess.run(["gedit"])
CompletedProcess(args=['gedit'], returncode=0)

PS> choco install processhacker

>>> subprocess.run(["gedit"])
CompletedProcess(args=['gedit'], returncode=0)

On executing

>>> subprocess.run(["gedit"])
CompletedProcess(args=['gedit'], returncode=0)

PS> choco install processhacker

On the command line, you might be used to starting a program with a single string:

$ python timer.py 5

However, with

>>> subprocess.run(["gedit"])
CompletedProcess(args=['gedit'], returncode=0)

>>> subprocess.run(["gedit"])
CompletedProcess(args=['gedit'], returncode=0)

Note: Calling

>>> subprocess.run(["gedit"])
CompletedProcess(args=['gedit'], returncode=0)

>>> subprocess.run(["gedit"])
CompletedProcess(args=['gedit'], returncode=0)

Shells typically do their own tokenization, which is why you just write the commands as one long string on the command line. With the Python

$ python timer.py 5

Note: You can use the

PS> choco install processhacker

>>>

>>> import shlex
>>> shlex.split("python timer.py 5")
['python', 'timer.py', '5']

>>> subprocess.run(shlex.split("python timer.py 5"))
Starting timer of 5 seconds
.....Done!
CompletedProcess(args=['python', 'timer.py', '5'], returncode=0)

The

PS> choco install processhacker

PS> choco install processhacker

>>>

>>> shlex.split("echo 'Hello, World!'")
['echo', 'Hello, World!']

You’ll note that the message, which contains spaces, is preserved as a single token, and the extra quotation marks are no longer needed. The extra quotation marks on the shell serve to group the token together, but since

$ python timer.py 5

Now that you’re familiar with some of the very basics of starting new processes with the Python

$ python timer.py 5

The Use of $ python timer.py 5 0 to Run Any App

With

$ python timer.py 5

• Windows
• Linux
• macOS

>>>

>>> subprocess.run(["notepad"])
CompletedProcess(args=['notepad'], returncode=0)

>>>

>>> subprocess.run(["gedit"])
CompletedProcess(args=['gedit'], returncode=0)

Depending on your Linux distribution, you may have a different text editor, such as

PS> choco install processhacker

PS> choco install processhacker

PS> choco install processhacker

PS> choco install processhacker

>>>

PS> choco install processhacker

These commands should open up a text editor window. Usually

PS> choco install processhacker

PS> choco install processhacker

PS> choco install processhacker

Launcher processes are in charge of launching a specific process and then ending. Sometimes programs, such as web browsers, have them built in. The mechanics of launcher processes is out of the scope of this tutorial, but suffice to say that they’re able to manipulate the operating system’s process tree to reassign parent-child relationships.

Note: There are many problems that you might initially reach for

$ python timer.py 5

$ python timer.py 5

An example of something that you might want to do with

$ python timer.py 5

PS> choco install processhacker

PS> choco install processhacker

$ python timer.py 5

Then again,

$ python timer.py 5

$ python timer.py 5

You’ve successfully started new processes using Python! That’s

$ python timer.py 5

PS> choco install processhacker

>>> subprocess.run(["gedit"])
CompletedProcess(args=['gedit'], returncode=0)

The PS> choco install processhacker 29 Object

When you use

>>> subprocess.run(["gedit"])
CompletedProcess(args=['gedit'], returncode=0)

PS> choco install processhacker

>>> subprocess.run(["gedit"])
CompletedProcess(args=['gedit'], returncode=0)

PS> choco install processhacker

PS> choco install processhacker

To see this clearly, you can assign the result of

>>> subprocess.run(["gedit"])
CompletedProcess(args=['gedit'], returncode=0)

PS> choco install processhacker

>>>

PS> choco install processhacker

The process has a return code that indicates failure, but it doesn’t raise an exception. Typically, when a

$ python timer.py 5

PS> choco install processhacker

>>>

PS> choco install processhacker

There are various ways to deal with failures, some of which will be covered in the next section. The important point to note for now is that

>>> subprocess.run(["gedit"])
CompletedProcess(args=['gedit'], returncode=0)

PS> choco install processhacker

The

PS> choco install processhacker

$ python timer.py 5

PS> choco install processhacker 78 for Non-Zero Exit Code

If a process returns an exit code that isn’t zero, you should interpret that as a failed process. Contrary to what you might expect, the Python

$ python timer.py 5

PS> choco install processhacker

>>> subprocess.run(["gedit"])
CompletedProcess(args=['gedit'], returncode=0)

>>>

PS> choco install processhacker

The

PS> choco install processhacker

One thing to bear in mind is that the

PS> choco install processhacker

PS> choco install processhacker

PS> choco install processhacker 85 for Processes That Take Too Long

Sometimes processes aren’t well behaved, and they might take too long or just hang indefinitely. To handle those situations, it’s always a good idea to use the

PS> choco install processhacker

>>> subprocess.run(["gedit"])
CompletedProcess(args=['gedit'], returncode=0)

Passing a

PS> choco install processhacker

>>> subprocess.run(["gedit"])
CompletedProcess(args=['gedit'], returncode=0)

PS> choco install processhacker

>>>

PS> choco install processhacker

In this example, the first dot of the timer animation was output, but the subprocess was shut down before being able to complete.

The other type of error that might happen is if the program doesn’t exist on that particular system, which raises one final type of error.

PS> choco install processhacker 91 for Programs That Don’t Exist

The final type of exception you’ll be looking at is the

PS> choco install processhacker

>>>

PS> choco install processhacker

This type of error is raised no matter what, so you don’t need to pass in any arguments for the

PS> choco install processhacker

Those are the main exceptions that you’ll run into when using the Python

$ python timer.py 5

PS> choco install processhacker

PS> choco install processhacker

However, if you have a more complex program, then you may want to handle errors more gracefully. For instance, you may need to call many processes over a long period of time. For this, you can use the

PS> choco install processhacker

PS> choco install processhacker

An Example of Exception Handling

Here’s a code snippet that shows the main exceptions that you’ll want to handle when using

$ python timer.py 5

PS> choco install processhacker

This snippet shows you an example of how you might handle the three main exceptions raised by the

$ python timer.py 5

Now that you’ve used

$ python timer.py 5

Use Cases for the Shell and $ python timer.py 5 0

There are a few common reasons why you might want to call the shell with the

PS> choco install sysinternals

• When you know certain commands are only available via the shell, which is more common in Windows
• When you’re experienced in writing shell scripts with a particular shell, so you want to leverage your ability there to do certain tasks while still working primarily in Python
• When you’ve inherited a large shell script that might do nothing that Python couldn’t do, but would take a long time to reimplement in Python

This isn’t an exhaustive list!

You might use the shell to wrap programs or to do some text processing. However, the syntax can be very cryptic when compared to Python. With Python, text processing workflows are easier to write, easier to maintain, generally more performant, and cross-platform to boot. So it’s well worth considering going without the shell.

What often happens, though, is that you just don’t have the time or it’s not worth the effort to reimplement existing shell scripts in Python. In those cases, using

$ python timer.py 5

Common reasons for using

$ python timer.py 5

$ python timer.py 5

• When you have to use or analyze a black box, or even a white box
• When you want a wrapper for an application
• When you need to launch another application
• As an alternative to basic shell scripts

Note: A black box could be a program that can be freely used but whose source code isn’t available, so there’s no way to know exactly what it does and no way to modify its internals.

Similarly, a white box could be a program whose source code is available but can’t be changed. It could also be a program whose source code you could change, but its complexity means that it would take you a long time to get your head around it to be able to change it.

In these cases, you can use

$ python timer.py 5

Often you’ll find that for

$ python timer.py 5

Even though specific libraries might be able to do your task, it may still be worth doing things with

$ python timer.py 5

Additionally, if you’re sharing this script with friends or colleagues, it’s convenient if your script is pure Python without any other dependencies, especially if your script needs to go on minimal environments like servers or embedded systems.

However, if you’re using

$ python timer.py 5

PS> choco install sysinternals

With that out of the way, it’s time to get familiar with the shell environments on both Windows and UNIX-based systems.

Basic Usage of $ python timer.py 5 0 With UNIX-Based Shells

To run a shell command using

>>> subprocess.run(["gedit"])
CompletedProcess(args=['gedit'], returncode=0)

PS> choco install processhacker

>>>

PS> choco install processhacker

Here a common shell command is demonstrated. It uses

$ python timer.py 5

PS> choco install sysinternals

PS> choco install sysinternals

You can replace

PS> choco install sysinternals

PS> choco install sysinternals

PS> choco install sysinternals

>>>

PS> choco install sysinternals

The

PS> choco install sysinternals

PS> choco install sysinternals

Note: On UNIX-based systems, the

PS> choco install sysinternals

PS> choco install sysinternals

This can often be different from the shell used with the terminal interface that you interact with. For instance, since macOS Catalina, the default shell that you’ll find on the command-line app has changed from Bash to Zsh, yet

PS> choco install sysinternals

PS> choco install sysinternals

So, calling

PS> choco install sysinternals

You’ll note that the token after

PS> choco install sysinternals

Basic Usage of $ python timer.py 5 0 With Windows Shells

In this section, you’ll cover basic use of the shell with

$ python timer.py 5

To run a shell command using

>>> subprocess.run(["gedit"])
CompletedProcess(args=['gedit'], returncode=0)

PS> choco install processhacker

>>>

PS> choco install sysinternals

Note that

PS> choco install sysinternals

PS> choco install sysinternals

PS> choco install sysinternals

PS> choco install sysinternals

You’ll note that the token after

PS> choco install sysinternals

If you need the Command Prompt, then the executable is

PS> choco install sysinternals

PS> choco install sysinternals

PS> choco install sysinternals

>>>

PS> choco install sysinternals

This last example is the exact equivalent of calling

>>> subprocess.run(["gedit"])
CompletedProcess(args=['gedit'], returncode=0)

PS> choco install sysinternals

PS> choco install sysinternals

PS> choco install sysinternals

PS> choco install sysinternals

Note: Windows’ evolution has been very different from that of UNIX-based systems. The most widely known shell is the Windows Command Prompt which is by now a legacy shell. The Command Prompt was made to emulate the pre-Windows MS-DOS environment. Many shell scripts, or batch

PS> choco install sysinternals

The

>>> subprocess.run(["gedit"])
CompletedProcess(args=['gedit'], returncode=0)

PS> choco install sysinternals

$ python timer.py 5

PS> choco install sysinternals

PS> choco install sysinternals

PS> choco install sysinternals

PS> choco install sysinternals

PS> choco install sysinternals

At this point, you should know about an important security concern that you’ll want to be aware of if you have user-facing elements in your Python program, regardless of the operating system. It’s a vulnerability that’s not confined to

$ python timer.py 5

A Security Warning

If at any point you plan to get user input and somehow translate that to a call to

$ python timer.py 5

To use a very simplistic example, where you take user input and send it, unfiltered, to subprocess to run on the shell:

• Windows
• Linux + macOS

PS> choco install sysinternals

PS> choco install sysinternals

You can imagine the intended use case is to wrap

$ python timer.py 5

PS> choco install sysinternals

• Windows
• Linux + macOS

PS> choco install sysinternals

73

PS> choco install sysinternals

74

Again, beware! These innocent-looking lines could try and delete everything on the system! In this case the malicious part is in quotes, so it won’t run, but if the quotes were not there, you’d be in trouble. The key part that does this is the call to

PS> choco install sysinternals

PS> choco install sysinternals

PS> choco install sysinternals

Running these malicious commands would cause irreparable damage to the file system, and would require reinstalling the operating system. So, beware!

Luckily, the operating system wouldn’t let you do this to some particularly important files. The

PS> choco install sysinternals

PS> choco install sysinternals

So, make sure that if you’re dynamically building user inputs to feed into a

$ python timer.py 5

The Standard I/O Streams

A stream at its most basic represents a sequence of elements that aren’t available all at once. When you read characters and lines from a file, you’re working with a stream in the form of a file object, which at its most basic is a file descriptor. File descriptors are often used for streams. So, it’s not uncommon to see the terms stream, file, and file-like used interchangeably.

When processes are initialized, there are three special streams that a process makes use of. A process does the following:

1. Reads

   PS> choco install sysinternals
   

   83 for input
2. Writes to

   PS> choco install sysinternals
   

   84 for general output
3. Writes to

   PS> choco install sysinternals
   

   85 for error reporting

These are the standard streams—a cross-platform pattern for process communication.

Sometimes the child process inherits these streams from the parent. This is what’s happening when you use

PS> choco install sysinternals

PS> choco install sysinternals

When you’re in a REPL environment, you’re looking at a command-line interface process, complete with the three standard I/O streams. The interface has a shell process as a child process, which itself has a Python REPL as a child. In this situation, unless you specify otherwise,

PS> choco install sysinternals

PS> choco install sysinternals

PS> choco install sysinternals

You can think of the standard I/O streams as byte dispensers. The subprocess fills up

PS> choco install sysinternals

PS> choco install sysinternals

PS> choco install sysinternals

PS> choco install sysinternals

PS> choco install sysinternals

PS> choco install sysinternals

As with a dispenser, you can stock

PS> choco install sysinternals

PS> choco install sysinternals

These three streams, or files, are the basis for communicating with your process. In the next section, you’ll start to see this in action by getting the output of a magic number generator program.

The Magic Number Generator Example

Often, when using the

$ python timer.py 5

Imagine that the magic number generator is some obscure program, a black box, inherited across generations of sysadmins at your job. It outputs a magic number that you need for your secret calculations. You’ll read from the

PS> choco install sysinternals

$ python timer.py 5

PS> choco install sysinternals

Okay, not really so magical. That said, it’s not the magic number generator that you’re interested in—it’s interacting with a hypothetical black box with

$ python timer.py 5

# timer.py

from argparse import ArgumentParser
from time import sleep

parser = ArgumentParser()
parser.add_argument("time", type=int)
args = parser.parse_args()
print(f"Starting timer of {args.time} seconds")
for _ in range(args.time):
    print(".", end="", flush=True)
    sleep(1)
print("Done!")

>>> subprocess.run(["gedit"])
CompletedProcess(args=['gedit'], returncode=0)

>>>

PS> choco install sysinternals

Passing a

# timer.py

from argparse import ArgumentParser
from time import sleep

parser = ArgumentParser()
parser.add_argument("time", type=int)
args = parser.parse_args()
print(f"Starting timer of {args.time} seconds")
for _ in range(args.time):
    print(".", end="", flush=True)
    sleep(1)
print("Done!")

# timer.py

from argparse import ArgumentParser
from time import sleep

parser = ArgumentParser()
parser.add_argument("time", type=int)
args = parser.parse_args()
print(f"Starting timer of {args.time} seconds")
for _ in range(args.time):
    print(".", end="", flush=True)
    sleep(1)
print("Done!")

>>> subprocess.run(["gedit"])
CompletedProcess(args=['gedit'], returncode=0)

# timer.py

from argparse import ArgumentParser
from time import sleep

parser = ArgumentParser()
parser.add_argument("time", type=int)
args = parser.parse_args()
print(f"Starting timer of {args.time} seconds")
for _ in range(args.time):
    print(".", end="", flush=True)
    sleep(1)
print("Done!")

Also note that the

# timer.py

from argparse import ArgumentParser
from time import sleep

parser = ArgumentParser()
parser.add_argument("time", type=int)
args = parser.parse_args()
print(f"Starting timer of {args.time} seconds")
for _ in range(args.time):
    print(".", end="", flush=True)
    sleep(1)
print("Done!")

PS> choco install processhacker

# timer.py

from argparse import ArgumentParser
from time import sleep

parser = ArgumentParser()
parser.add_argument("time", type=int)
args = parser.parse_args()
print(f"Starting timer of {args.time} seconds")
for _ in range(args.time):
    print(".", end="", flush=True)
    sleep(1)
print("Done!")

With the output available, you can use more than one subprocess to grab values and operate on them in your code:

>>>

PS> choco install sysinternals

In this example, you start two magic number processes that fetch two magic numbers and then add them together. For now, you rely on the automatic decoding of the bytes object by the

# timer.py

from argparse import ArgumentParser
from time import sleep

parser = ArgumentParser()
parser.add_argument("time", type=int)
args = parser.parse_args()
print(f"Starting timer of {args.time} seconds")
for _ in range(args.time):
    print(".", end="", flush=True)
    sleep(1)
print("Done!")

The Decoding of Standard Streams

Processes communicate in bytes, and you have a few different ways to deal with encoding and decoding these bytes. Beneath the surface,

$ python timer.py 5

Text mode means that

$ python timer.py 5

$ python timer.py 5

You can pass a

# timer.py

from argparse import ArgumentParser
from time import sleep

parser = ArgumentParser()
parser.add_argument("time", type=int)
args = parser.parse_args()
print(f"Starting timer of {args.time} seconds")
for _ in range(args.time):
    print(".", end="", flush=True)
    sleep(1)
print("Done!")

# timer.py

from argparse import ArgumentParser
from time import sleep

parser = ArgumentParser()
parser.add_argument("time", type=int)
args = parser.parse_args()
print(f"Starting timer of {args.time} seconds")
for _ in range(args.time):
    print(".", end="", flush=True)
    sleep(1)
print("Done!")

>>>

PS> choco install sysinternals

If in text mode, the

# timer.py

from argparse import ArgumentParser
from time import sleep

parser = ArgumentParser()
parser.add_argument("time", type=int)
args = parser.parse_args()
print(f"Starting timer of {args.time} seconds")
for _ in range(args.time):
    print(".", end="", flush=True)
    sleep(1)
print("Done!")

PS> choco install processhacker

You can also decode the bytes returned by calling the

# timer.py

from argparse import ArgumentParser
from time import sleep

parser = ArgumentParser()
parser.add_argument("time", type=int)
args = parser.parse_args()
print(f"Starting timer of {args.time} seconds")
for _ in range(args.time):
    print(".", end="", flush=True)
    sleep(1)
print("Done!")

PS> choco install sysinternals

>>>

PS> choco install sysinternals

There are other ways to put

>>> subprocess.run(["gedit"])
CompletedProcess(args=['gedit'], returncode=0)

# timer.py

from argparse import ArgumentParser
from time import sleep

parser = ArgumentParser()
parser.add_argument("time", type=int)
args = parser.parse_args()
print(f"Starting timer of {args.time} seconds")
for _ in range(args.time):
    print(".", end="", flush=True)
    sleep(1)
print("Done!")

# timer.py

from argparse import ArgumentParser
from time import sleep

parser = ArgumentParser()
parser.add_argument("time", type=int)
args = parser.parse_args()
print(f"Starting timer of {args.time} seconds")
for _ in range(args.time):
    print(".", end="", flush=True)
    sleep(1)
print("Done!")

# timer.py

from argparse import ArgumentParser
from time import sleep

parser = ArgumentParser()
parser.add_argument("time", type=int)
args = parser.parse_args()
print(f"Starting timer of {args.time} seconds")
for _ in range(args.time):
    print(".", end="", flush=True)
    sleep(1)
print("Done!")

>>> subprocess.run(["gedit"])
CompletedProcess(args=['gedit'], returncode=0)

$ python timer.py 5

Now that you know how to read and decode the output of a process, it’s time to take a look at writing to the input of a process.

Reaction Game Example

In this section, you’ll use

$ python timer.py 5

# timer.py

from argparse import ArgumentParser
from time import sleep

parser = ArgumentParser()
parser.add_argument("time", type=int)
args = parser.parse_args()
print(f"Starting timer of {args.time} seconds")
for _ in range(args.time):
    print(".", end="", flush=True)
    sleep(1)
print("Done!")

# timer.py

from argparse import ArgumentParser
from time import sleep

parser = ArgumentParser()
parser.add_argument("time", type=int)
args = parser.parse_args()
print(f"Starting timer of {args.time} seconds")
for _ in range(args.time):
    print(".", end="", flush=True)
    sleep(1)
print("Done!")

# timer.py

from argparse import ArgumentParser
from time import sleep

parser = ArgumentParser()
parser.add_argument("time", type=int)
args = parser.parse_args()
print(f"Starting timer of {args.time} seconds")
for _ in range(args.time):
    print(".", end="", flush=True)
    sleep(1)
print("Done!")

The program starts, asks for the user to press enter, and then after a random amount of time will ask the user to press enter again. It measures from the time the message appears to the time the user presses enter, or at least that’s what the game developer thinks:

The

# timer.py

from argparse import ArgumentParser
from time import sleep

parser = ArgumentParser()
parser.add_argument("time", type=int)
args = parser.parse_args()
print(f"Starting timer of {args.time} seconds")
for _ in range(args.time):
    print(".", end="", flush=True)
    sleep(1)
print("Done!")

PS> choco install sysinternals

PS> choco install sysinternals

$ python timer.py 5

>>>

# timer.py

from argparse import ArgumentParser
from time import sleep

parser = ArgumentParser()
parser.add_argument("time", type=int)
args = parser.parse_args()
print(f"Starting timer of {args.time} seconds")
for _ in range(args.time):
    print(".", end="", flush=True)
    sleep(1)
print("Done!")

A reaction time of 0 milliseconds! Not bad! Considering the average human reaction time is around 270 milliseconds, your program is definitely superhuman. Note that the game rounds its output, so 0 milliseconds doesn’t mean it’s instantaneous.

The

# timer.py

from argparse import ArgumentParser
from time import sleep

parser = ArgumentParser()
parser.add_argument("time", type=int)
args = parser.parse_args()
print(f"Starting timer of {args.time} seconds")
for _ in range(args.time):
    print(".", end="", flush=True)
    sleep(1)
print("Done!")

>>> subprocess.run(["gedit"])
CompletedProcess(args=['gedit'], returncode=0)

# timer.py

from argparse import ArgumentParser
from time import sleep

parser = ArgumentParser()
parser.add_argument("time", type=int)
args = parser.parse_args()
print(f"Starting timer of {args.time} seconds")
for _ in range(args.time):
    print(".", end="", flush=True)
    sleep(1)
print("Done!")

# timer.py

from argparse import ArgumentParser
from time import sleep

parser = ArgumentParser()
parser.add_argument("time", type=int)
args = parser.parse_args()
print(f"Starting timer of {args.time} seconds")
for _ in range(args.time):
    print(".", end="", flush=True)
    sleep(1)
print("Done!")

>>> subprocess.run(["gedit"])
CompletedProcess(args=['gedit'], returncode=0)

Before the program starts,

PS> choco install sysinternals

# timer.py

from argparse import ArgumentParser
from time import sleep

parser = ArgumentParser()
parser.add_argument("time", type=int)
args = parser.parse_args()
print(f"Starting timer of {args.time} seconds")
for _ in range(args.time):
    print(".", end="", flush=True)
    sleep(1)
print("Done!")

Now that you know what’s happening—namely that

PS> choco install sysinternals

$ python timer.py 5

PS> choco install sysinternals

# timer.py

from argparse import ArgumentParser
from time import sleep

parser = ArgumentParser()
parser.add_argument("time", type=int)
args = parser.parse_args()
print(f"Starting timer of {args.time} seconds")
for _ in range(args.time):
    print(".", end="", flush=True)
    sleep(1)
print("Done!")

# timer.py

from argparse import ArgumentParser
from time import sleep

parser = ArgumentParser()
parser.add_argument("time", type=int)
args = parser.parse_args()
print(f"Starting timer of {args.time} seconds")
for _ in range(args.time):
    print(".", end="", flush=True)
    sleep(1)
print("Done!")

The game developer gets wise to this, though, and vows to release another version, which will guard against this exploit. In the meantime, you’ll peek a bit further under the hood of

$ python timer.py 5

Introduction to Pipes

A pipe, or pipeline, is a special stream that, instead of having one file handle as most files do, has two. One handle is read-only, and the other is write-only. The name is very descriptive—a pipe serves to pipe a byte stream from one process to another. It’s also buffered, so a process can write to it, and it’ll hold onto those bytes until it’s read, like a dispenser.

You may be used to seeing pipes on the command line, as you did in the section on shells:

# timer.py

from argparse import ArgumentParser
from time import sleep

parser = ArgumentParser()
parser.add_argument("time", type=int)
args = parser.parse_args()
print(f"Starting timer of {args.time} seconds")
for _ in range(args.time):
    print(".", end="", flush=True)
    sleep(1)
print("Done!")

This command tells the shell to create an

$ python timer.py 5

# timer.py

from argparse import ArgumentParser
from time import sleep

parser = ArgumentParser()
parser.add_argument("time", type=int)
args = parser.parse_args()
print(f"Starting timer of {args.time} seconds")
for _ in range(args.time):
    print(".", end="", flush=True)
    sleep(1)
print("Done!")

PS> choco install sysinternals

PS> choco install sysinternals

$ python timer.py 5

PS> choco install sysinternals

PS> choco install sysinternals

PS> choco install sysinternals

# timer.py

from argparse import ArgumentParser
from time import sleep

parser = ArgumentParser()
parser.add_argument("time", type=int)
args = parser.parse_args()
print(f"Starting timer of {args.time} seconds")
for _ in range(args.time):
    print(".", end="", flush=True)
    sleep(1)
print("Done!")

Windows doesn’t have

PS> choco install sysinternals

# timer.py

from argparse import ArgumentParser
from time import sleep

parser = ArgumentParser()
parser.add_argument("time", type=int)
args = parser.parse_args()
print(f"Starting timer of {args.time} seconds")
for _ in range(args.time):
    print(".", end="", flush=True)
    sleep(1)
print("Done!")

However, on Windows PowerShell, things work very differently. As you learned in the Windows shell section of this tutorial, the different commands are not separate executables. Therefore, PowerShell is internally redirecting the output of one command into another without starting new processes.

Note: If you don’t have access to a UNIX-based operating system but have Windows 10 or above, then you actually do have access to a UNIX-based operating system! Check out Windows Subsystem for Linux, which will give you access to a fully featured Linux shell.

You can use pipes for different processes on PowerShell, though getting into the intricacies of which ones is outside the scope of this tutorial. For more information on PowerShell pipes, check out the documentation. So, for the rest of the pipe examples, only UNIX-based examples will be used, as the basic mechanism is the same for both systems. They’re not nearly as common on Windows, anyway.

If you want to let the shell take care of piping processes into one another, then you can just pass the whole string as a command into

$ python timer.py 5

>>>

# timer.py

from argparse import ArgumentParser
from time import sleep

parser = ArgumentParser()
parser.add_argument("time", type=int)
args = parser.parse_args()
print(f"Starting timer of {args.time} seconds")
for _ in range(args.time):
    print(".", end="", flush=True)
    sleep(1)
print("Done!")

This way, you can let your chosen shell take care of piping one process into another, instead of trying to reimplement things in Python. This is a perfectly valid choice in certain situations.

Later in the tutorial, you’ll also come to see that you can’t pipe processes directly with

>>> subprocess.run(["gedit"])
CompletedProcess(args=['gedit'], returncode=0)

>>> import shlex
>>> shlex.split("python timer.py 5")
['python', 'timer.py', '5']

>>> subprocess.run(shlex.split("python timer.py 5"))
Starting timer of 5 seconds
.....Done!
CompletedProcess(args=['python', 'timer.py', '5'], returncode=0)

Whether you mean to pipe one process into another with the

$ python timer.py 5

$ python timer.py 5

The Pipes of $ python timer.py 5 0

The Python

$ python timer.py 5

# timer.py

from argparse import ArgumentParser
from time import sleep

parser = ArgumentParser()
parser.add_argument("time", type=int)
args = parser.parse_args()
print(f"Starting timer of {args.time} seconds")
for _ in range(args.time):
    print(".", end="", flush=True)
    sleep(1)
print("Done!")

PS> choco install sysinternals

>>>

PS> choco install sysinternals

# timer.py

from argparse import ArgumentParser
from time import sleep

parser = ArgumentParser()
parser.add_argument("time", type=int)
args = parser.parse_args()
print(f"Starting timer of {args.time} seconds")
for _ in range(args.time):
    print(".", end="", flush=True)
    sleep(1)
print("Done!")

PS> choco install sysinternals

PS> choco install sysinternals

# timer.py

from argparse import ArgumentParser
from time import sleep

parser = ArgumentParser()
parser.add_argument("time", type=int)
args = parser.parse_args()
print(f"Starting timer of {args.time} seconds")
for _ in range(args.time):
    print(".", end="", flush=True)
    sleep(1)
print("Done!")

>>>

# timer.py

from argparse import ArgumentParser
from time import sleep

parser = ArgumentParser()
parser.add_argument("time", type=int)
args = parser.parse_args()
print(f"Starting timer of {args.time} seconds")
for _ in range(args.time):
    print(".", end="", flush=True)
    sleep(1)
print("Done!")

The

# timer.py

from argparse import ArgumentParser
from time import sleep

parser = ArgumentParser()
parser.add_argument("time", type=int)
args = parser.parse_args()
print(f"Starting timer of {args.time} seconds")
for _ in range(args.time):
    print(".", end="", flush=True)
    sleep(1)
print("Done!")

$ python timer.py 5

PS> choco install sysinternals

PS> choco install processhacker

PS> choco install sysinternals

PS> choco install processhacker

Note: Pipe buffers have a limited capacity. Depending on the system you are running on, you may easily run into that limit if you plan on holding large quantities of data in the buffer. To work around this limit, you can use normal files.

You can also pass a file object to any of the standard stream parameters:

>>>

# timer.py

from argparse import ArgumentParser
from time import sleep

parser = ArgumentParser()
parser.add_argument("time", type=int)
args = parser.parse_args()
print(f"Starting timer of {args.time} seconds")
for _ in range(args.time):
    print(".", end="", flush=True)
    sleep(1)
print("Done!")

You can’t pass a bytes object or a string directly to the

PS> choco install sysinternals

Note that the

# timer.py

from argparse import ArgumentParser
from time import sleep

parser = ArgumentParser()
parser.add_argument("time", type=int)
args = parser.parse_args()
print(f"Starting timer of {args.time} seconds")
for _ in range(args.time):
    print(".", end="", flush=True)
    sleep(1)
print("Done!")

# timer.py

from argparse import ArgumentParser
from time import sleep

parser = ArgumentParser()
parser.add_argument("time", type=int)
args = parser.parse_args()
print(f"Starting timer of {args.time} seconds")
for _ in range(args.time):
    print(".", end="", flush=True)
    sleep(1)
print("Done!")

The

# timer.py

from argparse import ArgumentParser
from time import sleep

parser = ArgumentParser()
parser.add_argument("time", type=int)
args = parser.parse_args()
print(f"Starting timer of {args.time} seconds")
for _ in range(args.time):
    print(".", end="", flush=True)
    sleep(1)
print("Done!")

# timer.py

from argparse import ArgumentParser
from time import sleep

parser = ArgumentParser()
parser.add_argument("time", type=int)
args = parser.parse_args()
print(f"Starting timer of {args.time} seconds")
for _ in range(args.time):
    print(".", end="", flush=True)
    sleep(1)
print("Done!")

# timer.py

from argparse import ArgumentParser
from time import sleep

parser = ArgumentParser()
parser.add_argument("time", type=int)
args = parser.parse_args()
print(f"Starting timer of {args.time} seconds")
for _ in range(args.time):
    print(".", end="", flush=True)
    sleep(1)
print("Done!")

# timer.py

from argparse import ArgumentParser
from time import sleep

parser = ArgumentParser()
parser.add_argument("time", type=int)
args = parser.parse_args()
print(f"Starting timer of {args.time} seconds")
for _ in range(args.time):
    print(".", end="", flush=True)
    sleep(1)
print("Done!")

PS> choco install sysinternals

To actually link up two processes with a pipe from within

$ python timer.py 5

>>> subprocess.run(["gedit"])
CompletedProcess(args=['gedit'], returncode=0)

$ python timer.py 5

If you needed to link up different processes without delegating any of the work to the shell, then you could do that with the underlying

>>> import shlex
>>> shlex.split("python timer.py 5")
['python', 'timer.py', '5']

>>> subprocess.run(shlex.split("python timer.py 5"))
Starting timer of 5 seconds
.....Done!
CompletedProcess(args=['python', 'timer.py', '5'], returncode=0)

>>> import shlex
>>> shlex.split("python timer.py 5")
['python', 'timer.py', '5']

>>> subprocess.run(shlex.split("python timer.py 5"))
Starting timer of 5 seconds
.....Done!
CompletedProcess(args=['python', 'timer.py', '5'], returncode=0)

>>> subprocess.run(["gedit"])
CompletedProcess(args=['gedit'], returncode=0)

Pipe Simulation With >>> subprocess.run(["gedit"]) CompletedProcess(args=['gedit'], returncode=0) 5

Though you can’t actually link up two processes together with a pipe by using the

>>> subprocess.run(["gedit"])
CompletedProcess(args=['gedit'], returncode=0)

PS> choco install sysinternals

If you’re on a UNIX-based system where almost all typical shell commands are separate executables, then you can just set the

# timer.py

from argparse import ArgumentParser
from time import sleep

parser = ArgumentParser()
parser.add_argument("time", type=int)
args = parser.parse_args()
print(f"Starting timer of {args.time} seconds")
for _ in range(args.time):
    print(".", end="", flush=True)
    sleep(1)
print("Done!")

# timer.py

from argparse import ArgumentParser
from time import sleep

parser = ArgumentParser()
parser.add_argument("time", type=int)
args = parser.parse_args()
print(f"Starting timer of {args.time} seconds")
for _ in range(args.time):
    print(".", end="", flush=True)
    sleep(1)
print("Done!")

PS> choco install processhacker

>>>

# timer.py

from argparse import ArgumentParser
from time import sleep

parser = ArgumentParser()
parser.add_argument("time", type=int)
args = parser.parse_args()
print(f"Starting timer of {args.time} seconds")
for _ in range(args.time):
    print(".", end="", flush=True)
    sleep(1)
print("Done!")

Here the

# timer.py

from argparse import ArgumentParser
from time import sleep

parser = ArgumentParser()
parser.add_argument("time", type=int)
args = parser.parse_args()
print(f"Starting timer of {args.time} seconds")
for _ in range(args.time):
    print(".", end="", flush=True)
    sleep(1)
print("Done!")

PS> choco install processhacker

$ python timer.py 5

# timer.py

from argparse import ArgumentParser
from time import sleep

parser = ArgumentParser()
parser.add_argument("time", type=int)
args = parser.parse_args()
print(f"Starting timer of {args.time} seconds")
for _ in range(args.time):
    print(".", end="", flush=True)
    sleep(1)
print("Done!")

>>> import subprocess
>>> subprocess.run(["python", "timer.py", "5"])
Starting timer of 5 seconds
.....Done!
CompletedProcess(args=['python', 'timer.py', '5'], returncode=0)

# timer.py

from argparse import ArgumentParser
from time import sleep

parser = ArgumentParser()
parser.add_argument("time", type=int)
args = parser.parse_args()
print(f"Starting timer of {args.time} seconds")
for _ in range(args.time):
    print(".", end="", flush=True)
    sleep(1)
print("Done!")

PS> choco install sysinternals

# timer.py

from argparse import ArgumentParser
from time import sleep

parser = ArgumentParser()
parser.add_argument("time", type=int)
args = parser.parse_args()
print(f"Starting timer of {args.time} seconds")
for _ in range(args.time):
    print(".", end="", flush=True)
    sleep(1)
print("Done!")

PS> choco install sysinternals

As an alternative, you can operate directly with files too, setting them to the standard stream parameters. When using files, you set the file object as the argument to

PS> choco install sysinternals

# timer.py

from argparse import ArgumentParser
from time import sleep

parser = ArgumentParser()
parser.add_argument("time", type=int)
args = parser.parse_args()
print(f"Starting timer of {args.time} seconds")
for _ in range(args.time):
    print(".", end="", flush=True)
    sleep(1)
print("Done!")

>>>

# timer.py

from argparse import ArgumentParser
from time import sleep

parser = ArgumentParser()
parser.add_argument("time", type=int)
args = parser.parse_args()
print(f"Starting timer of {args.time} seconds")
for _ in range(args.time):
    print(".", end="", flush=True)
    sleep(1)
print("Done!")

As you learned in the previous section, for Windows PowerShell, doing something like this doesn’t make a whole lot of sense because most of the time, these utilities are part of PowerShell itself. Because you aren’t dealing with separate executables, piping becomes less of a necessity. However, the pattern for piping is still the same if something like this needs to be done.

With most of the tools out the way, it’s now time to think about some practical applications for

$ python timer.py 5

Creating a New Project: An Example

Say you often need to create new local projects, each complete with a virtual environment and initialized as a Git repository. You could reach for the Cookiecutter library, which is dedicated to that task, and that wouldn’t be a bad idea.

However, using Cookiecutter would mean learning Cookiecutter. Imagine you didn’t have much time, and your environment was extremely minimal anyway—all you could really count on was Git and Python. In these cases,

$ python timer.py 5

>>> import subprocess
>>> subprocess.run(["python", "timer.py", "5"])
Starting timer of 5 seconds
.....Done!
CompletedProcess(args=['python', 'timer.py', '5'], returncode=0)

This is a command-line tool that you can call to start a project. It’ll take care of creating a

>>> import subprocess
>>> subprocess.run(["python", "timer.py", "5"])
Starting timer of 5 seconds
.....Done!
CompletedProcess(args=['python', 'timer.py', '5'], returncode=0)

>>> import subprocess
>>> subprocess.run(["python", "timer.py", "5"])
Starting timer of 5 seconds
.....Done!
CompletedProcess(args=['python', 'timer.py', '5'], returncode=0)

PS> choco install sysinternals

Could this be done with Cookiecutter? Could you use GitPython for the

>>> import subprocess
>>> subprocess.run(["python", "timer.py", "5"])
Starting timer of 5 seconds
.....Done!
CompletedProcess(args=['python', 'timer.py', '5'], returncode=0)

>>> import subprocess
>>> subprocess.run(["python", "timer.py", "5"])
Starting timer of 5 seconds
.....Done!
CompletedProcess(args=['python', 'timer.py', '5'], returncode=0)

$ python timer.py 5

Changing Extended Attributes

If you use Dropbox, you may not know that there’s a way to ignore files when syncing. For example, you can keep virtual environments in your project folder and use Dropbox to sync the code, but keep the virtual environment local.

That said, it’s not as easy as adding a

>>> import subprocess
>>> subprocess.run(["python", "timer.py", "5"])
Starting timer of 5 seconds
.....Done!
CompletedProcess(args=['python', 'timer.py', '5'], returncode=0)

• Windows
• Linux
• macOS

>>> import subprocess
>>> subprocess.run(["python", "timer.py", "5"])
Starting timer of 5 seconds
.....Done!
CompletedProcess(args=['python', 'timer.py', '5'], returncode=0)

>>> import subprocess
>>> subprocess.run(["python", "timer.py", "5"])
Starting timer of 5 seconds
.....Done!
CompletedProcess(args=['python', 'timer.py', '5'], returncode=0)

>>> import subprocess
>>> subprocess.run(["python", "timer.py", "5"])
Starting timer of 5 seconds
.....Done!
CompletedProcess(args=['python', 'timer.py', '5'], returncode=0)

There are some UNIX-based projects, like dropboxignore, that use shell scripts to make it easier to ignore files and folders. The code is relatively complex, and it won’t work on Windows.

With the

$ python timer.py 5

>>> import subprocess
>>> subprocess.run(["python", "timer.py", "5"])
Starting timer of 5 seconds
.....Done!
CompletedProcess(args=['python', 'timer.py', '5'], returncode=0)

This is a simplified snippet from the author’s dotDropboxIgnore repository. The

>>> import subprocess
>>> subprocess.run(["python", "timer.py", "5"])
Starting timer of 5 seconds
.....Done!
CompletedProcess(args=['python', 'timer.py', '5'], returncode=0)

>>> import subprocess
>>> subprocess.run(["python", "timer.py", "5"])
Starting timer of 5 seconds
.....Done!
CompletedProcess(args=['python', 'timer.py', '5'], returncode=0)

>>> import subprocess
>>> subprocess.run(["python", "timer.py", "5"])
Starting timer of 5 seconds
.....Done!
CompletedProcess(args=['python', 'timer.py', '5'], returncode=0)

The shell object allows you to call an

>>> import subprocess
>>> subprocess.run(["python", "timer.py", "5"])
Starting timer of 5 seconds
.....Done!
CompletedProcess(args=['python', 'timer.py', '5'], returncode=0)

PS> choco install sysinternals

>>> import subprocess
>>> subprocess.run(["python", "timer.py", "5"])
Starting timer of 5 seconds
.....Done!
CompletedProcess(args=['python', 'timer.py', '5'], returncode=0)

On the

>>> import subprocess
>>> subprocess.run(["python", "timer.py", "5"])
Starting timer of 5 seconds
.....Done!
CompletedProcess(args=['python', 'timer.py', '5'], returncode=0)

In the next section, you’ll review some of the other modules that might be interesting to keep in mind when deciding whether to use

$ python timer.py 5

Using >>> import shlex >>> shlex.split("python timer.py 5") ['python', 'timer.py', '5'] >>> subprocess.run(shlex.split("python timer.py 5")) Starting timer of 5 seconds .....Done! CompletedProcess(args=['python', 'timer.py', '5'], returncode=0) 3

Using the

>>> import shlex
>>> shlex.split("python timer.py 5")
['python', 'timer.py', '5']

>>> subprocess.run(shlex.split("python timer.py 5"))
Starting timer of 5 seconds
.....Done!
CompletedProcess(args=['python', 'timer.py', '5'], returncode=0)

>>> subprocess.run(["gedit"])
CompletedProcess(args=['gedit'], returncode=0)

>>> subprocess.run(["gedit"])
CompletedProcess(args=['gedit'], returncode=0)

>>> import shlex
>>> shlex.split("python timer.py 5")
['python', 'timer.py', '5']

>>> subprocess.run(shlex.split("python timer.py 5"))
Starting timer of 5 seconds
.....Done!
CompletedProcess(args=['python', 'timer.py', '5'], returncode=0)

>>> import subprocess
>>> subprocess.run(["python", "timer.py", "5"])
Starting timer of 5 seconds
.....Done!
CompletedProcess(args=['python', 'timer.py', '5'], returncode=0)

This program calls the timer process in a context manager and assigns

PS> choco install sysinternals

>>> import subprocess
>>> subprocess.run(["python", "timer.py", "5"])
Starting timer of 5 seconds
.....Done!
CompletedProcess(args=['python', 'timer.py', '5'], returncode=0)

>>> subprocess.run(["gedit"])
CompletedProcess(args=['gedit'], returncode=0)

PS> choco install sysinternals

The

>>> import subprocess
>>> subprocess.run(["python", "timer.py", "5"])
Starting timer of 5 seconds
.....Done!
CompletedProcess(args=['python', 'timer.py', '5'], returncode=0)

>>> import subprocess
>>> subprocess.run(["python", "timer.py", "5"])
Starting timer of 5 seconds
.....Done!
CompletedProcess(args=['python', 'timer.py', '5'], returncode=0)

>>> import subprocess
>>> subprocess.run(["python", "timer.py", "5"])
Starting timer of 5 seconds
.....Done!
CompletedProcess(args=['python', 'timer.py', '5'], returncode=0)

Then the program uses

>>> import subprocess
>>> subprocess.run(["python", "timer.py", "5"])
Starting timer of 5 seconds
.....Done!
CompletedProcess(args=['python', 'timer.py', '5'], returncode=0)

# timer.py

from argparse import ArgumentParser
from time import sleep

parser = ArgumentParser()
parser.add_argument("time", type=int)
args = parser.parse_args()
print(f"Starting timer of {args.time} seconds")
for _ in range(args.time):
    print(".", end="", flush=True)
    sleep(1)
print("Done!")

Note: If you put the

>>> subprocess.run(["gedit"])
CompletedProcess(args=['gedit'], returncode=0)

>>> import subprocess
>>> subprocess.run(["python", "timer.py", "5"])
Starting timer of 5 seconds
.....Done!
CompletedProcess(args=['python', 'timer.py', '5'], returncode=0)

# timer.py

from argparse import ArgumentParser
from time import sleep

parser = ArgumentParser()
parser.add_argument("time", type=int)
args = parser.parse_args()
print(f"Starting timer of {args.time} seconds")
for _ in range(args.time):
    print(".", end="", flush=True)
    sleep(1)
print("Done!")