martin-martin/coco_final.py

# How can I make sure that the exception messages
# of Exceptions that occur in the sub-function `load_models`
# show up in the stack trace of the main function `predict_raw`?

supported = ['a', 'b', ...]

def load_model(source, target):
    try:
        if source == target:
            raise AssertionError("source and target shouldn't be same")
        if (source in supported) and (target in supported):
            ...
            if source == "ta":
                raise ValueError("Not supported pair")
    except AssertionError as e:
        return {"inputerror": "Please enter required fields"}
    except ValueError as e:
        return {"error": e}

# Assume this as flask API endpoint
def predict_raw(X):
    try:
        tokenizer, model = load_model(X['s'], X['t'])
        ...
        return preds
    except Exception as e:
        return {"error": e}

# How can I make sure that the exception messages
# of Exceptions that occur in the sub-function `load_model()`
# show up in the stack trace of the `main()` function?


class UnsupportedPairError(Exception):
    pass


class SourceEqualsTargetError(Exception):
    pass


SUPPORTED_PARAMS = ["a", "b", ...]


def main(user_input):
    model = load_model(user_input["source"], user_input["target"])
    # try:
    #     model = load_model(user_input["source"], user_input["target"])
    # except (UnsupportedPairError, SourceEqualsTargetError) as e:
    #     print(e)
    #     # return sys.exit(0)  # Do you want to quit when theres an error?
    # else:  # Do something with the model
    #     print(model)


def validate(source, target, supported_params):
    if source not in supported_params or target not in supported_params:
        raise UnsupportedPairError("not supported pair")
    elif source == target:
        raise SourceEqualsTargetError("source and target shouldn't be same")


def load_model(source, target):
    validate(source, target, supported_params=SUPPORTED_PARAMS)
    print("Loading model...")
    model = "loaded model"  # Replace with code logic
    return model


print("Run #1")
valid_input = {"source": "a", "target": "b"}
main(valid_input)  # Should raise no error

print("Run #2")
invalid_input_1 = {"source": "a", "target": "a"}
main(invalid_input_1)  # Should raise SourceEqualsTargetError

print("Run #3")
invalid_input_2 = {"source": "a", "target": "unsupported"}
main(invalid_input_2)  # Should raise UnsupportedPairError

# How can I make sure that the exception messages
# of Exceptions that occur in the sub-function `validate()`
# show up in the stack trace of the main function `main()`?


class SourceEqualsTargetError(Exception):
    """Source and target shouldn't be same."""


def main(user_input):
    try:
        validate(user_input["source"], user_input["target"])
    except SourceEqualsTargetError:
        print("Source and target are the same.")
    else:
        print("Done")


def validate(source, target):
    if source == target:
        raise SourceEqualsTargetError()


print("Run #1")
valid_input = {"source": 0, "target": 1}
main(valid_input)

print("Run #2")
invalid_input = {"source": 0, "target": 0}
main(invalid_input)

# Remove the `try...except` block in `validate()`.

# How can I make sure that the exception messages
# of Exceptions that occur in the sub-function `load_model()`
# show up in the stack trace of the main function `main()`?

def load_model(source, target):
    if source == target:
        raise AssertionError("source and target shouldn't be same")

def main(X):
    load_model(X['s'], X['t'])
    print("Done")

X = {"s": 0, "t": 0}
main(X)

# Remove the `try...except` block in `load_model()`