localstack-core 4.7.1.dev49__py3-none-any.whl → 4.10.1.dev12__py3-none-any.whl

localstack/services/stepfunctions/asl/component/state/state_choice/comparison/comparison.py

@@ -72,7 +72,7 @@ class ComparisonCompositeSingle(ComparisonComposite, abc.ABC):
     rule: Final[ChoiceRule]
 
     def __init__(self, operator: ComparisonComposite.ChoiceOp, rule: ChoiceRule):
-        super(ComparisonCompositeSingle, self).__init__(operator=operator)
+        super().__init__(operator=operator)
         self.rule = rule
 
 
@@ -80,15 +80,13 @@ class ComparisonCompositeMulti(ComparisonComposite, abc.ABC):
     rules: Final[list[ChoiceRule]]
 
     def __init__(self, operator: ComparisonComposite.ChoiceOp, rules: list[ChoiceRule]):
-        super(ComparisonCompositeMulti, self).__init__(operator=operator)
+        super().__init__(operator=operator)
         self.rules = rules
 
 
 class ComparisonCompositeNot(ComparisonCompositeSingle):
     def __init__(self, rule: ChoiceRule):
-        super(ComparisonCompositeNot, self).__init__(
-            operator=ComparisonComposite.ChoiceOp.Not, rule=rule
-        )
+        super().__init__(operator=ComparisonComposite.ChoiceOp.Not, rule=rule)
 
     def _eval_body(self, env: Environment) -> None:
         self.rule.eval(env)
@@ -99,9 +97,7 @@ class ComparisonCompositeNot(ComparisonCompositeSingle):
 
 class ComparisonCompositeAnd(ComparisonCompositeMulti):
     def __init__(self, rules: list[ChoiceRule]):
-        super(ComparisonCompositeAnd, self).__init__(
-            operator=ComparisonComposite.ChoiceOp.And, rules=rules
-        )
+        super().__init__(operator=ComparisonComposite.ChoiceOp.And, rules=rules)
 
     def _eval_body(self, env: Environment) -> None:
         res = True
@@ -116,9 +112,7 @@ class ComparisonCompositeAnd(ComparisonCompositeMulti):
 
 class ComparisonCompositeOr(ComparisonCompositeMulti):
     def __init__(self, rules: list[ChoiceRule]):
-        super(ComparisonCompositeOr, self).__init__(
-            operator=ComparisonComposite.ChoiceOp.Or, rules=rules
-        )
+        super().__init__(operator=ComparisonComposite.ChoiceOp.Or, rules=rules)
 
     def _eval_body(self, env: Environment) -> None:
         res = False

localstack/services/stepfunctions/asl/component/state/state_choice/state_choice.py

@@ -17,7 +17,7 @@ class StateChoice(CommonStateField):
     default_state: DefaultDecl | None
 
     def __init__(self):
-        super(StateChoice, self).__init__(
+        super().__init__(
             state_entered_event_type=HistoryEventType.ChoiceStateEntered,
             state_exited_event_type=HistoryEventType.ChoiceStateExited,
         )
@@ -25,7 +25,7 @@ class StateChoice(CommonStateField):
         self._next_state_name = None
 
     def from_state_props(self, state_props: StateProps) -> None:
-        super(StateChoice, self).from_state_props(state_props)
+        super().from_state_props(state_props)
         self.choices_decl = state_props.get(ChoicesDecl)
         self.default_state = state_props.get(DefaultDecl)
 

localstack/services/stepfunctions/asl/component/state/state_execution/state_map/state_map.py

@@ -115,13 +115,13 @@ class StateMap(ExecutionState):
     result_writer: ResultWriter | None
 
     def __init__(self):
-        super(StateMap, self).__init__(
+        super().__init__(
             state_entered_event_type=HistoryEventType.MapStateEntered,
             state_exited_event_type=HistoryEventType.MapStateExited,
         )
 
     def from_state_props(self, state_props: StateProps) -> None:
-        super(StateMap, self).from_state_props(state_props)
+        super().from_state_props(state_props)
         if self._is_language_query_jsonpath():
             self.items = None
             self.items_path = state_props.get(ItemsPath) or ItemsPath(

localstack/services/stepfunctions/asl/component/state/state_execution/state_parallel/state_parallel.py

@@ -33,7 +33,7 @@ class StateParallel(ExecutionState):
         )
 
     def from_state_props(self, state_props: StateProps) -> None:
-        super(StateParallel, self).from_state_props(state_props)
+        super().from_state_props(state_props)
         self.branches = state_props.get(
             typ=BranchesDecl,
             raise_on_missing=ValueError(f"Missing Branches definition in props '{state_props}'."),

localstack/services/stepfunctions/asl/component/state/state_execution/state_task/state_task.py

@@ -35,13 +35,13 @@ class StateTask(ExecutionState, abc.ABC):
     credentials: Credentials | None
 
     def __init__(self):
-        super(StateTask, self).__init__(
+        super().__init__(
             state_entered_event_type=HistoryEventType.TaskStateEntered,
             state_exited_event_type=HistoryEventType.TaskStateExited,
         )
 
     def from_state_props(self, state_props: StateProps) -> None:
-        super(StateTask, self).from_state_props(state_props)
+        super().from_state_props(state_props)
         self.resource = state_props.get(Resource)
         self.parargs = state_props.get(Parargs)
         self.credentials = state_props.get(Credentials)

localstack/services/stepfunctions/asl/component/state/state_fail/state_fail.py

@@ -24,7 +24,7 @@ class StateFail(CommonStateField):
         self.error: ErrorDecl | None = None
 
     def from_state_props(self, state_props: StateProps) -> None:
-        super(StateFail, self).from_state_props(state_props)
+        super().from_state_props(state_props)
         self.cause = state_props.get(CauseDecl)
         self.error = state_props.get(ErrorDecl)
 

localstack/services/stepfunctions/asl/component/state/state_pass/state_pass.py

@@ -11,7 +11,7 @@ from localstack.services.stepfunctions.asl.eval.environment import Environment
 
 class StatePass(CommonStateField):
     def __init__(self):
-        super(StatePass, self).__init__(
+        super().__init__(
             state_entered_event_type=HistoryEventType.PassStateEntered,
             state_exited_event_type=HistoryEventType.PassStateExited,
         )
@@ -32,7 +32,7 @@ class StatePass(CommonStateField):
         self.parameters: Parameters | None = None
 
     def from_state_props(self, state_props: StateProps) -> None:
-        super(StatePass, self).from_state_props(state_props)
+        super().from_state_props(state_props)
         self.result = state_props.get(Result)
         self.result_path = state_props.get(ResultPath) or ResultPath(
             result_path_src=ResultPath.DEFAULT_PATH

localstack/services/stepfunctions/asl/component/state/state_succeed/state_succeed.py

@@ -17,7 +17,7 @@ class StateSucceed(CommonStateField):
         )
 
     def from_state_props(self, state_props: StateProps) -> None:
-        super(StateSucceed, self).from_state_props(state_props)
+        super().from_state_props(state_props)
         # TODO: assert all other fields are undefined?
 
         # No Next or End field: Succeed states are terminal states.

localstack/services/stepfunctions/asl/component/state/state_wait/state_wait.py

@@ -19,7 +19,7 @@ class StateWait(CommonStateField):
         )
 
     def from_state_props(self, state_props: StateProps) -> None:
-        super(StateWait, self).from_state_props(state_props)
+        super().from_state_props(state_props)
         self.wait_function = state_props.get(
             typ=WaitFunction,
             raise_on_missing=ValueError(f"Undefined WaitFunction for StateWait: '{self}'."),

localstack/services/stepfunctions/asl/eval/environment.py

@@ -73,7 +73,7 @@ class Environment:
         variable_store: VariableStore | None = None,
         mock_test_case: MockTestCase | None = None,
     ):
-        super(Environment, self).__init__()
+        super().__init__()
         self._state_mutex = threading.RLock()
         self._program_state = None
         self.program_state_event = threading.Event()

localstack/services/stepfunctions/asl/jsonata/jsonata.py

@@ -7,7 +7,7 @@ from pathlib import Path
 from typing import Any, Final
 
 import jpype
-import jpype.imports
+import jpype.imports  # noqa # Required for JVM Java class imports
 
 from localstack.services.stepfunctions.asl.utils.encoding import to_json_str
 from localstack.services.stepfunctions.packages import jpype_jsonata_package

localstack/services/stepfunctions/backend/execution.py

@@ -356,10 +356,11 @@ class Execution:
         try:
             self._get_events_client().put_events(Entries=[entry])
         except Exception:
-            LOG.exception(
+            LOG.error(
                 "Unable to send notification of Entry='%s' for Step Function execution with Arn='%s' to EventBridge.",
                 entry,
                 self.exec_arn,
+                exc_info=LOG.isEnabledFor(logging.DEBUG),
             )
 
 

localstack/services/stores.py

@@ -238,7 +238,7 @@ class RegionBundle(dict, Generic[BaseStoreType]):
 
                 store_obj._global = self._global
                 store_obj._universal = self._universal
-                store_obj.service_name = self.service_name
+                store_obj._service_name = self.service_name
                 store_obj._account_id = self.account_id
                 store_obj._region_name = region_name
 

localstack/services/transcribe/provider.py

@@ -412,4 +412,9 @@ class TranscribeProvider(TranscribeApi):
             job["FailureReason"] = failure_reason or str(exc)
             job["TranscriptionJobStatus"] = TranscriptionJobStatus.FAILED
 
-            LOG.exception("Transcription job %s failed: %s", job_name, job["FailureReason"])
+            LOG.error(
+                "Transcription job %s failed: %s",
+                job_name,
+                job["FailureReason"],
+                exc_info=LOG.isEnabledFor(logging.DEBUG),
+            )

localstack/state/codecs.py

@@ -0,0 +1,61 @@
+"""Factory for encoders and decoders"""
+
+from localstack import config
+from localstack.state import Decoder, Encoder
+from localstack.state.pickle import PickleDecoder, PickleEncoder
+
+ENCODERS = {
+    "dill": PickleEncoder,
+}
+"""Encoders that map to the name of ``STATE_SERIALIZATION_BACKEND``."""
+
+DECODERS = {
+    "dill": PickleDecoder,
+}
+"""Decoders that map to the name of ``STATE_SERIALIZATION_BACKEND``."""
+
+
+def create_encoder(encoder_type: str) -> Encoder:
+    cls = ENCODERS.get(encoder_type)
+    if cls is None:
+        raise ValueError(f"Unknown encoder type: {encoder_type}")
+    return cls()
+
+
+def create_decoder(decoder_type: str) -> Decoder:
+    cls = DECODERS.get(decoder_type, PickleDecoder)
+    if cls is None:
+        raise ValueError(f"Unknown decoder type: {decoder_type}")
+    return cls()
+
+
+def get_default_encoder() -> Encoder:
+    """
+    Gets the default encoder based on the state serialization backend defined in the configuration
+    ``STATE_SERIALIZATION_BACKEND``.
+
+    If the serialization backend specified in the configuration leads to an error
+    (such as an invalid backend), a ``PickleEncoder`` is returned as a fallback.
+
+    :return: The default encoder for state serialization.
+    """
+    try:
+        return create_encoder(config.STATE_SERIALIZATION_BACKEND)
+    except ValueError:
+        return PickleEncoder()
+
+
+def get_default_decoder() -> Decoder:
+    """
+    Gets the default decoder based on the state serialization backend defined in the configuration
+    ``STATE_SERIALIZATION_BACKEND``.
+
+    If the serialization backend specified in the configuration leads to an error
+    (such as an invalid backend), a ``PickleDecoder`` is returned as a fallback.
+
+    :return: The default decoder for state serialization.
+    """
+    try:
+        return create_decoder(config.STATE_SERIALIZATION_BACKEND)
+    except ValueError:
+        return PickleDecoder()

localstack/state/core.py

@@ -97,42 +97,48 @@ class AssetDirectory:
 
 
 class Encoder:
-    def encodes(self, obj: Any) -> bytes:
+    def encodes(self, obj: Any, py_type: type = None) -> bytes:
         """
         Encode an object into bytes.
 
         :param obj: the object to encode
+        :param py_type: the type of the object. needed by some encoders that don't have implicit type knowledge.
         :return: the encoded object
         """
         b = io.BytesIO()
         self.encode(obj, b)
         return b.getvalue()
 
-    def encode(self, obj: Any, file: IO[bytes]):
+    def encode(self, obj: Any, file: IO[bytes], py_type: type = None):
         """
         Encode an object into bytes.
 
         :param obj: the object to encode
+        :param py_type: the type of the object. needed by some encoders that don't have implicit type knowledge.
         :param file: the file to write the encoded data into
         """
         raise NotImplementedError
 
 
 class Decoder:
-    def decodes(self, data: bytes) -> Any:
+    def decodes(self, data: bytes, py_type: type = None) -> Any:
         """
         Decode a previously encoded object.
 
         :param data: the encoded object to decode
+        :param py_type: the type that is expected as return type. Needed by some decoders that don't have implicit
+        type knowledge.
         :return: the decoded object
         """
-        return self.decode(io.BytesIO(data))
+        return self.decode(io.BytesIO(data), py_type)
 
-    def decode(self, file: IO[bytes]) -> Any:
+    def decode(self, file: IO[bytes], py_type: type = None) -> Any:
         """
         Decode a previously encoded object.
 
         :param file: the io object containing the object to decode
+        :param py_type: the type that is expected as return type. Needed by some decoders that don't have implicit
+        type knowledge.
         :return: the decoded object
         """
         raise NotImplementedError

localstack/state/pickle.py

@@ -30,14 +30,11 @@ https://dill.readthedocs.io/en/latest/index.html?highlight=register#dill.Pickler
 
 import inspect
 from collections.abc import Callable
-from typing import IO, Any, BinaryIO, Generic, TypeVar
+from typing import Any, BinaryIO, Generic, TypeVar
 
 import dill
-import jsonpickle
 from dill._dill import MetaCatchingDict
 
-from localstack import config
-
 from .core import Decoder, Encoder
 
 _T = TypeVar("_T")
@@ -64,7 +61,7 @@ def register(cls: type = None, subclasses: bool = False):
         elif callable(fn):
             add_dispatch_entry(cls, fn, subclasses=subclasses)
         else:
-            raise ValueError("cannot register %s" % fn)
+            raise ValueError(f"cannot register {fn}")
 
         return fn
 
@@ -240,7 +237,7 @@ class PickleEncoder(Encoder):
     def __init__(self, pickler_class: type[dill.Pickler] = None):
         self.pickler_class = pickler_class or Pickler
 
-    def encode(self, obj: Any, file: BinaryIO):
+    def encode(self, obj: Any, file: BinaryIO, py_type: type = None) -> Any:
         return self.pickler_class(file).dump(obj)
 
 
@@ -255,56 +252,20 @@ class PickleDecoder(Decoder):
     def __init__(self, unpickler_class: type[dill.Unpickler] = None):
         self.unpickler_class = unpickler_class or dill.Unpickler
 
-    def decode(self, file: BinaryIO) -> Any:
+    def decode(self, file: BinaryIO, py_type=None) -> Any:
         return self.unpickler_class(file).load()
 
 
-class JsonEncoder(Encoder):
-    """
-    An Encoder that uses ``jsonpickle`` under the hood.
-    """
-
-    def __init__(self, pickler_class: type[jsonpickle.Pickler] = None):
-        self.pickler_class = pickler_class or jsonpickle.Pickler()
-
-    def encode(self, obj: Any, file: IO[bytes]):
-        json_str = jsonpickle.encode(obj, context=self.pickler_class)
-        file.write(json_str.encode("utf-8"))
-
-
-class JsonDecoder(Decoder):
-    """
-    A Decoder that uses ``jsonpickle`` under the hood.
-    """
-
-    unpickler_class: type[jsonpickle.Unpickler]
-
-    def __init__(self, unpickler_class: type[jsonpickle.Unpickler] = None):
-        self.unpickler_class = unpickler_class or jsonpickle.Unpickler()
-
-    def decode(self, file: IO[bytes]) -> Any:
-        json_str = file.read().decode("utf-8")
-        return jsonpickle.decode(json_str, context=self.unpickler_class)
-
-
 def get_default_encoder() -> Encoder:
-    match config.STATE_SERIALIZATION_BACKEND:
-        case "jsonpickle":
-            return JsonEncoder()
-        case "dill":
-            return PickleEncoder()
-        case _:
-            return PickleEncoder()
+    from .codecs import get_default_encoder
+
+    return get_default_encoder()
 
 
 def get_default_decoder() -> Decoder:
-    match config.STATE_SERIALIZATION_BACKEND:
-        case "jsonpickle":
-            return JsonDecoder()
-        case "dill":
-            return PickleDecoder()
-        case _:
-            return PickleDecoder()
+    from .codecs import get_default_decoder
+
+    return get_default_decoder()
 
 
 class ObjectStateReducer(Generic[_T]):

localstack/testing/aws/cloudformation_utils.py

@@ -29,7 +29,7 @@ def load_template_file(file_path: str | os.PathLike, *, path_ctx: str | os.PathL
     elif not file_path_obj.is_absolute():
         raise ValueError("Provided path must be absolute if no path_ctx is provided")
 
-    return load_file(file_path_obj.absolute())
+    return load_file(file_path_obj.absolute(), strict=True)
 
 
 # TODO: TBH this utility really doesn't add anything, probably better to just remove it

localstack/testing/pytest/cloudformation/fixtures.py

@@ -1,7 +1,7 @@
 import json
 from collections import defaultdict
-from collections.abc import Generator
-from typing import Callable, Optional, TypedDict
+from collections.abc import Callable, Generator
+from typing import TypedDict
 
 import pytest
 from botocore.exceptions import WaiterError
@@ -13,7 +13,7 @@ from localstack.utils.strings import short_uid
 
 
 class NormalizedEvent(TypedDict):
-    PhysicalResourceId: Optional[str]
+    PhysicalResourceId: str | None
     LogicalResourceId: str
     ResourceType: str
     ResourceStatus: str

localstack/testing/pytest/container.py

@@ -2,8 +2,7 @@ import logging
 import os
 import shlex
 import threading
-from collections.abc import Generator
-from typing import Callable, Optional
+from collections.abc import Callable, Generator
 
 import pytest
 
@@ -38,8 +37,8 @@ class ContainerFactory:
         self,
         # convenience properties
         pro: bool = False,
-        publish: Optional[list[int]] = None,
-        configurators: Optional[list[ContainerConfigurator]] = None,
+        publish: list[int] | None = None,
+        configurators: list[ContainerConfigurator] | None = None,
         # ContainerConfig properties
         **kwargs,
     ) -> Container:
@@ -172,7 +171,7 @@ def container_factory() -> Generator[ContainerFactory, None, None]:
 
 @pytest.fixture(scope="session")
 def wait_for_localstack_ready():
-    def _wait_for(container: RunningContainer, timeout: Optional[float] = None):
+    def _wait_for(container: RunningContainer, timeout: float | None = None):
         container.wait_until_ready(timeout)
 
         poll_condition(

localstack/testing/pytest/fixtures.py

@@ -6,7 +6,8 @@ import os
 import re
 import textwrap
 import time
-from typing import TYPE_CHECKING, Any, Callable, Optional, Unpack
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, Unpack
 
 import botocore.auth
 import botocore.config
@@ -232,7 +233,7 @@ def s3_create_bucket(s3_empty_bucket, aws_client):
 
     def factory(**kwargs) -> str:
         if "Bucket" not in kwargs:
-            kwargs["Bucket"] = "test-bucket-%s" % short_uid()
+            kwargs["Bucket"] = f"test-bucket-{short_uid()}"
 
         if (
             "CreateBucketConfiguration" not in kwargs
@@ -335,7 +336,7 @@ def sqs_create_queue(aws_client):
 
     def factory(**kwargs):
         if "QueueName" not in kwargs:
-            kwargs["QueueName"] = "test-queue-%s" % short_uid()
+            kwargs["QueueName"] = f"test-queue-{short_uid()}"
 
         response = aws_client.sqs.create_queue(**kwargs)
         url = response["QueueUrl"]
@@ -357,8 +358,8 @@ def sqs_create_queue(aws_client):
 def sqs_receive_messages_delete(aws_client):
     def factory(
         queue_url: str,
-        expected_messages: Optional[int] = None,
-        wait_time: Optional[int] = 5,
+        expected_messages: int | None = None,
+        wait_time: int | None = 5,
     ):
         response = aws_client.sqs.receive_message(
             QueueUrl=queue_url,
@@ -503,7 +504,7 @@ def sns_create_topic(aws_client):
 
     def _create_topic(**kwargs):
         if "Name" not in kwargs:
-            kwargs["Name"] = "test-topic-%s" % short_uid()
+            kwargs["Name"] = f"test-topic-{short_uid()}"
         response = aws_client.sns.create_topic(**kwargs)
         topic_arns.append(response["TopicArn"])
         return response
@@ -706,7 +707,7 @@ def route53_hosted_zone(aws_client):
 def transcribe_create_job(s3_bucket, aws_client):
     job_names = []
 
-    def _create_job(audio_file: str, params: Optional[dict[str, Any]] = None) -> str:
+    def _create_job(audio_file: str, params: dict[str, Any] | None = None) -> str:
         s3_key = "test-clip.wav"
 
         if not params:
@@ -1085,18 +1086,18 @@ def deploy_cfn_template(
 
     def _deploy(
         *,
-        is_update: Optional[bool] = False,
-        stack_name: Optional[str] = None,
-        change_set_name: Optional[str] = None,
-        template: Optional[str] = None,
-        template_path: Optional[str | os.PathLike] = None,
-        template_mapping: Optional[dict[str, Any]] = None,
-        parameters: Optional[dict[str, str]] = None,
-        role_arn: Optional[str] = None,
-        max_wait: Optional[int] = None,
-        delay_between_polls: Optional[int] = 2,
-        custom_aws_client: Optional[ServiceLevelClientFactory] = None,
-        raw_parameters: Optional[list[Parameter]] = None,
+        is_update: bool | None = False,
+        stack_name: str | None = None,
+        change_set_name: str | None = None,
+        template: str | None = None,
+        template_path: str | os.PathLike | None = None,
+        template_mapping: dict[str, Any] | None = None,
+        parameters: dict[str, str] | None = None,
+        role_arn: str | None = None,
+        max_wait: int | None = None,
+        delay_between_polls: int | None = 2,
+        custom_aws_client: ServiceLevelClientFactory | None = None,
+        raw_parameters: list[Parameter] | None = None,
     ) -> DeployResult:
         if is_update:
             assert stack_name
@@ -1137,9 +1138,16 @@ def deploy_cfn_template(
         change_set_id = response["Id"]
         stack_id = response["StackId"]
 
-        cfn_aws_client.cloudformation.get_waiter(WAITER_CHANGE_SET_CREATE_COMPLETE).wait(
-            ChangeSetName=change_set_id
-        )
+        try:
+            cfn_aws_client.cloudformation.get_waiter(WAITER_CHANGE_SET_CREATE_COMPLETE).wait(
+                ChangeSetName=change_set_id
+            )
+        except botocore.exceptions.WaiterError as e:
+            change_set = cfn_aws_client.cloudformation.describe_change_set(
+                ChangeSetName=change_set_id
+            )
+            raise Exception(f"{change_set['Status']}: {change_set.get('StatusReason')}") from e
+
         cfn_aws_client.cloudformation.execute_change_set(ChangeSetName=change_set_id)
         stack_waiter = cfn_aws_client.cloudformation.get_waiter(
             WAITER_STACK_UPDATE_COMPLETE if is_update else WAITER_STACK_CREATE_COMPLETE
@@ -1255,7 +1263,7 @@ def _has_stack_status(cfn_client, statuses: list[str]):
 
 @pytest.fixture
 def is_change_set_finished(aws_client):
-    def _is_change_set_finished(change_set_id: str, stack_name: Optional[str] = None):
+    def _is_change_set_finished(change_set_id: str, stack_name: str | None = None):
         def _inner():
             kwargs = {"ChangeSetName": change_set_id}
             if stack_name:
@@ -1986,7 +1994,7 @@ def setup_sender_email_address(ses_verify_identity):
     email address and verify them.
     """
 
-    def inner(sender_email_address: Optional[str] = None) -> str:
+    def inner(sender_email_address: str | None = None) -> str:
         if is_aws_cloud():
             if sender_email_address is None:
                 raise ValueError(
@@ -2245,7 +2253,7 @@ def assert_host_customisation(monkeypatch):
     def asserter(
         url: str,
         *,
-        custom_host: Optional[str] = None,
+        custom_host: str | None = None,
     ):
         if custom_host is not None:
             assert custom_host in url, f"Could not find `{custom_host}` in `{url}`"
@@ -2747,9 +2755,3 @@ def clean_up(
             call_safe(_delete_log_group)
 
     yield _clean_up
-
-
-@pytest.fixture(params=["dill", "jsonpickle"])
-def patch_default_encoder(request, monkeypatch):
-    backend = request.param
-    monkeypatch.setattr(config, "STATE_SERIALIZATION_BACKEND", backend)

localstack/testing/pytest/in_memory_localstack.py

@@ -63,8 +63,6 @@ def pytest_runtestloop(session: Session):
             return
         LOG.info("TEST_FORCE_LOCALSTACK_START is set, a Localstack instance will be created.")
 
-    from localstack.utils.common import safe_requests
-
     if is_aws_cloud():
         localstack_config.DEFAULT_DELAY = 5
         localstack_config.DEFAULT_MAX_ATTEMPTS = 60
@@ -73,8 +71,6 @@ def pytest_runtestloop(session: Session):
     os.environ[ENV_INTERNAL_TEST_RUN] = "1"
     localstack_config.INCLUDE_STACK_TRACES_IN_HTTP_RESPONSE = True
 
-    safe_requests.verify_ssl = False
-
     from localstack.runtime import current
 
     _started.set()