No. It is not guaranteed that lines will remain intact. They can become intermingled. From searching based on liori’s answer I found this: Write requests of {PIPE_BUF} bytes or less shall not be interleaved with data from other processes doing writes on the same pipe. Writes of greater than {PIPE_BUF} bytes may have data interleaved, … Read more
Essentially, pipes – whether named or anonymous – are used like message passing. Someone sends a piece of information to the recipient and the recipient can receive it. Shared memory is more like publishing data – someone puts data in shared memory and the readers (potentially many) must use synchronization e.g. via semaphores to learn … Read more
You might also run into a problem with grep buffering when inside a pipe. ie, you don’t see the output from tail –follow=name file.txt | grep something > output.txt since grep will buffer its own output. Use the –line-buffered switch for grep to work around this: tail –follow=name file.txt | grep –line-buffered something > output.txt … Read more
It’s a little tricky to write a function which can read standard input, but works properly when no standard input is given. If you simply try to read from standard input, it will block until it receives any, much like if you simply type cat at the prompt. In bash 4, you can work around … Read more
You need to use Console.Read() and Console.ReadLine() as if you were reading user input. Pipes replace user input transparently. You can’t use both easily (although I’m sure it’s quite possible…). Edit: A simple cat style program: class Program { static void Main(string[] args) { string s; while ((s = Console.ReadLine()) != null) { Console.WriteLine(s); } … Read more
There is a better way: soxi -D out.wav
Use a subprocess.PIPE, as explained in the subprocess docs section “Replacing shell pipeline”: import subprocess p1 = subprocess.Popen([“cat”, “file.log”], stdout=subprocess.PIPE) p2 = subprocess.Popen([“tail”, “-1”], stdin=p1.stdout, stdout=subprocess.PIPE) p1.stdout.close() # Allow p1 to receive a SIGPIPE if p2 exits. output,err = p2.communicate() Or, using the sh module, piping becomes composition of functions: import sh output = sh.tail(sh.cat(‘file.log’), … Read more
Lazy IO Lazy IO works like this readFile :: FilePath -> IO ByteString where ByteString is guaranteed to only be read chunk-by-chunk. To do so we could (almost) write — given `readChunk` which reads a chunk beginning at n readChunk :: FilePath -> Int -> IO (Int, ByteString) readFile fp = readChunks 0 where readChunks … Read more
Haha! Thanks to my Google-fu, I have found an SO answer that may interest you. Basically, the answer is going against the “don’t overload operators unless you really have to” argument by overloading the bitwise-OR operator to provide shell-like piping, resulting in Python code like this: for i in xrange(2,100) | sieve(2) | sieve(3) | … Read more
You don’t need to write a new tool to forward stdin – one has already been written (cat): (echo “initial command” && cat) | some_tool This does have the downside of connecting a pipe to some_tool, not a terminal.