Code improvements

Going from top to bottom, here are some improvements I would suggest.

If database_path is a constant, it should be named instead DATABASE_PATH, or some other all-caps name, to make it evident that it shouldn't be changed. You may consider storing this outside of the code in some config file, so if it ever changes you only need to change the config file and not the code.

Since you are using Python 3, consider using type hints. This will make your code easier to read, as well as allow static analysis of your code to make sure the correct types are used. For example, here would be your connect function with type hints. Note the added import from typing, which has common types like List, Dict, and Tuple.

from typing import Dict

def connect(database: str) -> Dict:
    """Open a connection and a cursor to the database file provided."""
    conexion = sqlite3.connect(database_path + database + ".db")
    cursor = conexion.cursor()
    return {"conexion":conexion, "cursor":cursor}

Instead of making up a word like conexion, consider just adding an underscore at the end when you are worried about using a reserved keyword, i.e.:

connection_ = sqlite3.connect(database_path + database + ".db")

I would recommend using the string .format() method instead of +'ing strings together. For example:

connection_ = sqlite3.connect("{0}{1}.db".format(database_path, database))

It makes the intention more clear, and makes sure everything is the right type to avoid type errors. You could also split the string building by itself for easier reading:

connection_string = "{0}{1}.db".format(database_path, database)
connection_ = sqlite3.connect(connection_string)

Design improvements

Having worked with SQL databases quite a bit, I personally think it is a bad idea to dynamically build SQL query strings as you are doing. The main reasons are as follows:

1. They are error-prone
2. They have potential security risks
3. They usually have poor performance

To briefly address each:

1. Imagine that you (or another programmer) makes a typing error, say typing "Usres" instead of "Users", the SQL DB will return an error stating that the "Usres" object doesn't exist. Then you need to build in error handling in your functions to account for misspelled or otherwise non-existent database objects.

2. Imagine you had some kind of input form where a user types in some information, for example, their user name; then, you put that into your SQL query string and execute it on the DB. It's all well and good, as long as the user types something that could be valid. But there is a risk for what has become jokingly known as a Bobby Tables problem, or SQL injection.

Take this for example: query_built = query_built + " WHERE " + str(sqlquery["where"])

Say I entered this as user name: Phrancis'; DROP TABLE Users;--

Your executable query string would then look something like this:

"SELECT Id FROM Users WHERE Name = 'Phrancis'; DROP TABLE Users;--'"

Notice that trailing single quote at the very end after --, which is now commented out and ignored, and the single quote I put in the user name is used instead.

And if SQL executed that, then, you better have a recent backup of your users table!

3. For performance, queries that are executed "ad hoc" (or, basically, improvised) on the database usually have a poorer performance than queries that are stored. The SQL database usually has to recalculate execution plans for ad hoc queries each time, as opposed to re-using the execution plan from the last time(s) a similar query was executed. On busy production databases, this can make a significant impact on the database processing load.

Ultimately, for any production code, database queries should each have their own functions/methods, as in this example:

def check_user_exists(user_name: str) -> bool:
    query = "SELECT id FROM users WHERE name = ?"
    cursor.execute(query, user_name)
    # etc.