#NEWLINE# def __init__( self , name , map_column = None , descriptor = None , comparator_factory = None , doc = None ) : #NEWLINE# #INDENT# 'Denote an attribute name as a synonym to a mapped property,\n        in that the attribute will mirror the value and expression behavior\n        of another attribute.\n\n        :param name: the name of the existing mapped property.  This\n          can refer to the string name of any :class:`.MapperProperty`\n          configured on the class, including column-bound attributes\n          and relationships.\n\n        :param descriptor: a Python :term:`descriptor` that will be used\n          as a getter (and potentially a setter) when this attribute is\n          accessed at the instance level.\n\n        :param map_column: if ``True``, the :func:`.synonym` construct will\n          locate the existing named :class:`.MapperProperty` based on the\n          attribute name of this :func:`.synonym`, and assign it to a new\n          attribute linked to the name of this :func:`.synonym`.\n          That is, given a mapping like::\n\n                class MyClass(Base):\n                    __tablename__ = \'my_table\'\n\n                    id = Column(Integer, primary_key=True)\n                    job_status = Column(String(50))\n\n                    job_status = synonym("_job_status", map_column=True)\n\n          The above class ``MyClass`` will now have the ``job_status``\n          :class:`.Column` object mapped to the attribute named\n          ``_job_status``, and the attribute named ``job_status`` will refer\n          to the synonym itself.  This feature is typically used in\n          conjunction with the ``descriptor`` argument in order to link a\n          user-defined descriptor as a "wrapper" for an existing column.\n\n        :param comparator_factory: A subclass of :class:`.PropComparator`\n          that will provide custom comparison behavior at the SQL expression\n          level.\n\n          .. note::\n\n            For the use case of providing an attribute which redefines both\n            Python-level and SQL-expression level behavior of an attribute,\n            please refer to the Hybrid attribute introduced at\n            :ref:`mapper_hybrids` for a more effective technique.\n\n        .. seealso::\n\n            :ref:`synonyms` - examples of functionality.\n\n            :ref:`mapper_hybrids` - Hybrids provide a better approach for\n            more complicated attribute-wrapping schemes than synonyms.\n\n        ' #NEWLINE# self . name = name #NEWLINE# self . map_column = map_column #NEWLINE# self . descriptor = descriptor #NEWLINE# self . comparator_factory = comparator_factory #NEWLINE# self . doc = ( doc or ( descriptor and self . __doc__ ) or None ) #NEWLINE# util . set_creation_order ( self )