/usr/lib/python2.7/dist-packages/Gnuplot/gp_java.py is in python-gnuplot 1.8-6.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 | # $Id: gp_java.py 291 2006-03-03 08:58:48Z mhagger $
# Copyright (C) 2002-2003 Michael Haggerty <mhagger@alum.mit.edu>
#
# This file is licensed under the GNU Lesser General Public License
# (LGPL). See LICENSE.txt for details.
"""gp_java -- an interface to gnuplot used under Jython/Java.
This file implements a low-level interface to a gnuplot program run
via Jython/Java. This file should be imported through gp.py, which in
turn should be imported via 'import Gnuplot' rather than these
low-level interfaces.
"""
# ############ Configuration variables: ################################
class GnuplotOpts:
"""The configuration options for gnuplot on generic platforms.
Store the options in a class to make them easy to import and
modify en masse. If you want to modify the options from the
command line or within a running program, do something like the
following::
import Gnuplot
Gnuplot.GnuplotOpts.gnuplot_command = '/bin/mygnuplot'
"""
gnuplot_command = 'gnuplot'
recognizes_persist = 1
prefer_persist = 0
recognizes_binary_splot = 1
prefer_inline_data = 0
support_fifo = 0
prefer_fifo_data = 0
default_term = 'x11'
default_lpr = '| lpr'
prefer_enhanced_postscript = 1
# ############ End of configuration options ############################
import sys
from java.lang import Thread
from java.lang import Runtime
def test_persist():
"""Determine whether gnuplot recognizes the option '-persist'.
"""
return GnuplotOpts.recognizes_persist
class OutputProcessor(Thread):
"""In a separate thread, read from one InputStream and output to a file.
"""
def __init__(self, name, input, output):
self.input = input
self.output = output
Thread.__init__(self, name)
self.setDaemon(1)
def run(self):
while 1:
self.output.write(chr(self.input.read()))
class GnuplotProcess:
"""Unsophisticated interface to a running gnuplot program.
This represents a running gnuplot program and the means to
communicate with it at a primitive level (i.e., pass it commands
or data). When the object is destroyed, the gnuplot program exits
(unless the 'persist' option was set). The communication is
one-way; gnuplot's text output just goes to stdout with no attempt
to check it for error messages.
Members:
Methods:
'__init__' -- start up the program.
'__call__' -- pass an arbitrary string to the gnuplot program,
followed by a newline.
'write' -- pass an arbitrary string to the gnuplot program.
'flush' -- cause pending output to be written immediately.
"""
def __init__(self, persist=None):
"""Start a gnuplot process.
Create a 'GnuplotProcess' object. This starts a gnuplot
program and prepares to write commands to it.
Keyword arguments:
'persist=1' -- start gnuplot with the '-persist' option,
(which leaves the plot window on the screen even after
the gnuplot program ends, and creates a new plot window
each time the terminal type is set to 'x11'). This
option is not available on older versions of gnuplot.
"""
if persist is None:
persist = GnuplotOpts.prefer_persist
command = [GnuplotOpts.gnuplot_command]
if persist:
if not test_persist():
raise RuntimeError, ('-persist does not seem to be supported '
'by your version of gnuplot!')
command.append('-persist')
# This is a kludge: distutils wants to import everything it
# sees when making a distribution, and if we just call exec()
# normally that causes a SyntaxError in CPython because "exec"
# is a keyword. Therefore, we call the exec() method
# indirectly.
#self.process = Runtime.getRuntime().exec(command)
exec_method = getattr(Runtime.getRuntime(), 'exec')
self.process = exec_method(command)
self.outprocessor = OutputProcessor(
'gnuplot standard output processor',
self.process.getInputStream(), sys.stdout
)
self.outprocessor.start()
self.errprocessor = OutputProcessor(
'gnuplot standard error processor',
self.process.getErrorStream(), sys.stderr
)
self.errprocessor.start()
self.gnuplot = self.process.getOutputStream()
def close(self):
# ### Does this close the gnuplot process under Java?
if self.gnuplot is not None:
self.gnuplot.close()
self.gnuplot = None
def __del__(self):
self.close()
def write(self, s):
self.gnuplot.write(s)
def flush(self):
self.gnuplot.flush()
def __call__(self, s):
"""Send a command string to gnuplot, followed by newline."""
self.write(s + '\n')
self.flush()
|