You can read the output through pipe:

>>> from subprocess import Popen, PIPE, STDOUT
>>> p = Popen(['java', '-jar', './GET_DB_DATA.jar'], stdout=PIPE, stderr=STDOUT)
>>> for line in p.stdout:
    print line

As regards passing string to stdin, you can achieve it this way:

>>> p = Popen(['cat'], stdin=PIPE, stdout=PIPE, stderr=STDOUT)
>>> stdout, stderr = p.communicate(input='passed_string')
>>> print stdout
passed_string

Assuming that your jar is writing to stdout and stderr, you can read those values with popen. Look into the documentation for the method. It's fairly straightforward.

I would use subprocess this way:

import subprocess
subprocess.call(['java', '-jar', 'Blender.jar'])

But, if you have a properly configured /proc/sys/fs/binfmt_misc/jar you should be able to run the jar directly, as you wrote.

So, which is exactly the error you are getting? Please post somewhere all the output you are getting from the failed execution.

Use subprocess. It is way better than os.system().

Here your first problem is with your java version with which you have compiled the code and java version with which you are running the code.

For example, if you have compiled the code with java version 8 and you are running the java application with java version 7 or 6 (lower than compiled one) you will get a Unsupported major.minor version 52.0 error. Hence compile the code with a lower or same version than your server one.

Check the version in your server : java --version

Check the version in your development tool with which you have compiled the code

In the below code, provide full path to your jar file as well.

os.system("java -jar \fullpath\PGPEncryption.jar BC.csv.pgp X.csv <password>")

There’s zipapp from the standard library. See especially the section on Creating Standalone Applications with zipapp . There are some caveats, like not being able to ship C extensions. [image] zipapp — Manage executable Python zip archives Source code: Lib/zipapp.py This module provides…

First you have to execute the program. A handy function for doing so:

def run_command(command):
    p = subprocess.Popen(command,
                     stdout=subprocess.PIPE,
                     stderr=subprocess.STDOUT)
    return iter(p.stdout.readline, b'')

It will return an iterable with all the lines of output.
And you can access the lines and print using

for output_line in run_command('java -jar jarfile.jar'):
    print(output_line)

add also import subprocess, as run_command uses subprocess.

Command '['java', 'parseJason.java']'

The command should be the same as before

• the classpath is missing
• the main class is called parseJason, not parseJason.java

Try

cmd = ['java', 
  '-classpath',  '.:/Users/blablalba/jackson-all-1.9.0.jar', 
  'parseJason']

One thing that frequently works is using shell=True option on the subprocess, this executes the command as if it was done in a shell (batch file or command prompt)

So using:

import subprocess
subprocess.call(['java', '-jar', 'StatsCalc.jar'],shell=True)

Should work for you, but please read the Security Considerations section of the subprocess's documentation before relying too heavily on this.

Usually the reason it does not work without shell is because it cannot find the command java without using the full path, so if you know the full path of the java executable that would be preferable to using shell=True

import subprocess
subprocess.call(['path/to/java', '-jar', 'StatsCalc.jar'])

It also may be possible to use /usr/bin/env command which searches the PATH environment variable for the correct executable, so this also may work:

import subprocess
subprocess.call(['/usr/bin/env', 'java', '-jar', 'StatsCalc.jar'])

This is pretty consistently defined on unix systems but probably won't work well on windows.

You can use Java Runtime.exec() to run python script, As an example first create a python script file using shebang and then set it executable.#!/usr/bin/python import sys print ('Number of Arguments:', len(sys.argv), 'arguments.') print ('Argument List:', str(sys.argv)) print('This is Python Code') print('Executing Python') print('From Java')if you save the above file as script_python and then set the execution permissions usingchmod 777 script_pythonThen you can call this script from Java Runtime.exec() like belowimport java.io.*; import java.nio.charset.StandardCharsets; public class ScriptPython { Process mProcess; public void runScript(){ Process process; try{ process = Runtime.getRuntime().exec(new String[]{"script_python","arg1","arg2"}); mProcess = process; }catch(Exception e) { System.out.println("Exception Raised" + e.toString()); } InputStream stdout = mProcess.getInputStream(); BufferedReader reader = new BufferedReader(new InputStreamReader(stdout,StandardCharsets.UTF_8)); String line; try{ while((line = reader.readLine()) != null){ System.out.println("stdout: "+ line); } }catch(IOException e){ System.out.println("Exception in reading output"+ e.toString()); } } } class Solution { public static void main(String[] args){ ScriptPython scriptPython = new ScriptPython(); scriptPython.runScript(); } }Hope this helps and if not then its recommended to join our Java training class and learn about Java in detail.

Not sure if I understand your question correctly, but provided that you can call the Python executable from the console and just want to capture its output in Java, you can use the exec() method in the Java Runtime class.

Process p = Runtime.getRuntime().exec("python yourapp.py");

You can read up on how to actually read the output from this resource: http://www.devdaily.com/java/edu/pj/pj010016 import java.io.*;

public class JavaRunCommand {

    public static void main(String args[]) {

        String s = null;

        try {
            
        // run the Unix "ps -ef" command
            // using the Runtime exec method:
            Process p = Runtime.getRuntime().exec("ps -ef");
            
            BufferedReader stdInput = new BufferedReader(new 
                 InputStreamReader(p.getInputStream()));

            BufferedReader stdError = new BufferedReader(new 
                 InputStreamReader(p.getErrorStream()));

            // read the output from the command
            System.out.println("Here is the standard output of the command:\n");
            while ((s = stdInput.readLine()) != null) {
                System.out.println(s);
            }
            
            // read any errors from the attempted command
            System.out.println("Here is the standard error of the command (if any):\n");
            while ((s = stdError.readLine()) != null) {
                System.out.println(s);
            }
            
            System.exit(0);
        }
        catch (IOException e) {
            System.out.println("exception happened - here's what I know: ");
            e.printStackTrace();
            System.exit(-1);
        }
    }
}

There is also an Apache library (the Apache exec project) that can help you with this. You can read more about it here:

http://www.devdaily.com/java/java-exec-processbuilder-process-1

http://commons.apache.org/exec/