You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@superset.apache.org by be...@apache.org on 2026/04/21 19:51:43 UTC

(superset) branch update-rison created (now f19b44cd63e)

This is an automated email from the ASF dual-hosted git repository.

betodealmeida pushed a change to branch update-rison
in repository https://gitbox.apache.org/repos/asf/superset.git


      at f19b44cd63e chore: bump rison to 2.0.0

This branch includes the following new commits:

     new f19b44cd63e chore: bump rison to 2.0.0

The 1 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails.  The revisions
listed as "add" were already present in the repository and have only
been added to this reference.



(superset) 01/01: chore: bump rison to 2.0.0

Posted by be...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

betodealmeida pushed a commit to branch update-rison
in repository https://gitbox.apache.org/repos/asf/superset.git

commit f19b44cd63e640ba9e6aed68435035b896f6c888
Author: Beto Dealmeida <ro...@dealmeida.net>
AuthorDate: Tue Apr 21 15:51:23 2026 -0400

    chore: bump rison to 2.0.0
---
 pyproject.toml                                     |  3 +-
 requirements/base.txt                              |  3 +-
 requirements/development.txt                       |  5 +-
 superset/dashboards/api.py                         |  6 +-
 superset/reports/models.py                         |  4 +-
 .../advanced_data_type/api_tests.py                | 10 +--
 .../annotation_layers/api_tests.py                 | 28 ++++----
 tests/integration_tests/base_api_tests.py          | 12 ++--
 tests/integration_tests/base_tests.py              |  4 +-
 tests/integration_tests/charts/api_tests.py        | 74 +++++++++++-----------
 tests/integration_tests/css_templates/api_tests.py | 18 +++---
 tests/integration_tests/dashboards/api_tests.py    | 74 +++++++++++-----------
 tests/integration_tests/dashboards/base_case.py    |  4 +-
 .../dashboards/security/security_dataset_tests.py  |  4 +-
 tests/integration_tests/databases/api_tests.py     | 46 +++++++-------
 tests/integration_tests/datasets/api_tests.py      | 38 +++++------
 tests/integration_tests/datasource_tests.py        | 16 ++---
 tests/integration_tests/log_api_tests.py           | 14 ++--
 tests/integration_tests/queries/api_tests.py       | 16 ++---
 .../queries/saved_queries/api_tests.py             | 42 ++++++------
 tests/integration_tests/reports/api_tests.py       | 26 ++++----
 .../security/row_level_security_tests.py           | 16 ++---
 tests/integration_tests/security_tests.py          |  4 +-
 tests/integration_tests/sql_lab/api_tests.py       |  6 +-
 tests/integration_tests/sqllab_tests.py            |  6 +-
 tests/integration_tests/tags/api_tests.py          | 10 +--
 tests/integration_tests/tasks/api_tests.py         | 10 +--
 .../integration_tests/test_granular_export_api.py  | 10 +--
 tests/integration_tests/themes/api_tests.py        | 18 +++---
 tests/unit_tests/databases/api_test.py             |  4 +-
 tests/unit_tests/reports/api_test.py               |  6 +-
 31 files changed, 273 insertions(+), 264 deletions(-)

diff --git a/pyproject.toml b/pyproject.toml
index 5eca094b984..5d1e9936fee 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -93,6 +93,7 @@ dependencies = [
     "pyyaml>=6.0.0, <7.0.0",
     "PyJWT>=2.4.0, <3.0",
     "redis>=5.0.0, <6.0",
+    "rison>=2.0.0, <3.0",
     "selenium>=4.14.0, <5.0",
     "shillelagh[gsheetsapi]>=1.4.3, <2.0",
     "sshtunnel>=0.4.0, <0.5",
@@ -240,7 +241,7 @@ combine_as_imports = true
 include_trailing_comma = true
 line_length = 88
 known_first_party = "superset, apache-superset-core, apache-superset-extensions-cli"
-known_third_party = "alembic, apispec, backoff, celery, click, colorama, cron_descriptor, croniter, cryptography, dateutil, deprecation, flask, flask_appbuilder, flask_babel, flask_caching, flask_compress, flask_jwt_extended, flask_login, flask_migrate, flask_sqlalchemy, flask_talisman, flask_testing, flask_wtf, freezegun, geohash, geopy, holidays, humanize, isodate, jinja2, jwt, markdown, markupsafe, marshmallow, marshmallow-union, msgpack, nh3, numpy, pandas, parameterized, parsedateti [...]
+known_third_party = "alembic, apispec, backoff, celery, click, colorama, cron_descriptor, croniter, cryptography, dateutil, deprecation, flask, flask_appbuilder, flask_babel, flask_caching, flask_compress, flask_jwt_extended, flask_login, flask_migrate, flask_sqlalchemy, flask_talisman, flask_testing, flask_wtf, freezegun, geohash, geopy, holidays, humanize, isodate, jinja2, jwt, markdown, markupsafe, marshmallow, marshmallow-union, msgpack, nh3, numpy, pandas, parameterized, parsedateti [...]
 multi_line_output = 3
 order_by_type = false
 
diff --git a/requirements/base.txt b/requirements/base.txt
index 5dc0423c966..ff13c485a9c 100644
--- a/requirements/base.txt
+++ b/requirements/base.txt
@@ -249,7 +249,6 @@ numpy==1.26.4
     #   bottleneck
     #   numexpr
     #   pandas
-    #   pyarrow
 odfpy==1.4.1
     # via pandas
 openapi-schema-validator==0.6.3
@@ -370,6 +369,8 @@ rfc3339-validator==0.1.4
     # via openapi-schema-validator
 rich==13.9.4
     # via flask-limiter
+rison==2.0.0
+    # via apache-superset (pyproject.toml)
 rpds-py==0.25.0
     # via
     #   jsonschema
diff --git a/requirements/development.txt b/requirements/development.txt
index 0cd5411b357..0b34212450a 100644
--- a/requirements/development.txt
+++ b/requirements/development.txt
@@ -580,7 +580,6 @@ numpy==1.26.4
     #   pandas
     #   pandas-gbq
     #   prophet
-    #   pyarrow
 oauthlib==3.2.2
     # via requests-oauthlib
 odfpy==1.4.1
@@ -897,6 +896,10 @@ rich==13.9.4
     #   rich-rst
 rich-rst==1.3.1
     # via cyclopts
+rison==2.0.0
+    # via
+    #   -c requirements/base-constraint.txt
+    #   apache-superset
 rpds-py==0.25.0
     # via
     #   -c requirements/base-constraint.txt
diff --git a/superset/dashboards/api.py b/superset/dashboards/api.py
index 3cd8f0a30d7..281db036b47 100644
--- a/superset/dashboards/api.py
+++ b/superset/dashboards/api.py
@@ -22,10 +22,10 @@ from io import BytesIO
 from typing import Any, Callable, cast
 from zipfile import is_zipfile, ZipFile
 
-import prison
+import rison
 from flask import current_app, g, redirect, request, Response, send_file, url_for
 from flask_appbuilder import permission_name
-from flask_appbuilder.api import expose, merge_response_func, protect, rison, safe
+from flask_appbuilder.api import expose, merge_response_func, protect, safe
 from flask_appbuilder.const import (
     API_DESCRIPTION_COLUMNS_RIS_KEY,
     API_LABEL_COLUMNS_RIS_KEY,
@@ -496,7 +496,7 @@ class DashboardRestApi(CustomTagsOptimizationMixin, BaseSupersetModelRestApi):
         columns: list[str] | None = None
         if q := request.args.get("q"):
             try:
-                args = prison.loads(q)
+                args = rison.loads(q)
             except Exception:
                 return self.response_400(message="Invalid rison query parameter")
             if isinstance(args, dict):
diff --git a/superset/reports/models.py b/superset/reports/models.py
index 5bea67c6d68..6b923567a8b 100644
--- a/superset/reports/models.py
+++ b/superset/reports/models.py
@@ -19,7 +19,7 @@
 import logging
 from typing import Any, Optional
 
-import prison
+import rison
 from cron_descriptor import get_description
 from flask_appbuilder import Model
 from flask_appbuilder.models.decorators import renders
@@ -227,7 +227,7 @@ class ReportSchedule(AuditMixinNullable, ExtraJSONMixin, Model):
                     warnings.append(filter_warning)
                 params = {**params, **filter_config}
         # hack(hughhh): workaround for escaping prison not handling quotes right
-        rison = prison.dumps(params)
+        rison = rison.dumps(params)
         rison = rison.replace("'", "%27")
         return rison, warnings
 
diff --git a/tests/integration_tests/advanced_data_type/api_tests.py b/tests/integration_tests/advanced_data_type/api_tests.py
index 403278db6d0..c9d9d24b94c 100644
--- a/tests/integration_tests/advanced_data_type/api_tests.py
+++ b/tests/integration_tests/advanced_data_type/api_tests.py
@@ -17,7 +17,7 @@
 # isort:skip_file
 """Unit tests for Superset"""
 
-import prison
+import rison
 
 from superset.utils.core import get_example_default_schema  # noqa: F401
 
@@ -86,7 +86,7 @@ def test_types_convert_bad_request_no_vals(test_client, login_as_admin):
     Advanced Data Type API: Test request to see if it behaves as expected when no values are passed
     """  # noqa: E501
     arguments = {"type": "type", "values": []}
-    uri = f"api/v1/advanced_data_type/convert?q={prison.dumps(arguments)}"
+    uri = f"api/v1/advanced_data_type/convert?q={rison.dumps(arguments)}"
     response_value = test_client.get(uri)
     assert response_value.status_code == 400
 
@@ -96,7 +96,7 @@ def test_types_convert_bad_request_no_type(test_client, login_as_admin):
     Advanced Data Type API: Test request to see if it behaves as expected when no type is passed
     """  # noqa: E501
     arguments = {"type": "", "values": [1]}
-    uri = f"api/v1/advanced_data_type/convert?q={prison.dumps(arguments)}"
+    uri = f"api/v1/advanced_data_type/convert?q={rison.dumps(arguments)}"
     response_value = test_client.get(uri)
     assert response_value.status_code == 400
 
@@ -108,7 +108,7 @@ def test_types_convert_bad_request_type_not_found(test_client, login_as_admin):
     not found/not valid
     """  # noqa: E501
     arguments = {"type": "not_found", "values": [1]}
-    uri = f"api/v1/advanced_data_type/convert?q={prison.dumps(arguments)}"
+    uri = f"api/v1/advanced_data_type/convert?q={rison.dumps(arguments)}"
     response_value = test_client.get(uri)
     assert response_value.status_code == 400
 
@@ -120,7 +120,7 @@ def test_types_convert_request(test_client, login_as_admin):
     and valid values are passed in
     """  # noqa: E501
     arguments = {"type": "type", "values": [1]}
-    uri = f"api/v1/advanced_data_type/convert?q={prison.dumps(arguments)}"
+    uri = f"api/v1/advanced_data_type/convert?q={rison.dumps(arguments)}"
     response_value = test_client.get(uri)
     assert response_value.status_code == 200
     data = json.loads(response_value.data.decode("utf-8"))
diff --git a/tests/integration_tests/annotation_layers/api_tests.py b/tests/integration_tests/annotation_layers/api_tests.py
index 8dc639d967f..b301c256fff 100644
--- a/tests/integration_tests/annotation_layers/api_tests.py
+++ b/tests/integration_tests/annotation_layers/api_tests.py
@@ -18,7 +18,7 @@
 """Unit tests for Superset"""
 
 import pytest
-import prison
+import rison
 from sqlalchemy.sql import func
 
 import tests.integration_tests.test_app  # noqa: F401
@@ -90,7 +90,7 @@ class TestAnnotationLayerApi(SupersetTestCase):
         """
         self.login(ADMIN_USERNAME)
         params = {"keys": ["permissions"]}
-        uri = f"api/v1/annotation_layer/_info?q={prison.dumps(params)}"
+        uri = f"api/v1/annotation_layer/_info?q={rison.dumps(params)}"
         rv = self.get_assert_metric(uri, "info")
         data = json.loads(rv.data.decode("utf-8"))
         assert rv.status_code == 200
@@ -153,7 +153,7 @@ class TestAnnotationLayerApi(SupersetTestCase):
 
         for order_column in order_columns:
             arguments = {"order_column": order_column, "order_direction": "asc"}
-            uri = f"api/v1/annotation_layer/?q={prison.dumps(arguments)}"
+            uri = f"api/v1/annotation_layer/?q={rison.dumps(arguments)}"
             rv = self.get_assert_metric(uri, "get_list")
             assert rv.status_code == 200
 
@@ -169,7 +169,7 @@ class TestAnnotationLayerApi(SupersetTestCase):
                 {"col": "name", "opr": "annotation_layer_all_text", "value": "2"}
             ],
         }
-        uri = f"api/v1/annotation_layer/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/annotation_layer/?q={rison.dumps(arguments)}"
         rv = self.get_assert_metric(uri, "get_list")
 
         expected_result = {
@@ -187,7 +187,7 @@ class TestAnnotationLayerApi(SupersetTestCase):
                 {"col": "name", "opr": "annotation_layer_all_text", "value": "descr3"}
             ],
         }
-        uri = f"api/v1/annotation_layer/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/annotation_layer/?q={rison.dumps(arguments)}"
         rv = self.get_assert_metric(uri, "get_list")
 
         expected_result = {
@@ -357,7 +357,7 @@ class TestAnnotationLayerApi(SupersetTestCase):
             annotation_layer.id for annotation_layer in no_child_layers
         ]
         self.login(ADMIN_USERNAME)
-        uri = f"api/v1/annotation_layer/?q={prison.dumps(no_child_layers_ids)}"
+        uri = f"api/v1/annotation_layer/?q={rison.dumps(no_child_layers_ids)}"
         rv = self.client.delete(uri)
         assert rv.status_code == 200
         deleted_annotation_layers = query_no_child_layers.all()
@@ -384,7 +384,7 @@ class TestAnnotationLayerApi(SupersetTestCase):
         max_id = db.session.query(func.max(AnnotationLayer.id)).scalar()
         all_annotation_layers_ids.append(max_id + 1)
         self.login(ADMIN_USERNAME)
-        uri = f"api/v1/annotation_layer/?q={prison.dumps(all_annotation_layers_ids)}"
+        uri = f"api/v1/annotation_layer/?q={rison.dumps(all_annotation_layers_ids)}"
         rv = self.client.delete(uri)
         assert rv.status_code == 404
 
@@ -474,7 +474,7 @@ class TestAnnotationLayerApi(SupersetTestCase):
         ]
         for order_column in order_columns:
             arguments = {"order_column": order_column, "order_direction": "asc"}
-            uri = f"api/v1/annotation_layer/{layer.id}/annotation/?q={prison.dumps(arguments)}"  # noqa: E501
+            uri = f"api/v1/annotation_layer/{layer.id}/annotation/?q={rison.dumps(arguments)}"  # noqa: E501
             rv = self.get_assert_metric(uri, "get_list")
             assert rv.status_code == 200
 
@@ -490,7 +490,9 @@ class TestAnnotationLayerApi(SupersetTestCase):
                 {"col": "short_descr", "opr": "annotation_all_text", "value": "2"}
             ]
         }
-        uri = f"api/v1/annotation_layer/{layer.id}/annotation/?q={prison.dumps(arguments)}"  # noqa: E501
+        uri = (
+            f"api/v1/annotation_layer/{layer.id}/annotation/?q={rison.dumps(arguments)}"  # noqa: E501
+        )
         rv = self.get_assert_metric(uri, "get_list")
 
         assert rv.status_code == 200
@@ -502,7 +504,9 @@ class TestAnnotationLayerApi(SupersetTestCase):
                 {"col": "short_descr", "opr": "annotation_all_text", "value": "descr3"}
             ]
         }
-        uri = f"api/v1/annotation_layer/{layer.id}/annotation/?q={prison.dumps(arguments)}"  # noqa: E501
+        uri = (
+            f"api/v1/annotation_layer/{layer.id}/annotation/?q={rison.dumps(arguments)}"  # noqa: E501
+        )
         rv = self.get_assert_metric(uri, "get_list")
 
         assert rv.status_code == 200
@@ -719,7 +723,7 @@ class TestAnnotationLayerApi(SupersetTestCase):
         annotations = query_annotations.all()
         annotations_ids = [annotation.id for annotation in annotations]
         self.login(ADMIN_USERNAME)
-        uri = f"api/v1/annotation_layer/{layer.id}/annotation/?q={prison.dumps(annotations_ids)}"  # noqa: E501
+        uri = f"api/v1/annotation_layer/{layer.id}/annotation/?q={rison.dumps(annotations_ids)}"  # noqa: E501
         rv = self.client.delete(uri)
         assert rv.status_code == 200
         deleted_annotations = query_annotations.all()
@@ -745,6 +749,6 @@ class TestAnnotationLayerApi(SupersetTestCase):
 
         annotations_ids.append(max_id + 1)
         self.login(ADMIN_USERNAME)
-        uri = f"api/v1/annotation_layer/{layer.id}/annotation/?q={prison.dumps(annotations_ids)}"  # noqa: E501
+        uri = f"api/v1/annotation_layer/{layer.id}/annotation/?q={rison.dumps(annotations_ids)}"  # noqa: E501
         rv = self.client.delete(uri)
         assert rv.status_code == 404
diff --git a/tests/integration_tests/base_api_tests.py b/tests/integration_tests/base_api_tests.py
index 7792d83c0ff..f694603fea5 100644
--- a/tests/integration_tests/base_api_tests.py
+++ b/tests/integration_tests/base_api_tests.py
@@ -24,7 +24,7 @@ from tests.integration_tests.fixtures.world_bank_dashboard import (
 
 import pytest
 from flask_appbuilder.models.sqla.interface import SQLAInterface
-import prison
+import rison
 
 import tests.integration_tests.test_app  # noqa: F401
 from superset import db, security_manager
@@ -248,7 +248,7 @@ class ApiOwnersTestCaseMixin:
         self.login(ADMIN_USERNAME)
         page_size = 1
         argument = {"page_size": page_size}
-        uri = f"api/v1/{self.resource_name}/related/owners?q={prison.dumps(argument)}"
+        uri = f"api/v1/{self.resource_name}/related/owners?q={rison.dumps(argument)}"
         rv = self.client.get(uri)
         assert rv.status_code == 200
         response = json.loads(rv.data.decode("utf-8"))
@@ -271,7 +271,7 @@ class ApiOwnersTestCaseMixin:
         """
         self.login(ADMIN_USERNAME)
         argument = {"page": 1, "page_size": 1, "include_ids": [2]}
-        uri = f"api/v1/{self.resource_name}/related/owners?q={prison.dumps(argument)}"
+        uri = f"api/v1/{self.resource_name}/related/owners?q={rison.dumps(argument)}"
         rv = self.client.get(uri)
         assert rv.status_code == 422
 
@@ -281,7 +281,7 @@ class ApiOwnersTestCaseMixin:
         """
         self.login(ADMIN_USERNAME)
         argument = {"filter": "gamma"}
-        uri = f"api/v1/{self.resource_name}/related/owners?q={prison.dumps(argument)}"
+        uri = f"api/v1/{self.resource_name}/related/owners?q={rison.dumps(argument)}"
 
         rv = self.client.get(uri)
         assert rv.status_code == 200
@@ -368,7 +368,7 @@ class ApiOwnersTestCaseMixin:
         """
         self.login(ADMIN_USERNAME)
         argument = {"filter": "gamma_sqllab", "include_ids": [2]}
-        uri = f"api/v1/{self.resource_name}/related/owners?q={prison.dumps(argument)}"
+        uri = f"api/v1/{self.resource_name}/related/owners?q={rison.dumps(argument)}"
 
         rv = self.client.get(uri)
         response = json.loads(rv.data.decode("utf-8"))
@@ -395,7 +395,7 @@ class ApiOwnersTestCaseMixin:
         """
         self.login(ADMIN_USERNAME)
         argument = {"filter": "gamma_sqllab", "include_ids": [2, 4]}
-        uri = f"api/v1/{self.resource_name}/related/owners?q={prison.dumps(argument)}"
+        uri = f"api/v1/{self.resource_name}/related/owners?q={rison.dumps(argument)}"
 
         rv = self.client.get(uri)
         response = json.loads(rv.data.decode("utf-8"))
diff --git a/tests/integration_tests/base_tests.py b/tests/integration_tests/base_tests.py
index 07278637cbf..9808dc2d3d2 100644
--- a/tests/integration_tests/base_tests.py
+++ b/tests/integration_tests/base_tests.py
@@ -25,7 +25,7 @@ from unittest.mock import MagicMock, Mock, patch
 from zipfile import ZipFile
 
 import pandas as pd
-import prison
+import rison
 import yaml
 from flask import g, Response
 from flask_appbuilder.security.sqla import models as ab_models
@@ -631,7 +631,7 @@ class SupersetTestCase(TestCase):
         Get list of assets, by default using admin account. Can be filtered.
         """
         self.login(username)
-        uri = f"api/v1/{asset_type}/?q={prison.dumps(filter)}"
+        uri = f"api/v1/{asset_type}/?q={rison.dumps(filter)}"
         response = self.get_assert_metric(uri, "get_list")
         return response
 
diff --git a/tests/integration_tests/charts/api_tests.py b/tests/integration_tests/charts/api_tests.py
index 733c9e0e676..18150610170 100644
--- a/tests/integration_tests/charts/api_tests.py
+++ b/tests/integration_tests/charts/api_tests.py
@@ -21,8 +21,8 @@ from unittest import mock
 from unittest.mock import patch
 from zipfile import is_zipfile
 
-import prison
 import pytest
+import rison
 from flask_babel import lazy_gettext as _
 from parameterized import parameterized
 from sqlalchemy import and_
@@ -297,7 +297,7 @@ class TestChartApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCase):
         """
         self.login(ADMIN_USERNAME)
         params = {"keys": ["permissions"]}
-        uri = f"api/v1/chart/_info?q={prison.dumps(params)}"
+        uri = f"api/v1/chart/_info?q={rison.dumps(params)}"
         rv = self.get_assert_metric(uri, "info")
         data = json.loads(rv.data.decode("utf-8"))
         assert rv.status_code == 200
@@ -334,7 +334,7 @@ class TestChartApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCase):
             )
         self.login(ADMIN_USERNAME)
         argument = chart_ids
-        uri = f"api/v1/chart/?q={prison.dumps(argument)}"
+        uri = f"api/v1/chart/?q={rison.dumps(argument)}"
         rv = self.delete_assert_metric(uri, "bulk_delete")
         assert rv.status_code == 200
         response = json.loads(rv.data.decode("utf-8"))
@@ -351,7 +351,7 @@ class TestChartApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCase):
         chart_ids = [1, "a"]
         self.login(ADMIN_USERNAME)
         argument = chart_ids
-        uri = f"api/v1/chart/?q={prison.dumps(argument)}"
+        uri = f"api/v1/chart/?q={rison.dumps(argument)}"
         rv = self.delete_assert_metric(uri, "bulk_delete")
         assert rv.status_code == 400
 
@@ -392,7 +392,7 @@ class TestChartApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCase):
         max_id = db.session.query(func.max(Slice.id)).scalar()
         chart_ids = [max_id + 1, max_id + 2]
         self.login(ADMIN_USERNAME)
-        uri = f"api/v1/chart/?q={prison.dumps(chart_ids)}"
+        uri = f"api/v1/chart/?q={rison.dumps(chart_ids)}"
         rv = self.delete_assert_metric(uri, "bulk_delete")
         assert rv.status_code == 404
 
@@ -412,7 +412,7 @@ class TestChartApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCase):
         chart_ids = [chart.id for chart in charts]
         chart_ids.append(chart_with_report.id)
 
-        uri = f"api/v1/chart/?q={prison.dumps(chart_ids)}"
+        uri = f"api/v1/chart/?q={rison.dumps(chart_ids)}"
         rv = self.client.delete(uri)
         response = json.loads(rv.data.decode("utf-8"))
         assert rv.status_code == 422
@@ -449,7 +449,7 @@ class TestChartApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCase):
 
         self.login(ADMIN_USERNAME)
         argument = chart_ids
-        uri = f"api/v1/chart/?q={prison.dumps(argument)}"
+        uri = f"api/v1/chart/?q={rison.dumps(argument)}"
         rv = self.delete_assert_metric(uri, "bulk_delete")
         response = json.loads(rv.data.decode("utf-8"))
         assert rv.status_code == 200
@@ -504,7 +504,7 @@ class TestChartApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCase):
 
         # verify we can't delete not owned charts
         arguments = [chart.id for chart in charts]
-        uri = f"api/v1/chart/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/chart/?q={rison.dumps(arguments)}"
         rv = self.delete_assert_metric(uri, "bulk_delete")
         assert rv.status_code == 403
         response = json.loads(rv.data.decode("utf-8"))
@@ -513,7 +513,7 @@ class TestChartApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCase):
 
         # # nothing is deleted in bulk with a list of owned and not owned charts
         arguments = [chart.id for chart in charts] + [owned_chart.id]
-        uri = f"api/v1/chart/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/chart/?q={rison.dumps(arguments)}"
         rv = self.delete_assert_metric(uri, "bulk_delete")
         assert rv.status_code == 403
         response = json.loads(rv.data.decode("utf-8"))
@@ -1158,7 +1158,7 @@ class TestChartApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCase):
                 {"col": "slice_name", "opr": "eq", "value": self.chart.slice_name}
             ]
         }
-        uri = f"api/v1/chart/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/chart/?q={rison.dumps(arguments)}"
         rv = self.get_assert_metric(uri, "get_list")
         assert rv.status_code == 200
         data = json.loads(rv.data.decode("utf-8"))
@@ -1184,7 +1184,7 @@ class TestChartApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCase):
                 }
             ]
         }
-        uri = f"api/v1/chart/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/chart/?q={rison.dumps(arguments)}"
         rv = self.get_assert_metric(uri, "get_list")
         assert rv.status_code == 200
         data = json.loads(rv.data.decode("utf-8"))
@@ -1248,7 +1248,7 @@ class TestChartApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCase):
             "order_column": "changed_on_delta_humanized",
             "order_direction": "desc",
         }
-        uri = f"api/v1/chart/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/chart/?q={rison.dumps(arguments)}"
 
         rv = self.get_assert_metric(uri, "get_list")
         assert rv.status_code == 200
@@ -1272,7 +1272,7 @@ class TestChartApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCase):
         """
         self.login(ADMIN_USERNAME)
         arguments = {"filters": [{"col": "slice_name", "opr": "sw", "value": "G"}]}
-        uri = f"api/v1/chart/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/chart/?q={rison.dumps(arguments)}"
         rv = self.get_assert_metric(uri, "get_list")
         assert rv.status_code == 200
         data = json.loads(rv.data.decode("utf-8"))
@@ -1329,7 +1329,7 @@ class TestChartApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCase):
             "columns": ["slice_name", "description", "viz_type"],
         }
         self.login(ADMIN_USERNAME)
-        uri = f"api/v1/chart/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/chart/?q={rison.dumps(arguments)}"
         rv = self.get_assert_metric(uri, "get_list")
         assert rv.status_code == 200
         data = json.loads(rv.data.decode("utf-8"))
@@ -1362,7 +1362,7 @@ class TestChartApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCase):
         }
         self.login(ADMIN_USERNAME)
 
-        uri = f"api/v1/chart/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/chart/?q={rison.dumps(arguments)}"
         rv = self.get_assert_metric(uri, "get_list")
         data = rv.json
         assert rv.status_code == 200
@@ -1394,7 +1394,7 @@ class TestChartApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCase):
         }
         self.login(ADMIN_USERNAME)
 
-        uri = f"api/v1/chart/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/chart/?q={rison.dumps(arguments)}"
         rv = self.get_assert_metric(uri, "get_list")
         assert rv.status_code == 200
         data = json.loads(rv.data.decode("utf-8"))
@@ -1415,7 +1415,7 @@ class TestChartApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCase):
         }
         self.login(ADMIN_USERNAME)
 
-        uri = f"api/v1/chart/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/chart/?q={rison.dumps(arguments)}"
         rv = self.get_assert_metric(uri, "get_list")
         assert rv.status_code == 200
         data = json.loads(rv.data.decode("utf-8"))
@@ -1437,7 +1437,7 @@ class TestChartApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCase):
         }
 
         self.login(GAMMA_USERNAME)
-        uri = f"api/v1/chart/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/chart/?q={rison.dumps(arguments)}"
         rv = self.get_assert_metric(uri, "get_list")
         assert rv.status_code == 200
         data = json.loads(rv.data.decode("utf-8"))
@@ -1494,7 +1494,7 @@ class TestChartApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCase):
             "columns": ["slice_name"],
         }
         self.login(ADMIN_USERNAME)
-        uri = f"api/v1/chart/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/chart/?q={rison.dumps(arguments)}"
         rv = self.client.get(uri)
         data = json.loads(rv.data.decode("utf-8"))
         assert rv.status_code == 200
@@ -1511,7 +1511,7 @@ class TestChartApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCase):
             .all()
         )
         arguments["filters"][0]["value"] = False
-        uri = f"api/v1/chart/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/chart/?q={rison.dumps(arguments)}"
         rv = self.client.get(uri)
         data = json.loads(rv.data.decode("utf-8"))
         assert rv.status_code == 200
@@ -1536,7 +1536,7 @@ class TestChartApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCase):
             "columns": ["slice_name"],
         }
         self.login(gamma_user.username)
-        uri = f"api/v1/chart/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/chart/?q={rison.dumps(arguments)}"
         rv = self.client.get(uri)
         data = json.loads(rv.data.decode("utf-8"))
         assert rv.status_code == 200
@@ -1565,7 +1565,7 @@ class TestChartApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCase):
         assert users_favorite_ids
         arguments = [s.id for s in db.session.query(Slice.id).all()]
         self.login(ADMIN_USERNAME)
-        uri = f"api/v1/chart/favorite_status/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/chart/favorite_status/?q={rison.dumps(arguments)}"
         rv = self.client.get(uri)
         data = json.loads(rv.data.decode("utf-8"))
         assert rv.status_code == 200
@@ -1588,7 +1588,7 @@ class TestChartApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCase):
         db.session.commit()
 
         self.login(ADMIN_USERNAME)
-        uri = f"api/v1/chart/favorite_status/?q={prison.dumps([chart.id])}"
+        uri = f"api/v1/chart/favorite_status/?q={rison.dumps([chart.id])}"
         rv = self.client.get(uri)
         data = json.loads(rv.data.decode("utf-8"))
         for res in data["result"]:
@@ -1597,7 +1597,7 @@ class TestChartApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCase):
         uri = f"api/v1/chart/{chart.id}/favorites/"
         self.client.post(uri)
 
-        uri = f"api/v1/chart/favorite_status/?q={prison.dumps([chart.id])}"
+        uri = f"api/v1/chart/favorite_status/?q={rison.dumps([chart.id])}"
         rv = self.client.get(uri)
         data = json.loads(rv.data.decode("utf-8"))
         for res in data["result"]:
@@ -1624,7 +1624,7 @@ class TestChartApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCase):
         uri = f"api/v1/chart/{chart.id}/favorites/"
         self.client.post(uri)
 
-        uri = f"api/v1/chart/favorite_status/?q={prison.dumps([chart.id])}"
+        uri = f"api/v1/chart/favorite_status/?q={rison.dumps([chart.id])}"
         rv = self.client.get(uri)
         data = json.loads(rv.data.decode("utf-8"))
         for res in data["result"]:
@@ -1633,7 +1633,7 @@ class TestChartApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCase):
         uri = f"api/v1/chart/{chart.id}/favorites/"
         self.client.delete(uri)
 
-        uri = f"api/v1/chart/favorite_status/?q={prison.dumps([chart.id])}"
+        uri = f"api/v1/chart/favorite_status/?q={rison.dumps([chart.id])}"
         rv = self.client.get(uri)
         data = json.loads(rv.data.decode("utf-8"))
         for res in data["result"]:
@@ -1648,7 +1648,7 @@ class TestChartApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCase):
         """
         self.login(ADMIN_USERNAME)
         humanize_time_range = "100 years ago : now"
-        uri = f"api/v1/time_range/?q={prison.dumps(humanize_time_range)}"
+        uri = f"api/v1/time_range/?q={rison.dumps(humanize_time_range)}"
         rv = self.client.get(uri)
         data = json.loads(rv.data.decode("utf-8"))
         assert rv.status_code == 200
@@ -1660,7 +1660,7 @@ class TestChartApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCase):
             {"timeRange": "2021-01-01 : 2022-02-01"},
             {"timeRange": "2022-01-01 : 2023-02-01"},
         ]
-        uri = f"api/v1/time_range/?q={prison.dumps(humanize_time_range)}"
+        uri = f"api/v1/time_range/?q={rison.dumps(humanize_time_range)}"
         rv = self.client.get(uri)
         data = json.loads(rv.data.decode("utf-8"))
         assert rv.status_code == 200
@@ -1673,7 +1673,7 @@ class TestChartApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCase):
             {"timeRange": "2021-01-01 : 2022-02-01", "shift": "1 year ago"},
             {"timeRange": "2022-01-01 : 2023-02-01", "shift": "2 year ago"},
         ]
-        uri = f"api/v1/time_range/?q={prison.dumps(humanize_time_range)}"
+        uri = f"api/v1/time_range/?q={rison.dumps(humanize_time_range)}"
         rv = self.client.get(uri)
         data = json.loads(rv.data.decode("utf-8"))
         assert rv.status_code == 200
@@ -1710,14 +1710,14 @@ class TestChartApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCase):
         # Assuming we have 33 sample charts
         self.login(ADMIN_USERNAME)
         arguments = {"page_size": 10, "page": 0}
-        uri = f"api/v1/chart/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/chart/?q={rison.dumps(arguments)}"
         rv = self.client.get(uri)
         assert rv.status_code == 200
         data = json.loads(rv.data.decode("utf-8"))
         assert len(data["result"]) == 10
 
         arguments = {"page_size": 10, "page": 3}
-        uri = f"api/v1/chart/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/chart/?q={rison.dumps(arguments)}"
         rv = self.get_assert_metric(uri, "get_list")
         assert rv.status_code == 200
         data = json.loads(rv.data.decode("utf-8"))
@@ -1740,7 +1740,7 @@ class TestChartApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCase):
         """
         example_chart = db.session.query(Slice).all()[0]
         argument = [example_chart.id]
-        uri = f"api/v1/chart/export/?q={prison.dumps(argument)}"
+        uri = f"api/v1/chart/export/?q={rison.dumps(argument)}"
 
         self.login(ADMIN_USERNAME)
         rv = self.get_assert_metric(uri, "export")
@@ -1756,7 +1756,7 @@ class TestChartApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCase):
         """
         # Just one does not exist and we get 404
         argument = [-1, 1]
-        uri = f"api/v1/chart/export/?q={prison.dumps(argument)}"
+        uri = f"api/v1/chart/export/?q={rison.dumps(argument)}"
         self.login(ADMIN_USERNAME)
         rv = self.get_assert_metric(uri, "export")
 
@@ -1768,7 +1768,7 @@ class TestChartApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCase):
         """
         example_chart = db.session.query(Slice).all()[0]
         argument = [example_chart.id]
-        uri = f"api/v1/chart/export/?q={prison.dumps(argument)}"
+        uri = f"api/v1/chart/export/?q={rison.dumps(argument)}"
 
         self.login(GAMMA_USERNAME)
         rv = self.client.get(uri)
@@ -1910,7 +1910,7 @@ class TestChartApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCase):
         }
         self.login(ADMIN_USERNAME)
 
-        uri = f"api/v1/chart/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/chart/?q={rison.dumps(arguments)}"
         rv = self.get_assert_metric(uri, "get_list")
         assert rv.status_code == 200
         data = json.loads(rv.data.decode("utf-8"))
@@ -1924,7 +1924,7 @@ class TestChartApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCase):
         }
         self.login(ADMIN_USERNAME)
 
-        uri = f"api/v1/chart/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/chart/?q={rison.dumps(arguments)}"
         rv = self.get_assert_metric(uri, "get_list")
         assert rv.status_code == 200
         data = json.loads(rv.data.decode("utf-8"))
@@ -1949,7 +1949,7 @@ class TestChartApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCase):
             "page": 0,
             "page_size": 25,
         }
-        rv = self.client.get(f"api/v1/chart/?q={prison.dumps(arguments)}")
+        rv = self.client.get(f"api/v1/chart/?q={rison.dumps(arguments)}")
         assert rv.status_code == 200
         data = json.loads(rv.data.decode("utf-8"))
 
diff --git a/tests/integration_tests/css_templates/api_tests.py b/tests/integration_tests/css_templates/api_tests.py
index 0e8054b07a4..16f2da6b675 100644
--- a/tests/integration_tests/css_templates/api_tests.py
+++ b/tests/integration_tests/css_templates/api_tests.py
@@ -18,7 +18,7 @@
 """Unit tests for Superset"""
 
 import pytest
-import prison
+import rison
 from datetime import datetime
 from freezegun import freeze_time
 from sqlalchemy.sql import func
@@ -111,7 +111,7 @@ class TestCssTemplateApi(SupersetTestCase):
         )
         self.login(ADMIN_USERNAME)
         query_string = {"order_column": "template_name", "order_direction": "asc"}
-        uri = f"api/v1/css_template/?q={prison.dumps(query_string)}"
+        uri = f"api/v1/css_template/?q={rison.dumps(query_string)}"
         rv = self.get_assert_metric(uri, "get_list")
         assert rv.status_code == 200
         data = json.loads(rv.data.decode("utf-8"))
@@ -138,7 +138,7 @@ class TestCssTemplateApi(SupersetTestCase):
                 }
             ],
         }
-        uri = f"api/v1/css_template/?q={prison.dumps(query_string)}"
+        uri = f"api/v1/css_template/?q={rison.dumps(query_string)}"
         rv = self.get_assert_metric(uri, "get_list")
         assert rv.status_code == 200
         data = json.loads(rv.data.decode("utf-8"))
@@ -158,7 +158,7 @@ class TestCssTemplateApi(SupersetTestCase):
                 }
             ],
         }
-        uri = f"api/v1/css_template/?q={prison.dumps(query_string)}"
+        uri = f"api/v1/css_template/?q={rison.dumps(query_string)}"
         rv = self.get_assert_metric(uri, "get_list")
         assert rv.status_code == 200
         data = json.loads(rv.data.decode("utf-8"))
@@ -179,7 +179,7 @@ class TestCssTemplateApi(SupersetTestCase):
         """
         self.login(ADMIN_USERNAME)
         params = {"keys": ["permissions"]}
-        uri = f"api/v1/css_template/_info?q={prison.dumps(params)}"
+        uri = f"api/v1/css_template/_info?q={rison.dumps(params)}"
         rv = self.get_assert_metric(uri, "info")
         data = json.loads(rv.data.decode("utf-8"))
         assert rv.status_code == 200
@@ -339,7 +339,7 @@ class TestCssTemplateApi(SupersetTestCase):
         css_template_ids = [css_template.id for css_template in css_templates]
 
         self.login(ADMIN_USERNAME)
-        uri = f"api/v1/css_template/?q={prison.dumps(css_template_ids)}"
+        uri = f"api/v1/css_template/?q={rison.dumps(css_template_ids)}"
         rv = self.delete_assert_metric(uri, "bulk_delete")
         assert rv.status_code == 200
         response = json.loads(rv.data.decode("utf-8"))
@@ -359,7 +359,7 @@ class TestCssTemplateApi(SupersetTestCase):
         css_template_ids = [css_template.id]
 
         self.login(ADMIN_USERNAME)
-        uri = f"api/v1/css_template/?q={prison.dumps(css_template_ids)}"
+        uri = f"api/v1/css_template/?q={rison.dumps(css_template_ids)}"
         rv = self.delete_assert_metric(uri, "bulk_delete")
         assert rv.status_code == 200
         response = json.loads(rv.data.decode("utf-8"))
@@ -374,7 +374,7 @@ class TestCssTemplateApi(SupersetTestCase):
         """
         css_template_ids = [1, "a"]
         self.login(ADMIN_USERNAME)
-        uri = f"api/v1/css_template/?q={prison.dumps(css_template_ids)}"
+        uri = f"api/v1/css_template/?q={rison.dumps(css_template_ids)}"
         rv = self.delete_assert_metric(uri, "bulk_delete")
         assert rv.status_code == 400
 
@@ -387,6 +387,6 @@ class TestCssTemplateApi(SupersetTestCase):
 
         css_template_ids = [max_id + 1, max_id + 2]
         self.login(ADMIN_USERNAME)
-        uri = f"api/v1/css_template/?q={prison.dumps(css_template_ids)}"
+        uri = f"api/v1/css_template/?q={rison.dumps(css_template_ids)}"
         rv = self.delete_assert_metric(uri, "bulk_delete")
         assert rv.status_code == 404
diff --git a/tests/integration_tests/dashboards/api_tests.py b/tests/integration_tests/dashboards/api_tests.py
index f71af99ad40..724185a9698 100644
--- a/tests/integration_tests/dashboards/api_tests.py
+++ b/tests/integration_tests/dashboards/api_tests.py
@@ -25,7 +25,7 @@ from zipfile import is_zipfile, ZipFile
 from tests.integration_tests.insert_chart_mixin import InsertChartMixin
 
 import pytest
-import prison
+import rison
 import yaml
 
 from freezegun import freeze_time
@@ -578,7 +578,7 @@ class TestDashboardApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCas
             "title", "slug1", [admin.id], created_by=admin
         )
         self.login(ADMIN_USERNAME)
-        params = prison.dumps({"columns": ["id", "dashboard_title"]})
+        params = rison.dumps({"columns": ["id", "dashboard_title"]})
         uri = f"api/v1/dashboard/{dashboard.id}?q={params}"
         rv = self.get_assert_metric(uri, "get")
         assert rv.status_code == 200
@@ -637,7 +637,7 @@ class TestDashboardApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCas
             "title", "slug1", [admin.id], created_by=admin
         )
         self.login(ADMIN_USERNAME)
-        params = prison.dumps({"columns": ["id", "changed_on_delta_humanized"]})
+        params = rison.dumps({"columns": ["id", "changed_on_delta_humanized"]})
         uri = f"api/v1/dashboard/{dashboard.id}?q={params}"
         rv = self.get_assert_metric(uri, "get")
         assert rv.status_code == 200
@@ -688,7 +688,7 @@ class TestDashboardApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCas
         """
         self.login(ADMIN_USERNAME)
         params = {"keys": ["permissions"]}
-        uri = f"api/v1/dashboard/_info?q={prison.dumps(params)}"
+        uri = f"api/v1/dashboard/_info?q={rison.dumps(params)}"
         rv = self.get_assert_metric(uri, "info")
         data = json.loads(rv.data.decode("utf-8"))
         assert rv.status_code == 200
@@ -747,7 +747,7 @@ class TestDashboardApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCas
                 "order_column": "changed_on_delta_humanized",
                 "order_direction": "desc",
             }
-            uri = f"api/v1/dashboard/?q={prison.dumps(arguments)}"
+            uri = f"api/v1/dashboard/?q={rison.dumps(arguments)}"
 
             rv = self.get_assert_metric(uri, "get_list")
             assert rv.status_code == 200
@@ -773,7 +773,7 @@ class TestDashboardApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCas
         arguments = {
             "filters": [{"col": "dashboard_title", "opr": "sw", "value": "ti"}]
         }
-        uri = f"api/v1/dashboard/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/dashboard/?q={rison.dumps(arguments)}"
 
         rv = self.get_assert_metric(uri, "get_list")
         assert rv.status_code == 200
@@ -785,7 +785,7 @@ class TestDashboardApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCas
                 {"col": "owners", "opr": "rel_m_m", "value": [admin.id, gamma.id]}
             ]
         }
-        uri = f"api/v1/dashboard/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/dashboard/?q={rison.dumps(arguments)}"
         rv = self.client.get(uri)
         assert rv.status_code == 200
         data = json.loads(rv.data.decode("utf-8"))
@@ -811,7 +811,7 @@ class TestDashboardApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCas
             "columns": ["dashboard_title", "slug"],
         }
         self.login(ADMIN_USERNAME)
-        uri = f"api/v1/dashboard/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/dashboard/?q={rison.dumps(arguments)}"
         rv = self.client.get(uri)
         assert rv.status_code == 200
         data = json.loads(rv.data.decode("utf-8"))
@@ -824,7 +824,7 @@ class TestDashboardApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCas
 
         # Test slug filter with ilike
         arguments["filters"][0]["value"] = "slug2"
-        uri = f"api/v1/dashboard/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/dashboard/?q={rison.dumps(arguments)}"
         rv = self.client.get(uri)
         assert rv.status_code == 200
         data = json.loads(rv.data.decode("utf-8"))
@@ -837,7 +837,7 @@ class TestDashboardApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCas
 
         self.logout()
         self.login(GAMMA_USERNAME)
-        uri = f"api/v1/dashboard/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/dashboard/?q={rison.dumps(arguments)}"
         rv = self.client.get(uri)
         assert rv.status_code == 200
         data = json.loads(rv.data.decode("utf-8"))
@@ -867,7 +867,7 @@ class TestDashboardApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCas
             "columns": ["dashboard_title"],
         }
         self.login(ADMIN_USERNAME)
-        uri = f"api/v1/dashboard/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/dashboard/?q={rison.dumps(arguments)}"
         rv = self.client.get(uri)
         assert rv.status_code == 200
         data = json.loads(rv.data.decode("utf-8"))
@@ -944,7 +944,7 @@ class TestDashboardApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCas
         assert users_favorite_ids
         arguments = [dash.id for dash in db.session.query(Dashboard.id).all()]
         self.login(ADMIN_USERNAME)
-        uri = f"api/v1/dashboard/favorite_status/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/dashboard/favorite_status/?q={rison.dumps(arguments)}"
         rv = self.client.get(uri)
         data = json.loads(rv.data.decode("utf-8"))
         assert rv.status_code == 200
@@ -970,7 +970,7 @@ class TestDashboardApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCas
         db.session.commit()
 
         self.login(ADMIN_USERNAME)
-        uri = f"api/v1/dashboard/favorite_status/?q={prison.dumps([dashboard.id])}"
+        uri = f"api/v1/dashboard/favorite_status/?q={rison.dumps([dashboard.id])}"
         rv = self.client.get(uri)
         data = json.loads(rv.data.decode("utf-8"))
         for res in data["result"]:
@@ -979,7 +979,7 @@ class TestDashboardApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCas
         uri = f"api/v1/dashboard/{dashboard.id}/favorites/"
         self.client.post(uri)
 
-        uri = f"api/v1/dashboard/favorite_status/?q={prison.dumps([dashboard.id])}"
+        uri = f"api/v1/dashboard/favorite_status/?q={rison.dumps([dashboard.id])}"
         rv = self.client.get(uri)
         data = json.loads(rv.data.decode("utf-8"))
         for res in data["result"]:
@@ -1009,7 +1009,7 @@ class TestDashboardApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCas
         uri = f"api/v1/dashboard/{dashboard.id}/favorites/"
         self.client.post(uri)
 
-        uri = f"api/v1/dashboard/favorite_status/?q={prison.dumps([dashboard.id])}"
+        uri = f"api/v1/dashboard/favorite_status/?q={rison.dumps([dashboard.id])}"
         rv = self.client.get(uri)
         data = json.loads(rv.data.decode("utf-8"))
         for res in data["result"]:
@@ -1018,7 +1018,7 @@ class TestDashboardApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCas
         uri = f"api/v1/dashboard/{dashboard.id}/favorites/"
         self.client.delete(uri)
 
-        uri = f"api/v1/dashboard/favorite_status/?q={prison.dumps([dashboard.id])}"
+        uri = f"api/v1/dashboard/favorite_status/?q={rison.dumps([dashboard.id])}"
         rv = self.client.get(uri)
         data = json.loads(rv.data.decode("utf-8"))
         for res in data["result"]:
@@ -1049,7 +1049,7 @@ class TestDashboardApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCas
             "keys": ["none"],
             "columns": ["dashboard_title"],
         }
-        uri = f"api/v1/dashboard/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/dashboard/?q={rison.dumps(arguments)}"
         self.login(ADMIN_USERNAME)
         rv = self.client.get(uri)
         data = json.loads(rv.data.decode("utf-8"))
@@ -1075,7 +1075,7 @@ class TestDashboardApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCas
         }
         self.login(ADMIN_USERNAME)
 
-        uri = f"api/v1/dashboard/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/dashboard/?q={rison.dumps(arguments)}"
         rv = self.get_assert_metric(uri, "get_list")
         assert rv.status_code == 200
         data = json.loads(rv.data.decode("utf-8"))
@@ -1097,7 +1097,7 @@ class TestDashboardApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCas
         }
         self.login(ADMIN_USERNAME)
 
-        uri = f"api/v1/dashboard/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/dashboard/?q={rison.dumps(arguments)}"
         rv = self.get_assert_metric(uri, "get_list")
         assert rv.status_code == 200
         data = json.loads(rv.data.decode("utf-8"))
@@ -1129,7 +1129,7 @@ class TestDashboardApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCas
             "page": 0,
             "page_size": 100,
         }
-        uri = f"api/v1/dashboard/?q={prison.dumps(query)}"
+        uri = f"api/v1/dashboard/?q={rison.dumps(query)}"
         self.login(GAMMA_USERNAME)
         rv = self.client.get(uri)
         data = json.loads(rv.data.decode("utf-8"))
@@ -1390,7 +1390,7 @@ class TestDashboardApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCas
             )
         self.login(ADMIN_USERNAME)
         argument = dashboard_ids
-        uri = f"api/v1/dashboard/?q={prison.dumps(argument)}"
+        uri = f"api/v1/dashboard/?q={rison.dumps(argument)}"
         rv = self.delete_assert_metric(uri, "bulk_delete")
         assert rv.status_code == 200
         response = json.loads(rv.data.decode("utf-8"))
@@ -1430,7 +1430,7 @@ class TestDashboardApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCas
             assert result["uuid"] != ""
             assert result["allowed_domains"] == allowed_domains
         argument = dashboard_ids
-        uri = f"api/v1/dashboard/?q={prison.dumps(argument)}"
+        uri = f"api/v1/dashboard/?q={rison.dumps(argument)}"
         rv = self.delete_assert_metric(uri, "bulk_delete")
         assert rv.status_code == 200
         response = json.loads(rv.data.decode("utf-8"))
@@ -1447,7 +1447,7 @@ class TestDashboardApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCas
         dashboard_ids = [1, "a"]
         self.login(ADMIN_USERNAME)
         argument = dashboard_ids
-        uri = f"api/v1/dashboard/?q={prison.dumps(argument)}"
+        uri = f"api/v1/dashboard/?q={rison.dumps(argument)}"
         rv = self.client.delete(uri)
         assert rv.status_code == 400
 
@@ -1488,7 +1488,7 @@ class TestDashboardApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCas
         dashboard_ids = [1001, 1002]
         self.login(ADMIN_USERNAME)
         argument = dashboard_ids
-        uri = f"api/v1/dashboard/?q={prison.dumps(argument)}"
+        uri = f"api/v1/dashboard/?q={rison.dumps(argument)}"
         rv = self.client.delete(uri)
         assert rv.status_code == 404
 
@@ -1511,7 +1511,7 @@ class TestDashboardApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCas
 
         dashboard_ids = [dashboard.id for dashboard in dashboards]
         dashboard_ids.append(dashboard_with_report.id)
-        uri = f"api/v1/dashboard/?q={prison.dumps(dashboard_ids)}"
+        uri = f"api/v1/dashboard/?q={rison.dumps(dashboard_ids)}"
         rv = self.client.delete(uri)
         response = json.loads(rv.data.decode("utf-8"))
         assert rv.status_code == 422
@@ -1552,7 +1552,7 @@ class TestDashboardApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCas
 
         self.login(ADMIN_USERNAME)
         argument = dashboard_ids
-        uri = f"api/v1/dashboard/?q={prison.dumps(argument)}"
+        uri = f"api/v1/dashboard/?q={rison.dumps(argument)}"
         rv = self.client.delete(uri)
         response = json.loads(rv.data.decode("utf-8"))
         assert rv.status_code == 200
@@ -1629,7 +1629,7 @@ class TestDashboardApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCas
 
         # verify we can't delete not owned dashboards
         arguments = [dashboard.id for dashboard in dashboards]
-        uri = f"api/v1/dashboard/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/dashboard/?q={rison.dumps(arguments)}"
         rv = self.client.delete(uri)
         assert rv.status_code == 403
         response = json.loads(rv.data.decode("utf-8"))
@@ -1638,7 +1638,7 @@ class TestDashboardApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCas
 
         # nothing is deleted in bulk with a list of owned and not owned dashboards
         arguments = [dashboard.id for dashboard in dashboards] + [owned_dashboard.id]
-        uri = f"api/v1/dashboard/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/dashboard/?q={rison.dumps(arguments)}"
         rv = self.client.delete(uri)
         assert rv.status_code == 403
         response = json.loads(rv.data.decode("utf-8"))
@@ -2659,7 +2659,7 @@ class TestDashboardApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCas
         """
         self.login(ADMIN_USERNAME)
         dashboards_ids = get_dashboards_ids(["world_health", "births"])
-        uri = f"api/v1/dashboard/export/?q={prison.dumps(dashboards_ids)}"
+        uri = f"api/v1/dashboard/export/?q={rison.dumps(dashboards_ids)}"
 
         rv = self.get_assert_metric(uri, "export")
 
@@ -2673,7 +2673,7 @@ class TestDashboardApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCas
         """
         self.login(ADMIN_USERNAME)
         argument = [1000]
-        uri = f"api/v1/dashboard/export/?q={prison.dumps(argument)}"
+        uri = f"api/v1/dashboard/export/?q={rison.dumps(argument)}"
         rv = self.client.get(uri)
         assert rv.status_code == 404
 
@@ -2686,7 +2686,7 @@ class TestDashboardApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCas
 
         self.login(GAMMA_USERNAME)
         argument = [dashboard.id]
-        uri = f"api/v1/dashboard/export/?q={prison.dumps(argument)}"
+        uri = f"api/v1/dashboard/export/?q={rison.dumps(argument)}"
         rv = self.client.get(uri)
         assert rv.status_code == 404
         db.session.delete(dashboard)
@@ -2697,7 +2697,7 @@ class TestDashboardApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCas
         Dashboard API: Test dashboard export
         """
         dashboards_ids = get_dashboards_ids(["world_health", "births"])
-        uri = f"api/v1/dashboard/export/?q={prison.dumps(dashboards_ids)}"
+        uri = f"api/v1/dashboard/export/?q={rison.dumps(dashboards_ids)}"
 
         self.login(ADMIN_USERNAME)
         rv = self.client.get(uri)
@@ -2713,7 +2713,7 @@ class TestDashboardApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCas
         """
         self.login(ADMIN_USERNAME)
         argument = [1000]
-        uri = f"api/v1/dashboard/export/?q={prison.dumps(argument)}"
+        uri = f"api/v1/dashboard/export/?q={rison.dumps(argument)}"
         rv = self.client.get(uri)
         assert rv.status_code == 404
 
@@ -2726,7 +2726,7 @@ class TestDashboardApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCas
 
         self.login(GAMMA_USERNAME)
         argument = [dashboard.id]
-        uri = f"api/v1/dashboard/export/?q={prison.dumps(argument)}"
+        uri = f"api/v1/dashboard/export/?q={rison.dumps(argument)}"
         rv = self.client.get(uri)
         assert rv.status_code == 404
 
@@ -3030,7 +3030,7 @@ class TestDashboardApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCas
         """
         self.login(ADMIN_USERNAME)
         argument = {"filter": "alpha"}
-        uri = f"api/v1/dashboard/related/roles?q={prison.dumps(argument)}"
+        uri = f"api/v1/dashboard/related/roles?q={rison.dumps(argument)}"
 
         rv = self.client.get(uri)
         assert rv.status_code == 200
@@ -3134,7 +3134,7 @@ class TestDashboardApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCas
         }
         self.login(ADMIN_USERNAME)
 
-        uri = f"api/v1/dashboard/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/dashboard/?q={rison.dumps(arguments)}"
         rv = self.get_assert_metric(uri, "get_list")
         assert rv.status_code == 200
         data = json.loads(rv.data.decode("utf-8"))
@@ -3155,7 +3155,7 @@ class TestDashboardApi(ApiOwnersTestCaseMixin, InsertChartMixin, SupersetTestCas
         }
         self.login(ADMIN_USERNAME)
 
-        uri = f"api/v1/dashboard/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/dashboard/?q={rison.dumps(arguments)}"
         rv = self.get_assert_metric(uri, "get_list")
         assert rv.status_code == 200
         data = json.loads(rv.data.decode("utf-8"))
diff --git a/tests/integration_tests/dashboards/base_case.py b/tests/integration_tests/dashboards/base_case.py
index 17ffdd9b0c1..b6e7347f292 100644
--- a/tests/integration_tests/dashboards/base_case.py
+++ b/tests/integration_tests/dashboards/base_case.py
@@ -15,7 +15,7 @@
 # specific language governing permissions and limitations
 # under the License.
 
-import prison
+import rison
 from flask import current_app, Response
 
 from superset import security_manager
@@ -55,7 +55,7 @@ class DashboardTestCase(SupersetTestCase):
         return self.delete_assert_metric(uri, "delete")
 
     def bulk_delete_dashboard_via_api(self, dashboard_ids):
-        uri = DASHBOARDS_API_URL_WITH_QUERY_FORMAT.format(prison.dumps(dashboard_ids))  # noqa: F405
+        uri = DASHBOARDS_API_URL_WITH_QUERY_FORMAT.format(rison.dumps(dashboard_ids))  # noqa: F405
         return self.delete_assert_metric(uri, "bulk_delete")
 
     def delete_dashboard(self, dashboard_id: int) -> Response:
diff --git a/tests/integration_tests/dashboards/security/security_dataset_tests.py b/tests/integration_tests/dashboards/security/security_dataset_tests.py
index 7a3757c1922..ea637cfc98f 100644
--- a/tests/integration_tests/dashboards/security/security_dataset_tests.py
+++ b/tests/integration_tests/dashboards/security/security_dataset_tests.py
@@ -16,8 +16,8 @@
 # under the License.
 """Unit tests for Superset"""
 
-import prison
 import pytest
+import rison
 from flask import (
     current_app,
     escape,  # noqa: F401
@@ -189,7 +189,7 @@ class TestDashboardDatasetSecurity(DashboardTestCase):
         arguments = {
             "filters": [{"col": "dashboard_title", "opr": "sw", "value": title[0:8]}]
         }
-        uri = DASHBOARDS_API_URL_WITH_QUERY_FORMAT.format(prison.dumps(arguments))  # noqa: F405
+        uri = DASHBOARDS_API_URL_WITH_QUERY_FORMAT.format(rison.dumps(arguments))  # noqa: F405
         rv = self.client.get(uri)
         self.assert200(rv)
         data = json.loads(rv.data.decode("utf-8"))
diff --git a/tests/integration_tests/databases/api_tests.py b/tests/integration_tests/databases/api_tests.py
index 632d15673fa..7171a3174f2 100644
--- a/tests/integration_tests/databases/api_tests.py
+++ b/tests/integration_tests/databases/api_tests.py
@@ -24,7 +24,7 @@ from unittest import mock
 from unittest.mock import patch, MagicMock
 from zipfile import is_zipfile
 
-import prison
+import rison
 import pytest
 
 from unittest.mock import Mock
@@ -226,7 +226,7 @@ class TestDatabaseApi(SupersetTestCase):
             "page": 0,
             "page_size": -1,
         }
-        uri = f"api/v1/database/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/database/?q={rison.dumps(arguments)}"
         rv = self.client.get(uri)
         response = json.loads(rv.data.decode("utf-8"))
         assert rv.status_code == 200
@@ -1581,7 +1581,7 @@ class TestDatabaseApi(SupersetTestCase):
         """
         self.login(ADMIN_USERNAME)
         params = {"keys": ["permissions"]}
-        uri = f"api/v1/database/_info?q={prison.dumps(params)}"
+        uri = f"api/v1/database/_info?q={rison.dumps(params)}"
         rv = self.get_assert_metric(uri, "info")
         data = json.loads(rv.data.decode("utf-8"))
         assert rv.status_code == 200
@@ -1761,7 +1761,7 @@ class TestDatabaseApi(SupersetTestCase):
                     }
                 ],
             }
-            uri = f"api/v1/database/?q={prison.dumps(arguments)}"
+            uri = f"api/v1/database/?q={rison.dumps(arguments)}"
             rv = self.client.get(uri)
             data = json.loads(rv.data.decode("utf-8"))
             assert data["count"] == 1
@@ -1802,7 +1802,7 @@ class TestDatabaseApi(SupersetTestCase):
                     }
                 ],
             }
-            uri = f"api/v1/database/?q={prison.dumps(arguments)}"
+            uri = f"api/v1/database/?q={rison.dumps(arguments)}"
             rv = self.client.get(uri)
             data = json.loads(rv.data.decode("utf-8"))
             assert data["count"] == 0
@@ -1843,7 +1843,7 @@ class TestDatabaseApi(SupersetTestCase):
                     }
                 ],
             }
-            uri = f"api/v1/database/?q={prison.dumps(arguments)}"
+            uri = f"api/v1/database/?q={rison.dumps(arguments)}"
             rv = self.client.get(uri)
             data = json.loads(rv.data.decode("utf-8"))
             assert data["count"] == 0
@@ -1883,7 +1883,7 @@ class TestDatabaseApi(SupersetTestCase):
                     }
                 ],
             }
-            uri = f"api/v1/database/?q={prison.dumps(arguments)}"
+            uri = f"api/v1/database/?q={rison.dumps(arguments)}"
             rv = self.client.get(uri)
             data = json.loads(rv.data.decode("utf-8"))
             assert data["count"] == 0
@@ -1916,7 +1916,7 @@ class TestDatabaseApi(SupersetTestCase):
                     }
                 ],
             }
-            uri = f"api/v1/database/?q={prison.dumps(arguments)}"
+            uri = f"api/v1/database/?q={rison.dumps(arguments)}"
             rv = self.client.get(uri)
             data = json.loads(rv.data.decode("utf-8"))
             assert data["count"] == 0
@@ -1960,7 +1960,7 @@ class TestDatabaseApi(SupersetTestCase):
                     }
                 ],
             }
-            uri = f"api/v1/database/?q={prison.dumps(arguments)}"
+            uri = f"api/v1/database/?q={rison.dumps(arguments)}"
             rv = self.client.get(uri)
             data = json.loads(rv.data.decode("utf-8"))
             assert data["count"] == 1
@@ -2000,7 +2000,7 @@ class TestDatabaseApi(SupersetTestCase):
                     }
                 ],
             }
-            uri = f"api/v1/database/?q={prison.dumps(arguments)}"
+            uri = f"api/v1/database/?q={rison.dumps(arguments)}"
             rv = self.client.get(uri)
             data = json.loads(rv.data.decode("utf-8"))
             assert data["count"] == 0
@@ -2040,7 +2040,7 @@ class TestDatabaseApi(SupersetTestCase):
                     }
                 ],
             }
-            uri = f"api/v1/database/?q={prison.dumps(arguments)}"
+            uri = f"api/v1/database/?q={rison.dumps(arguments)}"
             rv = self.client.get(uri)
             data = json.loads(rv.data.decode("utf-8"))
             assert data["count"] == 1
@@ -2064,7 +2064,7 @@ class TestDatabaseApi(SupersetTestCase):
         assert schemas == set(response["result"])
 
         rv = self.client.get(
-            f"api/v1/database/{database.id}/schemas/?q={prison.dumps({'force': True})}"
+            f"api/v1/database/{database.id}/schemas/?q={rison.dumps({'force': True})}"
         )
         response = json.loads(rv.data.decode("utf-8"))
         assert schemas == set(response["result"])
@@ -2086,7 +2086,7 @@ class TestDatabaseApi(SupersetTestCase):
         self.login(ADMIN_USERNAME)
         database = db.session.query(Database).first()
         rv = self.client.get(
-            f"api/v1/database/{database.id}/schemas/?q={prison.dumps({'force': 'nop'})}"
+            f"api/v1/database/{database.id}/schemas/?q={rison.dumps({'force': 'nop'})}"
         )
         assert rv.status_code == 400
 
@@ -2119,7 +2119,7 @@ class TestDatabaseApi(SupersetTestCase):
                 database, "get_all_schema_names", return_value=mock_schemas
             )
             arguments = {"upload_allowed": True}
-            uri = f"api/v1/database/{database.id}/schemas/?q={prison.dumps(arguments)}"
+            uri = f"api/v1/database/{database.id}/schemas/?q={rison.dumps(arguments)}"
             rv = self.client.get(uri)
             data = json.loads(rv.data.decode("utf-8"))
             assert data["result"] == mock_schemas
@@ -2156,7 +2156,7 @@ class TestDatabaseApi(SupersetTestCase):
                 return_value=["schema_1", "schema_2", "schema_3"],
             )
             arguments = {"upload_allowed": True}
-            uri = f"api/v1/database/{database.id}/schemas/?q={prison.dumps(arguments)}"
+            uri = f"api/v1/database/{database.id}/schemas/?q={rison.dumps(arguments)}"
             rv = self.client.get(uri)
             data = json.loads(rv.data.decode("utf-8"))
             assert data["result"] == ["schema_2"]
@@ -2171,7 +2171,7 @@ class TestDatabaseApi(SupersetTestCase):
         database = db.session.query(Database).filter_by(database_name="examples").one()
         self.login(ADMIN_USERNAME)
         arguments = {"upload_allowed": True}
-        uri = f"api/v1/database/{database.id}/schemas/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/database/{database.id}/schemas/?q={rison.dumps(arguments)}"
         rv = self.client.get(uri)
         assert rv.status_code == 200
         data = json.loads(rv.data.decode("utf-8"))
@@ -2186,7 +2186,7 @@ class TestDatabaseApi(SupersetTestCase):
 
         schema_name = self.default_schema_backend_map[database.backend]
         rv = self.client.get(
-            f"api/v1/database/{database.id}/tables/?q={prison.dumps({'schema_name': schema_name})}"  # noqa: E501
+            f"api/v1/database/{database.id}/tables/?q={rison.dumps({'schema_name': schema_name})}"  # noqa: E501
         )
 
         assert rv.status_code == 200
@@ -2211,7 +2211,7 @@ class TestDatabaseApi(SupersetTestCase):
         """
         self.login(GAMMA_USERNAME)
         example_db = get_example_database()
-        uri = f"api/v1/database/{example_db.id}/tables/?q={prison.dumps({'schema_name': 'non_existent'})}"  # noqa: E501
+        uri = f"api/v1/database/{example_db.id}/tables/?q={rison.dumps({'schema_name': 'non_existent'})}"  # noqa: E501
         rv = self.client.get(uri)
         assert rv.status_code == 404
         logger_mock.warning.assert_called_once_with(
@@ -2225,7 +2225,7 @@ class TestDatabaseApi(SupersetTestCase):
         self.login(ADMIN_USERNAME)
         database = db.session.query(Database).first()
         rv = self.client.get(
-            f"api/v1/database/{database.id}/tables/?q={prison.dumps({'force': 'nop'})}"
+            f"api/v1/database/{database.id}/tables/?q={rison.dumps({'force': 'nop'})}"
         )
         assert rv.status_code == 400
 
@@ -2243,7 +2243,7 @@ class TestDatabaseApi(SupersetTestCase):
         mock_can_access_database.side_effect = Exception("Test Error")
 
         rv = self.client.get(
-            f"api/v1/database/{database.id}/tables/?q={prison.dumps({'schema_name': 'main'})}"  # noqa: E501
+            f"api/v1/database/{database.id}/tables/?q={rison.dumps({'schema_name': 'main'})}"  # noqa: E501
         )
         assert rv.status_code == 422
         logger_mock.warning.assert_called_once_with("Test Error", exc_info=True)
@@ -2487,7 +2487,7 @@ class TestDatabaseApi(SupersetTestCase):
         self.login(ADMIN_USERNAME)
         database = get_example_database()
         argument = [database.id]
-        uri = f"api/v1/database/export/?q={prison.dumps(argument)}"
+        uri = f"api/v1/database/export/?q={rison.dumps(argument)}"
         rv = self.get_assert_metric(uri, "export")
         assert rv.status_code == 200
 
@@ -2501,7 +2501,7 @@ class TestDatabaseApi(SupersetTestCase):
         self.login(GAMMA_USERNAME)
         database = get_example_database()
         argument = [database.id]
-        uri = f"api/v1/database/export/?q={prison.dumps(argument)}"
+        uri = f"api/v1/database/export/?q={rison.dumps(argument)}"
         rv = self.client.get(uri)
         assert rv.status_code == 403
 
@@ -2515,7 +2515,7 @@ class TestDatabaseApi(SupersetTestCase):
 
         self.login(ADMIN_USERNAME)
         argument = [invalid_id]
-        uri = f"api/v1/database/export/?q={prison.dumps(argument)}"
+        uri = f"api/v1/database/export/?q={rison.dumps(argument)}"
         rv = self.get_assert_metric(uri, "export")
         assert rv.status_code == 404
 
diff --git a/tests/integration_tests/datasets/api_tests.py b/tests/integration_tests/datasets/api_tests.py
index d250b34958f..ba253573e2e 100644
--- a/tests/integration_tests/datasets/api_tests.py
+++ b/tests/integration_tests/datasets/api_tests.py
@@ -23,8 +23,8 @@ from io import BytesIO
 from unittest.mock import ANY, patch
 from zipfile import is_zipfile, ZipFile
 
-import prison
 import pytest
+import rison
 import yaml
 from freezegun import freeze_time
 from sqlalchemy import inspect
@@ -265,7 +265,7 @@ class TestDatasetApi(SupersetTestCase):
                 {"col": "table_name", "opr": "eq", "value": "birth_names"},
             ]
         }
-        uri = f"api/v1/dataset/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/dataset/?q={rison.dumps(arguments)}"
         rv = self.get_assert_metric(uri, "get_list")
         assert rv.status_code == 200
         response = json.loads(rv.data.decode("utf-8"))
@@ -581,7 +581,7 @@ class TestDatasetApi(SupersetTestCase):
         """
 
         def pg_test_query_parameter(query_parameter, expected_response):
-            uri = f"api/v1/dataset/distinct/schema?q={prison.dumps(query_parameter)}"
+            uri = f"api/v1/dataset/distinct/schema?q={rison.dumps(query_parameter)}"
             rv = self.client.get(uri)
             response = json.loads(rv.data.decode("utf-8"))
             assert rv.status_code == 200
@@ -689,7 +689,7 @@ class TestDatasetApi(SupersetTestCase):
 
         self.login(ADMIN_USERNAME)
         params = {"keys": ["permissions"]}
-        uri = f"api/v1/dataset/_info?q={prison.dumps(params)}"
+        uri = f"api/v1/dataset/_info?q={rison.dumps(params)}"
         rv = self.get_assert_metric(uri, "info")
         data = json.loads(rv.data.decode("utf-8"))
         assert rv.status_code == 200
@@ -2160,7 +2160,7 @@ class TestDatasetApi(SupersetTestCase):
             view_menu_names.append(dataset.get_perm())
 
         self.login(ADMIN_USERNAME)
-        uri = f"api/v1/dataset/?q={prison.dumps(dataset_ids)}"
+        uri = f"api/v1/dataset/?q={rison.dumps(dataset_ids)}"
         rv = self.delete_assert_metric(uri, "bulk_delete")
         data = json.loads(rv.data.decode("utf-8"))
         assert rv.status_code == 200
@@ -2186,7 +2186,7 @@ class TestDatasetApi(SupersetTestCase):
         dataset_ids = [dataset.id for dataset in datasets]
 
         self.login(ALPHA_USERNAME)
-        uri = f"api/v1/dataset/?q={prison.dumps(dataset_ids)}"
+        uri = f"api/v1/dataset/?q={rison.dumps(dataset_ids)}"
         rv = self.delete_assert_metric(uri, "bulk_delete")
         assert rv.status_code == 403
 
@@ -2201,7 +2201,7 @@ class TestDatasetApi(SupersetTestCase):
         dataset_ids.append(db.session.query(func.max(SqlaTable.id)).scalar())
 
         self.login(ADMIN_USERNAME)
-        uri = f"api/v1/dataset/?q={prison.dumps(dataset_ids)}"
+        uri = f"api/v1/dataset/?q={rison.dumps(dataset_ids)}"
         rv = self.delete_assert_metric(uri, "bulk_delete")
         assert rv.status_code == 404
 
@@ -2215,7 +2215,7 @@ class TestDatasetApi(SupersetTestCase):
         dataset_ids = [dataset.id for dataset in datasets]
 
         self.login(GAMMA_USERNAME)
-        uri = f"api/v1/dataset/?q={prison.dumps(dataset_ids)}"
+        uri = f"api/v1/dataset/?q={rison.dumps(dataset_ids)}"
         rv = self.client.delete(uri)
         assert rv.status_code == 403
 
@@ -2230,7 +2230,7 @@ class TestDatasetApi(SupersetTestCase):
         dataset_ids.append("Wrong")
 
         self.login(ADMIN_USERNAME)
-        uri = f"api/v1/dataset/?q={prison.dumps(dataset_ids)}"
+        uri = f"api/v1/dataset/?q={rison.dumps(dataset_ids)}"
         rv = self.client.delete(uri)
         assert rv.status_code == 400
 
@@ -2299,7 +2299,7 @@ class TestDatasetApi(SupersetTestCase):
             return
 
         argument = [birth_names_dataset.id]
-        uri = f"api/v1/dataset/export/?q={prison.dumps(argument)}"
+        uri = f"api/v1/dataset/export/?q={rison.dumps(argument)}"
 
         self.login(ADMIN_USERNAME)
         rv = self.get_assert_metric(uri, "export")
@@ -2327,7 +2327,7 @@ class TestDatasetApi(SupersetTestCase):
         max_id = db.session.query(func.max(SqlaTable.id)).scalar()
         # Just one does not exist and we get 404
         argument = [max_id + 1, 1]
-        uri = f"api/v1/dataset/export/?q={prison.dumps(argument)}"
+        uri = f"api/v1/dataset/export/?q={rison.dumps(argument)}"
         self.login(ADMIN_USERNAME)
         rv = self.get_assert_metric(uri, "export")
         assert rv.status_code == 404
@@ -2341,7 +2341,7 @@ class TestDatasetApi(SupersetTestCase):
         dataset = self.get_fixture_datasets()[0]
 
         argument = [dataset.id]
-        uri = f"api/v1/dataset/export/?q={prison.dumps(argument)}"
+        uri = f"api/v1/dataset/export/?q={rison.dumps(argument)}"
 
         self.login(GAMMA_USERNAME)
         rv = self.client.get(uri)
@@ -2374,7 +2374,7 @@ class TestDatasetApi(SupersetTestCase):
             return
 
         argument = [birth_names_dataset.id]
-        uri = f"api/v1/dataset/export/?q={prison.dumps(argument)}"
+        uri = f"api/v1/dataset/export/?q={rison.dumps(argument)}"
 
         self.login(ADMIN_USERNAME)
         rv = self.get_assert_metric(uri, "export")
@@ -2391,7 +2391,7 @@ class TestDatasetApi(SupersetTestCase):
 
         # Just one does not exist and we get 404
         argument = [-1, 1]
-        uri = f"api/v1/dataset/export/?q={prison.dumps(argument)}"
+        uri = f"api/v1/dataset/export/?q={rison.dumps(argument)}"
         self.login(ADMIN_USERNAME)
         rv = self.get_assert_metric(uri, "export")
 
@@ -2406,7 +2406,7 @@ class TestDatasetApi(SupersetTestCase):
         dataset = self.get_fixture_datasets()[0]
 
         argument = [dataset.id]
-        uri = f"api/v1/dataset/export/?q={prison.dumps(argument)}"
+        uri = f"api/v1/dataset/export/?q={rison.dumps(argument)}"
 
         self.login(GAMMA_USERNAME)
         rv = self.client.get(uri)
@@ -2446,7 +2446,7 @@ class TestDatasetApi(SupersetTestCase):
 
         self.login(ADMIN_USERNAME)
         argument = [first_dataset.id, second_dataset.id]
-        uri = f"api/v1/dataset/export/?q={prison.dumps(argument)}"
+        uri = f"api/v1/dataset/export/?q={rison.dumps(argument)}"
         rv = self.get_assert_metric(uri, "export")
 
         assert rv.status_code == 200
@@ -2519,7 +2519,7 @@ class TestDatasetApi(SupersetTestCase):
             ]
         }
         self.login(ADMIN_USERNAME)
-        uri = f"api/v1/dataset/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/dataset/?q={rison.dumps(arguments)}"
         rv = self.client.get(uri)
 
         assert rv.status_code == 200
@@ -2534,7 +2534,7 @@ class TestDatasetApi(SupersetTestCase):
             ]
         }
         self.login(ADMIN_USERNAME)
-        uri = f"api/v1/dataset/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/dataset/?q={rison.dumps(arguments)}"
         rv = self.client.get(uri)
         assert rv.status_code == 200
 
@@ -2813,7 +2813,7 @@ class TestDatasetApi(SupersetTestCase):
             "filters": [{"col": "id", "opr": "dataset_is_certified", "value": True}]
         }
         self.login(ADMIN_USERNAME)
-        uri = f"api/v1/dataset/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/dataset/?q={rison.dumps(arguments)}"
         rv = self.client.get(uri)
 
         assert rv.status_code == 200
diff --git a/tests/integration_tests/datasource_tests.py b/tests/integration_tests/datasource_tests.py
index 0129ba4b2fc..b9da228ea3c 100644
--- a/tests/integration_tests/datasource_tests.py
+++ b/tests/integration_tests/datasource_tests.py
@@ -20,8 +20,8 @@ from contextlib import contextmanager
 from datetime import datetime, timedelta
 from unittest import mock
 
-import prison
 import pytest
+import rison
 from flask import current_app
 
 from superset import db, security_manager as sm
@@ -174,7 +174,7 @@ class TestDatasource(SupersetTestCase):
     def test_external_metadata_by_name_for_physical_table(self):
         self.login(ADMIN_USERNAME)
         tbl = self.get_table(name="birth_names")
-        params = prison.dumps(
+        params = rison.dumps(
             {
                 "datasource_type": "table",
                 "database_name": tbl.database.database_name,
@@ -200,7 +200,7 @@ class TestDatasource(SupersetTestCase):
     def test_external_metadata_by_name_for_virtual_table(self):
         self.login(ADMIN_USERNAME)
         with create_and_cleanup_table() as tbl:
-            params = prison.dumps(
+            params = rison.dumps(
                 {
                     "datasource_type": "table",
                     "database_name": tbl.database.database_name,
@@ -221,7 +221,7 @@ class TestDatasource(SupersetTestCase):
                 lambda sql, **kwargs: "SELECT 456 as intcol, 'def' as mutated_strcol"
             )
 
-            params = prison.dumps(
+            params = rison.dumps(
                 {
                     "datasource_type": "table",
                     "database_name": tbl.database.database_name,
@@ -240,7 +240,7 @@ class TestDatasource(SupersetTestCase):
         self.login(ADMIN_USERNAME)
         example_database = get_example_database()
         with create_test_table_context(example_database):
-            params = prison.dumps(
+            params = rison.dumps(
                 {
                     "datasource_type": "table",
                     "database_name": example_database.database_name,
@@ -256,7 +256,7 @@ class TestDatasource(SupersetTestCase):
             assert col_names == {"first", "second"}
 
         # No databases found
-        params = prison.dumps(
+        params = rison.dumps(
             {
                 "datasource_type": "table",
                 "database_name": "foo",
@@ -274,7 +274,7 @@ class TestDatasource(SupersetTestCase):
         )
 
         # No table found
-        params = prison.dumps(
+        params = rison.dumps(
             {
                 "datasource_type": "table",
                 "database_name": example_database.database_name,
@@ -292,7 +292,7 @@ class TestDatasource(SupersetTestCase):
         )
 
         # invalid query params
-        params = prison.dumps(
+        params = rison.dumps(
             {
                 "datasource_type": "table",
             }
diff --git a/tests/integration_tests/log_api_tests.py b/tests/integration_tests/log_api_tests.py
index a08068defab..a5e9eb90939 100644
--- a/tests/integration_tests/log_api_tests.py
+++ b/tests/integration_tests/log_api_tests.py
@@ -22,7 +22,7 @@ from typing import Optional
 from unittest.mock import ANY
 
 from flask_appbuilder.security.sqla.models import User
-import prison
+import rison
 from unittest.mock import patch
 
 from superset import db
@@ -80,7 +80,7 @@ class TestLogApi(SupersetTestCase):
             self.insert_log("some_action", admin_user)
             self.login(ADMIN_USERNAME)
             arguments = {"filters": [{"col": "action", "opr": "sw", "value": "some_"}]}
-            uri = f"api/v1/log/?q={prison.dumps(arguments)}"
+            uri = f"api/v1/log/?q={rison.dumps(arguments)}"
             rv = self.client.get(uri)
             assert rv.status_code == 404
 
@@ -92,7 +92,7 @@ class TestLogApi(SupersetTestCase):
         log = self.insert_log("some_action", admin_user)
         self.login(ADMIN_USERNAME)
         arguments = {"filters": [{"col": "action", "opr": "sw", "value": "some_"}]}
-        uri = f"api/v1/log/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/log/?q={rison.dumps(arguments)}"
         rv = self.client.get(uri)
         assert rv.status_code == 200
         response = json.loads(rv.data.decode("utf-8"))
@@ -228,7 +228,7 @@ class TestLogApi(SupersetTestCase):
         )
 
         arguments = {"actions": ["mount_dashboard"]}
-        uri = f"api/v1/log/recent_activity/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/log/recent_activity/?q={rison.dumps(arguments)}"
         rv = self.client.get(uri)
 
         db.session.delete(log)
@@ -263,7 +263,7 @@ class TestLogApi(SupersetTestCase):
         )
 
         arguments = {"distinct": False}
-        uri = f"api/v1/log/recent_activity/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/log/recent_activity/?q={rison.dumps(arguments)}"
         rv = self.client.get(uri)
 
         db.session.delete(log)
@@ -308,7 +308,7 @@ class TestLogApi(SupersetTestCase):
         log.dttm = now - timedelta(days=2)
 
         arguments = {"page": 0, "page_size": 2}
-        uri = f"api/v1/log/recent_activity/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/log/recent_activity/?q={rison.dumps(arguments)}"
         rv = self.client.get(uri)
 
         assert rv.status_code == 200
@@ -335,7 +335,7 @@ class TestLogApi(SupersetTestCase):
         }
 
         arguments = {"page": 1, "page_size": 2}
-        uri = f"api/v1/log/recent_activity/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/log/recent_activity/?q={rison.dumps(arguments)}"
         rv = self.client.get(uri)
 
         db.session.delete(log)
diff --git a/tests/integration_tests/queries/api_tests.py b/tests/integration_tests/queries/api_tests.py
index db7b6b825e1..8bca4ea2d92 100644
--- a/tests/integration_tests/queries/api_tests.py
+++ b/tests/integration_tests/queries/api_tests.py
@@ -22,7 +22,7 @@ import random
 import string
 
 import pytest
-import prison
+import rison
 from sqlalchemy.sql import func
 
 import tests.integration_tests.test_app  # noqa: F401
@@ -298,7 +298,7 @@ class TestQueryApi(SupersetTestCase):
         """
         self.login(ADMIN_USERNAME)
         arguments = {"filters": [{"col": "sql", "opr": "ct", "value": "table2"}]}
-        uri = f"api/v1/query/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/query/?q={rison.dumps(arguments)}"
         rv = self.client.get(uri)
         assert rv.status_code == 200
         data = json.loads(rv.data.decode("utf-8"))
@@ -314,7 +314,7 @@ class TestQueryApi(SupersetTestCase):
         arguments = {
             "filters": [{"col": "database", "opr": "rel_o_m", "value": database_id}]
         }
-        uri = f"api/v1/query/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/query/?q={rison.dumps(arguments)}"
         rv = self.client.get(uri)
         assert rv.status_code == 200
         data = json.loads(rv.data.decode("utf-8"))
@@ -328,7 +328,7 @@ class TestQueryApi(SupersetTestCase):
         self.login(ADMIN_USERNAME)
         alpha_id = self.get_user("alpha").id
         arguments = {"filters": [{"col": "user", "opr": "rel_o_m", "value": alpha_id}]}
-        uri = f"api/v1/query/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/query/?q={rison.dumps(arguments)}"
         rv = self.client.get(uri)
         assert rv.status_code == 200
         data = json.loads(rv.data.decode("utf-8"))
@@ -346,7 +346,7 @@ class TestQueryApi(SupersetTestCase):
                 {"col": "changed_on", "opr": "gt", "value": "2019-12-30T00:00:00Z"},
             ]
         }
-        uri = f"api/v1/query/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/query/?q={rison.dumps(arguments)}"
         rv = self.client.get(uri)
         assert rv.status_code == 200
         data = json.loads(rv.data.decode("utf-8"))
@@ -370,7 +370,7 @@ class TestQueryApi(SupersetTestCase):
 
         for order_column in order_columns:
             arguments = {"order_column": order_column, "order_direction": "asc"}
-            uri = f"api/v1/query/?q={prison.dumps(arguments)}"
+            uri = f"api/v1/query/?q={rison.dumps(arguments)}"
             rv = self.client.get(uri)
             assert rv.status_code == 200
 
@@ -389,7 +389,7 @@ class TestQueryApi(SupersetTestCase):
 
         self.login(GAMMA_SQLLAB_USERNAME)
         arguments = {"filters": [{"col": "sql", "opr": "sw", "value": "SELECT col1"}]}
-        uri = f"api/v1/query/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/query/?q={rison.dumps(arguments)}"
         rv = self.client.get(uri)
         assert rv.status_code == 200
         data = json.loads(rv.data.decode("utf-8"))
@@ -430,7 +430,7 @@ class TestQueryApi(SupersetTestCase):
 
         self.login(ADMIN_USERNAME)
         timestamp = datetime.timestamp(now - timedelta(days=2)) * 1000
-        uri = f"api/v1/query/updated_since?q={prison.dumps({'last_updated_ms': timestamp})}"  # noqa: E501
+        uri = f"api/v1/query/updated_since?q={rison.dumps({'last_updated_ms': timestamp})}"  # noqa: E501
         rv = self.client.get(uri)
         assert rv.status_code == 200
 
diff --git a/tests/integration_tests/queries/saved_queries/api_tests.py b/tests/integration_tests/queries/saved_queries/api_tests.py
index 03ad660e47e..2e4110ebc3b 100644
--- a/tests/integration_tests/queries/saved_queries/api_tests.py
+++ b/tests/integration_tests/queries/saved_queries/api_tests.py
@@ -25,7 +25,7 @@ from zipfile import is_zipfile, ZipFile
 
 import yaml
 import pytest
-import prison
+import rison
 from freezegun import freeze_time
 from sqlalchemy.sql import func, and_
 
@@ -258,7 +258,7 @@ class TestSavedQueryApi(SupersetTestCase):
         ).all()
         self.login(ADMIN_USERNAME)
         query_string = {"order_column": "schema", "order_direction": "asc"}
-        uri = f"api/v1/saved_query/?q={prison.dumps(query_string)}"
+        uri = f"api/v1/saved_query/?q={rison.dumps(query_string)}"
         rv = self.get_assert_metric(uri, "get_list")
         assert rv.status_code == 200
         data = json.loads(rv.data.decode("utf-8"))
@@ -270,7 +270,7 @@ class TestSavedQueryApi(SupersetTestCase):
             "order_column": "database.database_name",
             "order_direction": "asc",
         }
-        uri = f"api/v1/saved_query/?q={prison.dumps(query_string)}"
+        uri = f"api/v1/saved_query/?q={rison.dumps(query_string)}"
         rv = self.get_assert_metric(uri, "get_list")
         assert rv.status_code == 200
 
@@ -278,7 +278,7 @@ class TestSavedQueryApi(SupersetTestCase):
             "order_column": "created_by.first_name",
             "order_direction": "asc",
         }
-        uri = f"api/v1/saved_query/?q={prison.dumps(query_string)}"
+        uri = f"api/v1/saved_query/?q={rison.dumps(query_string)}"
         rv = self.get_assert_metric(uri, "get_list")
         assert rv.status_code == 200
 
@@ -294,7 +294,7 @@ class TestSavedQueryApi(SupersetTestCase):
         query_string = {
             "filters": [{"col": "label", "opr": "ct", "value": "2"}],
         }
-        uri = f"api/v1/saved_query/?q={prison.dumps(query_string)}"
+        uri = f"api/v1/saved_query/?q={rison.dumps(query_string)}"
         rv = self.get_assert_metric(uri, "get_list")
         assert rv.status_code == 200
         data = json.loads(rv.data.decode("utf-8"))
@@ -319,7 +319,7 @@ class TestSavedQueryApi(SupersetTestCase):
         query_string = {
             "filters": [{"col": "database", "opr": "rel_o_m", "value": example_db.id}],
         }
-        uri = f"api/v1/saved_query/?q={prison.dumps(query_string)}"
+        uri = f"api/v1/saved_query/?q={rison.dumps(query_string)}"
         rv = self.get_assert_metric(uri, "get_list")
         assert rv.status_code == 200
         data = json.loads(rv.data.decode("utf-8"))
@@ -344,7 +344,7 @@ class TestSavedQueryApi(SupersetTestCase):
         query_string = {
             "filters": [{"col": "schema", "opr": "eq", "value": schema_name}],
         }
-        uri = f"api/v1/saved_query/?q={prison.dumps(query_string)}"
+        uri = f"api/v1/saved_query/?q={rison.dumps(query_string)}"
         rv = self.get_assert_metric(uri, "get_list")
         assert rv.status_code == 200
         data = json.loads(rv.data.decode("utf-8"))
@@ -367,7 +367,7 @@ class TestSavedQueryApi(SupersetTestCase):
         query_string = {
             "filters": [{"col": "label", "opr": "all_text", "value": "schema2"}],
         }
-        uri = f"api/v1/saved_query/?q={prison.dumps(query_string)}"
+        uri = f"api/v1/saved_query/?q={rison.dumps(query_string)}"
         rv = self.get_assert_metric(uri, "get_list")
         assert rv.status_code == 200
         data = json.loads(rv.data.decode("utf-8"))
@@ -389,7 +389,7 @@ class TestSavedQueryApi(SupersetTestCase):
         query_string = {
             "filters": [{"col": "label", "opr": "all_text", "value": "label3"}],
         }
-        uri = f"api/v1/saved_query/?q={prison.dumps(query_string)}"
+        uri = f"api/v1/saved_query/?q={rison.dumps(query_string)}"
         rv = self.get_assert_metric(uri, "get_list")
         assert rv.status_code == 200
         data = json.loads(rv.data.decode("utf-8"))
@@ -411,7 +411,7 @@ class TestSavedQueryApi(SupersetTestCase):
         query_string = {
             "filters": [{"col": "label", "opr": "all_text", "value": "table"}],
         }
-        uri = f"api/v1/saved_query/?q={prison.dumps(query_string)}"
+        uri = f"api/v1/saved_query/?q={rison.dumps(query_string)}"
         rv = self.get_assert_metric(uri, "get_list")
         assert rv.status_code == 200
         data = json.loads(rv.data.decode("utf-8"))
@@ -433,7 +433,7 @@ class TestSavedQueryApi(SupersetTestCase):
         query_string = {
             "filters": [{"col": "label", "opr": "all_text", "value": "cool"}],
         }
-        uri = f"api/v1/saved_query/?q={prison.dumps(query_string)}"
+        uri = f"api/v1/saved_query/?q={rison.dumps(query_string)}"
         rv = self.get_assert_metric(uri, "get_list")
         assert rv.status_code == 200
         data = json.loads(rv.data.decode("utf-8"))
@@ -508,7 +508,7 @@ class TestSavedQueryApi(SupersetTestCase):
             "columns": ["label"],
         }
         self.login(ADMIN_USERNAME)
-        uri = f"api/v1/saved_query/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/saved_query/?q={rison.dumps(arguments)}"
         rv = self.client.get(uri)
         data = json.loads(rv.data.decode("utf-8"))
         assert rv.status_code == 200
@@ -530,7 +530,7 @@ class TestSavedQueryApi(SupersetTestCase):
             .all()
         )
         arguments["filters"][0]["value"] = False
-        uri = f"api/v1/saved_query/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/saved_query/?q={rison.dumps(arguments)}"
         rv = self.client.get(uri)
         data = json.loads(rv.data.decode("utf-8"))
         assert rv.status_code == 200
@@ -551,7 +551,7 @@ class TestSavedQueryApi(SupersetTestCase):
         """
         self.login(ADMIN_USERNAME)
         params = {"keys": ["permissions"]}
-        uri = f"api/v1/saved_query/_info?q={prison.dumps(params)}"
+        uri = f"api/v1/saved_query/_info?q={rison.dumps(params)}"
         rv = self.get_assert_metric(uri, "info")
         data = json.loads(rv.data.decode("utf-8"))
         assert rv.status_code == 200
@@ -779,7 +779,7 @@ class TestSavedQueryApi(SupersetTestCase):
         saved_query_ids = [saved_query.id for saved_query in saved_queries]
 
         self.login(ADMIN_USERNAME)
-        uri = f"api/v1/saved_query/?q={prison.dumps(saved_query_ids)}"
+        uri = f"api/v1/saved_query/?q={rison.dumps(saved_query_ids)}"
         rv = self.delete_assert_metric(uri, "bulk_delete")
         assert rv.status_code == 200
         response = json.loads(rv.data.decode("utf-8"))
@@ -799,7 +799,7 @@ class TestSavedQueryApi(SupersetTestCase):
         saved_query_ids = [saved_query.id]
 
         self.login(ADMIN_USERNAME)
-        uri = f"api/v1/saved_query/?q={prison.dumps(saved_query_ids)}"
+        uri = f"api/v1/saved_query/?q={rison.dumps(saved_query_ids)}"
         rv = self.delete_assert_metric(uri, "bulk_delete")
         assert rv.status_code == 200
         response = json.loads(rv.data.decode("utf-8"))
@@ -814,7 +814,7 @@ class TestSavedQueryApi(SupersetTestCase):
         """
         saved_query_ids = [1, "a"]
         self.login(ADMIN_USERNAME)
-        uri = f"api/v1/saved_query/?q={prison.dumps(saved_query_ids)}"
+        uri = f"api/v1/saved_query/?q={rison.dumps(saved_query_ids)}"
         rv = self.delete_assert_metric(uri, "bulk_delete")
         assert rv.status_code == 400
 
@@ -827,7 +827,7 @@ class TestSavedQueryApi(SupersetTestCase):
 
         saved_query_ids = [max_id + 1, max_id + 2]
         self.login(ADMIN_USERNAME)
-        uri = f"api/v1/saved_query/?q={prison.dumps(saved_query_ids)}"
+        uri = f"api/v1/saved_query/?q={rison.dumps(saved_query_ids)}"
         rv = self.delete_assert_metric(uri, "bulk_delete")
         assert rv.status_code == 404
 
@@ -843,7 +843,7 @@ class TestSavedQueryApi(SupersetTestCase):
 
         self.login(ADMIN_USERNAME)
         argument = [sample_query.id]
-        uri = f"api/v1/saved_query/export/?q={prison.dumps(argument)}"
+        uri = f"api/v1/saved_query/export/?q={rison.dumps(argument)}"
         rv = self.client.get(uri)
         assert rv.status_code == 200
         buf = BytesIO(rv.data)
@@ -858,7 +858,7 @@ class TestSavedQueryApi(SupersetTestCase):
 
         self.login(ADMIN_USERNAME)
         argument = [max_id + 1, max_id + 2]
-        uri = f"api/v1/saved_query/export/?q={prison.dumps(argument)}"
+        uri = f"api/v1/saved_query/export/?q={rison.dumps(argument)}"
         rv = self.client.get(uri)
         assert rv.status_code == 404
 
@@ -874,7 +874,7 @@ class TestSavedQueryApi(SupersetTestCase):
 
         self.login(GAMMA_SQLLAB_USERNAME)
         argument = [sample_query.id]
-        uri = f"api/v1/saved_query/export/?q={prison.dumps(argument)}"
+        uri = f"api/v1/saved_query/export/?q={rison.dumps(argument)}"
         rv = self.client.get(uri)
         assert rv.status_code == 404
 
diff --git a/tests/integration_tests/reports/api_tests.py b/tests/integration_tests/reports/api_tests.py
index ad49736fa9b..26b69fd6020 100644
--- a/tests/integration_tests/reports/api_tests.py
+++ b/tests/integration_tests/reports/api_tests.py
@@ -24,7 +24,7 @@ from unittest.mock import patch
 import pytz
 
 import pytest
-import prison
+import rison
 from parameterized import parameterized
 from sqlalchemy.sql import func
 
@@ -331,7 +331,7 @@ class TestReportSchedulesApi(SupersetTestCase):
         """
         self.login(ADMIN_USERNAME)
         params = {"keys": ["permissions"]}
-        uri = f"api/v1/report/_info?q={prison.dumps(params)}"
+        uri = f"api/v1/report/_info?q={rison.dumps(params)}"
         rv = self.get_assert_metric(uri, "info")
         data = json.loads(rv.data.decode("utf-8"))
         assert rv.status_code == 200
@@ -477,7 +477,7 @@ class TestReportSchedulesApi(SupersetTestCase):
 
         for order_column in order_columns:
             arguments = {"order_column": order_column, "order_direction": "asc"}
-            uri = f"api/v1/report/?q={prison.dumps(arguments)}"
+            uri = f"api/v1/report/?q={rison.dumps(arguments)}"
             rv = self.get_assert_metric(uri, "get_list")
             assert rv.status_code == 200
 
@@ -492,7 +492,7 @@ class TestReportSchedulesApi(SupersetTestCase):
             "columns": ["name"],
             "filters": [{"col": "name", "opr": "ct", "value": "2"}],
         }
-        uri = f"api/v1/report/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/report/?q={rison.dumps(arguments)}"
         rv = self.get_assert_metric(uri, "get_list")
 
         expected_result = {
@@ -514,7 +514,7 @@ class TestReportSchedulesApi(SupersetTestCase):
             "columns": ["name"],
             "filters": [{"col": "name", "opr": "report_all_text", "value": "table3"}],
         }
-        uri = f"api/v1/report/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/report/?q={rison.dumps(arguments)}"
         rv = self.get_assert_metric(uri, "get_list")
 
         expected_result = {
@@ -535,7 +535,7 @@ class TestReportSchedulesApi(SupersetTestCase):
             "columns": ["name"],
             "filters": [{"col": "active", "opr": "eq", "value": True}],
         }
-        uri = f"api/v1/report/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/report/?q={rison.dumps(arguments)}"
         rv = self.get_assert_metric(uri, "get_list")
 
         assert rv.status_code == 200
@@ -554,7 +554,7 @@ class TestReportSchedulesApi(SupersetTestCase):
                 {"col": "type", "opr": "eq", "value": ReportScheduleType.ALERT}
             ],
         }
-        uri = f"api/v1/report/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/report/?q={rison.dumps(arguments)}"
         rv = self.get_assert_metric(uri, "get_list")
 
         assert rv.status_code == 200
@@ -568,7 +568,7 @@ class TestReportSchedulesApi(SupersetTestCase):
                 {"col": "type", "opr": "eq", "value": ReportScheduleType.REPORT}
             ],
         }
-        uri = f"api/v1/report/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/report/?q={rison.dumps(arguments)}"
         rv = self.get_assert_metric(uri, "get_list")
 
         assert rv.status_code == 200
@@ -2301,7 +2301,7 @@ class TestReportSchedulesApi(SupersetTestCase):
             report_schedule.id for report_schedule in report_schedules
         ]
         self.login(ADMIN_USERNAME)
-        uri = f"api/v1/report/?q={prison.dumps(report_schedules_ids)}"
+        uri = f"api/v1/report/?q={rison.dumps(report_schedules_ids)}"
         rv = self.delete_assert_metric(uri, "bulk_delete")
         assert rv.status_code == 200
         deleted_report_schedules = query_report_schedules.all()
@@ -2324,7 +2324,7 @@ class TestReportSchedulesApi(SupersetTestCase):
         max_id = db.session.query(func.max(ReportSchedule.id)).scalar()
         report_schedules_ids.append(max_id + 1)
         self.login(ADMIN_USERNAME)
-        uri = f"api/v1/report/?q={prison.dumps(report_schedules_ids)}"
+        uri = f"api/v1/report/?q={rison.dumps(report_schedules_ids)}"
         rv = self.delete_assert_metric(uri, "bulk_delete")
         assert rv.status_code == 404
 
@@ -2342,7 +2342,7 @@ class TestReportSchedulesApi(SupersetTestCase):
         report_schedules_ids = [report_schedule.id]
 
         self.login(username="alpha2", password="password")  # noqa: S106
-        uri = f"api/v1/report/?q={prison.dumps(report_schedules_ids)}"
+        uri = f"api/v1/report/?q={rison.dumps(report_schedules_ids)}"
         rv = self.delete_assert_metric(uri, "bulk_delete")
         assert rv.status_code == 403
 
@@ -2389,7 +2389,7 @@ class TestReportSchedulesApi(SupersetTestCase):
 
         for order_column in order_columns:
             arguments = {"order_column": order_column, "order_direction": "asc"}
-            uri = f"api/v1/report/{report_schedule.id}/log/?q={prison.dumps(arguments)}"
+            uri = f"api/v1/report/{report_schedule.id}/log/?q={rison.dumps(arguments)}"
             rv = self.get_assert_metric(uri, "get_list")
             if rv.status_code == 400:
                 raise Exception(json.loads(rv.data.decode("utf-8")))
@@ -2411,7 +2411,7 @@ class TestReportSchedulesApi(SupersetTestCase):
             "columns": ["name"],
             "filters": [{"col": "state", "opr": "eq", "value": ReportState.SUCCESS}],
         }
-        uri = f"api/v1/report/{report_schedule.id}/log/?q={prison.dumps(arguments)}"
+        uri = f"api/v1/report/{report_schedule.id}/log/?q={rison.dumps(arguments)}"
         rv = self.get_assert_metric(uri, "get_list")
 
         assert rv.status_code == 200
diff --git a/tests/integration_tests/security/row_level_security_tests.py b/tests/integration_tests/security/row_level_security_tests.py
index cab80b49476..1a4823aa9dd 100644
--- a/tests/integration_tests/security/row_level_security_tests.py
+++ b/tests/integration_tests/security/row_level_security_tests.py
@@ -21,7 +21,7 @@ from unittest import mock
 
 import pytest
 from flask import g
-import prison
+import rison
 
 from superset import db, security_manager
 from superset.connectors.sqla.models import RowLevelSecurityFilter, SqlaTable
@@ -592,7 +592,7 @@ class TestRowLevelSecurityDeleteAPI(SupersetTestCase):
     def test_invalid_id_failure(self):
         self.login(ADMIN_USERNAME)
 
-        ids_to_delete = prison.dumps([10000, 10001, 100002])
+        ids_to_delete = rison.dumps([10000, 10001, 100002])
         rv = self.client.delete(f"/api/v1/rowlevelsecurity/?q={ids_to_delete}")
         status_code, data = rv.status_code, json.loads(rv.data.decode("utf-8"))
 
@@ -624,7 +624,7 @@ class TestRowLevelSecurityDeleteAPI(SupersetTestCase):
 
         self.login(ADMIN_USERNAME)
 
-        ids_to_delete = prison.dumps([rls_1.id, rls_2.id])
+        ids_to_delete = rison.dumps([rls_1.id, rls_2.id])
         rv = self.client.delete(f"/api/v1/rowlevelsecurity/?q={ids_to_delete}")
         status_code, data = rv.status_code, json.loads(rv.data.decode("utf-8"))
 
@@ -638,7 +638,7 @@ class TestRowLevelSecurityWithRelatedAPI(SupersetTestCase):
     def test_rls_tables_related_api(self):
         self.login(ADMIN_USERNAME)
 
-        params = prison.dumps({"page": 0, "page_size": 100})
+        params = rison.dumps({"page": 0, "page_size": 100})
 
         rv = self.client.get(f"/api/v1/rowlevelsecurity/related/tables?q={params}")
         assert rv.status_code == 200
@@ -657,7 +657,7 @@ class TestRowLevelSecurityWithRelatedAPI(SupersetTestCase):
     def test_rls_tables_related_api_with_filter_matching_birth(self):
         self.login(ADMIN_USERNAME)
         # Test with filter that should match 'birth_names'
-        params = prison.dumps({"filter": "birth", "page": 0, "page_size": 100})
+        params = rison.dumps({"filter": "birth", "page": 0, "page_size": 100})
         rv = self.client.get(f"/api/v1/rowlevelsecurity/related/tables?q={params}")
         assert rv.status_code == 200
         data = json.loads(rv.data.decode("utf-8"))
@@ -670,7 +670,7 @@ class TestRowLevelSecurityWithRelatedAPI(SupersetTestCase):
     def test_rls_tables_related_api_with_filter_no_matches(self):
         self.login(ADMIN_USERNAME)
         # Test with filter that should match nothing
-        params = prison.dumps({"filter": "nonexistent", "page": 0, "page_size": 100})
+        params = rison.dumps({"filter": "nonexistent", "page": 0, "page_size": 100})
         rv = self.client.get(f"/api/v1/rowlevelsecurity/related/tables?q={params}")
         assert rv.status_code == 200
         data = json.loads(rv.data.decode("utf-8"))
@@ -680,7 +680,7 @@ class TestRowLevelSecurityWithRelatedAPI(SupersetTestCase):
 
     def test_rls_roles_related_api(self):
         self.login(ADMIN_USERNAME)
-        params = prison.dumps({"page": 0, "page_size": 100})
+        params = rison.dumps({"page": 0, "page_size": 100})
 
         rv = self.client.get(f"/api/v1/rowlevelsecurity/related/roles?q={params}")
         assert rv.status_code == 200
@@ -703,7 +703,7 @@ class TestRowLevelSecurityWithRelatedAPI(SupersetTestCase):
     def test_table_related_filter(self):
         self.login(ADMIN_USERNAME)
 
-        params = prison.dumps({"page": 0, "page_size": 10})
+        params = rison.dumps({"page": 0, "page_size": 10})
 
         rv = self.client.get(f"/api/v1/rowlevelsecurity/related/tables?q={params}")
         assert rv.status_code == 200
diff --git a/tests/integration_tests/security_tests.py b/tests/integration_tests/security_tests.py
index 1191c7fd9d8..686970dc2b8 100644
--- a/tests/integration_tests/security_tests.py
+++ b/tests/integration_tests/security_tests.py
@@ -24,7 +24,7 @@ from unittest.mock import Mock, patch, call, ANY
 from typing import Any
 
 import jwt
-import prison
+import rison
 import pytest
 
 from flask import current_app, g
@@ -1293,7 +1293,7 @@ class TestRolePermission(SupersetTestCase):
             "page": 0,
             "page_size": -1,
         }
-        NEW_FLASK_GET_SQL_DBS_REQUEST = f"/api/v1/database/?q={prison.dumps(arguments)}"  # noqa: N806
+        NEW_FLASK_GET_SQL_DBS_REQUEST = f"/api/v1/database/?q={rison.dumps(arguments)}"  # noqa: N806
         self.login(GAMMA_USERNAME)
         databases_json = self.client.get(NEW_FLASK_GET_SQL_DBS_REQUEST).json
         assert databases_json["count"] == 1
diff --git a/tests/integration_tests/sql_lab/api_tests.py b/tests/integration_tests/sql_lab/api_tests.py
index 4e9f50f1310..4329946fe89 100644
--- a/tests/integration_tests/sql_lab/api_tests.py
+++ b/tests/integration_tests/sql_lab/api_tests.py
@@ -24,7 +24,7 @@ import pandas as pd
 import io
 
 import pytest
-import prison
+import rison
 from sqlalchemy.sql import func  # noqa: F401
 from unittest import mock
 
@@ -462,11 +462,11 @@ class TestSqlLabApi(SupersetTestCase):
             # get all results
             arguments = {"key": "key"}
             result_key = json.loads(
-                self.get_resp(f"/api/v1/sqllab/results/?q={prison.dumps(arguments)}")
+                self.get_resp(f"/api/v1/sqllab/results/?q={rison.dumps(arguments)}")
             )
             arguments = {"key": "key", "rows": 1}
             result_limited = json.loads(
-                self.get_resp(f"/api/v1/sqllab/results/?q={prison.dumps(arguments)}")
+                self.get_resp(f"/api/v1/sqllab/results/?q={rison.dumps(arguments)}")
             )
 
         assert result_key == expected_key
diff --git a/tests/integration_tests/sqllab_tests.py b/tests/integration_tests/sqllab_tests.py
index 93870a252ac..d43f0d8a4c5 100644
--- a/tests/integration_tests/sqllab_tests.py
+++ b/tests/integration_tests/sqllab_tests.py
@@ -23,7 +23,7 @@ import pytest
 from celery.exceptions import SoftTimeLimitExceeded
 from parameterized import parameterized
 from unittest import mock
-import prison
+import rison
 
 from superset import db, security_manager
 from superset.connectors.sqla.models import SqlaTable  # noqa: F401
@@ -515,7 +515,7 @@ class TestSqlLab(SupersetTestCase):
                 {"col": "sql_editor_id", "opr": "eq", "value": str(tab_state_id)}
             ]
         }
-        url = f"/api/v1/query/?q={prison.dumps(arguments)}"
+        url = f"/api/v1/query/?q={rison.dumps(arguments)}"
         assert {"SELECT 1", "SELECT 2"} == {
             r.get("sql") for r in self.get_json_resp(url)["result"]
         }
@@ -547,7 +547,7 @@ class TestSqlLab(SupersetTestCase):
             "page": 0,
             "page_size": -1,
         }
-        url = f"api/v1/database/?q={prison.dumps(arguments)}"
+        url = f"api/v1/database/?q={rison.dumps(arguments)}"
 
         assert {"examples", "fake_db_100", "main"} == {
             r.get("database_name") for r in self.get_json_resp(url)["result"]
diff --git a/tests/integration_tests/tags/api_tests.py b/tests/integration_tests/tags/api_tests.py
index ba4ce8aba6c..52bd4c0ebb5 100644
--- a/tests/integration_tests/tags/api_tests.py
+++ b/tests/integration_tests/tags/api_tests.py
@@ -20,8 +20,8 @@ from datetime import datetime
 from unittest.mock import patch
 from urllib import parse
 
-import prison
 import pytest
+import rison
 from freezegun import freeze_time
 from markupsafe import Markup
 from sqlalchemy import and_
@@ -246,7 +246,7 @@ class TestTagApi(InsertChartMixin, SupersetTestCase):
                 }
             ],
         }
-        uri = f"api/v1/tag/?{parse.urlencode({'q': prison.dumps(query)})}"
+        uri = f"api/v1/tag/?{parse.urlencode({'q': rison.dumps(query)})}"
         rv = self.client.get(uri)
         assert rv.status_code == 200
         data = json.loads(rv.data.decode("utf-8"))
@@ -254,7 +254,7 @@ class TestTagApi(InsertChartMixin, SupersetTestCase):
 
         # Only system tags
         query["filters"][0]["value"] = False
-        uri = f"api/v1/tag/?{parse.urlencode({'q': prison.dumps(query)})}"
+        uri = f"api/v1/tag/?{parse.urlencode({'q': rison.dumps(query)})}"
         rv = self.client.get(uri)
         assert rv.status_code == 200
         data = json.loads(rv.data.decode("utf-8"))
@@ -542,7 +542,7 @@ class TestTagApi(InsertChartMixin, SupersetTestCase):
         tags = db.session.query(Tag).filter(Tag.name.in_(example_tag_names))
         assert tags.count() == 3
         # delete the first tag
-        uri = f"api/v1/tag/?q={prison.dumps(example_tag_names[:1])}"
+        uri = f"api/v1/tag/?q={rison.dumps(example_tag_names[:1])}"
         rv = self.client.delete(uri, follow_redirects=True)
         # successful request
         assert rv.status_code == 200
@@ -552,7 +552,7 @@ class TestTagApi(InsertChartMixin, SupersetTestCase):
         tags = db.session.query(Tag).filter(Tag.name.in_(example_tag_names))
         assert tags.count() == 2
         # delete multiple tags
-        uri = f"api/v1/tag/?q={prison.dumps(example_tag_names[1:])}"
+        uri = f"api/v1/tag/?q={rison.dumps(example_tag_names[1:])}"
         rv = self.client.delete(uri, follow_redirects=True)
         # successful request
         assert rv.status_code == 200
diff --git a/tests/integration_tests/tasks/api_tests.py b/tests/integration_tests/tasks/api_tests.py
index 6744a9140a8..45462ec3900 100644
--- a/tests/integration_tests/tasks/api_tests.py
+++ b/tests/integration_tests/tasks/api_tests.py
@@ -19,7 +19,7 @@
 from contextlib import contextmanager
 from typing import Generator
 
-import prison
+import rison
 from superset_core.tasks.types import TaskStatus
 
 from superset import db
@@ -205,7 +205,7 @@ class TestTaskApi(SupersetTestCase):
                     {"col": "status", "opr": "eq", "value": TaskStatus.PENDING.value}
                 ]
             }
-            uri = f"{self.TASK_API_BASE}/?q={prison.dumps(arguments)}"
+            uri = f"{self.TASK_API_BASE}/?q={rison.dumps(arguments)}"
             rv = self.client.get(uri)
             assert rv.status_code == 200
 
@@ -222,7 +222,7 @@ class TestTaskApi(SupersetTestCase):
             arguments = {
                 "filters": [{"col": "task_type", "opr": "eq", "value": "test_type"}]
             }
-            uri = f"{self.TASK_API_BASE}/?q={prison.dumps(arguments)}"
+            uri = f"{self.TASK_API_BASE}/?q={rison.dumps(arguments)}"
             rv = self.client.get(uri)
             assert rv.status_code == 200
 
@@ -241,7 +241,7 @@ class TestTaskApi(SupersetTestCase):
                 "order_column": "created_on",
                 "order_direction": "desc",
             }
-            uri = f"{self.TASK_API_BASE}/?q={prison.dumps(arguments)}"
+            uri = f"{self.TASK_API_BASE}/?q={rison.dumps(arguments)}"
             rv = self.client.get(uri)
             assert rv.status_code == 200
 
@@ -255,7 +255,7 @@ class TestTaskApi(SupersetTestCase):
         with self._create_tasks():
             self.login(ADMIN_USERNAME)
             arguments = {"page": 0, "page_size": 2}
-            uri = f"{self.TASK_API_BASE}/?q={prison.dumps(arguments)}"
+            uri = f"{self.TASK_API_BASE}/?q={rison.dumps(arguments)}"
             rv = self.client.get(uri)
             assert rv.status_code == 200
 
diff --git a/tests/integration_tests/test_granular_export_api.py b/tests/integration_tests/test_granular_export_api.py
index 18dd718dd64..5c907f39775 100644
--- a/tests/integration_tests/test_granular_export_api.py
+++ b/tests/integration_tests/test_granular_export_api.py
@@ -23,8 +23,8 @@ SQL Lab export endpoints (can_export_data).
 
 from unittest.mock import patch
 
-import prison
 import pytest
+import rison
 
 from superset.security import SupersetSecurityManager
 from tests.integration_tests.base_tests import SupersetTestCase
@@ -64,7 +64,7 @@ class TestGranularExportChartAPI(SupersetTestCase):
         self.login(ADMIN_USERNAME)
         chart = self.get_slice("Girls")
         uri = f"api/v1/chart/{chart.id}/cache_screenshot/"
-        rison_params = prison.dumps({"force": False})
+        rison_params = rison.dumps({"force": False})
         rv = self.client.get(f"{uri}?q={rison_params}")
         assert rv.status_code == 403
 
@@ -113,7 +113,7 @@ class TestGranularExportChartAPI(SupersetTestCase):
         self.login(ADMIN_USERNAME)
         chart = self.get_slice("Girls")
         uri = f"api/v1/chart/{chart.id}/cache_screenshot/"
-        rison_params = prison.dumps({"force": False})
+        rison_params = rison.dumps({"force": False})
         rv = self.client.get(f"{uri}?q={rison_params}")
         assert rv.status_code != 403
 
@@ -153,7 +153,7 @@ class TestGranularExportDashboardAPI(SupersetTestCase):
             "birth_names"
         )
         uri = f"api/v1/dashboard/{dashboard.id}/cache_dashboard_screenshot/"
-        rison_params = prison.dumps({"force": False})
+        rison_params = rison.dumps({"force": False})
         rv = self.client.post(
             f"{uri}?q={rison_params}",
             json={},
@@ -205,7 +205,7 @@ class TestGranularExportDashboardAPI(SupersetTestCase):
             "birth_names"
         )
         uri = f"api/v1/dashboard/{dashboard.id}/cache_dashboard_screenshot/"
-        rison_params = prison.dumps({"force": False})
+        rison_params = rison.dumps({"force": False})
         rv = self.client.post(f"{uri}?q={rison_params}", json={})
         assert rv.status_code == 202
 
diff --git a/tests/integration_tests/themes/api_tests.py b/tests/integration_tests/themes/api_tests.py
index 387b9edf866..bf506e0f43c 100644
--- a/tests/integration_tests/themes/api_tests.py
+++ b/tests/integration_tests/themes/api_tests.py
@@ -18,7 +18,7 @@
 """Unit tests for Superset"""
 
 import pytest
-import prison
+import rison
 import uuid
 import yaml
 from datetime import datetime
@@ -114,7 +114,7 @@ class TestThemeApi(SupersetTestCase):
         themes = db.session.query(Theme).order_by(Theme.theme_name.asc()).all()
         self.login(ADMIN_USERNAME)
         query_string = {"order_column": "theme_name", "order_direction": "asc"}
-        uri = f"api/v1/theme/?q={prison.dumps(query_string)}"
+        uri = f"api/v1/theme/?q={rison.dumps(query_string)}"
         rv = self.get_assert_metric(uri, "get_list")
         assert rv.status_code == 200
         data = json.loads(rv.data.decode("utf-8"))
@@ -142,7 +142,7 @@ class TestThemeApi(SupersetTestCase):
                 }
             ],
         }
-        uri = f"api/v1/theme/?q={prison.dumps(query_string)}"
+        uri = f"api/v1/theme/?q={rison.dumps(query_string)}"
         rv = self.get_assert_metric(uri, "get_list")
         assert rv.status_code == 200
         data = json.loads(rv.data.decode("utf-8"))
@@ -163,7 +163,7 @@ class TestThemeApi(SupersetTestCase):
                 }
             ],
         }
-        uri = f"api/v1/theme/?q={prison.dumps(query_string)}"
+        uri = f"api/v1/theme/?q={rison.dumps(query_string)}"
         rv = self.get_assert_metric(uri, "get_list")
         assert rv.status_code == 200
         data = json.loads(rv.data.decode("utf-8"))
@@ -184,7 +184,7 @@ class TestThemeApi(SupersetTestCase):
         """
         self.login(ADMIN_USERNAME)
         params = {"keys": ["permissions"]}
-        uri = f"api/v1/theme/_info?q={prison.dumps(params)}"
+        uri = f"api/v1/theme/_info?q={rison.dumps(params)}"
         rv = self.get_assert_metric(uri, "info")
         data = json.loads(rv.data.decode("utf-8"))
         assert rv.status_code == 200
@@ -353,7 +353,7 @@ class TestThemeApi(SupersetTestCase):
         theme_ids = [theme.id for theme in themes]
 
         self.login(ADMIN_USERNAME)
-        uri = f"api/v1/theme/?q={prison.dumps(theme_ids)}"
+        uri = f"api/v1/theme/?q={rison.dumps(theme_ids)}"
         rv = self.delete_assert_metric(uri, "bulk_delete")
         assert rv.status_code == 200
         response = json.loads(rv.data.decode("utf-8"))
@@ -373,7 +373,7 @@ class TestThemeApi(SupersetTestCase):
         theme_ids = [theme.id]
 
         self.login(ADMIN_USERNAME)
-        uri = f"api/v1/theme/?q={prison.dumps(theme_ids)}"
+        uri = f"api/v1/theme/?q={rison.dumps(theme_ids)}"
         rv = self.delete_assert_metric(uri, "bulk_delete")
         assert rv.status_code == 200
         response = json.loads(rv.data.decode("utf-8"))
@@ -388,7 +388,7 @@ class TestThemeApi(SupersetTestCase):
         """
         theme_ids = [1, "a"]
         self.login(ADMIN_USERNAME)
-        uri = f"api/v1/theme/?q={prison.dumps(theme_ids)}"
+        uri = f"api/v1/theme/?q={rison.dumps(theme_ids)}"
         rv = self.delete_assert_metric(uri, "bulk_delete")
         assert rv.status_code == 400
 
@@ -401,7 +401,7 @@ class TestThemeApi(SupersetTestCase):
 
         theme_ids = [max_id + 1, max_id + 2]
         self.login(ADMIN_USERNAME)
-        uri = f"api/v1/theme/?q={prison.dumps(theme_ids)}"
+        uri = f"api/v1/theme/?q={rison.dumps(theme_ids)}"
         rv = self.delete_assert_metric(uri, "bulk_delete")
         assert rv.status_code == 404
 
diff --git a/tests/unit_tests/databases/api_test.py b/tests/unit_tests/databases/api_test.py
index d907b02bf9f..853b71b2a8f 100644
--- a/tests/unit_tests/databases/api_test.py
+++ b/tests/unit_tests/databases/api_test.py
@@ -2375,7 +2375,7 @@ def test_export_includes_configuration_method(
     """
     import zipfile
 
-    import prison
+    import rison
 
     from superset.models.core import Database
 
@@ -2389,7 +2389,7 @@ def test_export_includes_configuration_method(
     db.session.add(db_obj)
     db.session.commit()
 
-    rison_ids = prison.dumps([db_obj.id])
+    rison_ids = rison.dumps([db_obj.id])
     response = client.get(f"/api/v1/database/export/?q={rison_ids}")
     assert response.status_code == 200
 
diff --git a/tests/unit_tests/reports/api_test.py b/tests/unit_tests/reports/api_test.py
index 6656b623bb1..c62bd7cfd8a 100644
--- a/tests/unit_tests/reports/api_test.py
+++ b/tests/unit_tests/reports/api_test.py
@@ -17,7 +17,7 @@
 from typing import Any
 from unittest.mock import patch
 
-import prison
+import rison
 
 from superset.exceptions import SupersetException
 from tests.unit_tests.conftest import with_feature_flags
@@ -31,7 +31,7 @@ def test_slack_channels_success(
     full_api_access: None,
 ) -> None:
     mock_search.return_value = [{"id": "C123", "name": "general"}]
-    params = prison.dumps({})
+    params = rison.dumps({})
     rv = client.get(f"/api/v1/report/slack_channels/?q={params}")
     assert rv.status_code == 200
     data = rv.json
@@ -46,7 +46,7 @@ def test_slack_channels_handles_superset_exception(
     full_api_access: None,
 ) -> None:
     mock_search.side_effect = SupersetException("Slack API error")
-    params = prison.dumps({})
+    params = rison.dumps({})
     rv = client.get(f"/api/v1/report/slack_channels/?q={params}")
     assert rv.status_code == 422
     assert "Slack API error" in rv.json["message"]