def _start(self): r""" Initialize the interface and start gap3. EXAMPLES:: sage: gap3 = Gap3() #optional - gap3 sage: gap3.is_running() False sage: gap3._start() #optional - gap3 sage: gap3.is_running() #optional - gap3 True Check that :trac:`23142` is fixed:: sage: gap3.eval("1+1") #optional - gap3 '2' sage: gap3.quit() #optional - gap3 """ Expect._start(self) # The -p command-line option to GAP3 produces the following # funny-looking patterns in the interface. We compile the patterns # now, and use them later for interpreting interface messages. self._compiled_full_pattern = self._expect.compile_pattern_list([ r'@p\d+\.', '@@', '@[A-Z]', r'@[123456!"#$%&][^+]*\+', '@e', '@c', '@f', '@h', '@i', '@m', '@n', '@r', r'@s\d', r'@w.*\+', '@x', '@z' ]) self._compiled_small_pattern = self._expect.compile_pattern_list('@J') self._expect.expect("@i")
def __init__(self, maxread=None, script_subdirectory=None, server=None, server_tmpdir=None, logfile=None): """ Create an instance of the Giac interpreter. EXAMPLES:: sage: giac == loads(dumps(giac)) True """ Expect.__init__( self, name='giac', prompt='[0-9]*>> ', command="giac --sage", init_code=['maple_mode(0);I:=i;' ], # coercion could be broken in maple_mode script_subdirectory=script_subdirectory, restart_on_ctrlc=False, server=server, server_tmpdir=server_tmpdir, verbose_start=False, logfile=logfile, eval_using_file_cutoff=1000)
def __init__(self, maxread = 100000, script_subdirectory = None, logfile = None, server = None, server_tmpdir = None): """ Pexpect-based interface to Julia """ self._prompt = 'julia>' Expect.__init__(self, name = 'Julia', prompt = self._prompt, command = "julia", maxread = maxread, server = server, server_tmpdir = server_tmpdir, script_subdirectory = script_subdirectory, restart_on_ctrlc = False, verbose_start = False, logfile = logfile) self.__seq = 0 self.__in_seq = 1
def __init__(self, maxread=100, script_subdirectory=None, logfile=None, server=None, server_tmpdir=None): Expect.__init__(self, name = 'mathematica', prompt = 'In[[0-9]+]:=', command = "math-readline", maxread = maxread, server = server, server_tmpdir = server_tmpdir, script_subdirectory = script_subdirectory, verbose_start = False, logfile=logfile, eval_using_file_cutoff=50)
def __init__(self, maxread=None, script_subdirectory=None, logfile=None, server=None, server_tmpdir=None, command=None, verbose_start=False): r""" TESTS: Test that :trac:`28075` is fixed:: sage: repr(mathematica.eval("Print[1]; Print[2]; Print[3]")) # optional - mathematica '1\n2\n3' """ # We use -rawterm to get a raw text interface in Mathematica 9 or later. # This works around the following issues of Mathematica 9 or later # (tested with Mathematica 11.0.1 for Mac OS X x86 (64-bit)) # # 1) If TERM is unset and input is a pseudoterminal, Mathematica shows no # prompts, so pexpect will not work. # # 2) If TERM is set (to dumb, lpr, vt100, or xterm), there will be # prompts; but there is bizarre echoing behavior by Mathematica (not # the terminal driver). For example, with TERM=dumb, many spaces and # \r's are echoed. With TERM=vt100 or better, in addition, many escape # sequences are printed. # if command is None: command = os.getenv('SAGE_MATHEMATICA_COMMAND') or 'math -rawterm' eval_using_file_cutoff = 1024 # Removing terminal echo using "stty -echo" is not essential but it slightly # improves performance (system time) and eliminates races of the terminal echo # as a possible source of error. if server: command = 'stty -echo; {}'.format(command) else: command = 'sh -c "stty -echo; {}"'.format(command) Expect.__init__(self, name='mathematica', terminal_echo=False, command=command, prompt=r'In\[[0-9]+\]:= ', server=server, server_tmpdir=server_tmpdir, script_subdirectory=script_subdirectory, verbose_start=verbose_start, logfile=logfile, eval_using_file_cutoff=eval_using_file_cutoff)
def __init__(self, maxread=10000, script_subdirectory=None, logfile=None, server=None, server_tmpdir=None): """ Initialize a Macaulay2 interface instance. We replace the standard input prompt with a strange one, so that we do not catch input prompts inside the documentation. We replace the standard input continuation prompt, which is just a bunch of spaces and cannot be automatically detected in a reliable way. This is necessary for allowing commands that occupy several strings. We also change the starting line number to make all the output labels to be of the same length. This allows correct stripping of the output of several commands. TESTS:: sage: macaulay2 == loads(dumps(macaulay2)) True """ init_str = ( # Prompt changing commands """ZZ#{Standard,Core#"private dictionary"#"InputPrompt"} = lineno -> "%s";""" % PROMPT + """ZZ#{Standard,Core#"private dictionary"#"InputContinuationPrompt"} = lineno -> "%s";""" % PROMPT + # Also prevent line wrapping in Macaulay2 "printWidth = 0;" + # And make all output labels to be of the same width "lineNumber = 10^9;") Expect.__init__( self, name='macaulay2', prompt=PROMPT, command="M2 --no-debug --no-readline --silent -e '%s'" % init_str, maxread=maxread, server=server, server_tmpdir=server_tmpdir, script_subdirectory=script_subdirectory, verbose_start=False, logfile=logfile, eval_using_file_cutoff=500)
def eval(self, code, strip=True, **kwds): r""" Send the code x to the Giac interpreter. Remark: To enable multi-lines codes in the notebook magic mode: ``%giac``, the ``\n`` are removed before sending the code to giac. INPUT: - code -- str - strip -- Default is True and removes ``\n`` EXAMPLES:: sage: giac.eval("2+2;\n3") '4,3' sage: giac.eval("2+2;\n3",False) '4\n3' sage: s='g(x):={\nx+1;\nx+2;\n}' sage: giac(s) ...x+1...x+2... sage: giac.g(5) 7 """ #we remove \n to enable multiline code in the notebook magic mode %giac if strip: code = code.replace("\n","").strip() ans = Expect.eval(self, code, strip=strip, **kwds).strip() return ans
def eval(self, code, strip=True, **kwds): """ Send the code x to the Giac interpreter. Remark: To enable multi-lines codes in the notebook magic mode: %giac, the \\n are removed before sending the code to giac. INPUT: code -- str strip -- Default is True and removes \n EXAMPLES: sage: giac.eval("2+2;\n3") #optional - giac '4,3' sage: giac.eval("2+2;\n3",False) # optional - giac '4\n3' sage: s='g(x):={\nx+1;\nx+2;\n}' sage: giac(s) # optional - giac (x)->{ x+1; x+2; } sage: giac.g(5) # optional - giac 7 """ #we remove \n to enable multiline code in the notebook magic mode %giac if strip: code = code.replace("\n","").strip() ans = Expect.eval(self, code, strip=strip, **kwds).strip() return ans
def _eval_line(self, line, allow_use_file=True, wait_for_prompt=True, restart_if_needed=False): """ EXAMPLES:: sage: giac._eval_line('2+2') '4' sage: A = matrix([range(280)]) sage: GA = giac(A) TESTS:: sage: h1 = 'int(sin(x)^2, x)' sage: h2 = 'int(cos(x)^2, x)' sage: giac_result = giac(h1) + giac(h2) sage: bool(giac_result.sage() == x) True """ with gc_disabled(): z = Expect._eval_line(self, line, allow_use_file=allow_use_file, wait_for_prompt=wait_for_prompt) if z.lower().find("error") != -1: raise RuntimeError( "An error occurred running a Giac command:\nINPUT:\n%s\nOUTPUT:\n%s" % (line, z)) lines = (line for line in z.splitlines() if not line.startswith('Evaluation time:')) return "\n".join(lines)
def _eval_line(self, line, reformat=True, allow_use_file=False, wait_for_prompt=True, restart_if_needed=False): """ EXAMPLES:: sage: print octave._eval_line('2+2') #optional - octave ans = 4 """ if not wait_for_prompt: return Expect._eval_line(self, line) if line == '': return '' if self._expect is None: self._start() if allow_use_file and len(line)>3000: return self._eval_line_using_file(line) try: E = self._expect verbose("in = '%s'"%line,level=3) E.sendline(line) E.expect(self._prompt) out = E.before verbose("out = '%s'"%out,level=3) except EOF: if self._quit_string() in line: return '' except KeyboardInterrupt: self._keyboard_interrupt() if reformat: if '>>> ' in out and 'syntax error' in out: raise SyntaxError(out) out = "\n".join(out.splitlines()[1:]) return out
def eval(self, code, strip=True, **kwds): # print "Evaluating %s"%code code = code.replace("\n", " ") result = Expect.eval(self, code, strip=strip, **kwds) if result.find("Exception") != -1: raise ValueError, "An Exception occured: %s" % result else: return result
def __init__(self, command=gap3_cmd): r""" Initialize the GAP3 interface and start a session. INPUT: - command - string (default "gap3"); points to the gap3 executable on your system; by default, it is assumed the executable is in your path. EXAMPLES:: sage: gap3 = Gap3() #optional - gap3 sage: gap3.is_running() False sage: gap3._start() #optional - gap3 sage: gap3.is_running() #optional - gap3 True """ self.__gap3_command_string = command # Explanation of additional command-line options passed to gap3: # # -p invokes the internal programmatic interace, which is how Sage # talks to GAP4. This allows reuse some of the GAP4 interface code. # # -y -- sets the number of lines of the terminal; controls how many # lines of text are output by GAP3 before the pager is invoked. # This option is useful in dealing with the GAP3 help system. Expect.__init__(self, name='gap3', prompt='gap> ', command=self.__gap3_command_string + " -p -y 500", server=None, ulimit=None, maxread=100000, script_subdirectory=None, restart_on_ctrlc=True, verbose_start=False, init_code=[], max_startup_time=None, logfile=None, eval_using_file_cutoff=100, do_cleaner=True, remote_cleaner=False, path=None)
def _start(self): """ Starts the Octave process. EXAMPLES:: sage: o = Octave() # optional - octave sage: o.is_running() # optional - octave False sage: o._start() # optional - octave sage: o.is_running() # optional - octave True """ Expect._start(self) self.eval("page_screen_output=0;") self.eval("format none;") # set random seed self.set_seed(self._seed)
def _eval_line(self, line, allow_use_file=True, wait_for_prompt=True, restart_if_needed=False): s = Expect._eval_line(self, line, allow_use_file=allow_use_file, wait_for_prompt=wait_for_prompt) return str(s).strip('\n')
def __init__(self, maxread=100000, script_subdirectory=None, logfile=None, server=None, server_tmpdir=None): Expect.__init__( self, name='conexp-clj', prompt='user=> ', # fix this! command='conexp-clj.sh', maxread=maxread, server=server, server_tmpdir=server_tmpdir, script_subdirectory=script_subdirectory, restart_on_ctrlc=True, verbose_start=False, logfile=logfile, eval_using_file_cutoff=1024)
def _start(self): r""" EXAMPLES:: sage: gap3 = Gap3() #optional - gap3 sage: gap3.is_running() False sage: gap3._start() #optional - gap3 sage: gap3.is_running() #optional - gap3 True sage: gap3.quit() #optional - gap3 """ n = self._session_number Expect._start(self) # The -p command-line option to GAP3 produces the following # funny-looking patterns in the interface. We compile the patterns # now, and use them later for interpreting interface messages. self._compiled_full_pattern = self._expect.compile_pattern_list([ '@p\d+\.','@@','@[A-Z]','@[123456!"#$%&][^+]*\+', '@e','@c', '@f','@h','@i','@m','@n','@r','@s\d','@w.*\+','@x','@z']) self._compiled_small_pattern = self._expect.compile_pattern_list('@J')
def _eval_line(self, line, allow_use_file=True, wait_for_prompt=True): """ EXAMPLES:: sage: giac._eval_line('2+2') # optional - giac '4' """ with gc_disabled(): z = Expect._eval_line(self, line, allow_use_file=allow_use_file, wait_for_prompt=wait_for_prompt) if z.lower().find("error") != -1: raise RuntimeError, "An error occurred running a Giac command:\nINPUT:\n%s\nOUTPUT:\n%s"%(line, z) return z
def set(self, var, value): """ Set the variable var to the given value. EXAMPLES:: sage: macaulay2.set("a", "2") # optional - macaulay2 sage: macaulay2.get("a") # optional - macaulay2 2 """ cmd = '%s=%s;'%(var,value) ans = Expect.eval(self, cmd) if ans.find("stdio:") != -1: raise RuntimeError("Error evaluating Macaulay2 code.\nIN:%s\nOUT:%s"%(cmd, ans))
def __init__(self, maxread=100, script_subdirectory=None, logfile=None, server=None, server_tmpdir=None, seed=None): """ EXAMPLES:: sage: octave == loads(dumps(octave)) True """ Expect.__init__(self, name = 'octave', # We want the prompt sequence to be unique to avoid confusion with syntax error messages containing >>> prompt = 'octave\:\d+> ', # We don't want any pagination of output command = "sage-native-execute octave --no-line-editing --silent --eval 'PS2(PS1());more off' --persist", maxread = maxread, server = server, server_tmpdir = server_tmpdir, script_subdirectory = script_subdirectory, restart_on_ctrlc = False, verbose_start = False, logfile = logfile, eval_using_file_cutoff=100) self._seed = seed
def _eval_line(self, line, allow_use_file=True, wait_for_prompt=True, restart_if_needed=False): """ EXAMPLES:: sage: giac._eval_line('2+2') '4' sage: A=matrix([range(280)]) sage: GA=giac(A) """ with gc_disabled(): z = Expect._eval_line(self, line, allow_use_file=allow_use_file, wait_for_prompt=wait_for_prompt) if z.lower().find("error") != -1: raise RuntimeError("An error occurred running a Giac command:\nINPUT:\n%s\nOUTPUT:\n%s"%(line, z)) return z
def eval(self, code, strip=True, **kwds): """ Send the code x to the Macaulay2 interpreter and return the output as a string suitable for input back into Macaulay2, if possible. INPUT: - code -- str - strip -- ignored EXAMPLES:: sage: macaulay2.eval("2+2") # optional - macaulay2 4 """ code = code.strip() # TODO: in some cases change toExternalString to toString?? ans = Expect.eval(self, code, strip=strip, **kwds).strip('\n') if strip: ans = remove_output_labels(ans) return AsciiArtString(ans)
def _eval_line(self, line, allow_use_file=True, wait_for_prompt=True, restart_if_needed=False): """ EXAMPLES:: sage: giac._eval_line('2+2') '4' sage: A = matrix([range(280)]) sage: GA = giac(A) TESTS:: sage: h='int(1/x*((-2*x^(1/3)+1)^(1/4))^3,x)' sage: giac(h) 12*(...) """ with gc_disabled(): z = Expect._eval_line(self, line, allow_use_file=allow_use_file, wait_for_prompt=wait_for_prompt) if z.lower().find("error") != -1: raise RuntimeError("An error occurred running a Giac command:\nINPUT:\n%s\nOUTPUT:\n%s"%(line, z)) lines = (line for line in z.splitlines() if not line.startswith('Evaluation time:')) return "\n".join(lines)
def eval(self, code, strip=True, **kwds): s = Expect.eval(self, code, **kwds) if strip: return AsciiArtString(clean_output(s)) else: return AsciiArtString(s)
def _start(self, *args, **kwds): Expect._start(self, *args, **kwds)