schemathesis 3.25.5__py3-none-any.whl → 4.0.0a1__py3-none-any.whl

schemathesis/specs/openapi/negative/mutations.py

@@ -1,5 +1,7 @@
 """Schema mutations."""
+
 from __future__ import annotations
+
 import enum
 from dataclasses import dataclass
 from functools import wraps
@@ -9,7 +11,8 @@ from hypothesis import reject
 from hypothesis import strategies as st
 from hypothesis.strategies._internal.featureflags import FeatureStrategy
 
-from ....internal.copy import fast_deepcopy
+from schemathesis.core.transforms import deepclone
+
 from ..utils import get_type, is_header_location
 from .types import Draw, Schema
 from .utils import can_negate
@@ -79,6 +82,10 @@ class MutationContext:
     def is_path_location(self) -> bool:
         return self.location == "path"
 
+    @property
+    def is_query_location(self) -> bool:
+        return self.location == "query"
+
     def mutate(self, draw: Draw) -> Schema:
         # On the top level, Schemathesis creates "object" schemas for all parameter "in" values except "body", which is
         # taken as-is. Therefore, we can only apply mutations that won't change the Open API semantics of the schema.
@@ -105,7 +112,7 @@ class MutationContext:
             # Body can be of any type and does not have any specific type semantic.
             mutations = draw(ordered(get_mutations(draw, self.keywords)))
         # Deep copy all keywords to avoid modifying the original schema
-        new_schema = fast_deepcopy(self.keywords)
+        new_schema = deepclone(self.keywords)
         enabled_mutations = draw(st.shared(FeatureStrategy(), key="mutations"))  # type: ignore
         # Always apply at least one mutation, otherwise everything is rejected, and we'd like to avoid it
         # for performance reasons
@@ -173,7 +180,7 @@ def remove_required_property(context: MutationContext, draw: Draw, schema: Schem
     else:
         candidate = draw(st.sampled_from(sorted(required)))
         enabled_properties = draw(st.shared(FeatureStrategy(), key="properties"))  # type: ignore
-        candidates = [candidate] + sorted([prop for prop in required if enabled_properties.is_enabled(prop)])
+        candidates = [candidate, *sorted([prop for prop in required if enabled_properties.is_enabled(prop)])]
         property_name = draw(st.sampled_from(candidates))
     required.remove(property_name)
     if not required:
@@ -201,8 +208,11 @@ def change_type(context: MutationContext, draw: Draw, schema: Schema) -> Mutatio
     if context.media_type == "application/x-www-form-urlencoded":
         # Form data should be an object, do not change it
         return MutationResult.FAILURE
-    # Headers are always strings, can't negate this
-    if context.is_header_location:
+    # For headers, query and path parameters, if the current type is string, then it already
+    # includes all possible values as those parameters will be stringified before sending,
+    # therefore it can't be negated.
+    types = get_type(schema)
+    if "string" in types and (context.is_header_location or context.is_path_location or context.is_query_location):
         return MutationResult.FAILURE
     candidates = _get_type_candidates(context, schema)
     if not candidates:
@@ -217,9 +227,10 @@ def change_type(context: MutationContext, draw: Draw, schema: Schema) -> Mutatio
     candidate = draw(st.sampled_from(sorted(candidates)))
     candidates.remove(candidate)
     enabled_types = draw(st.shared(FeatureStrategy(), key="types"))  # type: ignore
-    remaining_candidates = [candidate] + sorted(
-        [candidate for candidate in candidates if enabled_types.is_enabled(candidate)]
-    )
+    remaining_candidates = [
+        candidate,
+        *sorted([candidate for candidate in candidates if enabled_types.is_enabled(candidate)]),
+    ]
     new_type = draw(st.sampled_from(remaining_candidates))
     schema["type"] = new_type
     prevent_unsatisfiable_schema(schema, new_type)
@@ -362,6 +373,11 @@ def negate_constraints(context: MutationContext, draw: Draw, schema: Schema) ->
         # Should we negate this key?
         if k == "required":
             return v != []
+        if k in ("example", "examples"):
+            return False
+        if context.is_path_location and k == "minLength" and v == 1:
+            # Empty path parameter will be filtered out
+            return False
         return not (
             k in ("type", "properties", "items", "minItems")
             or (k == "additionalProperties" and context.is_header_location)

schemathesis/specs/openapi/parameters.py

@@ -1,13 +1,17 @@
 from __future__ import annotations
+
 import json
 from dataclasses import dataclass
-from typing import Any, ClassVar, Iterable
+from typing import TYPE_CHECKING, Any, ClassVar, Iterable
+
+from schemathesis.core.errors import InvalidSchema
+from schemathesis.schemas import Parameter
 
-from ...exceptions import OperationSchemaError
-from ...models import APIOperation
-from ...parameters import Parameter
 from .converter import to_json_schema_recursive
 
+if TYPE_CHECKING:
+    from ...schemas import APIOperation
+
 
 @dataclass(eq=False)
 class OpenAPIParameter(Parameter):
@@ -18,6 +22,8 @@ class OpenAPIParameter(Parameter):
     nullable_field: ClassVar[str]
     supported_jsonschema_keywords: ClassVar[tuple[str, ...]]
 
+    def _repr_pretty_(self, *args: Any, **kwargs: Any) -> None: ...
+
     @property
     def description(self) -> str | None:
         """A brief parameter description."""
@@ -47,16 +53,26 @@ class OpenAPIParameter(Parameter):
 
     @property
     def is_header(self) -> bool:
-        raise NotImplementedError
+        return self.location in ("header", "cookie")
 
-    def as_json_schema(self, operation: APIOperation) -> dict[str, Any]:
+    def as_json_schema(self, operation: APIOperation, *, update_quantifiers: bool = True) -> dict[str, Any]:
         """Convert parameter's definition to JSON Schema."""
+        # JSON Schema allows `examples` as an array
+        examples = []
+        if self.examples_field in self.definition:
+            examples.extend(
+                [example["value"] for example in self.definition[self.examples_field].values() if "value" in example]
+            )
+        if self.example_field in self.definition:
+            examples.append(self.definition[self.example_field])
         schema = self.from_open_api_to_json_schema(operation, self.definition)
-        return self.transform_keywords(schema)
+        if examples:
+            schema["examples"] = examples
+        return self.transform_keywords(schema, update_quantifiers=update_quantifiers)
 
-    def transform_keywords(self, schema: dict[str, Any]) -> dict[str, Any]:
+    def transform_keywords(self, schema: dict[str, Any], *, update_quantifiers: bool = True) -> dict[str, Any]:
         """Transform Open API specific keywords into JSON Schema compatible form."""
-        definition = to_json_schema_recursive(schema, self.nullable_field)
+        definition = to_json_schema_recursive(schema, self.nullable_field, update_quantifiers=update_quantifiers)
         # Headers are strings, but it is not always explicitly defined in the schema. By preparing them properly, we
         # can achieve significant performance improvements for such cases.
         # For reference (my machine) - running a single test with 100 examples with the resulting strategy:
@@ -116,12 +132,10 @@ class OpenAPI20Parameter(OpenAPIParameter):
         "uniqueItems",
         "enum",
         "multipleOf",
+        "example",
+        "examples",
     )
 
-    @property
-    def is_header(self) -> bool:
-        return self.location == "header"
-
 
 @dataclass(eq=False)
 class OpenAPI30Parameter(OpenAPIParameter):
@@ -162,12 +176,10 @@ class OpenAPI30Parameter(OpenAPIParameter):
         "properties",
         "additionalProperties",
         "format",
+        "example",
+        "examples",
     )
 
-    @property
-    def is_header(self) -> bool:
-        return self.location in ("header", "cookie")
-
     def from_open_api_to_json_schema(self, operation: APIOperation, open_api_schema: dict[str, Any]) -> dict[str, Any]:
         open_api_schema = get_parameter_schema(operation, open_api_schema)
         return super().from_open_api_to_json_schema(operation, open_api_schema)
@@ -216,15 +228,17 @@ class OpenAPI20Body(OpenAPIBody, OpenAPI20Parameter):
         "allOf",
         "properties",
         "additionalProperties",
+        "example",
+        "examples",
     )
     # NOTE. For Open API 2.0 bodies, we still give `x-example` precedence over the schema-level `example` field to keep
     # the precedence rules consistent.
 
-    def as_json_schema(self, operation: APIOperation) -> dict[str, Any]:
+    def as_json_schema(self, operation: APIOperation, *, update_quantifiers: bool = True) -> dict[str, Any]:
         """Convert body definition to JSON Schema."""
         # `schema` is required in Open API 2.0 when the `in` keyword is `body`
         schema = self.definition["schema"]
-        return self.transform_keywords(schema)
+        return self.transform_keywords(schema, update_quantifiers=update_quantifiers)
 
 
 FORM_MEDIA_TYPES = ("multipart/form-data", "application/x-www-form-urlencoded")
@@ -243,13 +257,13 @@ class OpenAPI30Body(OpenAPIBody, OpenAPI30Parameter):
     required: bool = False
     description: str | None = None
 
-    def as_json_schema(self, operation: APIOperation) -> dict[str, Any]:
+    def as_json_schema(self, operation: APIOperation, *, update_quantifiers: bool = True) -> dict[str, Any]:
         """Convert body definition to JSON Schema."""
         schema = get_media_type_schema(self.definition)
-        return self.transform_keywords(schema)
+        return self.transform_keywords(schema, update_quantifiers=update_quantifiers)
 
-    def transform_keywords(self, schema: dict[str, Any]) -> dict[str, Any]:
-        definition = super().transform_keywords(schema)
+    def transform_keywords(self, schema: dict[str, Any], *, update_quantifiers: bool = True) -> dict[str, Any]:
+        definition = super().transform_keywords(schema, update_quantifiers=update_quantifiers)
         if self.is_form:
             # It significantly reduces the "filtering" part of data generation.
             definition.setdefault("type", "object")
@@ -287,12 +301,14 @@ class OpenAPI20CompositeBody(OpenAPIBody, OpenAPI20Parameter):
         # We generate an object for formData - it is always required.
         return bool(self.definition)
 
-    def as_json_schema(self, operation: APIOperation) -> dict[str, Any]:
+    def as_json_schema(self, operation: APIOperation, *, update_quantifiers: bool = True) -> dict[str, Any]:
         """The composite body is transformed into an "object" JSON Schema."""
-        return parameters_to_json_schema(operation, self.definition)
+        return parameters_to_json_schema(operation, self.definition, update_quantifiers=update_quantifiers)
 
 
-def parameters_to_json_schema(operation: APIOperation, parameters: Iterable[OpenAPIParameter]) -> dict[str, Any]:
+def parameters_to_json_schema(
+    operation: APIOperation, parameters: Iterable[OpenAPIParameter], *, update_quantifiers: bool = True
+) -> dict[str, Any]:
     """Create an "object" JSON schema from a list of Open API parameters.
 
     :param List[OpenAPIParameter] parameters: A list of Open API parameters related to the same location. All of
@@ -332,7 +348,7 @@ def parameters_to_json_schema(operation: APIOperation, parameters: Iterable[Open
     required = []
     for parameter in parameters:
         name = parameter.name
-        properties[name] = parameter.as_json_schema(operation)
+        properties[name] = parameter.as_json_schema(operation, update_quantifiers=update_quantifiers)
         # If parameter names are duplicated, we need to avoid duplicate entries in `required` anyway
         if parameter.is_required and name not in required:
             required.append(name)
@@ -345,7 +361,7 @@ MISSING_SCHEMA_OR_CONTENT_MESSAGE = (
 )
 
 INVALID_SCHEMA_MESSAGE = (
-    'Can not generate data for {location} parameter "{name}"! ' "Its schema should be an object, got {schema}"
+    'Can not generate data for {location} parameter "{name}"! Its schema should be an object, got {schema}'
 )
 
 
@@ -354,7 +370,7 @@ def get_parameter_schema(operation: APIOperation, data: dict[str, Any]) -> dict[
     # In Open API 3.0, there could be "schema" or "content" field. They are mutually exclusive.
     if "schema" in data:
         if not isinstance(data["schema"], dict):
-            raise OperationSchemaError(
+            raise InvalidSchema(
                 INVALID_SCHEMA_MESSAGE.format(
                     location=data.get("in", ""), name=data.get("name", "<UNKNOWN>"), schema=data["schema"]
                 ),
@@ -368,7 +384,7 @@ def get_parameter_schema(operation: APIOperation, data: dict[str, Any]) -> dict[
     try:
         content = data["content"]
     except KeyError as exc:
-        raise OperationSchemaError(
+        raise InvalidSchema(
             MISSING_SCHEMA_OR_CONTENT_MESSAGE.format(location=data.get("in", ""), name=data.get("name", "<UNKNOWN>")),
             path=operation.path,
             method=operation.method,

schemathesis/specs/openapi/patterns.py

@@ -0,0 +1,137 @@
+from __future__ import annotations
+
+import re
+from functools import lru_cache
+
+try:  # pragma: no cover
+    import re._constants as sre
+    import re._parser as sre_parse
+except ImportError:
+    import sre_constants as sre
+    import sre_parse
+
+ANCHOR = sre.AT
+REPEATS: tuple
+if hasattr(sre, "POSSESSIVE_REPEAT"):
+    REPEATS = (sre.MIN_REPEAT, sre.MAX_REPEAT, sre.POSSESSIVE_REPEAT)
+else:
+    REPEATS = (sre.MIN_REPEAT, sre.MAX_REPEAT)
+LITERAL = sre.LITERAL
+IN = sre.IN
+MAXREPEAT = sre_parse.MAXREPEAT
+
+
+@lru_cache
+def update_quantifier(pattern: str, min_length: int | None, max_length: int | None) -> str:
+    """Update the quantifier of a regular expression based on given min and max lengths."""
+    if not pattern or (min_length in (None, 0) and max_length is None):
+        return pattern
+
+    try:
+        parsed = sre_parse.parse(pattern)
+        return _handle_parsed_pattern(parsed, pattern, min_length, max_length)
+    except re.error:
+        # Invalid pattern
+        return pattern
+
+
+def _handle_parsed_pattern(parsed: list, pattern: str, min_length: int | None, max_length: int | None) -> str:
+    """Handle the parsed pattern and update quantifiers based on different cases."""
+    if len(parsed) == 1:
+        op, value = parsed[0]
+        return _update_quantifier(op, value, pattern, min_length, max_length)
+    elif len(parsed) == 2:
+        if parsed[0][0] == ANCHOR:
+            # Starts with an anchor
+            op, value = parsed[1]
+            anchor_length = _get_anchor_length(parsed[0][1])
+            leading_anchor = pattern[:anchor_length]
+            return leading_anchor + _update_quantifier(op, value, pattern[anchor_length:], min_length, max_length)
+        if parsed[1][0] == ANCHOR:
+            # Ends with an anchor
+            op, value = parsed[0]
+            anchor_length = _get_anchor_length(parsed[1][1])
+            trailing_anchor = pattern[-anchor_length:]
+            return _update_quantifier(op, value, pattern[:-anchor_length], min_length, max_length) + trailing_anchor
+    elif len(parsed) == 3 and parsed[0][0] == ANCHOR and parsed[2][0] == ANCHOR:
+        op, value = parsed[1]
+        leading_anchor_length = _get_anchor_length(parsed[0][1])
+        trailing_anchor_length = _get_anchor_length(parsed[2][1])
+        leading_anchor = pattern[:leading_anchor_length]
+        trailing_anchor = pattern[-trailing_anchor_length:]
+        return (
+            leading_anchor
+            + _update_quantifier(
+                op, value, pattern[leading_anchor_length:-trailing_anchor_length], min_length, max_length
+            )
+            + trailing_anchor
+        )
+    return pattern
+
+
+def _get_anchor_length(node_type: int) -> int:
+    """Determine the length of the anchor based on its type."""
+    if node_type in {sre.AT_BEGINNING_STRING, sre.AT_END_STRING, sre.AT_BOUNDARY, sre.AT_NON_BOUNDARY}:
+        return 2  # \A, \Z, \b, or \B
+    return 1  # ^ or $ or their multiline/locale/unicode variants
+
+
+def _update_quantifier(op: int, value: tuple, pattern: str, min_length: int | None, max_length: int | None) -> str:
+    """Update the quantifier based on the operation type and given constraints."""
+    if op in REPEATS:
+        return _handle_repeat_quantifier(value, pattern, min_length, max_length)
+    if op in (LITERAL, IN) and max_length != 0:
+        return _handle_literal_or_in_quantifier(pattern, min_length, max_length)
+    return pattern
+
+
+def _handle_repeat_quantifier(
+    value: tuple[int, int, tuple], pattern: str, min_length: int | None, max_length: int | None
+) -> str:
+    """Handle repeat quantifiers (e.g., '+', '*', '?')."""
+    min_repeat, max_repeat, _ = value
+    min_length, max_length = _build_size(min_repeat, max_repeat, min_length, max_length)
+    if min_length > max_length:
+        return pattern
+    return f"({_strip_quantifier(pattern)})" + _build_quantifier(min_length, max_length)
+
+
+def _handle_literal_or_in_quantifier(pattern: str, min_length: int | None, max_length: int | None) -> str:
+    """Handle literal or character class quantifiers."""
+    min_length = 1 if min_length is None else max(min_length, 1)
+    return f"({pattern})" + _build_quantifier(min_length, max_length)
+
+
+def _build_quantifier(minimum: int | None, maximum: int | None) -> str:
+    """Construct a quantifier string based on min and max values."""
+    if maximum == MAXREPEAT or maximum is None:
+        return f"{{{minimum or 0},}}"
+    if minimum == maximum:
+        return f"{{{minimum}}}"
+    return f"{{{minimum or 0},{maximum}}}"
+
+
+def _build_size(min_repeat: int, max_repeat: int, min_length: int | None, max_length: int | None) -> tuple[int, int]:
+    """Merge the current repetition constraints with the provided min and max lengths."""
+    if min_length is not None:
+        min_repeat = max(min_repeat, min_length)
+    if max_length is not None:
+        if max_repeat == MAXREPEAT:
+            max_repeat = max_length
+        else:
+            max_repeat = min(max_repeat, max_length)
+    return min_repeat, max_repeat
+
+
+def _strip_quantifier(pattern: str) -> str:
+    """Remove quantifier from the pattern."""
+    # Lazy & posessive quantifiers
+    if pattern.endswith(("*?", "+?", "??", "*+", "?+", "++")):
+        return pattern[:-2]
+    if pattern.endswith(("?", "*", "+")):
+        pattern = pattern[:-1]
+    if pattern.endswith("}") and "{" in pattern:
+        # Find the start of the exact quantifier and drop everything since that index
+        idx = pattern.rfind("{")
+        pattern = pattern[:idx]
+    return pattern

schemathesis/specs/openapi/references.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from dataclasses import dataclass
+import sys
 from functools import lru_cache
 from typing import Any, Callable, Dict, Union, overload
 from urllib.request import urlopen
@@ -8,9 +8,11 @@ from urllib.request import urlopen
 import jsonschema
 import requests
 
-from ...constants import DEFAULT_RESPONSE_TIMEOUT
-from ...internal.copy import fast_deepcopy
-from ...loaders import load_yaml
+from schemathesis.core.compat import RefResolutionError
+from schemathesis.core.deserialization import deserialize_yaml
+from schemathesis.core.transforms import deepclone
+from schemathesis.core.transport import DEFAULT_RESPONSE_TIMEOUT
+
 from .constants import ALL_KEYWORDS
 from .converter import to_json_schema_recursive
 from .utils import get_type
@@ -22,7 +24,7 @@ RECURSION_DEPTH_LIMIT = 100
 def load_file_impl(location: str, opener: Callable) -> dict[str, Any]:
     """Load a schema from the given file."""
     with opener(location) as fd:
-        return load_yaml(fd)
+        return deserialize_yaml(fd)
 
 
 @lru_cache
@@ -39,8 +41,8 @@ def load_file_uri(location: str) -> dict[str, Any]:
 
 def load_remote_uri(uri: str) -> Any:
     """Load the resource and parse it as YAML / JSON."""
-    response = requests.get(uri, timeout=DEFAULT_RESPONSE_TIMEOUT / 1000)
-    return load_yaml(response.content)
+    response = requests.get(uri, timeout=DEFAULT_RESPONSE_TIMEOUT)
+    return deserialize_yaml(response.content)
 
 
 JSONType = Union[None, bool, float, str, list, Dict[str, Any]]
@@ -55,31 +57,57 @@ class InliningResolver(jsonschema.RefResolver):
         )
         super().__init__(*args, **kwargs)
 
+    if sys.version_info >= (3, 11):
+
+        def resolve(self, ref: str) -> tuple[str, Any]:
+            try:
+                return super().resolve(ref)
+            except RefResolutionError as exc:
+                exc.add_note(ref)
+                raise
+    else:
+
+        def resolve(self, ref: str) -> tuple[str, Any]:
+            try:
+                return super().resolve(ref)
+            except RefResolutionError as exc:
+                exc.__notes__ = [ref]
+                raise
+
     @overload
-    def resolve_all(self, item: dict[str, Any], recursion_level: int = 0) -> dict[str, Any]:
-        pass
+    def resolve_all(self, item: dict[str, Any], recursion_level: int = 0) -> dict[str, Any]: ...
 
     @overload
-    def resolve_all(self, item: list, recursion_level: int = 0) -> list:
-        pass
+    def resolve_all(self, item: list, recursion_level: int = 0) -> list: ...
 
     def resolve_all(self, item: JSONType, recursion_level: int = 0) -> JSONType:
         """Recursively resolve all references in the given object."""
+        resolve = self.resolve_all
         if isinstance(item, dict):
             ref = item.get("$ref")
-            if ref is not None and isinstance(ref, str):
-                with self.resolving(ref) as resolved:
+            if isinstance(ref, str):
+                url, resolved = self.resolve(ref)
+                self.push_scope(url)
+                try:
                     # If the next level of recursion exceeds the limit, then we need to copy it explicitly
                     # In other cases, this method create new objects for mutable types (dict & list)
                     next_recursion_level = recursion_level + 1
                     if next_recursion_level > RECURSION_DEPTH_LIMIT:
-                        copied = fast_deepcopy(resolved)
+                        copied = deepclone(resolved)
                         remove_optional_references(copied)
                         return copied
-                    return self.resolve_all(resolved, next_recursion_level)
-            return {key: self.resolve_all(sub_item, recursion_level) for key, sub_item in item.items()}
+                    return resolve(resolved, next_recursion_level)
+                finally:
+                    self.pop_scope()
+            return {
+                key: resolve(sub_item, recursion_level) if isinstance(sub_item, (dict, list)) else sub_item
+                for key, sub_item in item.items()
+            }
         if isinstance(item, list):
-            return [self.resolve_all(sub_item, recursion_level) for sub_item in item]
+            return [
+                self.resolve_all(sub_item, recursion_level) if isinstance(sub_item, (dict, list)) else sub_item
+                for sub_item in item
+            ]
         return item
 
     def resolve_in_scope(self, definition: dict[str, Any], scope: str) -> tuple[list[str], dict[str, Any]]:
@@ -89,7 +117,7 @@ class InliningResolver(jsonschema.RefResolver):
         if "$ref" in definition:
             self.push_scope(scope)
             try:
-                new_scope, definition = fast_deepcopy(self.resolve(definition["$ref"]))
+                new_scope, definition = self.resolve(definition["$ref"])
             finally:
                 self.pop_scope()
             scopes.append(new_scope)
@@ -186,7 +214,7 @@ def remove_optional_references(schema: dict[str, Any]) -> None:
             v = s.get(keyword)
             if v is not None:
                 elided = [sub for sub in v if not can_elide(sub)]
-                if len(elided) == 1 and "$ref" in elided[0]:
+                if len(elided) == 1 and contains_ref(elided[0]):
                     found.append(keyword)
         return found
 
@@ -205,41 +233,3 @@ def remove_optional_references(schema: dict[str, Any]) -> None:
                 clean_additional_properties(definition)
             for k in on_single_item_combinators(definition):
                 del definition[k]
-
-
-@dataclass
-class Unresolvable:
-    pass
-
-
-UNRESOLVABLE = Unresolvable()
-
-
-def resolve_pointer(document: Any, pointer: str) -> dict | list | str | int | float | None | Unresolvable:
-    """Implementation is adapted from Rust's `serde-json` crate.
-
-    Ref: https://github.com/serde-rs/json/blob/master/src/value/mod.rs#L751
-    """
-    if not pointer:
-        return document
-    if not pointer.startswith("/"):
-        return UNRESOLVABLE
-
-    def replace(value: str) -> str:
-        return value.replace("~1", "/").replace("~0", "~")
-
-    tokens = map(replace, pointer.split("/")[1:])
-    target = document
-    for token in tokens:
-        if isinstance(target, dict):
-            target = target.get(token, UNRESOLVABLE)
-            if target is UNRESOLVABLE:
-                return UNRESOLVABLE
-        elif isinstance(target, list):
-            try:
-                target = target[int(token)]
-            except IndexError:
-                return UNRESOLVABLE
-        else:
-            return UNRESOLVABLE
-    return target