set permision as execution and add this at first line
#!/usr/bin/env python
set permision as execution and add this at first line
#!/usr/bin/env python
Firstly you will need to add a shebang line to the top of your script like so:
#!/bin/python
Where the portion after the shebang "#!" Is the path to your python environment which is often /bin/python on Linux platforms.
After that you will need to use the chmod command to make the file executable.
chmod u+x /path/to/file
This command will make the file executable for the user. You will then be able to run the script by just typing the path to the file into the command line.
Converting a bash script to python (small script) - Stack Overflow
Help Request - convert python code to bash script
shell script - Python to Bash Conversion? - Unix & Linux Stack Exchange
How to convert this Python code into a shell script? - Stack Overflow
Videos
Answer
Let's break it down into pieces. Especially the pieces you got wrong. :)
Assignment
outfile=ReadsAgain.txt
It should come to little surprise that you need to put quotes around strings. On the other hand, you have the luxury of putting spaces around the = for readability.
outfilename = "ReadsAgain.txt"
Variable expansion → str.format (or, the % operation)
python reads.py <snip/> -q$queries <snip/>
So you know how to do the redirection already, but how do you do the variable expansion? You can use the format method (v2.6+):
command = "python reads.py -r1 -pquery1.sql -q{0} -shotelspec -k6 -a5".format(queries)
You can alternatively use the % operator:
#since queries is a number, use %d as a placeholder
command = "python reads.py -r1 -pquery1.sql -q%d -shotelspec -k6 -a5" % queries
C-style loop → Object-oriented-style loop
for ((r = 1; r < ($runs + 1); r++)) do done
Looping in Python is different from C-style iteration. What happens in Python is you iterate over an iterable object, like for example a list. Here, you are trying to do something runs times, so you would do this:
for r in range(runs):
#loop body here
range(runs) is equivalent to [0,1,...,runs-1], a list of runs = 5 integer elements. So you'll be repeating the body runs times. At every cicle, r is assigned the next item of the list. This is thus completely equivalent to what you are doing in Bash.
If you're feeling daring, use xrange instead. It's completely equivalent but uses more advanced language features (so it is harder to explain in layman's terms) but consumes less resources.
Output redirection → the subprocess module
The "tougher" part, if you will: executing a program and getting its output. Google to the rescue! Obviously, the top hit is a stackoverflow question: this one. You can hide all the complexity behind it with a simple function:
import subprocess, shlex
def get_output_of(command):
args = shlex.split(command)
return subprocess.Popen(args,
stdout=subprocess.PIPE).communicate()[0]
# this only returns stdout
So:
python reads.py -r1 -pquery1.sql -q$queries -shotelspec -k6 -a5 >> $outfile
becomes:
command = "python reads.py -r1 -pquery1.sql -q%s -shotelspec -k6 -a5" % queries
read_result = get_output_of(command)
Don't over-subprocess, batteries are included
Optionally, consider that you can get pretty much the same output of date with the following:
import time
time_now = time.strftime("%c", time.localtime()) # Sat May 15 15:42:47 2010
(Note the absence of the time zone information. This should be the subject of another question, if it is important to you.)
How your program should look like
The final result should then look like this:
import subprocess, shlex, time
def get_output_of(command):
#... body of get_output_of
#... more functions ...
if __name__ = "__main__":
#only execute the following if you are calling this .py file directly,
#and not, say, importing it
#... initialization ...
with file("outputfile.txt", "a") as output_file: #alternative way to open files, v2.5+
#... write date and other stuff ...
for r in range(runs):
#... loop body here ...
Post scriptum
That must look pretty horrible when compared to the relatively simple and short Bash script, right? Python is not a specialized language: it aims to do everything reasonably well, but isn't built directly for running programs and getting the output of those.
Still, you wouldn't normally write a database engine in Bash, right? It's different tools for different jobs. Here, unless you're planning to make some changes that would be non-trivial to write with that language, [Ba]sh was definitely the right choice.
It should be fairly simple to port your program. The only tricky part will be running the db2 command and (maybe) refactoring reads.py so that it can be called as a library function.
The basic idea is the same:
- Setting local variables is the same.
- Replace
echowithprint. - Replace your loop with
for r in range(runs):. - Get the
datewith the datetime module. - Replace write to file with the file objects module.
- Replace the call to
db2with the subprocess module. - You'll need to
import reads.pyto use as a library (or you can use subprocess).
But, as Marcelo says, if you want more help- you're best off putting in some effort of your own to ask direct questions.
» pip install python-script-converter
Apologies if this is the wrong subreddit to post this. I found a script to manipulate timecodes for FFMPEG metadata and am hoping someone would help me convert the code to a bash script.
Here's the python code:
import re
chapters = list()
with open('chapters.txt', 'r') as f:
for line in f:
x = re.match(r"(\d):(\d{2}):(\d{2}) (.*)", line)
hrs = int(x.group(1))
mins = int(x.group(2))
secs = int(x.group(3))
title = x.group(4)
minutes = (hrs * 60) + mins
seconds = secs + (minutes * 60)
timestamp = (seconds * 1000)
chap = {
"title": title,
"startTime": timestamp
}
chapters.append(chap)
text = ""
for i in range(len(chapters)-1):
chap = chapters[i]
title = chap['title']
start = chap['startTime']
end = chapters[i+1]['startTime']-1
text += f"""
[CHAPTER]
TIMEBASE=1/1000
START={start}
END={end}
title={title}
"""
with open("FFMETADATAFILE", "a") as myfile:
myfile.write(text)Thanks for any help provided.