class_docstr: A mutable matrix of objects from poly module or to operate with them.
  
  Examples
  ========
  
  >>> from sympy.polys.polymatrix import PolyMatrix
  >>> from sympy import Symbol, Poly
  >>> x = Symbol('x')
  >>> pm1 = PolyMatrix([[Poly(x**2, x), Poly(-x, x)], [Poly(x**3, x), Poly(-1 + x, x)]])
  >>> v1 = PolyMatrix([[1, 0], [-1, 0]], x)
  >>> pm1*v1
  PolyMatrix([
  [    x**2 + x, 0],
  [x**3 - x + 1, 0]], ring=QQ[x])
  
  >>> pm1.ring
  ZZ[x]
  
  >>> v1*pm1
  PolyMatrix([
  [ x**2, -x],
  [-x**2,  x]], ring=QQ[x])
  
  >>> pm2 = PolyMatrix([[Poly(x**2, x, domain='QQ'), Poly(0, x, domain='QQ'), Poly(1, x, domain='QQ'),             Poly(x**3, x, domain='QQ'), Poly(0, x, domain='QQ'), Poly(-x**3, x, domain='QQ')]])
  >>> v2 = PolyMatrix([1, 0, 0, 0, 0, 0], x)
  >>> v2.ring
  QQ[x]
  >>> pm2*v2
  PolyMatrix([[x**2]], ring=QQ[x])
code: def from_list(cls, rows, cols, items, gens, ring):
      # items can be Expr, Poly, or a mix of Expr and Poly
      items = [_sympify(item) for item in items]
      if items and all(isinstance(item, Poly) for item in items):
          polys = True
      else:
          polys = False
  
      # Identify the ring for the polys
      if ring is not None:
          # Parse a domain string like 'QQ[x]'
          if isinstance(ring, str):
              ring = Poly(0, Dummy(), domain=ring).domain
      elif polys:
          p = items[0]
          for p2 in items[1:]:
              p, _ = p.unify(p2)
          ring = p.domain[p.gens]
      else:
          items, info = parallel_poly_from_expr(items, gens, field=True)
          ring = info["domain"][info["gens"]]
          polys = True
  
      # Efficiently convert when all elements are Poly
      if polys:
          p_ring = Poly(0, ring.symbols, domain=ring.domain)
          to_ring = ring.ring.from_list
          convert_poly = lambda p: to_ring(
              p.unify(p_ring)[0].rep.to_list()
          )
          elements = [convert_poly(p) for p in items]
      else:
          convert_expr = ring.from_sympy
          elements = [convert_expr(e.as_expr()) for e in items]
  
      # Convert to domain elements and construct DomainMatrix
      elements_lol = [
          [elements[i * cols + j] for j in range(cols)]
          for i in range(rows)
      ]
      dm = DomainMatrix(elements_lol, (rows, cols), ring)
      return cls.from_dm(dm)
  
imports: from sympy.core.expr import Expr
  from sympy.core.symbol import Dummy
  from sympy.core.sympify import _sympify
  from sympy.polys.polyerrors import CoercionFailed
  from sympy.polys.polytools import Poly, parallel_poly_from_expr
  from sympy.polys.domains import QQ
  from sympy.polys.matrices import DomainMatrix
  from sympy.polys.matrices.domainscalar import DomainScalar
label_desc: Use image node_id 2 for calling the MutablePolyDenseMatrix obj's underlying member method code with example usage: obj.from_list(cls, rows, cols, items, gens, ring) and returns: cls