playground-ls-cli 4.14.1.dev8__py3-none-any.whl

localstack_cli/utils/objects.py

@@ -0,0 +1,235 @@
+import functools
+import re
+import threading
+from collections.abc import Callable
+from typing import Any, Generic, TypeVar
+
+from .collections import ensure_list
+from .strings import first_char_to_lower, first_char_to_upper
+
+ComplexType = list | dict | object
+
+_T = TypeVar("_T")
+
+
+class Value(Generic[_T]):
+    """
+    Simple value container.
+    """
+
+    value: _T | None
+
+    def __init__(self, value: _T = None) -> None:
+        self.value = value
+
+    def clear(self):
+        self.value = None
+
+    def set(self, value: _T):
+        self.value = value
+
+    def is_set(self) -> bool:
+        return self.value is not None
+
+    def get(self) -> _T | None:
+        return self.value
+
+    def __bool__(self):
+        return True if self.value else False
+
+
+class ArbitraryAccessObj:
+    """Dummy object that can be arbitrarily accessed - any attributes, as a callable, item assignment, ..."""
+
+    def __init__(self, name=None):
+        self.name = name
+
+    def __getattr__(self, name, *args, **kwargs):
+        return ArbitraryAccessObj(name)
+
+    def __call__(self, *args, **kwargs):
+        if self.name in ["items", "keys", "values"] and not args and not kwargs:
+            return []
+        return ArbitraryAccessObj()
+
+    def __getitem__(self, *args, **kwargs):
+        return ArbitraryAccessObj()
+
+    def __setitem__(self, *args, **kwargs):
+        return ArbitraryAccessObj()
+
+
+class Mock:
+    """Dummy class that can be used for mocking custom attributes."""
+
+    pass
+
+
+class ObjectIdHashComparator:
+    """Simple wrapper class that allows us to create a hashset using the object id(..) as the entries' hash value"""
+
+    def __init__(self, obj):
+        self.obj = obj
+        self._hash = id(obj)
+
+    def __hash__(self):
+        return self._hash
+
+    def __eq__(self, other):
+        # assumption here is that we're comparing only against ObjectIdHash instances!
+        return self.obj == other.obj
+
+
+class SubtypesInstanceManager:
+    """Simple instance manager base class that scans the subclasses of a base type for concrete named
+    implementations, and lazily creates and returns (singleton) instances on demand."""
+
+    _instances: dict[str, "SubtypesInstanceManager"]
+
+    @classmethod
+    def get(cls, subtype_name: str, raise_if_missing: bool = True):
+        instances = cls.instances()
+        base_type = cls.get_base_type()
+        instance = instances.get(subtype_name)
+        if instance is None:
+            # lazily load subtype instance (required if new plugins are dynamically loaded at runtime)
+            for clazz in get_all_subclasses(base_type):
+                impl_name = clazz.impl_name()
+                if impl_name not in instances and subtype_name == impl_name:
+                    instances[impl_name] = clazz()
+            instance = instances.get(subtype_name)
+        if not instance and raise_if_missing:
+            raise NotImplementedError(
+                f"Unable to find implementation named '{subtype_name}' for base type {base_type}"
+            )
+        return instance
+
+    @classmethod
+    def instances(cls) -> dict[str, "SubtypesInstanceManager"]:
+        base_type = cls.get_base_type()
+        if not hasattr(base_type, "_instances"):
+            base_type._instances = {}
+        return base_type._instances
+
+    @staticmethod
+    def impl_name() -> str:
+        """Name of this concrete subtype - to be implemented by subclasses."""
+        raise NotImplementedError
+
+    @classmethod
+    def get_base_type(cls) -> type:
+        """Get the base class for which instances are being managed - can be customized by subtypes."""
+        return cls
+
+
+# this requires that all subclasses have been imported before(!)
+def get_all_subclasses(clazz: type) -> set[type]:
+    """Recursively get all subclasses of the given class."""
+    result = set()
+    subs = clazz.__subclasses__()
+    for sub in subs:
+        result.add(sub)
+        result.update(get_all_subclasses(sub))
+    return result
+
+
+def fully_qualified_class_name(klass: type) -> str:
+    return f"{klass.__module__}.{klass.__name__}"
+
+
+def not_none_or(value: Any | None, alternative: Any) -> Any:
+    """Return 'value' if it is not None, or 'alternative' otherwise."""
+    return value if value is not None else alternative
+
+
+def recurse_object(obj: ComplexType, func: Callable, path: str = "") -> ComplexType:
+    """Recursively apply `func` to `obj` (might be a list, dict, or other object)."""
+    obj = func(obj, path=path)
+    if isinstance(obj, list):
+        for i in range(len(obj)):
+            tmp_path = f"{path or '.'}[{i}]"
+            obj[i] = recurse_object(obj[i], func, tmp_path)
+    elif isinstance(obj, dict):
+        for k, v in obj.items():
+            tmp_path = f"{f'{path}.' if path else ''}{k}"
+            obj[k] = recurse_object(v, func, tmp_path)
+    return obj
+
+
+def keys_to(
+    obj: ComplexType, op: Callable[[str], str], skip_children_of: list[str] = None
+) -> ComplexType:
+    """Recursively changes all dict keys to apply op. Skip children
+    of any elements whose names are contained in skip_children_of (e.g., ['Tags'])"""
+    skip_children_of = ensure_list(skip_children_of or [])
+
+    def fix_keys(o, path="", **kwargs):
+        if any(re.match(rf"(^|.*\.){k}($|[.\[].*)", path) for k in skip_children_of):
+            return o
+        if isinstance(o, dict):
+            for k, v in dict(o).items():
+                o.pop(k)
+                o[op(k)] = v
+        return o
+
+    result = recurse_object(obj, fix_keys)
+    return result
+
+
+def keys_to_lower(obj: ComplexType, skip_children_of: list[str] = None) -> ComplexType:
+    return keys_to(obj, first_char_to_lower, skip_children_of)
+
+
+def keys_to_upper(obj: ComplexType, skip_children_of: list[str] = None) -> ComplexType:
+    return keys_to(obj, first_char_to_upper, skip_children_of)
+
+
+def singleton_factory(factory: Callable[[], _T]) -> Callable[[], _T]:
+    """
+    Decorator for methods that create a particular value once and then return the same value in a thread safe way.
+
+    :param factory: the method to decorate
+    :return: a threadsafe singleton factory
+    """
+    lock = threading.RLock()
+    instance: Value[_T] = Value()
+
+    @functools.wraps(factory)
+    def _singleton_factory() -> _T:
+        if instance.is_set():
+            return instance.get()
+
+        with lock:
+            if not instance:
+                instance.set(factory())
+
+            return instance.get()
+
+    _singleton_factory.clear = instance.clear
+
+    return _singleton_factory
+
+
+def get_value_from_path(data, path):
+    keys = path.split(".")
+    try:
+        result = functools.reduce(dict.__getitem__, keys, data)
+        return result
+    except KeyError:
+        # Handle the case where the path is not valid for the given dictionary
+        return None
+
+
+def set_value_at_path(data, path, new_value):
+    keys = path.split(".")
+    last_key = keys[-1]
+
+    # Traverse the dictionary to the second-to-last level
+    nested_dict = functools.reduce(dict.__getitem__, keys[:-1], data)
+
+    try:
+        # Set the new value
+        nested_dict[last_key] = new_value
+    except KeyError:
+        # Handle the case where the path is not valid for the given dictionary
+        raise ValueError(f"Invalid path: {path}")

localstack_cli/utils/patch.py

@@ -0,0 +1,260 @@
+import functools
+import inspect
+import types
+from collections.abc import Callable
+from typing import Any
+
+
+def get_defining_object(method):
+    """Returns either the class or the module that defines the given function/method."""
+    # adapted from https://stackoverflow.com/a/25959545/804840
+    if inspect.ismethod(method):
+        return method.__self__
+
+    if inspect.isfunction(method):
+        class_name = method.__qualname__.split(".<locals>", 1)[0].rsplit(".", 1)[0]
+        try:
+            # method is not bound but referenced by a class, like MyClass.mymethod
+            cls = getattr(inspect.getmodule(method), class_name)
+        except AttributeError:
+            cls = method.__globals__.get(class_name)
+
+        if isinstance(cls, type):
+            return cls
+
+    # method is a module-level function
+    return inspect.getmodule(method)
+
+
+def to_metadata_string(obj: Any) -> str:
+    """
+    Creates a string that helps humans understand where the given object comes from. Examples::
+
+      to_metadata_string(func_thread.run) == "function(localstack.utils.threads:FuncThread.run)"
+
+    :param obj: a class, module, method, function or object
+    :return: a string representing the objects origin
+    """
+    if inspect.isclass(obj):
+        return f"class({obj.__module__}:{obj.__name__})"
+    if inspect.ismodule(obj):
+        return f"module({obj.__name__})"
+    if inspect.ismethod(obj):
+        return f"method({obj.__module__}:{obj.__qualname__})"
+    if inspect.isfunction(obj):
+        # TODO: distinguish bound method
+        return f"function({obj.__module__}:{obj.__qualname__})"
+    if isinstance(obj, object):
+        return f"object({obj.__module__}:{obj.__class__.__name__})"
+    return str(obj)
+
+
+def create_patch_proxy(target: Callable, new: Callable):
+    """
+    Creates a proxy that calls `new` but passes as first argument the target.
+    """
+
+    @functools.wraps(target)
+    def proxy(*args, **kwargs):
+        if _is_bound_method:
+            # bound object "self" is passed as first argument if this is a bound method
+            args = args[1:]
+        return new(target, *args, **kwargs)
+
+    # keep track of the real proxy subject (i.e., the new function that is used as patch)
+    proxy.__subject__ = new
+
+    _is_bound_method = inspect.ismethod(target)
+    if _is_bound_method:
+        proxy = types.MethodType(proxy, target.__self__)
+
+    return proxy
+
+
+class Patch:
+    applied_patches: list["Patch"] = []
+    """Bookkeeping for patches that are applied. You can use this to debug patches. For instance,
+    you could write something like::
+
+      for patch in Patch.applied_patches:
+          print(patch)
+
+    Which will output in a human readable format information about the currently active patches.
+    """
+
+    obj: Any
+    name: str
+    new: Any
+
+    def __init__(self, obj: Any, name: str, new: Any) -> None:
+        super().__init__()
+        self.obj = obj
+        self.name = name
+        try:
+            self.old = getattr(self.obj, name)
+        except AttributeError:
+            self.old = None
+        self.new = new
+        self.is_applied = False
+
+    def apply(self):
+        if self.is_applied:
+            return
+
+        if self.old and self.name == "__getattr__":
+            raise Exception("You can't patch class types implementing __getattr__")
+        if not self.old and self.name != "__getattr__":
+            raise AttributeError(f"`{self.obj.__name__}` object has no attribute `{self.name}`")
+        setattr(self.obj, self.name, self.new)
+        Patch.applied_patches.append(self)
+        self.is_applied = True
+
+    def undo(self):
+        if not self.is_applied:
+            return
+
+        # If we added a method to a class type, we don't have a self.old. We just delete __getattr__
+        setattr(self.obj, self.name, self.old) if self.old else delattr(self.obj, self.name)
+        Patch.applied_patches.remove(self)
+        self.is_applied = False
+
+    def __enter__(self):
+        self.apply()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.undo()
+        return self
+
+    @staticmethod
+    def extend_class(target: type, fn: Callable):
+        def _getattr(obj, name):
+            if name != fn.__name__:
+                raise AttributeError(f"`{target.__name__}` object has no attribute `{name}`")
+
+            return functools.partial(fn, obj)
+
+        return Patch(target, "__getattr__", _getattr)
+
+    @staticmethod
+    def function(target: Callable, fn: Callable, pass_target: bool = True):
+        obj = get_defining_object(target)
+        name = target.__name__
+
+        is_class_instance = not inspect.isclass(obj) and not inspect.ismodule(obj)
+        if is_class_instance:
+            # special case: If the defining object is not a class, but a class instance,
+            # then we need to bind the patch function to the target object. Also, we need
+            # to ensure that the final patched method has the same name as the original
+            # method on the defining object (required for restoring objects with patched
+            # methods from persistence, to avoid AttributeError).
+            fn.__name__ = name
+            fn = types.MethodType(fn, obj)
+
+        if pass_target:
+            new = create_patch_proxy(target, fn)
+        else:
+            new = fn
+
+        return Patch(obj, name, new)
+
+    def __str__(self):
+        try:
+            # try to unwrap the original underlying function that is used as patch (basically undoes what
+            # ``create_patch_proxy`` does)
+            new = self.new.__subject__
+        except AttributeError:
+            new = self.new
+
+        old = self.old
+        return f"Patch({to_metadata_string(old)} -> {to_metadata_string(new)}, applied={self.is_applied})"
+
+
+class Patches:
+    patches: list[Patch]
+
+    def __init__(self, patches: list[Patch] = None) -> None:
+        super().__init__()
+
+        self.patches = []
+        if patches:
+            self.patches.extend(patches)
+
+    def apply(self):
+        for p in self.patches:
+            p.apply()
+
+    def undo(self):
+        for p in self.patches:
+            p.undo()
+
+    def __enter__(self):
+        self.apply()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.undo()
+
+    def add(self, patch: Patch):
+        self.patches.append(patch)
+
+    def function(self, target: Callable, fn: Callable, pass_target: bool = True):
+        self.add(Patch.function(target, fn, pass_target))
+
+
+def patch(target, pass_target=True):
+    """
+    Function decorator to create a patch via Patch.function and immediately apply it.
+
+    Example::
+
+        def echo(string):
+            return "echo " + string
+
+        @patch(target=echo)
+        def echo_uppercase(target, string):
+            return target(string).upper()
+
+        echo("foo")
+        # will print "ECHO FOO"
+
+        echo_uppercase.patch.undo()
+        echo("foo")
+        # will print "echo foo"
+
+    When you are patching classes, with ``pass_target=True``, the unbound function will be passed as the first
+    argument before ``self``.
+
+    For example::
+
+        @patch(target=MyEchoer.do_echo, pass_target=True)
+        def my_patch(fn, self, *args):
+            return fn(self, *args)
+
+        @patch(target=MyEchoer.do_echo, pass_target=False)
+        def my_patch(self, *args):
+            ...
+
+    This decorator can also patch a class type with a new method.
+
+    For example:
+        @patch(target=MyEchoer)
+        def new_echo(self, *args):
+            ...
+
+    :param target: the function or method to patch
+    :param pass_target: whether to pass the target to the patching function as first parameter
+    :returns: the same function, but with a patch created
+    """
+
+    @functools.wraps(target)
+    def wrapper(fn):
+        fn.patch = (
+            Patch.extend_class(target, fn)
+            if inspect.isclass(target)
+            else Patch.function(target, fn, pass_target=pass_target)
+        )
+        fn.patch.apply()
+        return fn
+
+    return wrapper

localstack_cli/utils/platform.py

@@ -0,0 +1,77 @@
+import platform
+from functools import lru_cache
+
+
+def is_mac_os() -> bool:
+    return "darwin" == platform.system().lower()
+
+
+def is_linux() -> bool:
+    return "linux" == platform.system().lower()
+
+
+def is_windows() -> bool:
+    return "windows" == platform.system().lower()
+
+
+@lru_cache
+def is_debian() -> bool:
+    from localstack_cli.utils.files import load_file
+
+    return "Debian" in load_file("/etc/issue", "")
+
+
+@lru_cache
+def is_redhat() -> bool:
+    from localstack_cli.utils.files import load_file
+
+    return "rhel" in load_file("/etc/os-release", "")
+
+
+class Arch(str):
+    """LocalStack standardised machine architecture names"""
+
+    amd64 = "amd64"
+    arm64 = "arm64"
+
+
+def standardized_arch(arch: str):
+    """
+    Returns LocalStack standardised machine architecture name.
+    """
+    if arch == "x86_64":
+        return Arch.amd64
+    if arch == "aarch64":
+        return Arch.arm64
+    return arch
+
+
+def get_arch() -> str:
+    """
+    Returns the current machine architecture.
+    """
+    arch = platform.machine()
+    return standardized_arch(arch)
+
+
+# TODO: implement proper architecture detection (e.g., test whether an architecture-specific binary actually runs)
+#   because this naive implementation does not cover cross-architecture emulation
+def is_arm_compatible() -> bool:
+    """Returns true if the current machine is compatible with ARM instructions and false otherwise."""
+    return get_arch() == Arch.arm64
+
+
+def get_os() -> str:
+    if is_mac_os():
+        return "osx"
+    if is_linux():
+        return "linux"
+    if is_windows():
+        return "windows"
+    raise ValueError("Unable to determine local operating system")
+
+
+def in_docker() -> bool:
+    from localstack_cli import config
+
+    return config.in_docker()