old_contents: """
  This magical module will rewrite all public methods in the public interface
  of the library so they can run the loop on their own if it's not already
  running. This rewrite may not be desirable if the end user always uses the
  methods they way they should be ran, but it's incredibly useful for quick
  scripts and the runtime overhead is relatively low.
  
  Some really common methods which are hardly used offer this ability by
  default, such as ``.start()`` and ``.run_until_disconnected()`` (since
  you may want to start, and then run until disconnected while using async
  event handlers).
  """
  import asyncio
  import functools
  import inspect
  
  from .client.telegramclient import TelegramClient
  from .tl.custom import (
      Draft, Dialog, MessageButton, Forward, Message, InlineResult, Conversation
  )
  from .tl.custom.chatgetter import ChatGetter
  from .tl.custom.sendergetter import SenderGetter
  
  
  def _syncify_wrap(t, method_name):
      method = getattr(t, method_name)
  
      @functools.wraps(method)
      def syncified(*args, **kwargs):
          coro = method(*args, **kwargs)
          loop = asyncio.get_event_loop()
          if loop.is_running():
              return coro
          else:
              return loop.run_until_complete(coro)
  
      # Save an accessible reference to the original method
      setattr(syncified, '__tl.sync', method)
      setattr(t, method_name, syncified)
  
  
  def syncify(*types):
      """
      Converts all the methods in the given types (class definitions)
      into synchronous, which return either the coroutine or the result
      based on whether ``asyncio's`` event loop is running.
      """
      # Our asynchronous generators all are `RequestIter`, which already
      # provide a synchronous iterator variant, so we don't need to worry
      # about asyncgenfunction's here.
      for t in types:
          for name in dir(t):
              if not name.startswith('_') or name == '__call__':
                  if inspect.iscoroutinefunction(getattr(t, name)):
                      _syncify_wrap(t, name)
  
  
  syncify(TelegramClient, Draft, Dialog, MessageButton,
          ChatGetter, SenderGetter, Forward, Message, InlineResult, Conversation)
  
new_contents: """
  This magical module will rewrite all public methods in the public interface
  of the library so they can run the loop on their own if it's not already
  running. This rewrite may not be desirable if the end user always uses the
  methods they way they should be ran, but it's incredibly useful for quick
  scripts and the runtime overhead is relatively low.
  
  Some really common methods which are hardly used offer this ability by
  default, such as ``.start()`` and ``.run_until_disconnected()`` (since
  you may want to start, and then run until disconnected while using async
  event handlers).
  """
  import asyncio
  import functools
  import inspect
  
  from .client.account import _TakeoutClient
  from .client.telegramclient import TelegramClient
  from .tl.custom import (
      Draft, Dialog, MessageButton, Forward, Message, InlineResult, Conversation
  )
  from .tl.custom.chatgetter import ChatGetter
  from .tl.custom.sendergetter import SenderGetter
  
  
  def _syncify_wrap(t, method_name):
      method = getattr(t, method_name)
  
      @functools.wraps(method)
      def syncified(*args, **kwargs):
          coro = method(*args, **kwargs)
          loop = asyncio.get_event_loop()
          if loop.is_running():
              return coro
          else:
              return loop.run_until_complete(coro)
  
      # Save an accessible reference to the original method
      setattr(syncified, '__tl.sync', method)
      setattr(t, method_name, syncified)
  
  
  def syncify(*types):
      """
      Converts all the methods in the given types (class definitions)
      into synchronous, which return either the coroutine or the result
      based on whether ``asyncio's`` event loop is running.
      """
      # Our asynchronous generators all are `RequestIter`, which already
      # provide a synchronous iterator variant, so we don't need to worry
      # about asyncgenfunction's here.
      for t in types:
          for name in dir(t):
              if not name.startswith('_') or name == '__call__':
                  if inspect.iscoroutinefunction(getattr(t, name)):
                      _syncify_wrap(t, name)
  
  
  syncify(TelegramClient, _TakeoutClient, Draft, Dialog, MessageButton,
          ChatGetter, SenderGetter, Forward, Message, InlineResult, Conversation)
  
subject: Fix telethon.sync not syncifying takeout client