code: def emission_lock(self, name):
          
          e = self.__property_events.get(name)
          if e is None:
              e = self.__events[name]
          return e.emission_lock
docs: Holds emission of events and dispatches the last event on release
  
          The context manager returned will store the last event data called by
          :meth:`emit` and prevent callbacks until it exits. On exit, it will
          dispatch the last event captured (if any)::
  
              class Foo(Dispatcher):
                  _events_ = ['my_event']
  
              def on_my_event(value):
                  print(value)
  
              foo = Foo()
              foo.bind(my_event=on_my_event)
  
              with foo.emission_lock('my_event'):
                  foo.emit('my_event', 1)
                  foo.emit('my_event', 2)
  
              >>> 2
  
          Args:
              name (str): The name of the :class:`Event` or
                  :class:`~pydispatch.properties.Property`
  
          Returns:
              A context manager to be used by the :keyword:`with` statement.
  
              If available, this will also be an async context manager to be used
              with the :keyword:`async with` statement (see `PEP 492`_).
  
          Note:
              The context manager is re-entrant, meaning that multiple calls to
              this method within nested context scopes are possible.
  
          .. _PEP 492: https://www.python.org/dev/peps/pep-0492/#asynchronous-context-managers-and-async-with