code: def pdsolve(
      eq, func=None, hint="default", dict=False, solvefun=None, **kwargs
  ):
      """
      Solves any (supported) kind of partial differential equation.
  
      **Usage**
  
          pdsolve(eq, f(x,y), hint) -> Solve partial differential equation
          eq for function f(x,y), using method hint.
  
      **Details**
  
          ``eq`` can be any supported partial differential equation (see
              the pde docstring for supported methods).  This can either
              be an Equality, or an expression, which is assumed to be
              equal to 0.
  
          ``f(x,y)`` is a function of two variables whose derivatives in that
              variable make up the partial differential equation. In many
              cases it is not necessary to provide this; it will be autodetected
              (and an error raised if it could not be detected).
  
          ``hint`` is the solving method that you want pdsolve to use.  Use
              classify_pde(eq, f(x,y)) to get all of the possible hints for
              a PDE.  The default hint, 'default', will use whatever hint
              is returned first by classify_pde().  See Hints below for
              more options that you can use for hint.
  
          ``solvefun`` is the convention used for arbitrary functions returned
              by the PDE solver. If not set by the user, it is set by default
              to be F.
  
      **Hints**
  
          Aside from the various solving methods, there are also some
          meta-hints that you can pass to pdsolve():
  
          "default":
                  This uses whatever hint is returned first by
                  classify_pde(). This is the default argument to
                  pdsolve().
  
          "all":
                  To make pdsolve apply all relevant classification hints,
                  use pdsolve(PDE, func, hint="all").  This will return a
                  dictionary of hint:solution terms.  If a hint causes
                  pdsolve to raise the NotImplementedError, value of that
                  hint's key will be the exception object raised.  The
                  dictionary will also include some special keys:
  
                  - order: The order of the PDE.  See also ode_order() in
                    deutils.py
                  - default: The solution that would be returned by
                    default.  This is the one produced by the hint that
                    appears first in the tuple returned by classify_pde().
  
          "all_Integral":
                  This is the same as "all", except if a hint also has a
                  corresponding "_Integral" hint, it only returns the
                  "_Integral" hint.  This is useful if "all" causes
                  pdsolve() to hang because of a difficult or impossible
                  integral.  This meta-hint will also be much faster than
                  "all", because integrate() is an expensive routine.
  
          See also the classify_pde() docstring for more info on hints,
          and the pde docstring for a list of all supported hints.
  
      **Tips**
          - You can declare the derivative of an unknown function this way:
  
              >>> from sympy import Function, Derivative
              >>> from sympy.abc import x, y # x and y are the independent variables
              >>> f = Function("f")(x, y) # f is a function of x and y
              >>> # fx will be the partial derivative of f with respect to x
              >>> fx = Derivative(f, x)
              >>> # fy will be the partial derivative of f with respect to y
              >>> fy = Derivative(f, y)
  
          - See test_pde.py for many tests, which serves also as a set of
            examples for how to use pdsolve().
          - pdsolve always returns an Equality class (except for the case
            when the hint is "all" or "all_Integral"). Note that it is not possible
            to get an explicit solution for f(x, y) as in the case of ODE's
          - Do help(pde.pde_hintname) to get help more information on a
            specific hint
  
  
      Examples
      ========
  
      >>> from sympy.solvers.pde import pdsolve
      >>> from sympy import Function, Eq
      >>> from sympy.abc import x, y
      >>> f = Function('f')
      >>> u = f(x, y)
      >>> ux = u.diff(x)
      >>> uy = u.diff(y)
      >>> eq = Eq(1 + (2*(ux/u)) + (3*(uy/u)), 0)
      >>> pdsolve(eq)
      Eq(f(x, y), F(3*x - 2*y)*exp(-2*x/13 - 3*y/13))
  
      """
  
      if not solvefun:
          solvefun = Function("F")
  
      # See the docstring of _desolve for more details.
      hints = _desolve(
          eq, func=func, hint=hint, simplify=True, type="pde", **kwargs
      )
      eq = hints.pop("eq", False)
      all_ = hints.pop("all", False)
  
      if all_:
          # TODO : 'best' hint should be implemented when adequate
          # number of hints are added.
          pdedict = {}
          failed_hints = {}
          gethints = classify_pde(eq, dict=True)
          pdedict.update(
              {
                  "order": gethints["order"],
                  "default": gethints["default"],
              }
          )
          for hint in hints:
              try:
                  rv = _helper_simplify(
                      eq,
                      hint,
                      hints[hint]["func"],
                      hints[hint]["order"],
                      hints[hint][hint],
                      solvefun,
                  )
              except NotImplementedError as detail:
                  failed_hints[hint] = detail
              else:
                  pdedict[hint] = rv
          pdedict.update(failed_hints)
          return pdedict
  
      else:
          return _helper_simplify(
              eq,
              hints["hint"],
              hints["func"],
              hints["order"],
              hints[hints["hint"]],
              solvefun,
          )
  
imports: from functools import reduce
  from itertools import combinations_with_replacement
  from sympy.simplify import simplify
  from sympy.core import Add, S
  from sympy.core.function import Function, expand, AppliedUndef, Subs
  from sympy.core.relational import Equality, Eq
  from sympy.core.symbol import Symbol, Wild, symbols
  from sympy.functions import exp
  from sympy.integrals.integrals import Integral, integrate
  from sympy.utilities.iterables import has_dups, is_sequence
  from sympy.utilities.misc import filldedent
  from sympy.solvers.deutils import _preprocess, ode_order, _desolve
  from sympy.solvers.solvers import solve
  from sympy.simplify.radsimp import collect
  import operator
label_desc: Use image node_id 1 for calling a global function with example usage: pdsolve(eq, func, hint, dict, solvefun) and returns: pdedict, _helper_simplify