Bizarre Environment-dependent Bad Request 400 error

Question

I'm writing a program to convert a repository into a Docker with an API based on some specification files. When I run the app on my Macbook's base environment, the computer-generated API works perfectly with both gunicorn and uwsgi. However, within the miniconda-based docker container, it failed with Bad Request 400: The browser (or proxy) sent a request that this server could not understand. My goal is to eliminate this error. Obviously, this has to do with the versions of some dependency or set of dependencies. Interestingly, the last endpoint in the API, which has a request parser within a namespace with no arguments, works perfectly, unlike the two other endpoints in the default namespace that do have arguments.

The API is built on flask_restx and uses reqparse.

The API code is here:

from flask_restx import Api, Resource, Namespace, reqparse, inputs
import flask
import process
from load_data import store_data


app = flask.Flask("restful_api")
api = Api(app, title="My API", description="This is an extremely useful API for performing tasks you would do with an API.", version="3.14")
data = {}
data.update(store_data())


class DefaultClass():
    def __init__(self):
        self.data = data

    def _replace_get(self, **args):
        default_args = {}
        args = {**default_args, **args}
        return process.replace(**args)

    def _find_get(self, **args):
        default_args = {"data": self.data["data"]}
        args = {**default_args, **args}
        return process.find_in_data_string(**args)


def set_up_worker():
    global defaultClass
    defaultClass = DefaultClass()


set_up_worker()

_replaceGetParser = reqparse.RequestParser()
_replaceGetParser.add_argument("txt",
                               type=str,
                               required=True,
                               help="Text to search ")
_replaceGetParser.add_argument("old",
                               type=str,
                               required=True,
                               help="Substring to replace ")
_replaceGetParser.add_argument("new",
                               type=str,
                               required=True,
                               help="Replacement for old ")
_replaceGetParser.add_argument("irrelevant_parameter",
                               type=int,
                               required=False,
                               default=5,
                               help="")
_replaceGetParser.add_argument("smart_casing",
                               type=inputs.boolean,
                               required=False,
                               default=True,
                               help="True if we should infer replacement capitalization from original casing. ")
_replaceGetParser.add_argument("case_sensitive",
                               type=inputs.boolean,
                               required=False,
                               default=True,
                               help="True if we should only replace case-sensitive matches ")

_findGetParser = reqparse.RequestParser()
_findGetParser.add_argument("window",
                            type=int,
                            required=False,
                            default=5,
                            help="Number of characters before and after first match to return ")
_findGetParser.add_argument("txt",
                            type=str,
                            required=False,
                            default="quick",
                            help="Your search term ")


@api.route('/replace', endpoint='replace', methods=['GET'])
@api.doc('defaultClass')
class ReplaceFrontend(Resource):

    @api.expect(_replaceGetParser)
    def get(self):
        args = _replaceGetParser.parse_args()
        return defaultClass._replace_get(**args)


@api.route('/find', endpoint='find', methods=['GET'])
@api.doc('defaultClass')
class FindFrontend(Resource):

    @api.expect(_findGetParser)
    def get(self):
        args = _findGetParser.parse_args()
        return defaultClass._find_get(**args)


retrievalNamespace = Namespace("retrieval", description="Data retrieval operations")


class RetrievalNamespaceClass():
    def __init__(self):
        self.data = data

    def _retrieval_retrieve_data_get(self, **args):
        default_args = {"data": self.data["data"]}
        args = {**default_args, **args}
        return process.return_data(**args)


def set_up_retrieval_worker():
    global retrievalNamespaceClass
    retrievalNamespaceClass = RetrievalNamespaceClass()


set_up_retrieval_worker()

_retrieval_retrieve_dataGetParser = reqparse.RequestParser()


@retrievalNamespace.route('/retrieval/retrieve_data', endpoint='retrieval/retrieve_data', methods=['GET'])
@retrievalNamespace.doc('retrievalNamespaceClass')
class Retrieval_retrieve_dataFrontend(Resource):

    @retrievalNamespace.expect(_retrieval_retrieve_dataGetParser)
    def get(self):
        args = _retrieval_retrieve_dataGetParser.parse_args()
        return retrievalNamespaceClass._retrieval_retrieve_data_get(**args)
api.add_namespace(retrievalNamespace)

I have had this problem with both pip-installed gunicorn and conda-installed uwsgi. I'm putting the file imported by the API at the end, since I think it is likely irrelevant what the function definitions are.

import numpy as np
import pandas as pd
import re
from subprocess import Popen, PIPE
from flask_restx import abort


def replace(txt: str = '',  # apireq
            old: str = '',   # apireq
            new: str = '',  # apireq
            case_sensitive: bool = True,
            smart_casing: bool = True,
            irrelevant_parameter: int = 5):
    """
    Search and replace within a string, as long as the string and replacement
    contain no four letter words.

    arguments:
      txt: Text to search
      old: Substring to replace
      new: Replacement for old
      case_sensitive: True if we should only replace case-sensitive matches
      smart_casing: True if we should infer replacement capitalization
        from original casing.


    return
      return value
    """
    four_letter_words = [re.match('[a-zA-Z]{4}$', word).string
                         for word in ('%s %s' % (txt, new)).split()
                         if re.match('[a-zA-Z]{4}$', word)]
    if four_letter_words:
        error_message = ('Server refuses to process four letter word(s) %s'
                         % ', '.join(four_letter_words[:5])
                         + (', etc' if len(four_letter_words) > 5 else ''))
        abort(403, custom=error_message)
    return_value = {}
    if not case_sensitive:
        return_value['output'] = txt.replace(old, new)
    else:
        lowered = txt.replace(old, old.lower())
        return_value['output'] = lowered.replace(old.lower(), new)
    return return_value


def find_in_data_string(txt: str = "quick",  # req
                        window: int = 5,
                        data=None):  # noapi
    """
    Check if there is a match for your search string in our extensive database,
    and return the position of the first match with the surrounding text.

    arguments:
      txt: Your search term
      data: The server's text data
      window: Number of characters before and after first match to return
    """
    return_value = {}
    if txt in data:
        idx = data.find(txt)
        min_idx = max(idx-window, 0)
        max_idx = min(idx+len(txt)+window, len(data)-1)
        return_value['string_found'] = True
        return_value['position'] = idx
        return_value['surrounding_string'] = data[min_idx:max_idx]
        return_value['surrounding_string_indices'] = [min_idx, max_idx]
    else:
        return_value = {['string_found']: False}
    return return_value


def return_data(data=None):  # noapi
    """
    Return all the data in our text database.
    """
    with Popen(['which', 'aws'], shell=True, stdout=PIPE) as p:
        output = p.stdout.read()
    try:
        assert not output.strip()
    except AssertionError:
        abort(503, custom='The server is incorrectly configured.')
    return_value = {'data': data}
    return return_value