Vindicar

Вместо строки возвращай кортеж или словарь. Короче, структуру данных.

from typing import NamedTuple

class Result(NamedTuple):
    text: str  # текст запроса
    success: bool  # успешен ли запрос
    status: str  # статус

async def check_text(text: str) -> Result:
    url = f'https://сайт.com/?query={text}'

    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            if response.status != 200:
                return Result(text=text, success=False, status='Не удалось определить результат')
            html = await response.text()
            soup = BeautifulSoup(html, 'html.parser')
            status_element = soup.find('div', class_='table-block')
            if not status_element:
                return Result(text=text, success=False, status='Не удалось определить результат')
            status_text = status_element.get_text().strip()
            # тебе нужно будет решить, когда запрос был успешен (True), а когда нет (False)
            if "ok" in status_text:
                return Result(text=text, success=True, status='Можно')
            elif "no" in status_text:
                return Result(text=text, success=False, status='Данный вариант недоступен')
            elif "no1" in status_text:
                return Result(text=text, success=True, status='Можно под заказ')
            else:
                return Result(text=text, success=False, status='Неизвестно')

Тогда можно будет анализировать результат просто:

result = await check_text(text)
if result.success:
    ...  # реагируем на успешный запрос
    logger.info('%s: %s', result.text, result.status)
else:
    ...  # реагируем на неудачный запрос
    logger.info('%s: %s', result.text, result.status)

__getattribute__() вызывается ДО проверки содержимого __dict__. В большинстве случаев нужен __getattr__().
А вообще, что ты пытаешься сделать?

Можно, если сделать допущение, что текст кодируется посимвольно, а не группами из N символов.

open_text = 'текст'  # открытый текст

# letters - именно строка, одна позиция - один символ
letters = ''.join(['а', 'б', 'в', 'г', 'д', 'е', 'ё', 'ж', 'з', 'и', 'й', 'к', 'л', 'м', 'н', 'о', 'п', 'р', 'с', 'т', 'у', 'ф',
       'х', 'ц', 'ч', 'ш', 'щ', 'ъ', 'ы', 'ь', 'э', 'ю', 'я'])
key = 5  # ключ к шифру - величина сдвига. Может быть >0 или <0
# генерируем таблицы подстановки
encrypt_table = str.maketrans(letters, letters[key:]+letters[:key])  # для шифрования
decrypt_table = str.maketrans(letters, letters[-key:]+letters[:-key])  # для дешифрования

cypher_text = open_text.translate(encrypt_table)
restored_text = cypher_text.translate(decrypt_table)

print(open_text)
print(cypher_text)
print(restored_text)

Ты упускаешь из виду, что современные страницы часто набиты скриптами, да и банальную необходимость авторизации на сайте. Иными словами, если ты через requests запросишь тот же URL, далеко не факт что ты получишь ту же самую страницу. Тут нужно само содержимое страницы вытаскивать. А оно может быть большое, так что лучше уж выбранный текст.
Это проще всего сделать через браузерное расширение. Альтернатива - добавить окошко/иконку на панель задач/в трей, куда можно будет перетащить выделенный текст.

В комментариях уже написали простое решение, а я его чуток разовью.

import typing as tp

Func = tp.Callable[[], None]  # функция без апарметров, возвращает None

class FuncMap:
  def __init__(self):
    self.map: tp.Dict[str, Func] = dict()

  def register(self, key: str) -> tp.Callable[[Func], Func]:
    def decorate(f: Func) -> Func:
      self.map[key] = f
      return f
    return decorate
  
  def get(self, key: str) -> Func:
    return self.map[key]
  
  def run(self, key: str):
    return self.map[key]()

# а вот так этот класс используется
fmap = FuncMap()

@fmap.register('11')
def test():
  print('This is test()')

fmap.run('11')

Потому что вызов thread.start() который внутри start_listen() - не блокирующий. Главный поток продолжит работу, выйдет из try-except и завершится, так что на момент возникновения KeyboardInterrupt он уже будет завершён. Твой поток не помечен как daemon, поэтому интерпретатор продолжит работу (был бы помечен - программа бы завершилась тут же).
Если ты делаешь join() - то пока запущенный поток не закончится, главный не продолжит работу.

Собственно, в текущем виде тебе поток вообще не нужен, у тебя главный поток ничего не делает и так, и так.
Что ты пытаешься сделать?

Очевидно, надо в каждом словаре найти значение, которое уникально идентифицирует соединение.
Я бы сказал, это пара IP:порт удаленного узла (с которым установлено соединение).
Не уверен, будет ли эта информация в словаре, так как ты не озаботился привести пример, и как это будет работать с UDP (где формальных соединений нет), но попытаться можно.

Импортируй файл MAIN до f().

Вообще, если я верно понял ситуацию, у тебя циклическая зависимость.
Это надо разруливать иначе.
Например, пусть f() получает ссылку на f_from_main_file как параметр.
Или, возможно, у тебя вообще неправильно распределены обязанности, и часть f_rom_main_file() на самом деле должна быть там же, где f().

Ну раз проблема в цикле for, то вместо for line in data: делай цикл вручную, например так:

while True:
    line = data.readline()
    if not line:
        break
    ...  # тут выполняем дальнейшие операции

Этот код полагается на тот факт, что чтение в конце файла вернёт пустую строку (а "пустая" строка в середине файла всё равно будет иметь хотя бы один символ - символ перевода строки).

Программа доходит до строки print(mydoubler(11)). Чтобы напечать результат выполнения функции mydoubler, программа вызывает эту функцию с аргументом 11, для этого программа идёт к строке mydoubler = myfunc(2).

Ну вот тут ты уже неправ. Программа не идёт назад по коду.

Сначала отрабатывает оператор def, определяющий функцию myfunc. После этого в текущей области видимости программы появляется переменная myfunc, хранящая ссылку на объект-функцию.
Затем отрабатывает строка mydoubler = myfunc(2). Происходит вызов функции myfunc, при этом ей передаётся объект-число 2 как параметр. Внутри локальной области видимости myfunc теперь есть имя a, ссылающееся на объект-число 2. В ходе выполнения создаётся лямбда-функция, которая ссылается на этот параметр.
Лямбда функция возвращается из myfunc, myfunc завершает выполнение. Поскольку лямбда-функция продолжает существовать (мы её вернули), а она ссылается на объект-число 2, то этот объект тоже продолжает существовать.
Возвращённая функция присваивается имени mydoubler в текущей области видимости. Это позволяет её продолжать существовать (её не собирает сборщик мусора), ну и позволяет её вызвать по этому имени.

Если бы ты сделал ещё один вызов, скажем, mytripler = myfunc(3), это бы создало новую, отдельную лямбда-функцию, совершенно независимую от mydoubler, и ссылающуюся на объект-число 3.

astunparse?

Указанная тобой библиотека использует другой плейсхолдер для указания значений параметров - не ? а %s.
Смотри пример в документации.