docs: def pkg_manager_install(
              self, package_names=None,
              production=None, development=None,
              args=(), env={}, **kw):
          """
          This will install all dependencies into the current working
          directory for the specific Python package from the selected
          JavaScript package manager; this requires that this package
          manager's package definition file to be properly generated
          first, otherwise the process will be aborted.
  
          If the production argument is supplied, it will be passed to the
          underlying package manager binary as a true or false value with
          the --production flag, otherwise it will not be set.
  
          Likewise for development.  However, the production flag has
          priority.
  
          If the argument 'args' is supplied as a tuple, those will be
          passed through to the package manager install command as its
          arguments.  This will be very specific to the underlying
          program; use with care as misuse can result in an environment
          that is not expected by the other parts of the framework.
  
          If the argument 'env' is supplied, they will be additional
          environment variables that are not already defined by the
          framework, which are 'NODE_PATH' and 'PATH'.  Values set for
          those will have highest precedence, then the ones passed in
          through env, then finally whatever was already defined before
          the execution of this program.
  
          All other arguments to this method will be passed forward to the
          pkg_manager_init method, if the package_name is supplied for the
          Python package.
  
          If no package_name was supplied then just continue with the
          process anyway, to still enable the shorthand calling.
  
          If the package manager could not be invoked, it will simply not
          be.
  
          Arguments:
  
          package_names
              The names of the Python package to generate the manifest
              for.
          args
              The arguments to pass into the command line install.
          """
  
          if not package_names:
              logger.warning(
                  "no package name supplied, not continuing with '%s %s'",
                  self.pkg_manager_bin, self.install_cmd,
              )
              return
  
          result = self.pkg_manager_init(package_names, **kw)
          if result is False:
              logger.warning(
                  "not continuing with '%s %s' as the generation of "
                  "'%s' failed", self.pkg_manager_bin, self.install_cmd,
                  self.pkgdef_filename
              )
              return
  
          call_kw = self._gen_call_kws(**env)
          logger.debug(
              "invoking '%s %s'", self.pkg_manager_bin, self.install_cmd)
          if self.env_path:
              logger.debug(
                  "invoked with env_path '%s'", self.env_path)
          if self.working_dir:
              logger.debug(
                  "invoked from working directory '%s'", self.working_dir)
          try:
              cmd = [self._get_exec_binary(call_kw), self.install_cmd]
              cmd.extend(self._prodev_flag(
                  production, development, result.get(self.devkey)))
              cmd.extend(args)
              logger.info('invoking %s', ' '.join(cmd))
              call(cmd, **call_kw)
          except (IOError, OSError):
              logger.error(
                  "invocation of the '%s' binary failed; please ensure it and "
                  "its dependencies are installed and available.", self.binary
              )
              # Still raise the exception as this is a lower level API.
              raise
  
          return True