LineDance 0.1.1__py2.py3-none-any.whl

linedance-0.1.1.dist-info/METADATA

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: LineDance
+Version: 0.1.1
+Summary: Synchronous line-oriented IPC with command-line utilities
+Author: Jeremy Hill
+Author-email: jezhill@gmail.com
+License: CC0-1.0
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Description-Content-Type: text/x-rst
+License-File: LICENSE.txt
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license
+Dynamic: license-file
+Dynamic: summary
+
+.. default-role:: code
+
+
+LineDance
+=========
+
+LineDance provides a small, dependency-free interface for conducting synchronous,
+line-oriented exchanges with a command-line utility.  It supports Python 2.7 and
+Python 3.
+
+A `Partner` instance owns one subprocess.  Each call writes one line to its stdin
+and waits for stdout, stderr, or process termination::
+
+	from linedance import Partner
+
+	partner = Partner( "perl -ple '$|=1; tr/a-z/A-Z/'" )
+	partner( 'hello world' )
+	# 'HELLO WORLD'
+	partner.Close()
+
+Consecutive reply lines that arrive close together are returned in one newline-
+joined string.  Output on stderr raises `PartnerError`, while failure to produce
+the first reply before an optional timeout raises `PartnerTimeout`::
+
+	partner = Partner( command, timeout=10.0, interLineTimeout=0.010 )
+	reply = partner.Communicate( 'one request' )
+
+The defaults are mutable attributes and may also be overridden for one call.
+`timeout=None`, the default, permits an arbitrarily long computation before the
+first reply.  Once the first line arrives, only the resetting `interLineTimeout`
+applies, allowing any number of promptly consecutive lines to be collected.
+
+Transcript
+----------
+
+Every sent or received line is retained in one chronological transcript::
+
+	partner.transcript
+	# [(timestamp, 'stdin',  'hello again'),
+	#  (timestamp, 'stdout', 'HELLO AGAIN')]
+
+The `stdin`, `stdout`, and `stderr` properties provide filtered views of the same
+history.  Empty lines are preserved.  A received LF and one optional preceding CR
+are stripped from each line.
+
+Text and bytes
+--------------
+
+Native strings are encoded using the configurable `encoding` and receive the
+configurable `terminator` (default `\n`) unless already terminated.  On Python 3,
+explicit `bytes` input is written exactly as supplied, without encoding or an
+added terminator.
+
+Protocol boundaries
+-------------------
+
+LineDance deliberately assumes a request/reply protocol.  The child must flush
+its output and terminate reply lines with `\n`.  A command that remains alive but
+produces no output has no observable reply boundary and therefore waits until its
+timeout, if any.  A timeout leaves the exchange desynchronized, so the `Partner`
+refuses subsequent requests rather than risk attributing a late reply to the
+wrong request.
+
+Unsolicited output is retained but is not mistaken for a reply if it arrived
+before the request.  Protocols with prompts lacking line terminators, request IDs,
+or explicit completion sentinels need a protocol-specific adapter.
+
+LineDance is public-domain software released under CC0.

linedance-0.1.1.dist-info/RECORD

@@ -0,0 +1,6 @@
+linedance.py,sha256=8KfrVtR33RAChDJ65NfFog0hdxtnsEGSXd7Ebxft0yY,18742
+linedance-0.1.1.dist-info/licenses/LICENSE.txt,sha256=9Ofzc7m5lpUDN-jUGkopOcLZC3cl6brz1QhKInF60yg,7169
+linedance-0.1.1.dist-info/METADATA,sha256=EpBRuquP90iCJyKP6eV-unXMUmjRy-yDJYnL9LhFdrw,3112
+linedance-0.1.1.dist-info/WHEEL,sha256=TdQ5LtNwLuxTCjgxN51AgdU5w-KkB9ttmLbzjTH02pg,109
+linedance-0.1.1.dist-info/top_level.txt,sha256=M6NLGoj9uKdFahiKrStWU8kYAkFZ9e2uemslqA5018E,10
+linedance-0.1.1.dist-info/RECORD,,

linedance-0.1.1.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+

linedance-0.1.1.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,121 @@
+Creative Commons Legal Code
+
+CC0 1.0 Universal
+
+    CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
+    LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
+    ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
+    INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
+    REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
+    PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
+    THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
+    HEREUNDER.
+
+Statement of Purpose
+
+The laws of most jurisdictions throughout the world automatically confer
+exclusive Copyright and Related Rights (defined below) upon the creator
+and subsequent owner(s) (each and all, an "owner") of an original work of
+authorship and/or a database (each, a "Work").
+
+Certain owners wish to permanently relinquish those rights to a Work for
+the purpose of contributing to a commons of creative, cultural and
+scientific works ("Commons") that the public can reliably and without fear
+of later claims of infringement build upon, modify, incorporate in other
+works, reuse and redistribute as freely as possible in any form whatsoever
+and for any purposes, including without limitation commercial purposes.
+These owners may contribute to the Commons to promote the ideal of a free
+culture and the further production of creative, cultural and scientific
+works, or to gain reputation or greater distribution for their Work in
+part through the use and efforts of others.
+
+For these and/or other purposes and motivations, and without any
+expectation of additional consideration or compensation, the person
+associating CC0 with a Work (the "Affirmer"), to the extent that he or she
+is an owner of Copyright and Related Rights in the Work, voluntarily
+elects to apply CC0 to the Work and publicly distribute the Work under its
+terms, with knowledge of his or her Copyright and Related Rights in the
+Work and the meaning and intended legal effect of CC0 on those rights.
+
+1. Copyright and Related Rights. A Work made available under CC0 may be
+protected by copyright and related or neighboring rights ("Copyright and
+Related Rights"). Copyright and Related Rights include, but are not
+limited to, the following:
+
+  i. the right to reproduce, adapt, distribute, perform, display,
+     communicate, and translate a Work;
+ ii. moral rights retained by the original author(s) and/or performer(s);
+iii. publicity and privacy rights pertaining to a person's image or
+     likeness depicted in a Work;
+ iv. rights protecting against unfair competition in regards to a Work,
+     subject to the limitations in paragraph 4(a), below;
+  v. rights protecting the extraction, dissemination, use and reuse of data
+     in a Work;
+ vi. database rights (such as those arising under Directive 96/9/EC of the
+     European Parliament and of the Council of 11 March 1996 on the legal
+     protection of databases, and under any national implementation
+     thereof, including any amended or successor version of such
+     directive); and
+vii. other similar, equivalent or corresponding rights throughout the
+     world based on applicable law or treaty, and any national
+     implementations thereof.
+
+2. Waiver. To the greatest extent permitted by, but not in contravention
+of, applicable law, Affirmer hereby overtly, fully, permanently,
+irrevocably and unconditionally waives, abandons, and surrenders all of
+Affirmer's Copyright and Related Rights and associated claims and causes
+of action, whether now known or unknown (including existing as well as
+future claims and causes of action), in the Work (i) in all territories
+worldwide, (ii) for the maximum duration provided by applicable law or
+treaty (including future time extensions), (iii) in any current or future
+medium and for any number of copies, and (iv) for any purpose whatsoever,
+including without limitation commercial, advertising or promotional
+purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each
+member of the public at large and to the detriment of Affirmer's heirs and
+successors, fully intending that such Waiver shall not be subject to
+revocation, rescission, cancellation, termination, or any other legal or
+equitable action to disrupt the quiet enjoyment of the Work by the public
+as contemplated by Affirmer's express Statement of Purpose.
+
+3. Public License Fallback. Should any part of the Waiver for any reason
+be judged legally invalid or ineffective under applicable law, then the
+Waiver shall be preserved to the maximum extent permitted taking into
+account Affirmer's express Statement of Purpose. In addition, to the
+extent the Waiver is so judged Affirmer hereby grants to each affected
+person a royalty-free, non transferable, non sublicensable, non exclusive,
+irrevocable and unconditional license to exercise Affirmer's Copyright and
+Related Rights in the Work (i) in all territories worldwide, (ii) for the
+maximum duration provided by applicable law or treaty (including future
+time extensions), (iii) in any current or future medium and for any number
+of copies, and (iv) for any purpose whatsoever, including without
+limitation commercial, advertising or promotional purposes (the
+"License"). The License shall be deemed effective as of the date CC0 was
+applied by Affirmer to the Work. Should any part of the License for any
+reason be judged legally invalid or ineffective under applicable law, such
+partial invalidity or ineffectiveness shall not invalidate the remainder
+of the License, and in such case Affirmer hereby affirms that he or she
+will not (i) exercise any of his or her remaining Copyright and Related
+Rights in the Work or (ii) assert any associated claims and causes of
+action with respect to the Work, in either case contrary to Affirmer's
+express Statement of Purpose.
+
+4. Limitations and Disclaimers.
+
+ a. No trademark or patent rights held by Affirmer are waived, abandoned,
+    surrendered, licensed or otherwise affected by this document.
+ b. Affirmer offers the Work as-is and makes no representations or
+    warranties of any kind concerning the Work, express, implied,
+    statutory or otherwise, including without limitation warranties of
+    title, merchantability, fitness for a particular purpose, non
+    infringement, or the absence of latent or other defects, accuracy, or
+    the present or absence of errors, whether or not discoverable, all to
+    the greatest extent permissible under applicable law.
+ c. Affirmer disclaims responsibility for clearing rights of other persons
+    that may apply to the Work or any use thereof, including without
+    limitation any person's Copyright and Related Rights in the Work.
+    Further, Affirmer disclaims responsibility for obtaining any necessary
+    consents, permissions or other rights required for any use of the
+    Work.
+ d. Affirmer understands and acknowledges that Creative Commons is not a
+    party to this document and has no duty or obligation with respect to
+    this CC0 or use of the Work.

linedance-0.1.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+linedance

linedance.py

@@ -0,0 +1,483 @@
+# $BEGIN_LINEDANCE_LICENSE$
+#
+# This file is part of the LineDance project, a Python module for synchronous,
+# line-oriented interprocess communication.
+#
+# Author: Jeremy Hill (2026-)
+# Development was supported by the NIH, NYS SCIRB, and the Stratton VA Medical
+# Center.
+#
+# No Copyright
+# ============
+# The author has dedicated this work to the public domain under the terms of
+# Creative Commons' CC0 1.0 Universal legal code, waiving all of his rights to
+# the work worldwide under copyright law, including all related and neighboring
+# rights, to the extent allowed by law.
+#
+# You can copy, modify, distribute and perform the work, even for commercial
+# purposes, all without asking permission. See Other Information below.
+#
+# Other Information
+# =================
+# In no way are the patent or trademark rights of any person affected by CC0,
+# nor are the rights that other persons may have in the work or in how the work
+# is used, such as publicity or privacy rights.
+#
+# The author makes no warranties about the work, and disclaims liability for
+# all uses of the work, to the fullest extent permitted by applicable law. When
+# using or citing the work, you are requested to preserve the author attribution
+# and this copyright waiver, but you should not imply endorsement by the author.
+#
+# $END_LINEDANCE_LICENSE$
+r"""
+Synchronous, line-oriented IPC with a command-line utility.
+
+`Partner` starts one subprocess and supports repeated REPL-like request/reply
+exchanges. Each call to `Partner.Communicate()` writes one input payload and
+then waits for the first subsequent stdout line, stderr line, or process
+termination:
+
+- stdout lines are returned as a native string; consecutive lines separated by
+  no more than `interLineTimeout` are joined with ``'\n'``;
+- stderr lines are collated by the same rule and raised in `PartnerError`;
+- successful termination without a reply returns `None`; and
+- unsuccessful termination raises `PartnerError` with its `returnCode`.
+
+The initial `timeout` applies only until the first reply line.  Once output
+begins, any number of lines may follow provided each arrives within the
+resetting `interLineTimeout`.  A timed-out exchange leaves the protocol
+desynchronized, so that `Partner` cannot safely be used for another request.
+The exchange that first observes process termination reports it normally;
+subsequent communication attempts raise `RuntimeError` rather than repeatedly
+reporting EOF or writing to a finished process.
+
+Native-string input is encoded and receives the mutable `terminator` if it does
+not already have one.  On Python 3, explicit `bytes` bypass encoding and
+termination and are written exactly as supplied.  Incoming lines are expected
+to end in LF; exactly that LF and one optional preceding CR are removed.  Empty
+lines remain real replies and transcript events.
+
+Every stdin, stdout, and stderr line is atomically appended to `transcript` as
+``(timestamp, eventType, line)``.  The `stdin`, `stdout`, and `stderr` properties
+are filtered snapshots of that sequence.  Unsolicited output is always recorded,
+but output received before a request is not mistaken for that request's reply.
+
+Dedicated daemon threads continuously drain stdout and stderr, avoiding pipe
+deadlock without platform-specific polling and retaining Python 2.7 support.
+The child must flush its output; parent-side buffering options cannot flush a
+child's private buffers.  Deleting a `Partner` closes stdin, briefly permits an
+EOF-driven exit, and then escalates through terminate and kill while reaping the
+process.
+"""
+
+from __future__ import absolute_import
+
+__version__ = '0.1.1'
+
+__all__ = [
+	'Partner',
+	'PartnerError', 'PartnerTimeout',
+]
+
+import os
+import sys
+import time
+import shlex
+import threading
+import subprocess
+try: import queue
+except ImportError: import Queue as queue # Python 2
+
+PY3 = ( sys.version_info[ 0 ] >= 3 )
+WINDOWS = ( sys.platform.lower().startswith( 'win' ) )
+
+class PartnerError( RuntimeError ):
+	"""The partner wrote to stderr or terminated unsuccessfully."""
+
+	def __init__( self, command, returnCode, stderr='' ):
+		self.command = command
+		self.returnCode = returnCode
+		self.stderr = stderr
+		message = 'partner process reported an error'
+		if returnCode is not None: message += ' with return code %s' % returnCode
+		if stderr: message += ':\n' + stderr.rstrip()
+		RuntimeError.__init__( self, message )
+
+
+class PartnerTimeout( RuntimeError ):
+	"""The partner did not complete its response before the deadline."""
+
+	def __init__( self, timeout ):
+		self.timeout = timeout
+		RuntimeError.__init__( self, 'partner did not respond within %g seconds' % timeout )
+
+
+class Partner( object ):
+	"""
+	Start `command` as a subprocess, and conduct one line-oriented exchange at
+	a time.
+
+	`command` may be a sequence of arguments or a command string.  A string is
+	split with `shlex` on POSIX when `shell=False`; passing a sequence is the
+	least ambiguous form on every platform.  If `shell=True`, `command` must be
+	a string.
+
+	`.Communicate(line)` writes one native `str`, adding the configured terminator
+	if it is not already present, and then returns the first newline-stripped
+	native `str` received from stdout after the write begins, together with any
+	further lines received within its `interLineTimeout`.  Earlier unsolicited
+	lines are ignored as replies, but remain available in `.stdout` and `.transcript`.
+	The method returns `None` if the process instead terminates successfully.
+	Output on stderr, or an unsuccessful return code, raises `PartnerError`; all
+	stderr text is available as the exception's `.stderr` attribute and in the
+	`Partner` instance's `.stderr` and `.transcript`. The `.stdin`, `.stdout`,
+	and `.stderr` properties are filtered views of the single chronologically
+	appended `(timestamp, eventType, line)` sequence in `.transcript`.
+
+	`timeout` is the default maximum wait for the first reply line, and
+	`interLineTimeout` is the default maximum gap between bundled reply lines.
+	Both are mutable attributes and may be overridden for one `.Communicate()`
+	call.  Native-string input is encoded after appending the mutable `terminator`
+	if necessary.  On Python 3, explicit `bytes` input is sent exactly as supplied.
+
+	The child must flush each stdout reply.  No parent-side implementation can
+	make an independently buffered child reveal a line that it has not flushed.
+	A Perl child, for example, should execute `$|=1` to disable buffering.
+	"""
+
+	def __init__( self, command, shell=False, encoding='utf-8', terminator='\n', timeout=None, interLineTimeout=0.010 ):
+		if shell and isinstance( command, ( list, tuple ) ):
+			if WINDOWS: command = ' '.join( '"' + word.replace( '"', '""' )                          + '"' for word in command )
+			else:       command = ' '.join( '"' + word.replace( '\\', '\\\\' ).replace( '"', '\\"' ) + '"' for word in command )
+		if not shell and hasattr( command, 'split' ):
+			command = shlex.split( command )
+
+		self.__command = command
+		self.__encoding = encoding
+		self.terminator = terminator
+		self.timeout = timeout
+		self.interLineTimeout = interLineTimeout
+		self.__events = queue.Queue()
+		self.__lock = threading.Lock()
+		self.__receptionLock = threading.Lock()
+		self.__generation = [ 0 ]
+		self.__transcript = []
+		self.__stdoutEOF = False
+		self.__stderrEOF = False
+		self.__desynchronized = False
+		self.__retired = False
+		self.__sp = subprocess.Popen(
+			command,
+			shell = shell,
+			stdin = subprocess.PIPE,
+			stdout = subprocess.PIPE,
+			stderr = subprocess.PIPE,
+			bufsize = 0,
+		)
+		self.__StartReader( 'stdout', self.__sp.stdout )
+		self.__StartReader( 'stderr', self.__sp.stderr )
+
+	def __StartReader( self, name, stream ):
+		# Do not let the long-lived reader target capture `self`: otherwise a reader
+		# blocked on the pipe would prevent an abandoned Partner from being collected.
+		encoding = self.__encoding
+		Decode = lambda value: value.decode( encoding ) if PY3 and encoding else value
+		StripLineTerminator = self.__StripLineTerminator
+		receptionLock = self.__receptionLock
+		generation = self.__generation
+		transcript = self.__transcript
+		events = self.__events
+		Clock = time.time
+		def ReadLines():
+			try:
+				while True:
+					line = stream.readline()
+					if not line: break
+					decoded = StripLineTerminator( Decode( line ) )
+					timestamp = Clock()
+					receptionLock.acquire()
+					try:
+						currentGeneration = generation[ 0 ]
+						transcript.append( ( timestamp, name, decoded ) )
+					finally:
+						receptionLock.release()
+					events.put( ( timestamp, currentGeneration, name, line ) )
+			finally:
+				try: stream.close()
+				except: pass
+				receptionLock.acquire()
+				try: currentGeneration = generation[ 0 ]
+				finally: receptionLock.release()
+				events.put( ( Clock(), currentGeneration, name, None ) )
+		thread = threading.Thread( target=ReadLines )
+		thread.daemon = True
+		thread.start()
+
+	def __Encode( self, value ):
+		return value.encode( self.__encoding ) if PY3 and self.__encoding else value
+
+	def __Decode( self, value ):
+		return value.decode( self.__encoding ) if PY3 and self.__encoding else value
+
+	@staticmethod
+	def __StripLineTerminator( value ):
+		if value.endswith( '\n' ):
+			value = value[ :-1 ]
+			if value.endswith( '\r' ): value = value[ :-1 ]
+		return value
+
+	def __PrepareInput( self, value ):
+		if PY3 and isinstance( value, bytes ):
+			return value, value
+		if not isinstance( value, str ):
+			raise TypeError( 'input must be a native str%s, not %s' % ( ' or bytes' if PY3 else '', type( value ).__name__ ) )
+		terminator = self.terminator
+		if terminator is None: terminator = ''
+		if not isinstance( terminator, str ):
+			raise TypeError( 'terminator must be a native str or None' )
+		if terminator and value.endswith( terminator ):
+			return self.__Encode( value ), value[ :-len( terminator ) ]
+		return self.__Encode( value + terminator ), value
+
+	def __Remaining( self, deadline ):
+		if deadline is None: return None
+		return max( 0.0, deadline - time.time() )
+
+	def __NextEvent( self, deadline ):
+		remaining = self.__Remaining( deadline )
+		try:
+			if remaining is None: return self.__events.get()
+			return self.__events.get( True, remaining )
+		except queue.Empty:
+			raise PartnerTimeout( 0.0 )
+
+	def __RecordEvent( self, event, stderr, minimumGeneration=None ):
+		timestamp, generation, name, value = event
+		if value is None:
+			if name == 'stdout': self.__stdoutEOF = True
+			else: self.__stderrEOF = True
+		elif name == 'stderr' and ( minimumGeneration is None or generation >= minimumGeneration ):
+			stderr.append( value )
+		return timestamp, generation, name, value
+
+	def __BeginRequest( self, line ):
+		self.__receptionLock.acquire()
+		try:
+			self.__generation[ 0 ] += 1
+			self.__transcript.append( ( time.time(), 'stdin', line ) )
+			return self.__generation[ 0 ]
+		finally:
+			self.__receptionLock.release()
+
+	def __TerminalResult( self, deadline, stderr ):
+		while not ( self.__stdoutEOF and self.__stderrEOF ):
+			self.__RecordEvent( self.__NextEvent( deadline ), stderr )
+		while self.__sp.poll() is None:
+			if deadline is not None and time.time() >= deadline:
+				raise PartnerTimeout( 0.0 )
+			time.sleep( 0.001 )
+		returnCode = self.__sp.returncode
+		self.__CloseStdin()
+		self.__retired = True
+		stderr = self.__Decode( b''.join( stderr ) )
+		if stderr or returnCode:
+			raise PartnerError( self.__command, returnCode, stderr )
+		return None
+
+	def __StdoutResult( self, firstTimestamp, firstLine, generation, stderr, interLineTimeout ):
+		lines = [ self.__StripLineTerminator( self.__Decode( firstLine ) ) ]
+		if not interLineTimeout: return lines[ 0 ]
+		cutoff = firstTimestamp + interLineTimeout
+		while True:
+			try:
+				timestamp, receivedGeneration, name, value = self.__RecordEvent( self.__NextEvent( cutoff ), stderr, generation )
+			except PartnerTimeout:
+				return '\n'.join( lines )
+			if name == 'stderr' and value is not None and receivedGeneration >= generation:
+				return self.__StderrResult( timestamp, generation, stderr, interLineTimeout )
+			if name == 'stdout' and value is not None and receivedGeneration >= generation:
+				if timestamp > cutoff: return '\n'.join( lines )
+				lines.append( self.__StripLineTerminator( self.__Decode( value ) ) )
+				cutoff = timestamp + interLineTimeout
+			if self.__stdoutEOF:
+				# Return the final reply once, but do not let a subsequent request be
+				# mistaken for the one that caused this already-observed EOF.
+				self.__retired = True
+				self.__CloseStdin()
+				return '\n'.join( lines )
+
+	def __StderrResult( self, firstTimestamp, generation, stderr, interLineTimeout ):
+		if self.__sp.poll() is not None: return self.__TerminalResult( None, stderr )
+		if not interLineTimeout:
+			raise PartnerError( self.__command, None, self.__Decode( b''.join( stderr ) ) )
+		cutoff = firstTimestamp + interLineTimeout
+		while True:
+			oldLength = len( stderr )
+			try:
+				timestamp, receivedGeneration, name, value = self.__RecordEvent( self.__NextEvent( cutoff ), stderr, generation )
+			except PartnerTimeout:
+				raise PartnerError( self.__command, self.__sp.poll(), self.__Decode( b''.join( stderr ) ) )
+			if name == 'stderr' and value is not None and receivedGeneration >= generation:
+				if timestamp > cutoff:
+					del stderr[ oldLength: ]
+					raise PartnerError( self.__command, self.__sp.poll(), self.__Decode( b''.join( stderr ) ) )
+				cutoff = timestamp + interLineTimeout
+			if self.__stderrEOF:
+				return self.__TerminalResult( None, stderr )
+
+	def __CloseStdin( self ):
+		try:
+			if not self.__sp.stdin.closed: self.__sp.stdin.close()
+		except: pass
+
+	def Communicate( self, line='', timeout=None, interLineTimeout=None ):
+		"""
+		Send one line and return one reply, `None`, or raise `PartnerError`.
+		Consecutive stdout or stderr lines separated by no more than
+		`interLineTimeout` seconds are joined with newline characters into one
+		reply or one `PartnerError`, respectively.
+
+		`timeout=None` and `interLineTimeout=None` use the corresponding mutable
+		instance attributes.  If the effective `timeout` expires before the first
+		reply line, `PartnerTimeout` is raised and this instance becomes unusable:
+		the outstanding request makes the protocol state unknowable.  Once the first
+		line arrives, only the resetting `interLineTimeout` applies.  After process
+		termination has been observed, subsequent calls raise `RuntimeError`
+		immediately.
+		"""
+		self.__lock.acquire()
+		try:
+			returnCode = self.__sp.poll()
+			if self.__retired or returnCode is not None:
+				self.__retired = True
+				self.__CloseStdin()
+				raise RuntimeError( 'partner process has already terminated with return code %s' % returnCode )
+			if timeout is None: timeout = self.timeout
+			if interLineTimeout is None: interLineTimeout = self.interLineTimeout
+			if interLineTimeout is None: interLineTimeout = 0.0
+			if timeout is not None and timeout < 0.0: raise ValueError( 'timeout cannot be negative' )
+			if interLineTimeout < 0.0: raise ValueError( 'interLineTimeout cannot be negative' )
+			if self.__desynchronized:
+				raise RuntimeError( 'partner is desynchronized after an earlier timeout' )
+			deadline = None if timeout is None else time.time() + timeout
+			stderr = []
+
+			wireInput, recordedInput = self.__PrepareInput( line )
+			generation = self.__BeginRequest( recordedInput )
+			try:
+				self.__sp.stdin.write( wireInput )
+				self.__sp.stdin.flush()
+			except ( IOError, OSError ):
+				return self.__TerminalResult( deadline, stderr )
+
+			while True:
+				timestamp, receivedGeneration, name, value = self.__RecordEvent( self.__NextEvent( deadline ), stderr, generation )
+
+				if name == 'stderr' and value is not None and receivedGeneration >= generation:
+					return self.__StderrResult( timestamp, generation, stderr, interLineTimeout )
+				if name == 'stdout' and value is not None and receivedGeneration >= generation:
+					return self.__StdoutResult( timestamp, value, generation, stderr, interLineTimeout )
+				if self.__stdoutEOF:
+					return self.__TerminalResult( deadline, stderr )
+		except PartnerTimeout:
+			self.__desynchronized = True
+			raise PartnerTimeout( timeout )
+		finally:
+			self.__lock.release()
+
+	__call__ = Communicate
+
+	@property
+	def command( self ):
+		return self.__command
+
+	@property
+	def pid( self ):
+		return self.__sp.pid
+
+	@property
+	def returnCode( self ):
+		returnCode = self.__sp.poll()
+		if returnCode is not None:
+			self.__CloseStdin()
+			self.__retired = True
+		return returnCode
+
+	def __History( self, stream=None ):
+		self.__receptionLock.acquire()
+		try:
+			if stream is None: return list( self.__transcript )
+			return [ line for timestamp, eventType, line in self.__transcript if eventType == stream ]
+		finally: self.__receptionLock.release()
+
+	@property
+	def stdin( self ):
+		"""All stdin sent so far: unterminated native strings or exact Python 3 bytes."""
+		return self.__History( 'stdin' )
+
+	@property
+	def stdout( self ):
+		"""All stdout lines received so far, without line terminators."""
+		return self.__History( 'stdout' )
+
+	@property
+	def stderr( self ):
+		"""All stderr lines received so far, without line terminators."""
+		return self.__History( 'stderr' )
+
+	@property
+	def transcript( self ):
+		"""All `(timestamp, eventType, line)` tuples in atomic chronological order."""
+		return self.__History()
+
+	@property
+	def finished( self ):
+		returnCode = self.__sp.poll()
+		if returnCode is not None:
+			self.__CloseStdin()
+			self.__retired = True
+		return returnCode is not None
+
+	def Wait( self, timeout=None ):
+		deadline = None if timeout is None else time.time() + timeout
+		while self.__sp.poll() is None:
+			if deadline is not None and time.time() >= deadline:
+				raise PartnerTimeout( timeout )
+			time.sleep( 0.01 )
+		self.__CloseStdin()
+		self.__retired = True
+		return self.__sp.returncode
+
+	def Close( self, timeout=None ):
+		"""Close stdin, wait for the child to finish, and return its exit code."""
+		self.__CloseStdin()
+		return self.Wait( timeout=timeout )
+
+	def Terminate( self, timeout=None ):
+		if self.__sp.poll() is None: self.__sp.terminate()
+		return self.Wait( timeout=timeout )
+
+	def Kill( self, timeout=None ):
+		if self.__sp.poll() is None: self.__sp.kill()
+		return self.Wait( timeout=timeout )
+
+	def __enter__( self ):
+		return self
+
+	def __exit__( self, excType, excValue, traceback ):
+		if self.__sp.poll() is None: self.Close()
+
+	def __del__( self ):
+		try:
+			sp = self.__sp
+			try: sp.stdin.closed or sp.stdin.close()
+			except: pass
+			for Action in [ sp.terminate, sp.kill ]:
+				deadline = time.time() + 0.050
+				while sp.poll() is None and time.time() < deadline:
+					time.sleep( 0.001 )
+				if sp.poll() is not None: break
+				Action()
+			if sp.poll() is None: sp.kill()
+			sp.wait()
+		except: pass