class_docstr: Main class which validates the passed estimator and
  coordinates the kind of estimator to a concrete subclass.
docstr: Make predictions with transpiled estimators locally.
  
  Parameters
  ----------
  x : Union[List, np.ndarray] of shape (n_samples, n_features) or (n_features)
      Input data.
  n_jobs : Union[bool, int] (default: True, which uses `count_cpus()`)
      The number of processes to make the predictions.
  directory : Optional[Union[str, Path]] (default: current working dir)
      Set the directory where all generated files should be saved.
  delete_created_files : bool (default: True)
      Whether to delete the generated files finally or not.
  check_dependencies : bool (default: True)
      Check whether all required applications are in the PATH or not.
  shell_executable : str (default: '/bin/bash')
      The shell which should be used for the Popen system calls.
  kwargs
  
  Returns
  -------
  Return the predictions and probabilities.
docstr_tok: ["Make","predictions","with","transpiled","estimators","locally",".","Parameters","--","--","--","--","--","x",":","Union","[","List",",","np.ndarray","]","of","shape","(","n_samples",",","n_features",")","or","(","n_features",")","Input","data",".","n_jobs",":","Union","[","bool",",","int","]","(","default",":","True",",","which","uses","`","count_cpus","(",")","`",")","The","number","of","processes","to","make","the","predictions",".","directory",":","Optional","[","Union","[","str",",","Path","]","]","(","default",":","current","working","dir",")","Set","the","directory","where","all","generated","files","should","be","saved",".","delete_created_files",":","bool","(","default",":","True",")","Whether","to","delete","the","generated","files","finally","or","not",".","check_dependencies",":","bool","(","default",":","True",")","Check","whether","all","required","applications","are","in","the","PATH","or","not",".","shell_executable",":","str","(","default",":","'\/bin\/bash","'",")","The","shell","which","should","be","used","for","the","Popen","system","calls",".","kwargs","Returns","--","--","--","-","Return","the","predictions","and","probabilities","."]
code: def make(
      self,
      x: Union[List, np.ndarray],
      n_jobs: Union[bool, int] = True,
      directory: Optional[Union[str, Path]] = None,
      delete_created_files: bool = True,
      check_dependencies: bool = True,
      shell_executable: str = "/bin/bash",
      **kwargs,
  ) -> Union[
      Tuple[np.int64, np.ndarray],
      Tuple[np.ndarray, np.ndarray],
      Tuple[np.ndarray, None],
  ]:
      """
      Make predictions with transpiled estimators locally.
  
      Parameters
      ----------
      x : Union[List, np.ndarray] of shape (n_samples, n_features) or (n_features)
          Input data.
      n_jobs : Union[bool, int] (default: True, which uses `count_cpus()`)
          The number of processes to make the predictions.
      directory : Optional[Union[str, Path]] (default: current working dir)
          Set the directory where all generated files should be saved.
      delete_created_files : bool (default: True)
          Whether to delete the generated files finally or not.
      check_dependencies : bool (default: True)
          Check whether all required applications are in the PATH or not.
      shell_executable : str (default: '/bin/bash')
          The shell which should be used for the Popen system calls.
      kwargs
  
      Returns
      -------
      Return the predictions and probabilities.
      """
      self._check_kwargs(kwargs)
      if check_dependencies:
          self._check_dependencies(self._language)
  
      if not directory:
          directory = mktemp()
      created_files = []  # for final deletion
  
      # Transpile model:
      out = self.save(directory=directory, to_json=True, **kwargs)
  
      if isinstance(out, tuple):  # indicator for Template.EXPORTED
          src_path, data_path = out[0], out[1]
          if not isinstance(data_path, Path):
              data_path = Path(data_path)
          data_path = data_path.resolve()
          created_files.append(data_path)
      else:
          src_path, data_path = out, None
      if not isinstance(src_path, Path):
          src_path = Path(src_path)
      src_path = src_path.resolve()
  
      created_files.append(src_path)
      class_paths = []
  
      language = self._language
      template = self._template
  
      # Compilation:
      self._compile(
          src_path, class_paths, created_files, language, template
      )
  
      # Execution:
      cmd = language.value.CMD_EXECUTE
      cmd_args = {}
  
      if language in (enum.Language.C, enum.Language.GO):
          cmd_args["dest_path"] = str(src_path.parent / src_path.stem)
      elif language is enum.Language.JAVA:
          if bool(class_paths):
              cmd_args["class_path"] = "-cp " + ":".join(class_paths)
          cmd_args["dest_path"] = str(src_path.stem)
      elif language in (
          enum.Language.JS,
          enum.Language.PHP,
          enum.Language.RUBY,
      ):
          cmd_args["src_path"] = str(src_path)
  
      paths_to_check = []
      if "src_path" in cmd_args.keys():
          paths_to_check.append(cmd_args.get("src_path"))
      if "dest_path" in cmd_args.keys():
          paths_to_check.append(cmd_args.get("dest_path"))
      for path_to_check in paths_to_check:
          for _ in range(10):
              try:
                  fp = open(path_to_check)
              except IOError:
                  sleep(0.1)
              else:
                  fp.close()
                  break
  
      cmd = cmd.format(**cmd_args)
      L.info("Execution command: `{}`".format(cmd))
  
      # Model data:
      json_path = " " if not data_path else " " + str(data_path) + " "
  
      # Features:
      if not isinstance(x, np.ndarray):
          x = np.array(x)
      if x.ndim == 1:
          x = x[np.newaxis, :]
      x = x.tolist()
  
      # Command:
      x = [cmd + json_path + " ".join(list(map(str, e))) for e in x]
      calls = partial(_system_call, executable=shell_executable)
  
      if isinstance(n_jobs, int) and n_jobs <= 1:
          n_jobs = False
  
      if not n_jobs:
          y = list(map(calls, x))
      else:
          if isinstance(n_jobs, bool):
              n_jobs = cpu_count()
          if not isinstance(n_jobs, int):
              n_jobs = cpu_count()
          with Pool(n_jobs) as pool:
              y = pool.map(calls, x)
      y = list(zip(*y))
      y = list(map(np.array, y))
  
      # Delete generated files finally:
      if delete_created_files:
          for path in created_files:
              if path and path.exists():
                  remove(str(path))
  
      if len(y) == 1:  # predict
          if len(y[0]) == 1:
              return y[0][0], None
          return y[0], None
      else:
          if len(y[0]) == 1:  # predict, predict_proba
              return y[0][0], y[1][0]
          return y[0], y[1]
  
imports: import urllib.request
  from abc import ABCMeta
  from collections import OrderedDict
  from functools import partial
  from json import JSONDecodeError, loads
  from multiprocessing import Pool, cpu_count
  from os import environ, remove
  from pathlib import Path
  from shutil import which
  from subprocess import STDOUT, CalledProcessError, check_output
  from sys import platform, stdout, version_info
  from tempfile import mktemp
  from textwrap import dedent
  from time import sleep
  from typing import Callable, Dict, List, Optional, Tuple, Union
  import numpy
  from loguru import logger
  from tabulate import tabulate
  from sklearn import __version__
  from sklearn.base import BaseEstimator, ClassifierMixin, RegressorMixin
  from sklearn.ensemble import BaseEnsemble
  from sklearn.metrics import accuracy_score
  from sklearn_porter import decorators
  from sklearn_porter import enums
  from sklearn_porter import exceptions
  from sklearn_porter import meta
  from sklearn_porter.utils import options
label_desc: Use image node_id 18 for calling the Estimator obj's underlying member method code with example usage: obj.make(x, n_jobs, directory, delete_created_files, check_dependencies, shell_executable) and returns: y,  None, y,  y, y,  None, y,  y