code: def cmdify(self):
          
          return " ".join(itertools.chain(
              [_quote_if_contains(self.command, r'[\s^()]')],
              (_quote_if_contains(arg, r'[\s^]') for arg in self.args),
          ))
docs: Encode into a cmd-executable string.
  
          This re-implements CreateProcess's quoting logic to turn a list of
          arguments into one single string for the shell to interpret.
  
          * All double quotes are escaped with a backslash.
          * Existing backslashes before a quote are doubled, so they are all
            escaped properly.
          * Backslashes elsewhere are left as-is; cmd will interpret them
            literally.
  
          The result is then quoted into a pair of double quotes to be grouped.
  
          An argument is intentionally not quoted if it does not contain
          foul characters. This is done to be compatible with Windows built-in
          commands that don't work well with quotes, e.g. everything with `echo`,
          and DOS-style (forward slash) switches.
  
          Foul characters include:
  
          * Whitespaces.
          * Carets (^). (pypa/pipenv#3307)
          * Parentheses in the command. (pypa/pipenv#3168)
  
          Carets introduce a difficult situation since they are essentially
          "lossy" when parsed. Consider this in cmd.exe::
  
              > echo "foo^bar"
              "foo^bar"
              > echo foo^^bar
              foo^bar
  
          The two commands produce different results, but are both parsed by the
          shell as `foo^bar`, and there's essentially no sensible way to tell
          what was actually passed in. This implementation assumes the quoted
          variation (the first) since it is easier to implement, and arguably
          the more common case.
  
          The intended use of this function is to pre-process an argument list
          before passing it into ``subprocess.Popen(..., shell=True)``.
  
          See also: https://docs.python.org/3/library/subprocess.html#converting-argument-sequence