code: def preview(
      expr,
      output="png",
      viewer=None,
      euler=True,
      packages=(),
      filename=None,
      outputbuffer=None,
      preamble=None,
      dvioptions=None,
      outputTexFile=None,
      extra_preamble=None,
      fontsize=None,
      **latex_settings,
  ):
      r"""
      View expression or LaTeX markup in PNG, DVI, PostScript or PDF form.
  
      If the expr argument is an expression, it will be exported to LaTeX and
      then compiled using the available TeX distribution.  The first argument,
      'expr', may also be a LaTeX string.  The function will then run the
      appropriate viewer for the given output format or use the user defined
      one. By default png output is generated.
  
      By default pretty Euler fonts are used for typesetting (they were used to
      typeset the well known "Concrete Mathematics" book). For that to work, you
      need the 'eulervm.sty' LaTeX style (in Debian/Ubuntu, install the
      texlive-fonts-extra package). If you prefer default AMS fonts or your
      system lacks 'eulervm' LaTeX package then unset the 'euler' keyword
      argument.
  
      To use viewer auto-detection, lets say for 'png' output, issue
  
      >>> from sympy import symbols, preview, Symbol
      >>> x, y = symbols("x,y")
  
      >>> preview(x + y, output='png')
  
      This will choose 'pyglet' by default. To select a different one, do
  
      >>> preview(x + y, output='png', viewer='gimp')
  
      The 'png' format is considered special. For all other formats the rules
      are slightly different. As an example we will take 'dvi' output format. If
      you would run
  
      >>> preview(x + y, output='dvi')
  
      then 'view' will look for available 'dvi' viewers on your system
      (predefined in the function, so it will try evince, first, then kdvi and
      xdvi). If nothing is found, it will fall back to using a system file
      association (via ``open`` and ``xdg-open``). To always use your system file
      association without searching for the above readers, use
  
      >>> from sympy.printing.preview import system_default_viewer
      >>> preview(x + y, output='dvi', viewer=system_default_viewer)
  
      If this still does not find the viewer you want, it can be set explicitly.
  
      >>> preview(x + y, output='dvi', viewer='superior-dvi-viewer')
  
      This will skip auto-detection and will run user specified
      'superior-dvi-viewer'. If ``view`` fails to find it on your system it will
      gracefully raise an exception.
  
      You may also enter ``'file'`` for the viewer argument. Doing so will cause
      this function to return a file object in read-only mode, if ``filename``
      is unset. However, if it was set, then 'preview' writes the generated
      file to this filename instead.
  
      There is also support for writing to a ``io.BytesIO`` like object, which
      needs to be passed to the ``outputbuffer`` argument.
  
      >>> from io import BytesIO
      >>> obj = BytesIO()
      >>> preview(x + y, output='png', viewer='BytesIO',
      ...         outputbuffer=obj)
  
      The LaTeX preamble can be customized by setting the 'preamble' keyword
      argument. This can be used, e.g., to set a different font size, use a
      custom documentclass or import certain set of LaTeX packages.
  
      >>> preamble = "\\documentclass[10pt]{article}\n" \
      ...            "\\usepackage{amsmath,amsfonts}\\begin{document}"
      >>> preview(x + y, output='png', preamble=preamble)
  
      It is also possible to use the standard preamble and provide additional
      information to the preamble using the ``extra_preamble`` keyword argument.
  
      >>> from sympy import sin
      >>> extra_preamble = "\\renewcommand{\\sin}{\\cos}"
      >>> preview(sin(x), output='png', extra_preamble=extra_preamble)
  
      If the value of 'output' is different from 'dvi' then command line
      options can be set ('dvioptions' argument) for the execution of the
      'dvi'+output conversion tool. These options have to be in the form of a
      list of strings (see ``subprocess.Popen``).
  
      Additional keyword args will be passed to the :func:`~sympy.printing.latex.latex` call,
      e.g., the ``symbol_names`` flag.
  
      >>> phidd = Symbol('phidd')
      >>> preview(phidd, symbol_names={phidd: r'\ddot{\varphi}'})
  
      For post-processing the generated TeX File can be written to a file by
      passing the desired filename to the 'outputTexFile' keyword
      argument. To write the TeX code to a file named
      ``"sample.tex"`` and run the default png viewer to display the resulting
      bitmap, do
  
      >>> preview(x + y, outputTexFile="sample.tex")
  
  
      """
      # pyglet is the default for png
      if viewer is None and output == "png":
          try:
              import pyglet  # noqa: F401
          except ImportError:
              pass
          else:
              viewer = pyglet_viewer
  
      # look up a known application
      if viewer is None:
          # sorted in order from most pretty to most ugly
          # very discussable, but indeed 'gv' looks awful :)
          candidates = {
              "dvi": ["evince", "okular", "kdvi", "xdvi"],
              "ps": ["evince", "okular", "gsview", "gv"],
              "pdf": [
                  "evince",
                  "okular",
                  "kpdf",
                  "acroread",
                  "xpdf",
                  "gv",
              ],
          }
  
          for candidate in candidates.get(output, []):
              path = shutil.which(candidate)
              if path is not None:
                  viewer = path
                  break
  
      # otherwise, use the system default for file association
      if viewer is None:
          viewer = system_default_viewer
  
      if viewer == "file":
          if filename is None:
              raise ValueError(
                  'filename has to be specified if viewer="file"'
              )
      elif viewer == "BytesIO":
          if outputbuffer is None:
              raise ValueError(
                  "outputbuffer has to be a BytesIO "
                  'compatible object if viewer="BytesIO"'
              )
      elif not callable(viewer) and not shutil.which(viewer):
          raise OSError("Unrecognized viewer: %s" % viewer)
  
      latex_main = _get_latex_main(
          expr,
          preamble=preamble,
          packages=packages,
          euler=euler,
          extra_preamble=extra_preamble,
          fontsize=fontsize,
          **latex_settings,
      )
  
      debug("Latex code:")
      debug(latex_main)
      with tempfile.TemporaryDirectory() as workdir:
          with open(
              join(workdir, "texput.tex"), "w", encoding="utf-8"
          ) as fh:
              fh.write(latex_main)
  
          if outputTexFile is not None:
              shutil.copyfile(
                  join(workdir, "texput.tex"), outputTexFile
              )
  
          if not shutil.which("latex"):
              raise RuntimeError("latex program is not installed")
  
          try:
              _check_output_no_window(
                  [
                      "latex",
                      "-halt-on-error",
                      "-interaction=nonstopmode",
                      "texput.tex",
                  ],
                  cwd=workdir,
                  stderr=STDOUT,
              )
          except CalledProcessError as e:
              raise RuntimeError(
                  "'latex' exited abnormally with the following output:\n%s"
                  % e.output
              )
  
          src = "texput.%s" % (output)
  
          if output != "dvi":
              # in order of preference
              commandnames = {
                  "ps": ["dvips"],
                  "pdf": ["dvipdfmx", "dvipdfm", "dvipdf"],
                  "png": ["dvipng"],
                  "svg": ["dvisvgm"],
              }
              try:
                  cmd_variants = commandnames[output]
              except KeyError:
                  raise ValueError(
                      "Invalid output format: %s" % output
                  ) from None
  
              # find an appropriate command
              for cmd_variant in cmd_variants:
                  cmd_path = shutil.which(cmd_variant)
                  if cmd_path:
                      cmd = [cmd_path]
                      break
              else:
                  if len(cmd_variants) > 1:
                      raise RuntimeError(
                          "None of %s are installed"
                          % ", ".join(cmd_variants)
                      )
                  else:
                      raise RuntimeError(
                          "%s is not installed" % cmd_variants[0]
                      )
  
              defaultoptions = {
                  "dvipng": ["-T", "tight", "-z", "9", "--truecolor"],
                  "dvisvgm": ["--no-fonts"],
              }
  
              commandend = {
                  "dvips": ["-o", src, "texput.dvi"],
                  "dvipdf": ["texput.dvi", src],
                  "dvipdfm": ["-o", src, "texput.dvi"],
                  "dvipdfmx": ["-o", src, "texput.dvi"],
                  "dvipng": ["-o", src, "texput.dvi"],
                  "dvisvgm": ["-o", src, "texput.dvi"],
              }
  
              if dvioptions is not None:
                  cmd.extend(dvioptions)
              else:
                  cmd.extend(defaultoptions.get(cmd_variant, []))
              cmd.extend(commandend[cmd_variant])
  
              try:
                  _check_output_no_window(
                      cmd, cwd=workdir, stderr=STDOUT
                  )
              except CalledProcessError as e:
                  raise RuntimeError(
                      "'%s' exited abnormally with the following output:\n%s"
                      % (" ".join(cmd), e.output)
                  )
  
          if viewer == "file":
              shutil.move(join(workdir, src), filename)
          elif viewer == "BytesIO":
              with open(join(workdir, src), "rb") as fh:
                  outputbuffer.write(fh.read())
          elif callable(viewer):
              viewer(join(workdir, src), fmt=output)
          else:
              try:
                  _check_output_no_window(
                      [viewer, src], cwd=workdir, stderr=STDOUT
                  )
              except CalledProcessError as e:
                  raise RuntimeError(
                      "'%s %s' exited abnormally with the following output:\n%s"
                      % (viewer, src, e.output)
                  )
  
file_path: sympy/sympy/printing/preview.py
imports: import os
  from os.path import join
  import shutil
  import tempfile
  from sympy.utilities.decorator import doctest_depends_on
  from sympy.utilities.misc import debug
  from .latex import latex
label_desc: Use image node_id 5 for calling a global function with example usage: preview(expr, output, viewer, euler, packages, filename, outputbuffer, preamble, dvioptions, outputTexFile, extra_preamble, fontsize) without return types