outputting a command to the terminal?

[John Salerno]

Here's my new project: I want to write a little script that I can type
at the terminal like this:

$ scriptname package1 [package2, ...]

where scriptname is my module name and any subsequent arguments are the
names of Linux packages to install. Running the script as above will
create this line:

sudo aptitude install package1 package2 ...

It will run that line at the terminal so the package(s) will be installed.

Now, the extra functionality I want to add (otherwise I would just
install them normally!) is to save the package names to a text file so I
can now the names of programs I've manually installed, if I ever want to
check the list or remove packages.

So creating the proper bash command (sudo aptitude install ...) is easy,
and writing the names to a file is easy. But I have two questions:

1. First of all, does Linux keep track of the packages you manually
install? If so, then I won't have to do this at all.

2. Assuming I write this, how do output the bash command to the
terminal? Is there a particular module that Python uses to interact with
the terminal window that I can use to send the install command to the
terminal?

Thanks.

[Diez B. Roggisch]

John Salerno schrieb:

Here's my new project: I want to write a little script that I can type
at the terminal like this:

$ scriptname package1 [package2, ...]

where scriptname is my module name and any subsequent arguments are the
names of Linux packages to install. Running the script as above will
create this line:

sudo aptitude install package1 package2 ...

It will run that line at the terminal so the package(s) will be installed.

Now, the extra functionality I want to add (otherwise I would just
install them normally!) is to save the package names to a text file so I
can now the names of programs I've manually installed, if I ever want to
check the list or remove packages.

So creating the proper bash command (sudo aptitude install ...) is easy,
and writing the names to a file is easy. But I have two questions:

1. First of all, does Linux keep track of the packages you manually
install? If so, then I won't have to do this at all.

2. Assuming I write this, how do output the bash command to the
terminal? Is there a particular module that Python uses to interact with
the terminal window that I can use to send the install command to the
terminal?

You don't put a command to the terminal. The shell executes commands.
But it is mainly just a program itself - it can spawn subprocesses and
make these execute the actual commands. so - the module you need is most
probably subprocess.

Diez

[Yu-Xi Lim]

John Salerno wrote:

1. First of all, does Linux keep track of the packages you manually
install? If so, then I won't have to do this at all.

I assume you're using a Debian-based distro with aptitude as the front
end. In which case, all dpkg operations should be logged in
/var/log/dpkg.log

Generally, after the initial installation, all subsequent operations are
either updates of existing packages or packages you installed manually.
Only rarely do you get new packages installed automatically as a result
of an additional dependency from an original automatically installed
package.

If you know when you completed your initial installation, you can easily
parse the log files to determine what else was installed after that.

2. Assuming I write this, how do output the bash command to the
terminal? Is there a particular module that Python uses to interact with
the terminal window that I can use to send the install command to the
terminal?

I'm wondering about the need to "output the bash command to the
terminal". It would probably suffice if your Python script just spawned
an instance of the shell with the necessary command line. Take a look at
the subprocess module.

But this really calls for a bash script:

#!/bin/bash
echo $@ >/path/to/manual_install. log
sudo aptitude install $@
Shorter than the equivalent Python code. You could probably declare this
as a function in your bash initialization files too, if you know how to
do this.

[John Salerno]

Yu-Xi Lim wrote:

I assume you're using a Debian-based distro with aptitude as the front
end. In which case, all dpkg operations should be logged in
/var/log/dpkg.log

Yes, I'm using Ubuntu. But I checked this log file and I'm a bit
confused. It has a lot of listings for 5-31-06, but I didn't even
install Linux until last Saturday. The next date after 5-31 is 8-5-06,
and I know I installed things between last Saturday and Aug. 5.

(But this is OT, so don't worry about it.)

I'm wondering about the need to "output the bash command to the
terminal". It would probably suffice if your Python script just spawned
an instance of the shell with the necessary command line. Take a look at
the subprocess module.

But this really calls for a bash script:

#!/bin/bash
echo $@ >/path/to/manual_install. log
sudo aptitude install $@
Shorter than the equivalent Python code. You could probably declare this
as a function in your bash initialization files too, if you know how to
do this.

Hmm, interesting. I figured I could do this with a bash script, but I
don't know bash at all and I'm trying to stick with Python. I don't
quite understand your bash script (not familiar with the $@ syntax).

I think I'll take a look at the subprocess module, just for fun. :)

[John Machin]

John Salerno wrote:

>
I think I'll take a look at the subprocess module, just for fun. :)

.... and for learning too :-)

Also, consider that some operating system commands are built into the
shell (i.e. not run as a separate process), which makes using the
subprocess module a bit difficult -- for more fun and learning, check
out os.system()

Cheers,
John

[John Salerno]

Dennis Lee Bieber wrote:

On Sun, 13 Aug 2006 20:21:26 -0400, John Salerno
<jo******@NOSPA Mgmail.comdecla imed the following in comp.lang.pytho n:

>Yes, I'm using Ubuntu. But I checked this log file and I'm a bit
confused. It has a lot of listings for 5-31-06, but I didn't even
install Linux until last Saturday. The next date after 5-31 is 8-5-06,
and I know I installed things between last Saturday and Aug. 5.

Pardon, between when?

Wow, I can't believe how time goes. Aug. 5 *was* the first day! I knew I
had installed it a week ago, but I was thinking it was the last Saturday
in July, not Aug. 5 already!

>
August 5 was "last Saturday" if you ignore "yesterday" (well, since
my watch says it is now Monday... "day before last").

I'd guess the "May 31" entries are those that were "snapshots" of
the OS installer date. August 5, first Saturday in the month, might be
the first non-standard installed package.

>Hmm, interesting. I figured I could do this with a bash script, but I
don't know bash at all and I'm trying to stick with Python. I don't
quite understand your bash script (not familiar with the $@ syntax).

Well, I don't do shell scripts either, but... looking at the
sample... "$@" is likely the shell equivalent of Python's sys.argv -- or
*sys.argv if passed down

[Steven Bethard]

John Salerno wrote:

Here's my new project: I want to write a little script that I can type
at the terminal like this:

$ scriptname package1 [package2, ...]

where scriptname is my module name and any subsequent arguments are the
names of Linux packages to install. Running the script as above will
create this line:

sudo aptitude install package1 package2 ...

It will run that line at the terminal so the package(s) will be installed.

Now, the extra functionality I want to add (otherwise I would just
install them normally!) is to save the package names to a text file so I
can now the names of programs I've manually installed, if I ever want to
check the list or remove packages.

So creating the proper bash command (sudo aptitude install ...) is easy,
and writing the names to a file is easy. But I have two questions:

1. First of all, does Linux keep track of the packages you manually
install? If so, then I won't have to do this at all.

2. Assuming I write this, how do output the bash command to the
terminal? Is there a particular module that Python uses to interact with
the terminal window that I can use to send the install command to the
terminal?

I don't know the answer to the first bit here, but I think the following
should get you most of what you want as far as the second bit is concerned:
---------------------------- scriptname.py ----------------------------
import argparse # http://argparse.python-hosting.com/
import subprocess
import sys

def outputfile(file name):
return open(filename, 'w')

if __name__ == '__main__':
# parse the command line arguments
parser = argparse.Argume ntParser()
parser.add_argu ment('packages' , metavar='packag e', nargs='+',
help='one of the packages to install')
parser.add_argu ment('--save', type=outputfile , default=sys.std out,
help='a file to save the package names to')
namespace = parser.parse_ar gs()

# call the command
command = ['sudo', 'aptitude', 'install'] + namespace.packa ges
subprocess.call (command)

# write the package name file
for package_name in namespace.packa ges:
namespace.save. write('%s\n' % package_name)
-----------------------------------------------------------------------
$ scriptname.py -h
usage: scriptname.py [-h] [--save SAVE] package [package ...]

positional arguments:
package one of the packages to install

optional arguments:
-h, --help show this help message and exit
--save SAVE a file to save the package names to

STeVe

[John Salerno]

Steven Bethard wrote:

John Salerno wrote:

>Here's my new project: I want to write a little script that I can type
at the terminal like this:

$ scriptname package1 [package2, ...]

where scriptname is my module name and any subsequent arguments are
the names of Linux packages to install. Running the script as above
will create this line:

sudo aptitude install package1 package2 ...

It will run that line at the terminal so the package(s) will be
installed.

Now, the extra functionality I want to add (otherwise I would just
install them normally!) is to save the package names to a text file so
I can now the names of programs I've manually installed, if I ever
want to check the list or remove packages.

So creating the proper bash command (sudo aptitude install ...) is
easy, and writing the names to a file is easy. But I have two questions:

1. First of all, does Linux keep track of the packages you manually
install? If so, then I won't have to do this at all.

2. Assuming I write this, how do output the bash command to the
terminal? Is there a particular module that Python uses to interact
with the terminal window that I can use to send the install command to
the terminal?

I don't know the answer to the first bit here, but I think the following
should get you most of what you want as far as the second bit is concerned:
---------------------------- scriptname.py ----------------------------
import argparse # http://argparse.python-hosting.com/
import subprocess
import sys

def outputfile(file name):
return open(filename, 'w')

if __name__ == '__main__':
# parse the command line arguments
parser = argparse.Argume ntParser()
parser.add_argu ment('packages' , metavar='packag e', nargs='+',
help='one of the packages to install')
parser.add_argu ment('--save', type=outputfile , default=sys.std out,
help='a file to save the package names to')
namespace = parser.parse_ar gs()

# call the command
command = ['sudo', 'aptitude', 'install'] + namespace.packa ges
subprocess.call (command)

# write the package name file
for package_name in namespace.packa ges:
namespace.save. write('%s\n' % package_name)
-----------------------------------------------------------------------
$ scriptname.py -h
usage: scriptname.py [-h] [--save SAVE] package [package ...]

positional arguments:
package one of the packages to install

optional arguments:
-h, --help show this help message and exit
--save SAVE a file to save the package names to

STeVe

yikes! I'll have to take some time to study this! I appreciate it. :)

[Yu-Xi Lim]

Steven Bethard wrote:

import argparse # http://argparse.python-hosting.com/
import subprocess
import sys

Why not the standard lib's optparse?

[Steven Bethard]

John Salerno wrote:

Steven Bethard wrote:

>---------------------------- scriptname.py ----------------------------
import argparse # http://argparse.python-hosting.com/
import subprocess
import sys

def outputfile(file name):
return open(filename, 'w')

if __name__ == '__main__':
# parse the command line arguments
parser = argparse.Argume ntParser()
parser.add_argu ment('packages' , metavar='packag e', nargs='+',
help='one of the packages to install')
parser.add_argu ment('--save', type=outputfile , default=sys.std out,
help='a file to save the package names to')
namespace = parser.parse_ar gs()

# call the command
command = ['sudo', 'aptitude', 'install'] + namespace.packa ges
subprocess.call (command)

# write the package name file
for package_name in namespace.packa ges:
namespace.save. write('%s\n' % package_name)
-----------------------------------------------------------------------
$ scriptname.py -h
usage: scriptname.py [-h] [--save SAVE] package [package ...]

positional arguments:
package one of the packages to install

optional arguments:
-h, --help show this help message and exit
--save SAVE a file to save the package names to

yikes! I'll have to take some time to study this! I appreciate it. :)

For just calling the command, the important lines are::

command = ['sudo', 'aptitude', 'install'] + namespace.packa ges
subprocess.call (command)

where you could have probably used ``sys.argv[1:]`` instead of
namespace.packa ges.
For writing the file, as I'm sure you've already figured out, the
important lines are::

for package_name in namespace.packa ges:
namespace.save. write('%s\n' % package_name)

where again, if you weren't using argparse, you could have used
``sys.argv`` to determine the package names (namespace.pack ages) and the
file to write to (namespace.save ).
The remaining lines involving the ``parser`` object are basically
defining a command line interface in a similar way to what optparse in
the stdlib does. Sure, you could do all of this by fiddling with
sys.argv, but the argparse module will do all the parsing and
conversions for you, and give your script a meaningful usage message.
And I'm a firm believer in meaningful usage messages. =)

STeVe

P.S. Thank *you* for posting this. As a result, I've been convinced
that argparse should grow a 'outfile' type, something I've been debating
with myself about for a while now.