finished aux.Command, working volume detection pre-pass

aux.py

@@ -5,28 +5,46 @@ import queue
 import subprocess
 import sys
 import threading
-import time
-
-import over # FIXME
 
 # --------------------------------------------------
 
 def capture_output(stream, fifo):
 	while True:
-		chunk = stream.read1(100)
+		chunk = stream.read1(128)
 		
 		if chunk:
 			fifo.put(chunk)
 		else:
+			fifo.put(None) # indicates a process has terminated
 			break
 	
 	stream.close()
 
 class Command:
+	"""
+	A shell command with argument substitution and output capture.
+	
+	>>> c = Command(["process.sh", "-x", "ARGUMENT"])
+	>>> c.ARGUMENT = "file.txt"
+	>>> c.dump()
+	['process.sh', '-x', 'file.txt']
+	>>> c.run(stderr=False) # capture stdout
+	>>> c.get_output()
+	b'some output'
+	>>> c.get_output()
+	b'' # there was no output since the last call
+	>>> c.get_output()
+	b'more of it\nand some more'
+	>>> c.get_output()
+	None # indicates the process ended and there is no more output
+	
+	"""
+	
 	def __init__(self, sequence):
 		self.__dict__["sequence"] = list(sequence)
 		self.__dict__["thread"] = None
 		self.__dict__["fifo"] = None
+		self.__dict__["terminated"] = False
 	
 	def __setattr__(self, name, value):
 		found = False
@@ -53,11 +71,10 @@ class Command:
 		
 		return out
 	
-	def run(self, async=False, stderr=False):
+	def run(self, stderr=False):
 		"""
 		Executes the command in the current environment.
 		
-		async     return immediatelly, use poll_output to get output
 		stderr    capture stderr instead of stdout
 		"""
 		
@@ -67,54 +84,53 @@ class Command:
 			target=capture_output,
 			args=(self.process.stderr if stderr else self.process.stdout, self.fifo)
 		)
+		self.__dict__["terminated"] = False
 		self.thread.daemon = True # thread dies with the program
 		self.thread.start()
-		
-		if not async:
-			buffer = []
-			probably_dead = False
-			
-			while True:
-				probably_dead = self.process.poll() is not None
-				
-				chunk = self.poll_output()
-				
-				if chunk:
-					buffer.append(chunk)
-				else:
-					time.sleep(0.01)
-				
-				if not chunk and self.process.poll() is not None and probably_dead:
-					break
-			
-			return b"".join(buffer)
-		
-		else:
-			return None
 	
-	def poll_output(self):
+	def get_output(self, blocking=False):
 		"""
 		Returns the output of a currently running process and clears the buffer.
 		
-		Returns None if no process is running.
+		Returns None if no process is running and no more output is available.
 		
-		Blocking - always returns at least one char.
+		blocking    block until some output is available or the process terminates
 		"""
 		
-		if self.fifo.empty():
+		buffer = []
+		
+		if self.terminated:
 			return None
 		
-		else:
-			buffer = []
+		if blocking:
+			buffer.append(self.fifo.get())
+		
+		while not self.fifo.empty():
+			buffer.append(self.fifo.get_nowait()) # FIXME nowait needed?
+		
+		if None in buffer:
+			self.__dict__["terminated"] = True
 			
-			while not self.fifo.empty():
-				buffer.append(self.fifo.get_nowait())
-			
-			return b"".join(buffer)
+			if len(buffer) == 1:
+				return None
+			else:
+				assert(buffer[-1] is None)
+				del buffer[-1]
+		
+		return b"".join(buffer)
 	
-	@property
-	def running(self):
-		return self.process.poll() is None
+	def get_all_output(self):
+		buffer = []
+		
+		while True:
+			chunk = self.get_output(blocking=True)
+			
+			if chunk is None:
+				break
+			else:
+				buffer.append(chunk)
+		
+		return b''.join(buffer) if buffer else None
 
 # --------------------------------------------------