500 urlopen error

The following code:

   req = urllib.request.Request(url=r"http://borel.slu.edu/cgi-bin/cc.cgi?foirm_ionchur=im&foirm=Seol&hits=1&format=xml",headers={'User-Agent':' Mozilla/5.0 (Windows NT 6.1; WOW64; rv:12.0) Gecko/20100101 Firefox/12.0'})
   handler = urllib.request.urlopen(req)

is giving me the following exception:

Traceback (most recent call last):
  File "C:/Users/Foo/lang/old/test.py", line 46, in <module>
    rip()
  File "C:/Users/Foo/lang/old/test.py", line 36, in rip
    handler = urllib.request.urlopen(req)
  File "C:Python32liburllibrequest.py", line 138, in urlopen
    return opener.open(url, data, timeout)
  File "C:Python32liburllibrequest.py", line 375, in open
    response = meth(req, response)
  File "C:Python32liburllibrequest.py", line 487, in http_response
    'http', request, response, code, msg, hdrs)
  File "C:Python32liburllibrequest.py", line 413, in error
    return self._call_chain(*args)
  File "C:Python32liburllibrequest.py", line 347, in _call_chain
    result = func(*args)
  File "C:Python32liburllibrequest.py", line 495, in http_error_default
    raise HTTPError(req.full_url, code, msg, hdrs, fp)
urllib.error.HTTPError: HTTP Error 500: Internal Server Error

but it works fine in my browser, whats the issue?

I’m getting an intermittent errors (`urllib.error.HTTPError: HTTP Error 500: Internal Server Error` & `pyactiveresource.connection.ServerError: Internal Server`), when trying to save a new order. I’m using `ShopifyAPI==3.1.0`

Here is the traceback that I’m seeing in the logs:

Traceback (most recent call last):
File "/usr/local/lib/python3.6/dist-packages/pyactiveresource/connection.py", line 286, in _open
http_response = self._handle_error(self._urlopen(request))
File "/usr/local/lib/python3.6/dist-packages/pyactiveresource/connection.py", line 316, in _urlopen
return urllib.request.urlopen(request, timeout=self.timeout)
File "/usr/lib/python3.6/urllib/request.py", line 223, in urlopen
return opener.open(url, data, timeout)
File "/usr/lib/python3.6/urllib/request.py", line 532, in open
response = meth(req, response)
File "/usr/lib/python3.6/urllib/request.py", line 642, in http_response
'http', request, response, code, msg, hdrs)
File "/usr/lib/python3.6/urllib/request.py", line 570, in error
return self._call_chain(*args)
File "/usr/lib/python3.6/urllib/request.py", line 504, in _call_chain
result = func(*args)
File "/usr/lib/python3.6/urllib/request.py", line 650, in http_error_default
raise HTTPError(req.full_url, code, msg, hdrs, fp)
urllib.error.HTTPError: HTTP Error 500: Internal Server Error
During handling of the above exception, another exception occurred:
Traceback (most recent call last):
File "/var/www/html/shopifyapp/util.py", line 252, in create_shopify_order
order.save()
File "/usr/local/lib/python3.6/dist-packages/pyactiveresource/activeresource.py", line 824, in save
data=self.encode())
File "/usr/local/lib/python3.6/dist-packages/pyactiveresource/connection.py", line 364, in post
return self._open('POST', path, headers=headers, data=data)
File "/usr/local/lib/python3.6/dist-packages/shopify/base.py", line 23, in _open
self.response = super(ShopifyConnection, self)._open(*args, **kwargs)
File "/usr/local/lib/python3.6/dist-packages/pyactiveresource/connection.py", line 288, in _open
http_response = self._handle_error(err)
File "/usr/local/lib/python3.6/dist-packages/pyactiveresource/connection.py", line 418, in _handle_error
raise ServerError(err)
pyactiveresource.connection.ServerError: Internal Server Error

When I retry that I end up with double orders.

I’ve been troubleshooting my RPi and I keep getting an internal 500 error in my errors.log for a script written in python. I actually get 2 errors in the logs, wondering how I would go about fixing them

@berryGate:~/usb-scanner $ tail errors.log
2017-08-01 08:02:13 [URL Error] While sending data to remote Server: <urlopen error [Errno -5] No address associated with hostname>
2017-08-01 09:20:56 [HTTP Error]    While sending data to remote Server: HTTP Error 500: Internal Server Error
2017-08-01 12:12:22 [HTTP Error]    While sending data to remote Server: HTTP Error 500: Internal Server Error
2017-08-01 13:01:42 [HTTP Error]    While sending data to remote Server: HTTP Error 500: Internal Server Error

So it’s 2 errors, the HTTP and URL error -5.

Ok so the Script is written in python

Stack
DigitalOcean VPS: Ubuntu 16.04 (32 bit due to low VPS resources), Python3, Django, PostgreSQL, Gunicorn, NGINX

Stack info and build

The script authenticates to a server and allows pass to a security gate. It is working, both entrance and exit, but sometimes it will stick and i fear its due to this error. I did not write this code, and I don’t code, so im just trying to do the best I can.

Here is the beginning and end of the script. Please let me know if there’s a better way for me to post this.

#!/usr/bin/python3

    -Listens continuously for two usb scanner located in /dev/input/by-path/
-A correct scanner code must meet the following criteria:
        * Starts with one of <CODE_PREFIXES>
        * Ends with <TERMINATION_CHAR>
        * #<CODE_PREFIX> + #code + #<TERMINATION_CHAR> = 1 + <CODE_LENGTH> + 1 (                                                                                        # = length of)
-All cought errors will get logged in a specified file
-A local database will be fetched from the remote server and kept updated every                                                                                         x minutes
-Offers buttons to restart the RPI, power off the RPI, and updating local databa                                                                                        se
"""


import struct

import sys

import os, os.path

import time

import datetime

import json

import urllib.parse, urllib.request, urllib.error
from threading import Thread, Event

import pifacedigitalio as piface


# GLOBALS
RELAY_ONE = 0
RELAY_TWO = 1
CUR_PATH = os.path.abspath(os.path.dirname(__file__))
error_occurred = False
debug_loop_funcs = []



 ###### THIS HAS BEEN SHORTENED TO THE END######

        try:
            with open(DATABASE_PATH) as f:
                self.database = json.load(f)
        except FileNotFoundError as e:
            with open(DATABASE_PATH, 'w') as f:
                pass
        except json.decoder.JSONDecodeError as e:
            logError("JSON", "Local database is not valid JSON")

    def writeDatabase(self):
        with open(DATABASE_PATH, 'w') as f:
            json.dump(self.database, f)

    def updateDatabase(self):
        dprint(1, "Updating database...")
        data = {"key": self.server.api_key}
        success = False
        try:
            response = json.loads(self.server.get(SERVER_DATABASE_PATH, data))
            success = True
            if self.checkResponse(response) is not None:
                self.database = response["data"]
        except Server.HTTPError as e:
            logError("HTTP Error", "On remote database update query: %s" %e)
        except Server.URLError as e:
            logError("URL Error", "On remote database update query: %s" %e)
        except json.decoder.JSONDecodeError as e:
            logError("JSON", "Remote database is not valid JSON")

        return success

    def onReceiveCode(self, name, full_code, stripped_code, filename):
        granted = False
        if stripped_code in self.database:
            granted = True
            Thread(target=toggleRelay, args=(CODE_PREFIXES[name][1],)).start()

        data = {
            "key" : self.server.api_key,
            "gate" : name,
            "code" : stripped_code,
            "timestamp" : datetime.datetime.fromtimestamp(time.time()).strftime(                                                                                        "%Y-%m-%d %H:%M:%S"),
            "allow" : granted
        }
        dprint(1, "[%s]: %s | %s | Access granted: %s" %(name, full_code, filena                                                                                        me, granted))

        try:
            response = json.loads(self.server.send(SERVER_ADD_PATH, data))
            self.checkResponse(response)
        except Server.HTTPError as e:
            logError("HTTP Error", "While sending data to remote Server: %s" %e)
        except Server.URLError as e:
            logError("URL Error", "While sending data to remote Server: %s" %e)
        except json.decoder.JSONDecodeError as e:
            logError("JSON", "Remote server response is not valid JSON")

    def onConnectScanner(self, name, filename):
        dprint(1, "[%s] connected! (%s)" %(name, filename))

    def onDisconnectScanner(self, name, filename):
        dprint(1, "[%s] disconnected! (%s)" %(name, filename))

    def checkResponse(self, response):
        if response["status"] == "success":
            return response
        logError("Server", response["msg"])
        return None


if __name__ == "__main__":
    lf = [] if not DEBUG else debug_loop_funcs
    with Main(loop_funcs=lf) as m:
        pass

Requests — это модуль для языка Python, который используют для упрощения работы с HTTP-запросами. Он удобнее и проще встроенного Urllib настолько, что даже в документации Python рекомендовано использовать Requests.

Установка библиотеки Requests

Самый простой вариант установки сторонних пакетов в Python — использовать pip — систему управления пакетами. Обычно pip предустанавливается вместе с интерпретатором. Если его нет — можно скачать. Для этого нужно ввести в командную строку:

Linux / MacOS

python -m ensurepip --upgrade

Windows

py -m ensurepip --upgrade

Когда pip установлен, для установки модуля Requests нужно ввести команду:

pip install requests

Как настроить библиотеку Requests. Библиотека не требует дополнительной настройки — ею можно сразу же пользоваться.

Начало работы. Давайте рассмотрим пример простейшего запроса в модуле Requests:

import requests # делаем запрос на чтение страницы https://sky.pro/media/
response = requests.get('https://sky.pro/media/')
print(response.ok)  # проверяем успешен ли запрос?
print(response.text)  # выводим полученный ответ на экран

А вот как сделать то же самое, но при помощи встроенной библиотеки Urllib:

from urllib.request import urlopen

# открываем запрос на чтение страницы http://sky.pro/media
with urlopen('http://sky.pro/media') as response:
   response_status = response.status  # сохраняем статус запроса в переменную
   html = response.read()  # вычитываем ответ в переменную

print(response_status == 200)  # проверяем успешен ли запрос
print(html.decode())  # выводим полученный ответ на экран

Модуль Requests в Python упрощает и автоматизирует многие действия, которые в стандартной библиотеке надо делать самостоятельно. Именно за это её любят и используют многие разработчики.

Давайте разберёмся, как работать с Requests, и из чего состоят HTTP-запросы.

Методы HTTP-запросов

HTTP — это протокол передачи информации в интернете. Он описывает правила и формат общения между двумя сторонами. Например, как браузеру описать запрос, а серверу — сформировать ответ. HTTP — это текстовый протокол, поэтому его может прочитать и человек.

Давайте разберем простейший запрос:

GET /media/ HTTP/1.1
Host: sky.pro

Первая строка формирует запрос: мы говорим серверу, что хотим прочитать (GET) ресурс по адресу /media/. В конце указывается версия протокола: HTTP/1.1.

Начиная со второй строки передается дополнительная информация, которая называется заголовками. Она опциональная — кроме заголовка Host. Он указывает домен, на котором находится запрашиваемый ресурс.

HTTP-ответ выглядит аналогично:

HTTP/1.1 200 OK
Content-Type: text/html
<тело ответа>

В первой строке указывается версия протокола и код ответа — статус, который описывает результат запроса. В следующих строках, так же, как и в запросе, перечисляются заголовки. В данном случае сервер говорит, что в ответе находится HTML-страница (Content-Type: text/html).

И в самом конце находится тело ответа: файл, HTML-страница или ничего. Браузер отрисовывает тело ответа — это уже то, что видит человек, когда загружает страницу.

Методы HTTP-запросов нужны, чтобы объяснить серверу, какое действие мы хотим совершить над ресурсом. Ресурс — это цель HTTP-запроса. Это может быть документ, фотография или просто веб-страница.

Разберем на примерах распространённые методы — в чём их суть и чем они отличаются. Важно: ниже разбираются механизмы работы каждого метода в том виде, в котором они описаны в спецификации. На практике поведение может отличаться, но такое встречается нечасто.

OPTIONS

Метод OPTIONS нужен, чтобы спросить сервер о том, какие методы поддерживает ресурс. Он редко используется напрямую, обычно вызывается браузером автоматически. Поддерживается не всеми сайтами/ресурсами. Пример:

HTTP-ответ выглядит аналогично:

import requests
response = requests.options('https://httpbin.org')
print(response.text)  # будет пустым
print(response.headers['Allow'])  # 'HEAD, GET, OPTIONS'

GET

GET — самый распространённый HTTP-метод. Его используют для чтения интернет-ресурса. Браузер отправляет метод GET, когда мы открываем какой-либо сайт. Пример:

import requests
response = requests.get('https://httpbin.org/get')
print(response.text)

POST

Метод POST используют для отправки на сервер данных, которые передаются в теле запроса. Для этого при вызове requests.post() надо указать аргумент data, который принимает на вход словарь, список кортежей, байты или файл.

Если для передачи данных используется формат JSON, вместо data можно указать json. Это просто удобная конвенция, которая правильно формирует отправляемый запрос. Пример:

import requests
data_response = requests.post('https://httpbin.org/post', data={'foo': 'bar'})
print(data_response.text)  # переданные данные находятся по ключу form
json_response = requests.post('https://httpbin.org/post', json={'foo': 'bar'})
print(data_response.text)  # ключ form пустой, теперь данные лежат в json

HEAD

Этот метод очень похож на GET — с той лишь разницей, что HEAD возвращает пустое тело ответа. Он нужен, когда нужно посмотреть только на заголовки, не загружая ответ целиком.

Например, мы хотим иметь свежую версию PDF-файла с расписанием автобусов. Файл хранится на каком-то сайте и периодически обновляется. Вместо того, чтобы каждый раз скачивать и сверять файл вручную, можно использовать метод HEAD. Он поможет быстро проверить дату изменения файла по заголовкам ответа.

import requests
response = requests.get('https://httpbin.org/head')
print(response.text)  # ответ будет пустым
print(response.headers)

PUT

Метод PUT очень похож на POST — с той разницей, что несколько последовательных вызовов PUT должны приводить к одному и тому же результату.

POST этого не гарантирует и может привести к неожиданным результатам, например к дублированию созданной сущности.

import requests
response = requests.put('https://httpbin.org/put', data={'foo': 'bar'})
print(response.text)

PATCH

PATCH аналогичен методу POST, но с двумя отличиями: он используется для частичных изменений ресурса и его нельзя использовать в HTML-формах.

В теле запроса передается набор модификаций, которые надо применить.

import requests
response = requests.patch('https://httpbin.org/patch', data={'foo': 'bar'})
print(response.text)

DELETE

Метод используется для удаления ресурса. Поддерживает передачу данных, однако не требует её: тело запроса может быть пустым.

Как и PUT, последовательный вызов DELETE должен приводить к одному и тому же результату.

import requests
response = requests.delete('https://httpbin.org/delete')
print(response.text)

HTTP-коды состояний

Каждый ответ HTTP-запроса обязательно имеет код состояния — трехзначное число, которое как-то характеризует полученный результат. По этому коду можно понять, всё ли успешно отработало, и если произошла ошибка, то почему.

Всего выделяют пять групп кодов состояний:

1хх-коды.

К этой группе относятся информационные коды состояний. Они сообщают клиенту о промежуточном статусе запроса и не являются финальным результатом.

Их немного, и останавливаться на них мы не будем, потому что они встречаются нечасто.

2хх-коды.

Коды из этой группы означают, что запрос принят и обработан сервером без ошибок:

• 200 OK — запрос выполнен успешно. Чаще всего встречается именно это число.
• 201 Created — в результате запроса был создан новый ресурс. Как правило, этим кодом отвечают на POST- и иногда PUT-запросы.
• 202 Accepted — запрос принят, но ещё не выполнен. Используется, когда по какой-то причине сервер не может выполнить его сразу. Например, если обработку делает какой-то сторонний процесс, который выполняется раз в день.
• 204 No Content — указывает, что тело ответа пустое, но заголовки могут содержать полезную информацию. Не используется с методом HEAD, поскольку ответ на него всегда должен быть пустым.

3хх-коды.

Это группа кодов перенаправления. Это значит, что клиенту нужно сделать какое-то действие, чтобы запрос продолжил выполняться:

• 301 Moved Permanently — URL запрашиваемого ресурса изменился, новый URL содержится в ответе.
• 302 Found — аналогичен предыдущему коду. Отличие в том, что URL изменился временно. При этом статусе состояния поисковые системы не будут менять ссылку в своей поисковой выдаче на новую.
• 304 Not Modified — означает, что содержимое ресурса было закешировано, его содержимое не поменялось и запрос можно не продолжать.

4хх-коды.

Это коды ошибок, которые допустил клиент при формировании запроса:

• 400 Bad Request — запрос сформирован с ошибкой, поэтому сервер не может его обработать. Причин может быть много, но чаще всего ошибку надо искать в теле запроса.
• 401 Unauthorized — для продолжения необходимо залогиниться.
• 403 Forbidden — пользователь залогинен, но у него нет прав для доступа к ресурсу.
• 404 Not Found — всем известный код: страница не найдена. Некоторые сайты могут возвращать 404 вместо 403, чтобы скрыть информацию от неавторизованных пользователей.
• 405 Method Not Allowed — данный ресурс не поддерживает метод запроса. Например, так бывает, если разработчик хочет отправить PUT-запрос на ресурс, который его не поддерживает.
• 429 Too Many Requests — означает, что сработал защитный механизм: он ограничивает слишком частые запросы от одного пользователя. Таким образом защищаются от DDoS- или brute-force-атак.

5хх-коды.

Это ошибки, которые возникли на сервере во время выполнения запроса:

• 500 Internal Server Error — на сервере произошла неожиданная ошибка. Как правило, происходит из-за того, что в коде сервера возникает исключение.
• 502 Bad Gateway — возникает, если на сервере используется обратный прокси, который не смог достучаться до приложения.
• 503 Service Unavailable — сервер пока не готов обработать запрос. В ответе также может содержаться информация о том, когда сервис станет доступен.
• 504 Gateway Timeout — эта ошибка означает, что обратный прокси не смог получить ответ за отведенное время (обычно — 60 секунд).

Заголовки, текст ответа и файлы Cookie

Теперь рассмотрим, как работать с запросами и ответами в Requests. Чтобы увидеть результат HTTP-запроса, можно использовать один из трех способов.

Выбор способа зависит от того, какие данные мы получили. В непонятной ситуации можно использовать атрибут text, который возвращает содержимое в виде строки:

import requests
response = requests.get('https://httpbin.org/get')
print(response.text)

Если заранее известно, что ответ будет в формате JSON, можно использовать одноименный атрибут, который автоматически распарсит ответ и вернет его в виде словаря:

json_response = response.json()
print(json_response)

Обратите внимание, как изменится вывод функции print().

Наконец, если ответом на запрос является файл, стоит использовать атрибут content, который возвращает байты:

import requests
response = requests.get('https://httpbin.org/image/jpeg')
print(response.content)

Попробуйте вывести на экран response.text для предыдущего запроса и сравните результат.

Заголовок — это дополнительная информация, которой обмениваются клиент и сервер. В заголовках могут содержаться: размер ответа (Content-Length), формат передаваемых данных (Content-Type) или информация о клиенте (User-Agent).

Полный список очень длинный, знать их все необязательно, а часть и вовсе подставляется автоматом. Например, модуль Requests зачастую сам проставляет Content-Type — формат передаваемых данных.

Заголовок состоит из названия и значения, которые разделяются двоеточием, поэтому удобнее всего передавать их в виде словаря. Рассмотрим на примере, как это работает:

import requests
response = requests.get('https://httpbin.org/image', headers={'Accept': 'image/jpeg'})
print(response.headers)

Здесь мы передали заголовок, который указывает, в каком формате мы хотим получить изображение. Попробуйте поменять значение на image/png и посмотрите, как изменится ответ.

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

print(response.request.headers)

Обратите внимание, что Requests сам подставил информацию о клиенте — User-Agent.

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

Работать с куками в модуле Requests очень просто:

import requests
response = requests.get('https://httpbin.org/cookies', cookies={'foo': 'bar'})
print(response.text)

Посмотреть, какие куки пришли от сервера, можно при помощи атрибута cookies объекта Response:

print(response.cookies)

Как отправлять запросы при помощи Python Requests

Рассмотрим несколько частых примеров использования модуля Requests, чтобы понять, как отправлять запросы.

Скачивание файлов

import requests
response = requests.get('https://www.python.org/static/img/python-logo.png')
with open('python_logo.png', 'wb') as image:
    image.write(response.content)

Выше описан не самый эффективный способ скачивания файлов. Если файл окажется большого размера, код выше загрузит результат целиком в оперативную память. В лучшем случае программа упадет с ошибкой, в худшем — всё намертво зависнет.

Вот как это можно исправить:

import requests
response = requests.get('https://www.python.org/static/img/python-logo@2x.png', stream=True)

with open('python_logo.png', 'wb') as image:
    for chunk in response.iter_content(chunk_size=1024):
        image.write(chunk)

В этом варианте мы используем параметр stream=True, который открывает соединение, но не скачивает содержимое. Затем мы задаем размер чанка — кусочка информации, который будет скачиваться за одну итерацию цикла, и делаем его равным 1 Кб (1024 байт). Модуль Requests сам закрывает соединение после прочтения последнего чанка.

Чтобы заранее узнать размер файла, можно воспользоваться методом HEAD. Эта информация передается в заголовке ‘Content-Length’ и исчисляется в байтах.

import requests
head_response = requests.head('https://www.python.org/static/img/python-logo@2x.png')
image_size = int(head_response.headers['Content-Length'])
print('Размер загружаемого файла: {0} кб'.format(image_size / 1024))

Авторизация на сайте

Рассмотрим два способа авторизации, которые встречаются чаще всего: Basic Auth и Bearer Auth. В обоих случаях механизм очень похожий — запрос должен передать заголовок ‘Authorization’ с каким-то значением. Для Basic Auth — это логин и пароль, закодированные в base64, для Bearer — токен, который мы получили на сайте заранее.

Для базовой авторизации у модуля Requests есть очень удобный параметр auth=, который делает всю работу за нас:

import requests
response = requests.get('https://httpbin.org/basic-auth/foo/bar')
print(response.status_code)  # 401
response = requests.get('https://httpbin.org/basic-auth/foo/bar', auth=('foo', 'bar'))
print(response.status_code)  # 200
print(response.request.headers[‘Authorization’])  # 'Basic Zm9vOmJhcg=='

Обратите внимание, что модуль Requests сам добавил заголовок Authorization и подставил туда закодированные логин и пароль.

Для Bearer Auth нам придется добавлять его самостоятельно:

import requests
response = requests.get('https://httpbin.org/bearer')
print(response.status_code)  # 401
headers = {'Authorization': 'Bearer some_token'}
response = requests.get('https://httpbin.org/bearer', headers=headers)
print(response.status_code)  # 200

У каждого API своя спецификация — вместо Bearer может быть Token или что-то другое. Поэтому важно внимательно читать документацию сервиса.

Мультискачивание

Напишем код, который умеет скачивать сразу несколько файлов. Для этого вынесем работу с модулем Requests в отдельную функцию и параметризируем место сохранения файла.

Не забывайте про сохранение файла по чанкам, чтобы крупные файлы не загружались в память целиком.

import requests
def download_file(url, save_path):
    response = requests.get(url, stream=True)
    with open(save_path, 'wb') as file:
        for chunk in response.iter_content(chunk_size=1024):
            file.write(chunk)
download_list = [
    'https://cdn.pixabay.com/photo/2022/04/10/19/33/house-7124141_1280.jpg',
    'https://cdn.pixabay.com/photo/2022/08/05/18/50/houseplant-7367379_1280.jpg',
    'https://cdn.pixabay.com/photo/2022/06/09/04/53/ride-7251713_1280.png',
]

for url in download_list:
    save_path = url.split('/')[-1]
    download_file(url, save_path)

Заключение

Модуль Requests — мощный инструмент, с которым разработчик может сделать сложный HTTP-запрос всего в пару строк. У него интуитивно понятный интерфейс, поэтому он так популярен в сообществе Python.

С помощью модуля реквест можно выполнить множество функций: от авторизации на сайте до скачивания нескольких файлов одновременно.

1. None поправил
2. timeout=0.001 — без этого параметра ошибка такая же

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

@app.route('/node', methods=['GET', 'POST'])
def node():
    response = {
            'send adress': request.form['key1'],
            'send atom': request.form['key2'],
        }
    return jsonify(response), 200
 
 
@app.route('/post', methods=['GET', 'POST'])
def post_to_node():
    base_url = "http://localhost:5000/node"
    payload = {'key1': 'value1', 'key2': 'value2'}
    response = requests.post(base_url, data=payload, timeout=0.001)
    #response = requests.get(base_url, data=payload, timeout=0.001)
    res = response.text
    if print(response.text) is not None:
        res = response.text
    else:
        res = 'none'
    return  print(res)# TEXT/HTML

Добавлено через 3 минуты
Лог ошибки:

Добавлено через 2 минуты
если таймаут убрать, страница бесконечно пытается грузится с пустым экраном