amulet-core 2.0a7__cp312-cp312-win_amd64.whl → 2.0.1a2.post250529084747__cp312-cp312-win_amd64.whl

amulet/utils/call_spec/_call_spec.py

@@ -1,257 +0,0 @@
-"""This modules contains classes to notify other code of the call specification for a function.
-The aim is to support generating GUIs without having to manually program a GUI to handle the function call.
-"""
-
-from __future__ import annotations
-
-from typing import (
-    Any,
-    Callable,
-    Protocol,
-    TypeVar,
-    cast,
-    ParamSpec,
-    overload,
-    Concatenate,
-    runtime_checkable,
-)
-from collections.abc import Sequence, Hashable
-from abc import ABC
-
-
-class AbstractArg(ABC):
-    """The base class for all arguments."""
-
-
-class AbstractHashableArg(AbstractArg, ABC):
-    """A base class for all arguments that are hashable."""
-
-
-class DocumentationArg(AbstractArg):
-    """A way to add documentation for an argument."""
-
-    def __init__(
-        self, arg: AbstractArg, name: str | None = None, description: str | None = None
-    ) -> None:
-        """Construct a DocumentationArg instance.
-
-        :param arg: The argument this documentation relates to.
-        :param name: The short name for the argument.
-        :param description: A longer description for the argument.
-        """
-        self.arg = arg
-        self.name = name
-        self.description = description
-
-
-class ConstantArg(AbstractArg):
-    """A constant argument.
-    Use this for fixed values.
-    """
-
-    def __init__(self, value: Any) -> None:
-        self.value = value
-
-
-class StringArg(AbstractHashableArg):
-    """A string argument"""
-
-    def __init__(self, default: str = "") -> None:
-        self.default = default
-
-
-class FilePathArg(StringArg):
-    """A path to a file on disk. Converts to a string."""
-
-
-class DirectoryPathArg(StringArg):
-    """A path to a directory on disk. Converts to a string."""
-
-
-class BytesArg(AbstractHashableArg):
-    """A bytes argument"""
-
-    def __init__(self, default: bytes = b"") -> None:
-        self.default = default
-
-
-class BoolArg(AbstractHashableArg):
-    """A bool argument"""
-
-    def __init__(self, default: bool = False) -> None:
-        self.default = default
-
-
-class IntArg(AbstractHashableArg):
-    """An int argument"""
-
-    def __init__(
-        self,
-        default: int = 0,
-        min_value: int | None = None,
-        max_value: int | None = None,
-    ) -> None:
-        self.default = default
-        self.min_value = min_value
-        self.max_value = max_value
-
-
-class FloatArg(AbstractHashableArg):
-    """A float argument"""
-
-    def __init__(
-        self,
-        default: float = 0,
-        min_value: float | None = None,
-        max_value: float | None = None,
-    ) -> None:
-        self.default = default
-        self.min_value = min_value
-        self.max_value = max_value
-
-
-class TupleArg(AbstractArg):
-    """A tuple argument"""
-
-    def __init__(self, *args: AbstractArg) -> None:
-        self.args = args
-
-
-class HashableTupleArg(AbstractArg):
-    """A tuple argument where all elements are hashable."""
-
-    def __init__(self, *args: AbstractHashableArg) -> None:
-        self.args = args
-
-
-class SequenceArg(AbstractArg):
-    """
-    A sequence of other arguments.
-    Each element must match element_type.
-    length must be a positive integer for a fixed length or None for unbounded length.
-    """
-
-    def __init__(
-        self,
-        element_type: AbstractArg,
-        default: Sequence[AbstractArg] = (),
-        min_length: int | None = None,
-        max_length: int | None = None,
-    ) -> None:
-        self.element_type = element_type
-        self.default = default
-        self.min_length = min_length
-        self.max_length = max_length
-
-
-class PositionalArgs(SequenceArg):
-    """A sequence of arguments that should be unpacked into the container.
-    This is useful when a CallableArg can take a variable number of an argument.
-    """
-
-
-class DictArg(AbstractArg):
-    """A dictionary argument"""
-
-    def __init__(self, key: AbstractHashableArg, value: AbstractArg) -> None:
-        self.key = key
-        self.value = value
-
-
-class UnionArg(AbstractArg):
-    """The object must match one of the types in args"""
-
-    def __init__(self, *args: AbstractArg) -> None:
-        self.args = args
-
-
-class HashableUnionArg(AbstractArg):
-    """The object must match one of the types in args"""
-
-    def __init__(self, *args: AbstractHashableArg) -> None:
-        self.args = args
-
-
-class CallableArg(AbstractArg):
-    """An argument generated by a function.
-    This can be used to create instances of classes.
-    kwargs specify the arguments to pass to the function.
-    """
-
-    def __init__(
-        self, func: Callable[..., Any], *args: AbstractArg, **kwargs: AbstractArg
-    ) -> None:
-        self.func = func
-        self.call_spec = CallSpec(*args, **kwargs)
-
-
-class HashableCallableArg(AbstractHashableArg):
-    """An argument generated by a function.
-    This can be used to create instances of classes.
-    kwargs specify the arguments to pass to the function.
-    """
-
-    def __init__(self, func: Callable[..., Hashable], call_spec: CallSpec) -> None:
-        self.func = func
-        self.call_spec = call_spec
-
-
-class CallSpec:
-    """Arguments and keyword arguments that should be unpacked to call a function."""
-
-    def __init__(self, *args: AbstractArg, **kwargs: AbstractArg) -> None:
-        self.args = args
-        self.kwargs = kwargs
-
-
-# The following is a really janky workaround to add a variable to a function or method in a way that mypy likes.
-# This would be made so much simpler if Python had an Intersection type hint.
-
-P = ParamSpec("P")
-R = TypeVar("R", covariant=True)
-
-
-@runtime_checkable
-class TypedCallable(Protocol[P, R]):
-    call_spec: CallSpec
-
-    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> R: ...
-
-
-@runtime_checkable
-class TypedMethod(Protocol[P, R]):
-    call_spec: CallSpec
-
-    def __call__(self, self_: Any, *args: P.args, **kwargs: P.kwargs) -> R: ...
-
-    @overload
-    def __get__(self, instance: None, owner: None) -> TypedMethod[P, R]: ...
-
-    @overload
-    def __get__(self, instance: object, owner: object) -> TypedCallable[P, R]: ...
-
-
-def callable_spec(
-    *args: AbstractArg, **kwargs: AbstractArg
-) -> Callable[[Callable[P, R]], TypedCallable[P, R]]:
-    call_spec: CallSpec = CallSpec(*args, **kwargs)
-
-    def wrap(func: Callable[P, R]) -> TypedCallable[P, R]:
-        func_ = cast(TypedCallable[P, R], func)
-        func_.call_spec = call_spec
-        return func_
-
-    return wrap
-
-
-def method_spec(
-    *args: AbstractArg, **kwargs: AbstractArg
-) -> Callable[[Callable[Concatenate[Any, P], R]], TypedMethod[P, R]]:
-    call_spec: CallSpec = CallSpec(*args, **kwargs)
-
-    def wrap(func: Callable[Concatenate[Any, P], R]) -> TypedMethod[P, R]:
-        func_ = cast(TypedMethod[P, R], func)
-        func_.call_spec = call_spec
-        return func_
-
-    return wrap

amulet/utils/comment_json.py

@@ -1,188 +0,0 @@
-from json import JSONDecodeError, loads as json_loads
-from typing import TextIO, Union
-
-"""
-Some of the Bedrock json files contain comments which is not valid JSON and the standard json parser
-will throw errors. This will first try and use the vanilla json parser and fall back to the slower version if that fails.
-"""
-
-
-JSONValue = Union[str, int, float, bool, None, "JSONDict", "JSONList"]
-JSONDict = dict[str, JSONValue]
-JSONList = list[JSONValue]
-
-
-class CommentJSONDecodeError(JSONDecodeError):
-    pass
-
-
-def from_file(path: str) -> JSONValue:
-    with open(path) as f:
-        return load(f)
-
-
-def load(obj: TextIO) -> JSONValue:
-    return loads(obj.read())
-
-
-def loads(s: str) -> JSONValue:
-    try:
-        return json_loads(s)  # type: ignore
-    except JSONDecodeError:
-        return _loads(s)
-
-
-def _loads(text: str) -> JSONValue:
-    # given a valid MinecraftJSON string will return the values as python objects
-    # in this context MinecraftJSON is standard JSON but with comment blocks and
-    # line comments that would normally be illegal in standard JSON
-    _number = set("0123456789-")
-    _float = set("0123456789-.")
-    _whitespace = set(" \t\r\n")
-
-    def strip_whitespace(index: int) -> int:
-        # skips whitespace characters (<space>, <tab>, <charrage return> and <newline>)
-        # as well as block comments and line comments
-        while text[index] in _whitespace:
-            index += 1
-        if text[index] == "/":
-            if text[index + 1] == "/":
-                index += 2
-                while text[index] != "\n":
-                    index += 1
-                index = strip_whitespace(index)
-            elif text[index + 1] == "*":
-                index += 2
-                while text[index : index + 2] != "*/":
-                    index += 1
-                    if index + 1 >= len(text):
-                        raise JSONDecodeError(
-                            "expected */ but reached the end of file", text, index
-                        )
-                index += 2
-                index = strip_whitespace(index)
-            else:
-                raise JSONDecodeError(f"unexpected / at index {index}", text, index)
-        return index
-
-    def parse_json_recursive(index: int = 0) -> tuple[JSONValue, int]:
-        index = strip_whitespace(index)
-        if text[index] == "{":
-            index += 1
-            # dictionary
-            json_obj = {}
-            repeat = True
-            while repeat:
-                index = strip_whitespace(index)
-                # }"
-                if text[index] == '"':
-                    index += 1
-                    key = ""
-                    while text[index] != '"':
-                        key += text[index]
-                        index += 1
-                    index += 1
-
-                    index = strip_whitespace(index)
-
-                    if text[index] == ":":
-                        index += 1
-                    else:
-                        raise JSONDecodeError(
-                            f"expected : got {text[index]} at index {index}",
-                            text,
-                            index,
-                        )
-
-                    index = strip_whitespace(index)
-
-                    json_obj[key], index = parse_json_recursive(index)
-
-                    index = strip_whitespace(index)
-
-                    if text[index] == ",":
-                        index += 1
-                    else:
-                        repeat = False
-                else:
-                    repeat = False
-
-            if index >= len(text):
-                raise JSONDecodeError("expected } but reached end of file", text, index)
-            elif text[index] == "}":
-                index += 1
-            else:
-                raise JSONDecodeError(
-                    f"expected }} got {text[index]} at index {index}", text, index
-                )
-            return json_obj, index
-
-        elif text[index] == "[":
-            index += 1
-            # list
-            json_array = []
-            index = strip_whitespace(index)
-            repeat = text[index] != "]"
-            while repeat:
-                val, index = parse_json_recursive(index)
-                json_array.append(val)
-
-                index = strip_whitespace(index)
-
-                if text[index] == ",":
-                    index += 1
-                else:
-                    repeat = False
-                index = strip_whitespace(index)
-
-            if index >= len(text):
-                raise JSONDecodeError("expected ] but reached end of file", text, index)
-            elif text[index] == "]":
-                index += 1
-            else:
-                raise JSONDecodeError(
-                    f"expected ] got {text[index]} at index {index}", text, index
-                )
-            return json_array, index
-
-        elif text[index] == '"':
-            index += 1
-            # string
-            json_obj_list = []
-            while text[index] != '"':
-                json_obj_list.append(text[index])
-                index += 1
-            index += 1
-            return "".join(json_obj_list), index
-
-        elif text[index] in _number:
-            # number
-            json_obj_list = []
-            while text[index] in _float:
-                json_obj_list += text[index]
-                index += 1
-            if "." in json_obj_list:
-                return float("".join(json_obj_list)), index
-            else:
-                return int("".join(json_obj_list)), index
-
-        elif text[index] == "n" and text[index : index + 4] == "null":
-            index += 4
-            return None, index
-
-        elif text[index] == "t" and text[index : index + 4] == "true":
-            index += 4
-            return True, index
-
-        elif text[index] == "f" and text[index : index + 5] == "false":
-            index += 5
-            return False, index
-        else:
-            raise JSONDecodeError(
-                f'unexpected key {text[index]} at {index}. Expected {{, [, ", num, null, true or false',
-                text,
-                index,
-            )
-
-    # call recursive function and pass back python object
-    return parse_json_recursive()[0]

amulet/utils/format_utils.py

@@ -1,41 +0,0 @@
-from __future__ import annotations
-
-import os
-import warnings
-
-from amulet_nbt import read_nbt, NamedTag
-
-
-def check_all_exist(in_dir: str, *args: str) -> bool:
-    """
-    Check that all files exist in a parent directory
-
-    :param in_dir: The parent directory
-    :param args: file or folder names to look for
-    :return: Boolean value indicating whether all were found
-    """
-
-    return all(os.path.exists(os.path.join(in_dir, child)) for child in args)
-
-
-def check_one_exists(in_dir: str, *args: str) -> bool:
-    """
-    Check that at least one file exists in a parent directory
-
-    :param in_dir: The parent directory
-    :param args: file or folder names to look for
-    :return: Boolean value indicating whether at least one was found
-    """
-
-    return any(os.path.exists(os.path.join(in_dir, child)) for child in args)
-
-
-def load_leveldat(in_dir: str) -> NamedTag:
-    """
-    Load the root tag of the level.dat file in the directory
-
-    :param in_dir: The world directory containing the level.dat file
-    :return: The NBT root tag
-    """
-    warnings.warn("load_leveldat is depreciated.", DeprecationWarning)
-    return read_nbt(os.path.join(in_dir, "level.dat"))

amulet/utils/generator.py

@@ -1,18 +0,0 @@
-from typing import Generator, TypeVar, Any
-
-
-T = TypeVar("T")
-
-
-def generator_unpacker(gen: Generator[Any, Any, T]) -> T:
-    """
-    Unpack a generator and return the value returned by the generator.
-
-    :param gen: The generator to unpack.
-    :return: The value that was returned by the generator.
-    """
-    try:
-        while True:
-            next(gen)
-    except StopIteration as e:
-        return e.value  # type: ignore