class_docstr: A MappedTest pre-configured with a common set of fixtures.
class_docstr_tok: ["A","MappedTest","pre-configured","with","a","common","set","of","fixtures","."]
code: def _setup_stock_mapping(cls):
      (
          Node,
          composite_pk_table,
          users,
          Keyword,
          items,
          Dingaling,
          order_items,
          item_keywords,
          Item,
          User,
          dingalings,
          Address,
          keywords,
          CompositePk,
          nodes,
          Order,
          orders,
          addresses,
      ) = (
          cls.classes.Node,
          cls.tables.composite_pk_table,
          cls.tables.users,
          cls.classes.Keyword,
          cls.tables.items,
          cls.classes.Dingaling,
          cls.tables.order_items,
          cls.tables.item_keywords,
          cls.classes.Item,
          cls.classes.User,
          cls.tables.dingalings,
          cls.classes.Address,
          cls.tables.keywords,
          cls.classes.CompositePk,
          cls.tables.nodes,
          cls.classes.Order,
          cls.tables.orders,
          cls.tables.addresses,
      )
  
      # use OrderedDict on this one to support some tests that
      # assert the order of attributes (e.g. orm/test_inspect)
      cls.mapper_registry.map_imperatively(
          User,
          users,
          properties=util.OrderedDict(
              [
                  (
                      "addresses",
                      relationship(
                          Address,
                          backref="user",
                          order_by=addresses.c.id,
                      ),
                  ),
                  (
                      "orders",
                      relationship(
                          Order, backref="user", order_by=orders.c.id
                      ),
                  ),  # o2m, m2o
              ]
          ),
      )
      cls.mapper_registry.map_imperatively(
          Address,
          addresses,
          properties={
              # o2o
              "dingaling": relationship(
                  Dingaling, uselist=False, backref="address"
              )
          },
      )
      cls.mapper_registry.map_imperatively(Dingaling, dingalings)
      cls.mapper_registry.map_imperatively(
          Order,
          orders,
          properties={
              # m2m
              "items": relationship(
                  Item, secondary=order_items, order_by=items.c.id
              ),
              "address": relationship(Address),  # m2o
          },
      )
      cls.mapper_registry.map_imperatively(
          Item,
          items,
          properties={
              "keywords": relationship(
                  Keyword, secondary=item_keywords
              )  # m2m
          },
      )
      cls.mapper_registry.map_imperatively(Keyword, keywords)
      cls.mapper_registry.map_imperatively(
          Node,
          nodes,
          properties={
              "children": relationship(
                  Node,
                  backref=backref("parent", remote_side=[nodes.c.id]),
              )
          },
      )
  
      cls.mapper_registry.map_imperatively(
          CompositePk, composite_pk_table
      )
  
      configure_mappers()
  
imports: from sqlalchemy import ForeignKey
  from sqlalchemy import Integer
  from sqlalchemy import String
  from sqlalchemy import util
  from sqlalchemy.orm import backref
  from sqlalchemy.orm import configure_mappers
  from sqlalchemy.orm import relationship
  from sqlalchemy.testing import fixtures
  from sqlalchemy.testing.schema import Column
  from sqlalchemy.testing.schema import Table
label_desc: Use image node_id 2 for calling the FixtureTest obj's underlying member method code with example usage: obj._setup_stock_mapping(cls) without return types