Ошибка 400 flask

import sentry_sdk
from sentry_sdk.integrations.flask import FlaskIntegration

sentry_sdk.init('YOUR_DSN_HERE', integrations=[FlaskIntegration()])

@app.errorhandler(werkzeug.exceptions.BadRequest)
def handle_bad_request(e):
    return 'bad request!', 400

# or, without the decorator
app.register_error_handler(400, handle_bad_request)

class InsufficientStorage(werkzeug.exceptions.HTTPException):
    code = 507
    description = 'Not enough storage space.'

app.register_error_handler(InsufficientStorage, handle_507)

raise InsufficientStorage()

from flask import json
from werkzeug.exceptions import HTTPException

@app.errorhandler(HTTPException)
def handle_exception(e):
    """Return JSON instead of HTML for HTTP errors."""
    # start with the correct headers and status code from the error
    response = e.get_response()
    # replace the body with JSON
    response.data = json.dumps({
        "code": e.code,
        "name": e.name,
        "description": e.description,
    })
    response.content_type = "application/json"
    return response

from werkzeug.exceptions import HTTPException

@app.errorhandler(Exception)
def handle_exception(e):
    # pass through HTTP errors
    if isinstance(e, HTTPException):
        return e

    # now you're handling non-HTTP exceptions only
    return render_template("500_generic.html", e=e), 500

from flask import abort, render_template, request

# a username needs to be supplied in the query args
# a successful request would be like /profile?username=jack
@app.route("/profile")
def user_profile():
    username = request.arg.get("username")
    # if a username isn't supplied in the request, return a 400 bad request
    if username is None:
        abort(400)

    user = get_user(username=username)
    # if a user can't be found by their username, return 404 not found
    if user is None:
        abort(404)

    return render_template("profile.html", user=user)

from flask import render_template

@app.errorhandler(404)
def page_not_found(e):
    # note that we set the 404 status explicitly
    return render_template('404.html'), 404

from flask import Flask, render_template

def page_not_found(e):
  return render_template('404.html'), 404

def create_app(config_filename):
    app = Flask(__name__)
    app.register_error_handler(404, page_not_found)
    return app

{% extends "layout.html" %}
{% block title %}Page Not Found{% endblock %}
{% block body %}
  <h1>Page Not Found</h1>
  <p>What you were looking for is just not there.
  <p><a href="{{ url_for('index') }}">go somewhere nice</a>
{% endblock %}

{% extends "layout.html" %}
{% block title %}Internal Server Error{% endblock %}
{% block body %}
  <h1>Internal Server Error</h1>
  <p>Oops... we seem to have made a mistake, sorry!</p>
  <p><a href="{{ url_for('index') }}">Go somewhere nice instead</a>
{% endblock %}

from flask import render_template

@app.errorhandler(500)
def internal_server_error(e):
    # note that we set the 500 status explicitly
    return render_template('500.html'), 500

from flask import Flask, render_template

def internal_server_error(e):
  return render_template('500.html'), 500

def create_app():
    app = Flask(__name__)
    app.register_error_handler(500, internal_server_error)
    return app

from flask import Blueprint

blog = Blueprint('blog', __name__)

# as a decorator
@blog.errorhandler(500)
def internal_server_error(e):
    return render_template('500.html'), 500

# or with register_error_handler
blog.register_error_handler(500, internal_server_error)

from flask import jsonify, render_template

# at the application level
# not the blueprint level
@app.errorhandler(404)
def page_not_found(e):
    # if a request is in our blog URL space
    if request.path.startswith('/blog/'):
        # we return a custom blog 404 page
        return render_template("blog/404.html"), 404
    else:
        # otherwise we return our generic site-wide 404 page
        return render_template("404.html"), 404

@app.errorhandler(405)
def method_not_allowed(e):
    # if a request has the wrong method to our API
    if request.path.startswith('/api/'):
        # we return a json saying so
        return jsonify(message="Method Not Allowed"), 405
    else:
        # otherwise we return a generic site-wide 405 page
        return render_template("405.html"), 405

from flask import abort, jsonify

@app.errorhandler(404)
def resource_not_found(e):
    return jsonify(error=str(e)), 404

@app.route("/cheese")
def get_one_cheese():
    resource = get_resource()

    if resource is None:
        abort(404, description="Resource not found")

    return jsonify(resource)

from flask import jsonify, request

class InvalidAPIUsage(Exception):
    status_code = 400

    def __init__(self, message, status_code=None, payload=None):
        super().__init__()
        self.message = message
        if status_code is not None:
            self.status_code = status_code
        self.payload = payload

    def to_dict(self):
        rv = dict(self.payload or ())
        rv['message'] = self.message
        return rv

@app.errorhandler(InvalidAPIUsage)
def invalid_api_usage(e):
    return jsonify(e.to_dict()), e.status_code

# an API app route for getting user information
# a correct request might be /api/user?user_id=420
@app.route("/api/user")
def user_api(user_id):
    user_id = request.arg.get("user_id")
    if not user_id:
        raise InvalidAPIUsage("No user id provided!")

    user = get_user(user_id=user_id)
    if not user:
        raise InvalidAPIUsage("No such user!", status_code=404)

    return jsonify(user.to_dict())

Issue

I intend to send a video to a flask server with the post request sent from an android application. I get this error

werkzeug.exceptions.BadRequestKeyError: 400 Bad Request: The browser (or proxy) sent a request that this server could not understand.
KeyError: 'file'

Below is the python code for the flask server. Note that I am trying to get the content of the files (MultiDict) for debugging purpose using the for loop. I get no output on the powershell window. Also, since the error is KeyError: 'file', I understand that the files variable is null?

from flask import Flask, request, jsonify

path_upload_folder = 'C:\Users\vishw\Desktop\cse535a3_uploads\uploads'

app = Flask(__name__)
app.config['path_upload_folder'] = path_upload_folder
@app.route('/mainapp', methods=['GET', 'POST'])
def upload_video():
    print('Started')
    if request.method == 'POST':
        keys = request.files.keys()
        for each in keys:
            print(each)
        sent_file = request.files['file']
        sent_file.save(app.config['path_upload_folder'] + '\' + secure_filename(sent_file.filename))
        return jsonify(operation_status="true")
    return jsonify(operation_status="false")

app.run(host="0.0.0.0", port=5000, debug=True)

Here is the relevant code for the android application

public class ExampleGesture extends AppCompatActivity {
    private final int VIDEO_CAPTURE = 1;
    private VideoView example_gesture;
    private boolean captured_video = false;
    private MediaType object_mediatype;
    private Intent intent_record_video;
    private File file_media;
    private String name_file;
    private String gesture_received;
    private String address_server_ipv4;
    private String port_number;
    private String posturl;
    private int count_files = -1;
    private int [] count_practice; //= ((MainApplication)getApplication()).count_practice;
    private HashMap links;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_example_gesture);
//        Log.i("APP: ", getApplication().getClass().getSimpleName());
        Log.i("EG: ", "Under Super");
        Log.i("EXAMACTTHREAD: ", String.valueOf((Thread.currentThread()).getId()));
        Context context_current = getApplicationContext();
        new Thread(new Runnable() {
            public void run() {
              Log.i("EXAMACTTHREADNEW: ", String.valueOf((Thread.currentThread()).getId()));
//                Log.i("EG: ", "Setting COntent View");
                count_practice = ((MainApplication)getApplication()).count_practice;
                Intent intent_current = getIntent();
                String gesture = intent_current.getStringExtra("EXTRA_GESTURE");
                gesture_received = gesture;
                ArrayAdapter<CharSequence> arrayAdapter_gestures = ArrayAdapter.createFromResource(context_current,
                        R.array.list_gestures,
                        android.R.layout.simple_spinner_item);
//              Log.i("ARRAY: ", String.valueOf(arrayAdapter_gestures.getCount()));
                links = new HashMap();
                for (int index = 0; index < arrayAdapter_gestures.getCount(); ++index) {
//                  Log.i("ARRAY: ", (arrayAdapter_gestures.getItem(index)).toString());
                    if (!((arrayAdapter_gestures.getItem(index)).toString().equals("Select Gesture"))) {
                        links.put((arrayAdapter_gestures.getItem(index)).toString(), 0);
                    }
                }
//              Log.i("GESTURE: ", gesture);
                String path_file = "/sdcard/Movies/";
                if (gesture == "FanUp") {
                    path_file = path_file + "H-IncreaseFanSpeed.mp4";
                } else if (gesture == "FanDown") {
                    path_file = path_file + "H-DecreaseFanSpeed.mp4";
                } else path_file = path_file + "H-" + gesture + ".mp4";
                Uri u1 = Uri.fromFile(new File(path_file));
                example_gesture = (VideoView)findViewById(R.id.videoView_gesture);
                example_gesture.setVideoURI(u1);
                example_gesture.setOnCompletionListener(new MediaPlayer.OnCompletionListener() {
                    @Override
                    public void onCompletion(MediaPlayer arg_mp) { example_gesture.start(); }
                });
                example_gesture.start();
                Button button_record = (Button) findViewById(R.id.button_record);
                button_record.setOnClickListener(new View.OnClickListener() {
                    @Override
                    public void onClick(View arg_view) {
                        intent_record_video = new Intent(MediaStore.ACTION_VIDEO_CAPTURE);
                        intent_record_video.putExtra(MediaStore.EXTRA_DURATION_LIMIT, 5);
                        File k = new File("/storage/self/primary/DCIM/Camera/");
                        count_files = (k.list()).length;
                        startActivityForResult(intent_record_video, VIDEO_CAPTURE);

                    }
                });
                Button button_previous_screen = (Button) findViewById(R.id.button_previous_screen);
                button_previous_screen.setOnClickListener(new View.OnClickListener() {
                    @Override
                    public void onClick(View arg_view) {
                        startActivity(new Intent(getApplicationContext(), MainActivity.class));
                    }
                });
                Button button_upload = (Button) findViewById(R.id.button_upload);
                button_upload.setOnClickListener(new View.OnClickListener() {
                    @Override
                    public void onClick(View arg_view) {
                        if (name_file.length() > 0) {
                            RequestBody postbody = RequestBody.create(object_mediatype, file_media);
                            OkHttpClient client = new OkHttpClient();

                            Request request = new Request.Builder()
                                    .url(posturl)
                                    .post(postbody)
                                    .build();
                            
                            Log.i("REQUEST: ", "Throwing a request");
                            client.newCall(request).enqueue(new Callback() {
                                @Override
                                public void onFailure(final Call call, final IOException e) {
                                    call.cancel();
                                    Log.i("REQUEST: ", "Call canceled");
                                }

                                @Override
                                public void onResponse(Call call, final Response response) throws IOException {
                                }
                            });
                            name_file = "";
                        }
                    }
                });
                address_server_ipv4 = "192.168.0.113";
                port_number = "5000";
                posturl = "http://" + address_server_ipv4 + ":" + port_number + "/mainapp";
                Thread.currentThread().interrupt();
            }
        }).start();
    }
    @Override
    protected void onResume() {
        super.onResume();

                Log.i("THREAD: ", "ran the resume thread");
        File file = new File("/storage/self/primary/DCIM/Camera/");
        String[] list_files = file.list();
        if (list_files.length > count_files && count_files != -1) {
            captured_video = true;
            count_files = list_files.length;
        }
        if (!example_gesture.isPlaying()) {
            example_gesture.start();
        }
        if (captured_video) {

//          File file = new File("/storage/self/primary/DCIM/Camera/");
//          String[] list_files = file.list();
            for (int index = 0; index < list_files.length; ++index) {
                if ((list_files[index]).charAt(0) == 'V') {
                    File f = new File(file.getPath() +'/' + list_files[index]);
                    name_file = file.getPath() + '/' + gesture_received
                            + "_PRACTICE_"
                            + count_practice[(int) links.get(gesture_received)] + "_desai.mp4";
                    File f2 = new File(name_file);
                    boolean result = f.renameTo(f2);
                    file_media = f2;
                    ++count_practice[(int) links.get(gesture_received)];
                    break;
                }
            }
            captured_video = false;
            object_mediatype = MediaType.parse("video/mp4");
        }
    }
}

As I proposed before, is the files variable in the Request null? I.e the file is not being sent? Also, kindly give your opinion on whether am I sending the video file in a correct way or not. It would be most generous of you to show me the correct way If I am mistaken as well.

Solution

Forgot to answer it instantly since assignment deadlines, but you want to focus on the name of the file you are sending in that request and the name you use in the flask program. That’s all I can recall right now.

EDIT:
sent_file = request.files['file'], here, ‘file’ should be ‘name’ of the the information sent in the RequestBody

Answered By – Vishwad

This Answer collected from stackoverflow, is licensed under cc by-sa 2.5 , cc by-sa 3.0 and cc by-sa 4.0