Python doesn't have any exact equivalent to a .jar file.

There are many differences, and without knowing exactly what you want to do, it's hard to explain how to do it. But the Python Packaging User Guide does a pretty good job of explaining just about everything relevant.

Here are some of the major differences.

A .jar file is a compiled collection of classes that can be dropped into your application, or installed anywhere on your CLASSPATH.

In Python:

• A .py (or .pyc) module can be dropped into your application, or installed anywhere on your sys.path, and it can be imported and used.
• A directory full of modules can be treated the same way; it becomes a package (or, if it doesn't contain an __init__.py, it merges with other directories of the same name elsewhere on sys.path into a single package).
• A .zip archive containing any number of modules and packages can be stored anywhere, and its path added to your sys.path (e.g., at runtime or via PYTHONPATH) and all of its contents become importable.

Most commonly, you want things to be installed into a system, user, or virtualenv site-packages directory. The recommended way to do that is to create a pip-compatible package distribution; people then install it (and possibly automatically download it from PyPI or a private repo) via pip.

pip does a lot more than that, however. It also allows you to manage dependencies between packages. So ideally, instead of listing a bunch of prereqs that someone has to go download and install manually, you just make them dependencies, and someone just has to pip install your-library. And it keeps track of the state of your site-packages, so you can uninstall or upgrade a package without having to track down the specific files.

Meanwhile, in Java, most .jar files are cross-platform; build once, run anywhere. A few packages have JNI native code and can't be used this way, but it's not the norm.

In Python, many packages have C extensions that have to be compiled for each platform, and even pure-Python packages often need to do some install-time configuration. And meanwhile, "compiling" pure Python doesn't do anything that can't be done just as well at runtime. So in Python, you generally distribute source packages, not compiled packages.

However, .wheel is a binary package format. You can pip wheel to build binary packages for different targets from the source package; then, if someone tries to pip install your package, if there's a wheel for his system, that will be downloaded and installed.

I believe this is what you are looking for.

Post-install script with Python setuptools

It looks like what you are trying to do is have an installation script that symlinks the jar file into sparks path when the user runs foo.py. The issue is that if the jvm is already started this wont work, and plus the user wont have the permissions to do this anyway.

What you should do instead is add a post install hook to your setup.py file so that when the user runs pip install it will automatically do the symlinking.

from setuptools.command.install import install
from setuptools import setup

class PostInstallCommand(install):
    """Post-installation for installation mode."""
    def run(self):
        install.run(self)
        package_dir = os.path.dirname(os.path.realpath(__file__))
        jar_file_path = os.path.join(package_dir, f"foo/jars/foo.jar")
        tgt = f"{os.environ.get('SPARK_HOME')}/jars/foo.jar"
        if os.path.islink(tgt):
            print(f"Removing existing symlink {tgt}")
            os.unlink(tgt)
        os.symlink(jar_file_path, tgt)

then insert cmdclass argument to setup() function in setup.py:

setup(
    ...

    cmdclass={
        'develop': PostDevelopCommand,
        'install': PostInstallCommand,
    },

    ...
)

If you have administrators setup the python environments for the datascientist this should solve the permissions issue

First to search for a package on PyPI

pip search <seach_string>

Example:

pip search ply | grep -i '^ply'

Output:

plyer                     - Platform-independant wrapper for platform-dependant APIs
plyvel                    - Plyvel, a fast and feature-rich Python interface to LevelDB
plywood                   - A template language grammar inspired by the Python code aesthetic
ply                       - Python Lex & Yacc
plytix-retailers-sdk      - Plytix Retailers SDK for Python
plymgf                    - A MGF files reader with PLY
plyfile                   - PLY file reader/writer
plypatch                  - Ply: Git-based Patch Management
plyj                      - A Java parser written in Python using PLY.
plyr                      - UNKNOWN
PlyPlus                   - a friendly yet powerful LR-parser written in Python

Then Install the package you want:

pip install <package_name>

Example:

pip install ply

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.