odxtools 6.6.0__py3-none-any.whl → 6.7.0__py3-none-any.whl

odxtools/__init__.py

@@ -62,11 +62,11 @@ References
 - _`[ISO22901]` The ISO 22901 Standard: https://www.iso.org/standard/41207.html
 
 """
-from .load_file import load_file
-from .load_odx_d_file import load_odx_d_file
-from .load_pdx_file import load_pdx_file
-from .version import __version__
-from .write_pdx_file import write_pdx_file
+from .load_file import load_file as load_file  # noqa: F401
+from .load_odx_d_file import load_odx_d_file as load_odx_d_file  # noqa: F401
+from .load_pdx_file import load_pdx_file as load_pdx_file  # noqa: F401
+from .version import __version__ as __version__  # noqa: F401
+from .write_pdx_file import write_pdx_file as write_pdx_file  # noqa: F401
 
 __author__ = "Katrin Bauer"
 

odxtools/basicstructure.py

@@ -68,7 +68,8 @@ class BasicStructure(ComplexDop):
             cursor += param_bit_length
             length = max(length, cursor)
 
-        # Round up to account for padding bits
+        # Round up to account for padding bits (all structures are
+        # byte aligned)
         return ((length + 7) // 8) * 8
 
     def coded_const_prefix(self, request_prefix: bytes = b'') -> bytes:
@@ -210,18 +211,18 @@ class BasicStructure(ComplexDop):
                 stacklevel=1)
 
     def convert_physical_to_bytes(self,
-                                  param_values: ParameterValue,
+                                  physical_value: ParameterValue,
                                   encode_state: EncodeState,
                                   bit_position: int = 0) -> bytes:
-        if not isinstance(param_values, dict):
+        if not isinstance(physical_value, dict):
             raise EncodeError(
                 f"Expected a dictionary for the values of structure {self.short_name}, "
-                f"got {type(param_values)}")
+                f"got {type(physical_value)}")
         if bit_position != 0:
             raise EncodeError("Structures must be aligned, i.e. bit_position=0, but "
                               f"{self.short_name} was passed the bit position {bit_position}")
         return self.convert_physical_to_internal(
-            param_values,
+            physical_value,
             triggering_coded_request=encode_state.triggering_request,
             is_end_of_pdu=encode_state.is_end_of_pdu,
         )
@@ -254,9 +255,7 @@ class BasicStructure(ComplexDop):
             Parameters of the RPC as mapping from SHORT-NAME of the parameter to the value
         """
         return self.convert_physical_to_internal(
-            params,  # type: ignore[arg-type]
-            triggering_coded_request=coded_request,
-            is_end_of_pdu=True)
+            params, triggering_coded_request=coded_request, is_end_of_pdu=True)
 
     def decode(self, message: bytes) -> ParameterValueDict:
         decode_state = DecodeState(coded_message=message)

odxtools/cli/_parser_utils.py

@@ -2,11 +2,26 @@
 #
 # SPDX-License-Identifier: MIT
 import argparse
+from typing import Any, Protocol, runtime_checkable
 
 from ..database import Database
 from ..load_file import load_file as _load_file
 
 
+@runtime_checkable
+class SubparsersList(Protocol):
+    """This protocol reproduces the parts of `argparse._SubparsersAction` which are needed by odxtools
+
+    Unfortunately this is necessary because
+    `argparse._SubparsersAction` is a private class of the `argparse`
+    module that is used by some of its public API and thus cannot be
+    used outside of the `argparse` module.
+    """
+
+    def add_parser(self, name: str, **kwargs: Any) -> "argparse.ArgumentParser":
+        ...
+
+
 def add_pdx_argument(parser: argparse.ArgumentParser, is_optional: bool = False) -> None:
     parser.add_argument(
         "pdx_file",

odxtools/cli/_print_utils.py

@@ -36,7 +36,7 @@ def print_diagnostic_service(service: DiagService,
                              print_state_transitions: bool = False,
                              print_audiences: bool = False,
                              allow_unknown_bit_lengths: bool = False,
-                             print_fn: Callable = print) -> None:
+                             print_fn: Callable[..., Any] = print) -> None:
 
     print_fn(f" Service '{service.short_name}':")
 
@@ -70,7 +70,7 @@ def print_diagnostic_service(service: DiagService,
 
 def print_service_parameters(service: DiagService,
                              allow_unknown_bit_lengths: bool = False,
-                             print_fn: Callable = print) -> None:
+                             print_fn: Callable[..., Any] = print) -> None:
     # prints parameter details of request, positive response and negative response of diagnostic service
 
     # Request
@@ -156,6 +156,7 @@ def extract_parameter_tabulation_data(parameters: List[Parameter]) -> Dict[str,
         byte.append(param.byte_position)
         semantic.append(param.semantic)
         param_type.append(param.parameter_type)
+        length = 0
         if param.get_static_bit_length() is not None:
             bit_length.append(param.get_static_bit_length())
             length = (param.get_static_bit_length() or 0) // 4
@@ -227,7 +228,7 @@ def extract_parameter_tabulation_data(parameters: List[Parameter]) -> Dict[str,
     }
 
 
-def print_dl_metrics(variants: List[DiagLayer], print_fn: Callable = print) -> None:
+def print_dl_metrics(variants: List[DiagLayer], print_fn: Callable[..., Any] = print) -> None:
 
     name = []
     type = []

odxtools/cli/browse.py

@@ -4,7 +4,7 @@ import logging
 import sys
 from typing import List, Optional, Union, cast
 
-from InquirerPy import prompt as PI_prompt
+import InquirerPy.prompt as IP_prompt
 from tabulate import tabulate  # TODO: switch to rich tables
 
 from ..database import Database
@@ -20,6 +20,7 @@ from ..parameters.valueparameter import ValueParameter
 from ..request import Request
 from ..response import Response
 from . import _parser_utils
+from ._parser_utils import SubparsersList
 from ._print_utils import extract_parameter_tabulation_data
 
 # name of the tool
@@ -88,13 +89,15 @@ def prompt_single_parameter_value(parameter: Parameter) -> Optional[AtomicOdxTyp
         # else _convert_string_to_odx_type(x, p.physical_type.base_data_type, param=p) # This does not work because the next parameter to be promted is used (for some reason?)
     }]
 
-    if hasattr(parameter, "dop") and hasattr(parameter.dop, "compu_method") \
-       and hasattr(parameter.dop.compu_method, "get_scales"):
-        scales = parameter.dop.compu_method.get_scales()
+    if (dop := getattr(parameter, "dop", None)) and \
+       (compu_method := getattr(dop, "compu_method", None)):
+        scales = compu_method.internal_to_phys
         choices = [scale.compu_const for scale in scales if scale is not None]
+        if (cdv := compu_method.compu_default_value) is not None:
+            choices.append(cdv.compu_const)
         param_prompt[0]["choices"] = choices
 
-    answer = PI_prompt(param_prompt)
+    answer = IP_prompt(param_prompt)
     if answer.get(parameter.short_name) == "" and not parameter.is_required:
         return None
     elif parameter.physical_type.base_data_type is not None:
@@ -104,7 +107,7 @@ def prompt_single_parameter_value(parameter: Parameter) -> Optional[AtomicOdxTyp
         logging.warning(
             f"Parameter {parameter.short_name} does not have a physical data type. Param details: {parameter}"
         )
-        return answer.get(parameter.short_name)
+        return cast(str, answer.get(parameter.short_name))
 
 
 def encode_message_interactively(sub_service: Union[Request, Response],
@@ -117,7 +120,7 @@ def encode_message_interactively(sub_service: Union[Request, Response],
     for param_or_dict in param_dict.values():
         if isinstance(param_or_dict, dict):
             for param in param_or_dict.values():
-                if not isinstance(param_or_dict, dict) and param.is_settable:
+                if isinstance(param, Parameter) and param.is_settable:
                     exists_definable_param = True
         elif param_or_dict.is_settable:
             exists_definable_param = True
@@ -132,10 +135,11 @@ def encode_message_interactively(sub_service: Union[Request, Response],
                 "message": f"Do you want to encode a message? [y/n]",
                 "choices": ["yes", "no"],
             }]
-            answer = PI_prompt(encode_message_prompt)
+            answer = IP_prompt(encode_message_prompt)
             if answer.get("yes_no_prompt") == "no":
                 return
 
+        answered_request = b''
         if isinstance(sub_service, Response):
             answered_request_prompt = [{
                 "type":
@@ -147,7 +151,7 @@ def encode_message_interactively(sub_service: Union[Request, Response],
                 "filter":
                     lambda input: _convert_string_to_bytes(input),
             }]
-            answer = PI_prompt(answered_request_prompt)
+            answer = IP_prompt(answered_request_prompt)
             answered_request = cast(bytes, answer.get("request"))
             print(f"Input interpretation as list: {list(answered_request)}")
 
@@ -250,7 +254,8 @@ def encode_message_from_string_values(
                 parameter_values[parameter_sn] = _convert_string_to_odx_type(
                     parameter_value, DataType.A_BYTEFIELD)
 
-    payload = sub_service.encode(**parameter_values)  # type: ignore
+    payload = sub_service.encode(coded_request=b'\xff' * 100, **parameter_values)
+
     print(f"Message payload: 0x{bytes(payload).hex()}")
 
 
@@ -266,7 +271,7 @@ def browse(odxdb: Database) -> None:
             "message": "Select a Variant.",
             "choices": list(dl_names) + ["[exit]"],
         }]
-        answer = PI_prompt(selection)
+        answer = IP_prompt(selection)
         if answer.get("variant") == "[exit]":
             return
 
@@ -304,7 +309,7 @@ def browse(odxdb: Database) -> None:
                     f"The variant {variant.short_name} offers the following services. Select one!",
                 "choices": [s.short_name for s in services] + ["[back]"],
             }]
-            answer = PI_prompt(selection)
+            answer = IP_prompt(selection)
             if answer.get("service") == "[back]":
                 break
 
@@ -339,7 +344,7 @@ def browse(odxdb: Database) -> None:
                     "short": f"Negative response: {nr.short_name}",
                 } for nr in service.negative_responses] + ["[back]"],  # type: ignore
             }]
-            answer = PI_prompt(selection)
+            answer = IP_prompt(selection)
             if answer.get("message_type") == "[back]":
                 continue
 
@@ -353,7 +358,7 @@ def browse(odxdb: Database) -> None:
                 encode_message_interactively(codec, ask_user_confirmation=True)
 
 
-def add_subparser(subparsers: "argparse._SubParsersAction") -> None:
+def add_subparser(subparsers: SubparsersList) -> None:
     # Browse interactively to avoid spamming the console.
     parser = subparsers.add_parser(
         "browse",

odxtools/cli/compare.py

@@ -3,7 +3,7 @@
 
 import argparse
 import os
-from typing import Any, Dict, List, Optional, Set, Union
+from typing import Any, Dict, List, Optional, Set, Union, cast
 
 from rich import print
 from tabulate import tabulate  # TODO: switch to rich tables
@@ -19,6 +19,7 @@ from ..parameters.parameter import Parameter
 from ..parameters.physicalconstantparameter import PhysicalConstantParameter
 from ..parameters.valueparameter import ValueParameter
 from . import _parser_utils
+from ._parser_utils import SubparsersList
 from ._print_utils import (extract_service_tabulation_data, print_dl_metrics,
                            print_service_parameters)
 
@@ -104,8 +105,10 @@ class Display:
                     f"  Detailed changes of diagnostic service [u cyan]{service.short_name}[/u cyan]"
                 )
                 #   detailed_info in [infotext1, dict1, infotext2, dict2, ...]
-                for detailed_info in service_dict["changed_parameters_of_service"][2][
-                        service_idx]:  # type: ignore[arg-type, index, union-attr]
+                info_list = cast(
+                    list,  # type: ignore[type-arg]
+                    service_dict["changed_parameters_of_service"])[2][service_idx]
+                for detailed_info in info_list:
                     if isinstance(detailed_info, str):
                         print()
                         print(detailed_info)
@@ -256,7 +259,8 @@ class Comparison(Display):
 
         return {"Property": property, "Old Value": old, "New Value": new}
 
-    def compare_services(self, service1: DiagService, service2: DiagService) -> list:
+    def compare_services(self, service1: DiagService,
+                         service2: DiagService) -> List[SpecsServiceDict]:
         # compares request, positive response and negative response parameters of two diagnostic services
 
         information: List[Union[str, Dict[str, Any]]] = [
@@ -382,9 +386,10 @@ class Comparison(Display):
                            str(service2.negative_responses)]
             })
 
-        return [information, changed_params]
+        return [information, changed_params]  # type: ignore[list-item]
 
-    def compare_diagnostic_layers(self, dl1: DiagLayer, dl2: DiagLayer) -> dict:
+    def compare_diagnostic_layers(self, dl1: DiagLayer,
+                                  dl2: DiagLayer) -> dict:  # type: ignore[type-arg]
         # compares diagnostic services of two diagnostic layers with each other
         # save changes in dictionary (service_dict)
         # TODO: add comparison of SingleECUJobs
@@ -467,21 +472,23 @@ class Comparison(Display):
                         # add parameters which have been changed (type: String)
                         service_dict["changed_parameters_of_service"][
                             1].append(  # type: ignore[union-attr]
-                                detailed_information[1])
+                                detailed_information[1])  # type: ignore[arg-type]
                         # add detailed information about changed service parameters (type: list) [infotext1, table1, infotext2, table2, ...]
                         service_dict["changed_parameters_of_service"][
                             2].append(  # type: ignore[union-attr]
-                                detailed_information[0])
+                                detailed_information[0])  # type: ignore[arg-type]
 
             for service2_idx, service2 in enumerate(dl2.services):
 
                 # check for deleted diagnostic services
                 if service2.short_name not in dl1_service_names and dl2_request_prefixes[
-                        service2_idx] not in dl1_request_prefixes and service2 not in service_dict[
-                            "deleted_services"]:
+                        service2_idx] not in dl1_request_prefixes:
 
-                    service_dict["deleted_services"].append(  # type: ignore[union-attr]
-                        service2)  # type: ignore[arg-type]
+                    deleted_list = service_dict["deleted_services"]
+                    assert isinstance(deleted_list, list)
+                    if service2 not in deleted_list:
+                        service_dict["deleted_services"].append(  # type: ignore[union-attr]
+                            service2)  # type: ignore[arg-type]
 
                 if service1.short_name == service2.short_name:
                     # compare request, pos. response and neg. response parameters of both diagnostic services
@@ -496,13 +503,14 @@ class Comparison(Display):
                                 service1)
                         # add parameters which have been changed (type: String)
                         service_dict["changed_parameters_of_service"][  # type: ignore[union-attr]
-                            1].append(detailed_information[1])
+                            1].append(detailed_information[1])  # type: ignore[arg-type]
                         # add detailed information about changed service parameters (type: list) [infotext1, table1, infotext2, table2, ...]
                         service_dict["changed_parameters_of_service"][  # type: ignore[union-attr]
-                            2].append(detailed_information[0])
+                            2].append(detailed_information[0])  # type: ignore[arg-type]
         return service_dict
 
-    def compare_databases(self, database_new: Database, database_old: Database) -> dict:
+    def compare_databases(self, database_new: Database,
+                          database_old: Database) -> dict:  # type: ignore[type-arg]
         # compares two PDX-files with each other
 
         new_variants: NewVariants = []
@@ -539,7 +547,7 @@ class Comparison(Display):
         return changes_variants
 
 
-def add_subparser(subparsers: "argparse._SubParsersAction") -> None:
+def add_subparser(subparsers: SubparsersList) -> None:
     parser = subparsers.add_parser(
         "compare",
         description="\n".join([

odxtools/cli/decode.py

@@ -9,6 +9,7 @@ from ..exceptions import odxraise
 from ..odxtypes import ParameterValue
 from ..singleecujob import SingleEcuJob
 from . import _parser_utils
+from ._parser_utils import SubparsersList
 
 # name of the tool
 _odxtools_tool_name_ = "decode"
@@ -70,7 +71,7 @@ def print_summary(
                 print(f"  {param_name}={get_display_value(param_value)}")
 
 
-def add_subparser(subparsers: "argparse._SubParsersAction") -> None:
+def add_subparser(subparsers: SubparsersList) -> None:
     parser = subparsers.add_parser(
         "decode",
         description="\n".join([

odxtools/cli/dummy_sub_parser.py

@@ -4,6 +4,8 @@ import sys
 import traceback
 from io import StringIO
 
+from ._parser_utils import SubparsersList
+
 
 class DummyTool:
     """A tool which acts as a placeholder for a "real" tool that
@@ -20,7 +22,7 @@ class DummyTool:
         self._odxtools_tool_name_ = tool_name
         self._error = error
 
-    def add_subparser(self, subparser_list: "argparse._SubParsersAction") -> None:
+    def add_subparser(self, subparser_list: SubparsersList) -> None:
         desc = StringIO()
 
         print(f"Tool '{self._odxtools_tool_name_}' is unavailable: {self._error}", file=desc)

odxtools/cli/find.py

@@ -7,6 +7,7 @@ from ..diagservice import DiagService
 from ..odxtypes import ParameterValue
 from ..singleecujob import SingleEcuJob
 from . import _parser_utils
+from ._parser_utils import SubparsersList
 from ._print_utils import print_diagnostic_service
 
 # name of the tool
@@ -66,7 +67,7 @@ def print_summary(odxdb: Database,
             print(f"Unknown service: {service}")
 
 
-def add_subparser(subparsers: "argparse._SubParsersAction") -> None:
+def add_subparser(subparsers: SubparsersList) -> None:
     parser = subparsers.add_parser(
         "find",
         description="\n".join([

odxtools/cli/list.py

@@ -10,6 +10,7 @@ from ..diaglayer import DiagLayer
 from ..diagservice import DiagService
 from ..singleecujob import SingleEcuJob
 from . import _parser_utils
+from ._parser_utils import SubparsersList
 from ._print_utils import format_desc, print_diagnostic_service, print_dl_metrics
 
 # name of the tool
@@ -111,7 +112,7 @@ def print_summary(odxdb: Database,
                 rich.print(f"  {com_param.short_name}: {com_param.value}")
 
 
-def add_subparser(subparsers: "argparse._SubParsersAction") -> None:
+def add_subparser(subparsers: SubparsersList) -> None:
     parser = subparsers.add_parser(
         "list",
         description="\n".join([

odxtools/cli/main.py

@@ -4,6 +4,7 @@ import importlib
 from typing import Any, List
 
 import odxtools
+import odxtools.exceptions
 
 from ..version import __version__ as odxtools_version
 from .dummy_sub_parser import DummyTool

odxtools/cli/snoop.py

@@ -15,6 +15,7 @@ from odxtools.isotp_state_machine import IsoTpStateMachine
 from odxtools.response import Response, ResponseType
 
 from . import _parser_utils
+from ._parser_utils import SubparsersList
 
 # name of the tool
 _odxtools_tool_name_ = "snoop"
@@ -30,6 +31,8 @@ def handle_telegram(telegram_id: int, payload: bytes) -> None:
     global odx_diag_layer
     global last_request
 
+    assert odx_diag_layer is not None
+
     if telegram_id == ecu_tx_id:
         if uds.is_response_pending(payload):
             print(f" ... (response pending)")
@@ -209,7 +212,7 @@ def add_cli_arguments(parser: argparse.ArgumentParser) -> None:
     _parser_utils.add_pdx_argument(parser)
 
 
-def add_subparser(subparsers: "argparse._SubParsersAction") -> None:
+def add_subparser(subparsers: SubparsersList) -> None:
     parser = subparsers.add_parser(
         "snoop",
         description="Live decoding of a diagnostic session.",

odxtools/comparaminstance.py

@@ -7,7 +7,7 @@ from xml.etree import ElementTree
 from .basecomparam import BaseComparam
 from .comparam import Comparam
 from .complexcomparam import ComplexComparam, ComplexValue, create_complex_value_from_et
-from .exceptions import OdxWarning, odxassert, odxraise, odxrequire
+from .exceptions import OdxWarning, odxraise, odxrequire
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from .utils import create_description_from_et
 
@@ -75,7 +75,7 @@ class ComparamInstance:
     def spec(self) -> BaseComparam:
         return self._spec
 
-    def get_value(self) -> Optional[str]:
+    def get_value(self) -> str:
         """Retrieve the value of a simple communication parameter
 
         This takes the default value of the comparam (if any) into
@@ -91,7 +91,8 @@ class ComparamInstance:
         else:
             result = self.spec.physical_default_value
 
-        odxassert(isinstance(result, str))
+        if not isinstance(result, str):
+            odxraise()
 
         return result
 
@@ -119,6 +120,7 @@ class ComparamInstance:
         name_list = [cp.short_name for cp in comparam_spec.subparams]
         try:
             idx = name_list.index(subparam_name)
+            subparam = comparam_spec.subparams[idx]
         except ValueError:
             warnings.warn(
                 f"Communication parameter '{self.short_name}' "
@@ -129,8 +131,8 @@ class ComparamInstance:
             return None
 
         result = value_list[idx]
-        if result is None:
-            result = comparam_spec.subparams[idx].physical_default_value
+        if result is None and isinstance(subparam, (Comparam, ComplexComparam)):
+            result = subparam.physical_default_value
         if not isinstance(result, str):
             odxraise()
 

odxtools/compumethods/compumethod.py

@@ -1,5 +1,4 @@
 # SPDX-License-Identifier: MIT
-import abc
 from dataclasses import dataclass
 from typing import Literal
 
@@ -15,14 +14,13 @@ CompuMethodCategory = Literal[
 
 
 @dataclass
-class CompuMethod(abc.ABC):
+class CompuMethod:
     internal_type: DataType
     physical_type: DataType
 
     @property
-    @abc.abstractmethod
     def category(self) -> CompuMethodCategory:
-        pass
+        raise NotImplementedError()
 
     def convert_physical_to_internal(self, physical_value: AtomicOdxType) -> AtomicOdxType:
         raise NotImplementedError()

odxtools/compumethods/compuscale.py

@@ -42,13 +42,22 @@ class CompuScale:
     compu_const: Optional[AtomicOdxType]
     compu_rational_coeffs: Optional[CompuRationalCoeffs]
 
+    # the following two attributes are not specified for COMPU-SCALE
+    # tags in the XML, but they are required to do anything useful
+    # with it.
+    internal_type: DataType
+    physical_type: DataType
+
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment], *,
-                internal_type: DataType, physical_type: DataType) -> "CompuScale":
+    def compuscale_from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment], *,
+                           internal_type: DataType, physical_type: DataType) -> "CompuScale":
         short_label = et_element.findtext("SHORT-LABEL")
         description = create_description_from_et(et_element.find("DESC"))
-        lower_limit = Limit.from_et(et_element.find("LOWER-LIMIT"), internal_type=internal_type)
-        upper_limit = Limit.from_et(et_element.find("UPPER-LIMIT"), internal_type=internal_type)
+
+        lower_limit = Limit.limit_from_et(
+            et_element.find("LOWER-LIMIT"), doc_frags, value_type=internal_type)
+        upper_limit = Limit.limit_from_et(
+            et_element.find("UPPER-LIMIT"), doc_frags, value_type=internal_type)
 
         compu_inverse_value = internal_type.create_from_et(et_element.find("COMPU-INVERSE-VALUE"))
         compu_const = physical_type.create_from_et(et_element.find("COMPU-CONST"))
@@ -64,4 +73,35 @@ class CompuScale:
             upper_limit=upper_limit,
             compu_inverse_value=compu_inverse_value,
             compu_const=compu_const,
-            compu_rational_coeffs=compu_rational_coeffs)
+            compu_rational_coeffs=compu_rational_coeffs,
+            internal_type=internal_type,
+            physical_type=physical_type)
+
+    def applies(self, internal_value: AtomicOdxType) -> bool:
+
+        if self.lower_limit is None and self.upper_limit is None:
+            # Everything is allowed: No limits have been specified
+            return True
+        elif self.upper_limit is None:
+            # no upper limit has been specified. the spec says that
+            # the value specified by the lower limit is the only one
+            # which is allowed (cf section 7.3.6.6.1)
+            assert self.lower_limit is not None
+
+            return internal_value == self.lower_limit.value
+        elif self.lower_limit is None:
+            # only the upper limit has been specified. the spec is
+            # ambiguous: it only says that if no upper limit is
+            # defined, the lower limit shall also be used as the upper
+            # limit and a closed interval type ought to be assumed,
+            # but it does not say what happens if the lower limit is
+            # not defined (which is allowed by the XSD). We thus
+            # assume that if only the upper limit is defined, is
+            # treated the same way as if only the lower limit is
+            # specified.
+            assert self.upper_limit is not None
+
+            return internal_value == self.upper_limit.value
+
+        return self.lower_limit.complies_to_lower(internal_value) and \
+            self.upper_limit.complies_to_upper(internal_value)