Pythonista 3.4: 'pip install' (alternative to StaSh)

[RichardPotthoff]

Here is a method that can be used to install Python packages using pip (including pip itself) in Pythonista 3.4:

The Idea is to use an existing pip installation on a shared resource, e.g. shared drive on a remote machine where pip is already installed.

1. Share a folder with a pip installation on a PC, and connect to this folder from an iPad/iPhone. (I use a shared SMB folder on a Raspberry Pi, and connect to it using the "Files" app on my iPad (Files > ... > connect to Server). An alternative could be to save the folders "pip" and "pip-25.2.dist-info" into a folder on the iCloud drive, where the iPad/iPhone can see it.)

2. In Pythonista: Navigate to this folder using "External Files > Open... Folder...", and open the shared folder.

3. Create a new empty Python script inside this folder ( "+" > "New ... Empty Script"), and give it a name (e.g. "shared_pip_sh.py"), and copy/paste the following script into it, and run the script (The script will give further instructions):

import sys, os, pathlib, shutil, shlex, runpy
sh_name=os.path.splitext(os.path.basename(__file__))[0] if '__file__' in locals() else 'pip_sh'
def help_text(): return ('\n'
  'List of Commands:\n\n'
  '  pip: This is the standard Python pip command.\n'
  '       If "pip" is not yet installed, copy "pip_sh.py" to a remote share that\n'
  '       contains an installed "pip" module (e.g. on a shared remote drive) to\n'
  '       bootstrap the installation of "pip" (using the command: "pip install pip").\n'
  '       Running "pip" from a remote shared drive may be slow (~30s to install pip),\n'
  '       so it should be avoided once "pip" is installed locally.\n'
  'clone: This command copies a list of files/directories from the "cwd" (current\n'
  '       working directory) to "site-packages(user)" (PIP_TARGET), or to a directory\n'
  '       with a file "CLONE_TARGET.py" (the directories have to be on the "sys.path"\n'
  '       search path so Python can find them).\n'
  '       Tip 1: Copy/paste the filenames from the "ls" output to the input line.\n'
  '              (Line breaks in the pasted text are not a problem.)\n'
  '       Tip 2: Copy "pip_sh.py" to a remote shared drive, and run it from there.\n'
  '              (The initial "cwd" is the parent directory of the script being run.)\n'
  '   ls: List an alphabetically sorted list of files/directories of the "cwd".\n' 
  '   cd: Change the "cwd".\n'
 f" exit: Exit '{sh_name}'.\n"
  ' help: This help text.\n'
  ) 
try:
  import PIP_TARGET
except ImportError:
  print('Module "PIP_TARGET.py" missing in "site-packages(user)"!\n\n'
        'Add an empty file named "PIP_TARGET.py" to "site-packages(user)". \n'
        'This file acts as a tag that marks the target directory for the\n'
        'commands "pip" and "clone".',file=sys.stderr)
  sys.exit(1)
pip_packages_path=os.path.dirname(PIP_TARGET.__file__)
os.environ['PIP_TARGET']=pip_packages_path

cloned_packages_path=pip_packages_path
try:
  import CLONE_TARGET
  cloned_packages_path=os.path.dirname(CLONE_TARGET.__file__)
except ImportError: pass

def clone_selected(src, dst, selected, logging=False):
  src, dst = pathlib.Path(src), pathlib.Path(dst)
  if logging: print(f'\nCopying {len(selected)} items:') 
  for i,item in enumerate(selected):
    if logging: print(f'{i+1:5d}: {item:30}',end='')
    try:
      src_path = src / item
      dst_path = dst / item
      if os.path.exists(dst_path):
        if logging: print("can't overwrite existing item",file=sys.stderr)
      elif src_path.is_dir():
        shutil.copytree(src_path, dst_path,copy_function=shutil.copy)
        if logging: print("O.K.")
      elif src_path.is_file():
        shutil.copy(src_path, dst_path)
        if logging: print("O.K.")
      else:
        if logging: print("source item invalid",file=sys.stderr)
    except Exception as e:
      if logging:
        print()
        print(e,file=sys.stderr)

def sh_cmd(cmdln):
  if not cmdln:
    return
  saved_argv=sys.argv
  sys.argv=shlex.split(cmdln)
  cmd,*args=sys.argv
  quit=False
  try:
    if   'clone'==cmd: clone_selected(src=os.getcwd(),dst=cloned_packages_path,selected=args,logging=True)
    elif 'ls'   ==cmd: print('\n',' \n '.join(map(shlex.quote,sorted(os.listdir(*args)))),'\n')
    elif 'cd'   ==cmd: os.chdir(*args)
    elif 'help' ==cmd: print(help_text(),end='\n\n')
    elif 'quit' ==cmd: quit=True
    elif 'exit' ==cmd: quit=True
    else:              runpy.run_module(cmd,run_name='__main__')
  except Exception as e: raise e
  except BaseException: pass
  finally: sys.argv=saved_argv
  if quit: raise KeyboardInterrupt
  return 0
    
def sh():
  while True:
    try:
      cwd=os.path.basename(os.getcwd())
      cmdln=input(f'{sh_name}:{cwd} $ ')
      sh_cmd(cmdln)
    except Exception as e: print(e,file=sys.stderr)
    except BaseException:  break 
      
if __name__=='__main__':
  if len(sys.argv)>1: sh_name=sys.argv[1]
  print(help_text())
  saved_cwd=os.getcwd() 
  sh()
  os.chdir(saved_cwd) 
  print(f"\nKeyboard interrupt received, exiting '{sh_name}'. ")

This works because the script's path is added to Python's "sys.path", and since "pip" is installed in the same folder, Python can find, load, and execute the "pip" module on the shared drive. (Pythonista has permissions to read the files inside the shared folder, because otherwise it would not be able to run the script.)