maxframe 1.3.1__cp39-cp39-macosx_10_9_universal2.whl → 2.0.0__cp39-cp39-macosx_10_9_universal2.whl

maxframe/mixin.py

@@ -12,15 +12,18 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import errno
 import logging.config
-from typing import Union
+import os
+from typing import List, Union
 
 import traitlets as T
+from tornado import httpserver, web
 from tornado.log import enable_pretty_logging
 from traitlets.config import Configurable
 
 from . import env
-from .utils import trait_from_env
+from .utils import random_ports, trait_from_env
 
 
 class ServiceConfigMixin(Configurable):
@@ -66,6 +69,55 @@ class ServiceConfigMixin(Configurable):
     )
     base_url_default = trait_from_env("base_url", base_url_env)
 
+    def init_http_server(self) -> None:
+        """Initializes an HTTP server for the Tornado web application on the
+        configured interface and port.
+
+        Tries to find an open port if the one configured is not available using
+        the same logic as the Jupyter Notebook server.
+        """
+        self.http_server = httpserver.HTTPServer(self.web_app)
+
+        for port in random_ports(self.port, self.port_retries + 1):
+            try:
+                self.http_server.listen(port, self.ip)
+            except OSError as e:
+                if e.errno == errno.EADDRINUSE:
+                    self.log.info(
+                        "The port %i is already in use, trying another port." % port
+                    )
+                    continue
+                elif e.errno in (
+                    errno.EACCES,
+                    getattr(errno, "WSAEACCES", errno.EACCES),
+                ):
+                    self.log.warning("Permission to listen on port %i denied" % port)
+                    continue
+                else:
+                    raise
+            else:
+                self.port = port
+                if env.MAXFRAME_HTTP_PORT_FILE in os.environ:
+                    try:
+                        with open(os.getenv(env.MAXFRAME_HTTP_PORT_FILE), "w") as outf:
+                            outf.write(str(port))
+                    except IOError:  # pragma: no cover
+                        self.log.warning(
+                            "Failed to write port file %s",
+                            os.getenv(env.MAXFRAME_HTTP_PORT_FILE),
+                        )
+                break
+        else:
+            self.log.critical(
+                "ERROR: the gateway server could not be started because "
+                "no available port could be found."
+            )
+            self.exit(1)
+
+    @classmethod
+    def get_health_handlers(cls) -> List[tuple]:
+        return [("/health", HealthHandler)]
+
 
 class LoggerConfigMixin(Configurable):
     log_config_file_env = env.MAXFRAME_SERVICE_LOG_CONFIG_FILE
@@ -98,3 +150,8 @@ class LoggerConfigMixin(Configurable):
             logging.getLogger().setLevel(log_level)
         # Adjust kubernetes logging level to hide secrets when logging
         logging.getLogger("kubernetes").setLevel(logging.WARNING)
+
+
+class HealthHandler(web.RequestHandler):
+    async def get(self):
+        self.set_status(200)

maxframe/opcodes.py

@@ -305,7 +305,7 @@ QUANTILE = 440
 FILL_DIAGONAL = 441
 NORMALIZE = 442
 TOPK = 443
-TRAPZ = 444
+TRAPEZOID = 444
 GET_SHAPE = 445
 BINCOUNT = 446
 # fancy index, distributed phase is a shuffle operation that
@@ -528,7 +528,7 @@ START_TRACKER = 3004
 # LightGBM
 LGBM_TRAIN = 3020
 LGBM_PREDICT = 3021
-LGBM_ALIGN = 3022
+TO_LGBM_DATASET = 3022
 
 # TensorFlow
 RUN_TENSORFLOW = 3010
@@ -560,19 +560,27 @@ COLLECT_PORTS = 3306
 UNIQUE_LABELS = 3307
 # preprocessing
 LABEL_BINARIZE = 3308
-# ensemble: blockwise
-BLOCKWISE_ENSEMBLE_FIT = 3309
-BLOCKWISE_ENSEMBLE_PREDICT = 3310
+# check consistent length
+CHECK_CONSISTENT_LENGTH = 3309
+
 # ensemble: bagging
 BAGGING_SHUFFLE_SAMPLE = 3400
 BAGGING_SHUFFLE_REINDEX = 3401
 BAGGING_FIT = 3402
 BAGGING_PREDICTION = 3403
 
+# ensemble: blockwise
+BLOCKWISE_ENSEMBLE_FIT = 3410
+BLOCKWISE_ENSEMBLE_PREDICT = 3411
+
 # Remote Functions and class
 REMOTE_FUNCATION = 5001
 RUN_SCRIPT = 5002
 
+# learn metrics
+MULTILABEL_CONFUSION_MATRIX = 5201
+PRECISION_RECALL_F_SCORE_SUPPORT = 5202
+
 CHOLESKY_FUSE = 999988
 
 # MaxFrame-dedicated functions

maxframe/protocol.py

@@ -44,6 +44,26 @@ pickling_support.install()
 
 BodyType = TypeVar("BodyType", bound="Serializable")
 
+_PANDAS_HAS_MGR = hasattr(pd.Series([0]), "_mgr")
+
+
+def _base64_pickle(val: Any) -> str:
+    return base64.b64encode(pickle.dumps(val)).decode()
+
+
+def _base64_unpickle(val: str) -> Any:
+    # as pandas prior to 1.1.0 use _data instead of _mgr to hold BlockManager,
+    # deserializing from high versions may produce mal-functioned pandas objects,
+    # thus the patch is needed
+
+    res = pickle.loads(base64.b64decode(val))
+    if _PANDAS_HAS_MGR or not isinstance(res, (pd.DataFrame, pd.Series)):
+        return res
+    if hasattr(res, "_mgr"):
+        res._data = getattr(res, "_mgr")
+        delattr(res, "_mgr")
+    return res
+
 
 class JsonSerializable(Serializable):
     _ignore_non_existing_keys = True
@@ -63,7 +83,7 @@ class ProtocolBody(Generic[BodyType], Serializable):
     body: BodyType = AnyField("body", default=None)
 
 
-class DagStatus(enum.Enum):
+class ExecutionStatus(enum.Enum):
     PREPARING = 0
     RUNNING = 1
     SUCCEEDED = 2
@@ -72,7 +92,15 @@ class DagStatus(enum.Enum):
     CANCELLED = 5
 
     def is_terminated(self):
-        return self in (DagStatus.CANCELLED, DagStatus.SUCCEEDED, DagStatus.FAILED)
+        return self in (
+            ExecutionStatus.CANCELLED,
+            ExecutionStatus.SUCCEEDED,
+            ExecutionStatus.FAILED,
+        )
+
+
+# keep compatibility
+DagStatus = ExecutionStatus
 
 
 class DimensionIndex(Serializable):
@@ -85,6 +113,7 @@ class ResultType(enum.Enum):
     NULL = 0
     ODPS_TABLE = 1
     ODPS_VOLUME = 2
+    CONSTANT = 3
 
 
 class DataSerializeType(enum.Enum):
@@ -133,6 +162,26 @@ class ResultInfo(JsonSerializable):
 ResultInfoType = TypeVar("ResultInfoType", bound=ResultInfo)
 
 
+class ConstantResultInfo(ResultInfo):
+    _result_type = ResultType.CONSTANT
+
+    data: Any = AnyField("data", default=None)
+
+    def __init__(self, result_type: ResultType = None, **kw):
+        result_type = result_type or ResultType.CONSTANT
+        super().__init__(result_type=result_type, **kw)
+
+    def to_json(self) -> dict:
+        ret = super().to_json()
+        ret["data"] = _base64_pickle(self.data)
+        return ret
+
+    def _json_to_kwargs(self, serialized: dict) -> dict:
+        kw = super()._json_to_kwargs(serialized)
+        kw["data"] = _base64_unpickle(kw["data"])
+        return kw
+
+
 class ODPSTableResultInfo(ResultInfo):
     _result_type = ResultType.ODPS_TABLE
 
@@ -254,7 +303,9 @@ class ErrorInfo(JsonSerializable):
 class DagInfo(JsonSerializable):
     session_id: str = StringField("session_id", default=None)
     dag_id: str = StringField("dag_id", default=None)
-    status: DagStatus = EnumField("status", DagStatus, FieldTypes.int8, default=None)
+    status: ExecutionStatus = EnumField(
+        "status", ExecutionStatus, FieldTypes.int8, default=None
+    )
     progress: float = Float64Field("progress", default=None)
     tileable_to_result_infos: Dict[str, ResultInfo] = DictField(
         "tileable_to_result_infos",
@@ -277,7 +328,7 @@ class DagInfo(JsonSerializable):
         if serialized is None:
             return None
         kw = serialized.copy()
-        kw["status"] = DagStatus(kw["status"])
+        kw["status"] = ExecutionStatus(kw["status"])
         if kw.get("tileable_to_result_infos"):
             kw["tileable_to_result_infos"] = {
                 k: ResultInfo.from_json(s)
@@ -402,7 +453,9 @@ class SubDagSubmitInstanceInfo(JsonSerializable):
 
 class SubDagInfo(JsonSerializable):
     subdag_id: str = StringField("subdag_id")
-    status: DagStatus = EnumField("status", DagStatus, FieldTypes.int8, default=None)
+    status: ExecutionStatus = EnumField(
+        "status", ExecutionStatus, FieldTypes.int8, default=None
+    )
     progress: float = Float64Field("progress", default=None)
     error_info: Optional[ErrorInfo] = ReferenceField(
         "error_info", reference_type=ErrorInfo, default=None
@@ -424,7 +477,7 @@ class SubDagInfo(JsonSerializable):
     @classmethod
     def from_json(cls, serialized: dict) -> "SubDagInfo":
         kw = serialized.copy()
-        kw["status"] = DagStatus(kw["status"])
+        kw["status"] = ExecutionStatus(kw["status"])
         if kw.get("tileable_to_result_infos"):
             kw["tileable_to_result_infos"] = {
                 k: ResultInfo.from_json(s)
@@ -516,27 +569,27 @@ class DataFrameTableMeta(JsonSerializable):
         return True
 
     def to_json(self) -> dict:
-        b64_pk = lambda x: base64.b64encode(pickle.dumps(x)).decode()
         ret = {
             "table_name": self.table_name,
             "type": self.type.value,
             "table_column_names": self.table_column_names,
             "table_index_column_names": self.table_index_column_names,
-            "pd_column_dtypes": b64_pk(self.pd_column_dtypes),
-            "pd_column_level_names": b64_pk(self.pd_column_level_names),
-            "pd_index_dtypes": b64_pk(self.pd_index_dtypes),
+            "pd_column_dtypes": _base64_pickle(self.pd_column_dtypes),
+            "pd_column_level_names": _base64_pickle(self.pd_column_level_names),
+            "pd_index_dtypes": _base64_pickle(self.pd_index_dtypes),
         }
         return ret
 
     @classmethod
     def from_json(cls, serialized: dict) -> "DataFrameTableMeta":
-        b64_upk = lambda x: pickle.loads(base64.b64decode(x))
         serialized.update(
             {
                 "type": OutputType(serialized["type"]),
-                "pd_column_dtypes": b64_upk(serialized["pd_column_dtypes"]),
-                "pd_column_level_names": b64_upk(serialized["pd_column_level_names"]),
-                "pd_index_dtypes": b64_upk(serialized["pd_index_dtypes"]),
+                "pd_column_dtypes": _base64_unpickle(serialized["pd_column_dtypes"]),
+                "pd_column_level_names": _base64_unpickle(
+                    serialized["pd_column_level_names"]
+                ),
+                "pd_index_dtypes": _base64_unpickle(serialized["pd_index_dtypes"]),
             }
         )
         return DataFrameTableMeta(**serialized)

maxframe/remote/core.py

@@ -13,9 +13,10 @@
 # limitations under the License.
 
 from functools import partial
+from typing import List
 
 from .. import opcodes
-from ..core import ENTITY_TYPE
+from ..core import ENTITY_TYPE, EntityData
 from ..core.operator import ObjectOperator, ObjectOperatorMixin
 from ..dataframe.core import DATAFRAME_TYPE, INDEX_TYPE, SERIES_TYPE
 from ..serialization.serializables import (
@@ -26,6 +27,7 @@ from ..serialization.serializables import (
     ListField,
 )
 from ..tensor.core import TENSOR_TYPE
+from ..udf import BuiltinFunction
 from ..utils import find_objects, replace_objects
 
 
@@ -54,21 +56,21 @@ class RemoteFunction(ObjectOperatorMixin, ObjectOperator):
             tileable, (TENSOR_TYPE, DATAFRAME_TYPE, SERIES_TYPE, INDEX_TYPE)
         )
 
-    def _set_inputs(self, inputs):
-        raw_inputs = getattr(self, "_inputs", None)
-        super()._set_inputs(inputs)
+    def has_custom_code(self) -> bool:
+        return not isinstance(self.function, BuiltinFunction)
 
-        function_inputs = iter(inp for inp in self._inputs)
-        mapping = {inp: new_inp for inp, new_inp in zip(inputs, self._inputs)}
+    @classmethod
+    def _set_inputs(cls, op: "RemoteFunction", inputs: List[EntityData]):
+        raw_inputs = getattr(op, "_inputs", None)
+        super()._set_inputs(op, inputs)
+
+        function_inputs = iter(inp for inp in op._inputs)
+        mapping = {inp: new_inp for inp, new_inp in zip(inputs, op._inputs)}
         if raw_inputs is not None:
             for raw_inp in raw_inputs:
-                if self._no_prepare(raw_inp):
-                    # not in tile, set_inputs from tileable
-                    mapping[raw_inp] = next(function_inputs)
-                else:
-                    mapping[raw_inp] = next(function_inputs)
-        self.function_args = replace_objects(self.function_args, mapping)
-        self.function_kwargs = replace_objects(self.function_kwargs, mapping)
+                mapping[raw_inp] = next(function_inputs)
+        op.function_args = replace_objects(op.function_args, mapping)
+        op.function_kwargs = replace_objects(op.function_kwargs, mapping)
 
     def __call__(self):
         find_inputs = partial(find_objects, types=ENTITY_TYPE)
@@ -85,7 +87,7 @@ def spawn(
     func,
     args=(),
     kwargs=None,
-    retry_when_fail=False,
+    retry_when_fail=True,
     resolve_tileable_input=False,
     n_output=None,
     **kw,

maxframe/remote/run_script.py

@@ -17,7 +17,7 @@ from typing import Any, BinaryIO, Dict, List, TextIO, Union
 
 from .. import opcodes
 from ..core import TILEABLE_TYPE, OutputType
-from ..core.operator import MergeDictOperator
+from ..core.operator import ObjectOperator, ObjectOperatorMixin
 from ..serialization.serializables import (
     BoolField,
     BytesField,
@@ -29,7 +29,7 @@ from ..typing_ import SessionType, TileableType
 from ..utils import to_binary
 
 
-class RunScript(MergeDictOperator):
+class RunScript(ObjectOperator, ObjectOperatorMixin):
     _op_type_ = opcodes.RUN_SCRIPT
 
     code: bytes = BytesField("code", default=None)
@@ -49,6 +49,9 @@ class RunScript(MergeDictOperator):
     def retryable(self):
         return self.retry_when_fail
 
+    def has_custom_code(self) -> bool:
+        return True
+
     def __call__(self, inputs):
         return self.new_tileable(inputs)
 
@@ -74,7 +77,7 @@ def run_script(
     n_workers: int = 1,
     command_argv: List[str] = None,
     session: SessionType = None,
-    retry_when_fail: bool = False,
+    retry_when_fail: bool = True,
     run_kwargs: Dict[str, Any] = None,
 ):
     """

maxframe/serialization/__init__.py

@@ -15,9 +15,11 @@
 from . import arrow, exception, maxframe_objects, numpy, pandas, scipy, serializables
 from .core import (
     PickleContainer,
+    PickleHookOptions,
     Serializer,
     clear_type_cache,
     deserialize,
+    load_member,
     load_type,
     pickle_buffers,
     serialize,

maxframe/serialization/core.pxd

@@ -15,6 +15,9 @@
 from libc.stdint cimport int32_t, uint64_t
 
 
+cdef bint unpickle_allowed
+
+
 cdef class Serializer:
     cdef int _serializer_id
 

maxframe/serialization/core.pyi

@@ -13,7 +13,7 @@
 # limitations under the License.
 
 from concurrent.futures import Executor
-from typing import Any, Callable, Dict, List, TypeVar
+from typing import Any, Callable, Dict, List, Type, TypeVar
 
 def buffered(func: Callable) -> Callable: ...
 def fast_id(obj: Any) -> int: ...
@@ -21,6 +21,8 @@ def fast_id(obj: Any) -> int: ...
 LoadType = TypeVar("LoadType")
 
 def load_type(class_name: str, parent_class: LoadType) -> LoadType: ...
+def load_member(class_name: str, restrict_type: Type[LoadType]) -> LoadType: ...
+def reload_unpickle_flag(): ...
 
 class PickleContainer:
     def __init__(self, buffers: List[bytes]): ...

maxframe/serialization/core.pyx

@@ -14,9 +14,12 @@
 # limitations under the License.
 
 import asyncio
+import contextvars
+import copy
 import datetime
 import hashlib
 import importlib
+import os
 import re
 from collections import OrderedDict
 from functools import partial, wraps
@@ -38,7 +41,7 @@ from .._utils cimport TypeDispatcher
 
 from ..lib import wrapped_pickle as pickle
 from ..lib.dtypes_extension import ArrowDtype
-from ..utils import NoDefault, arrow_type_from_str, no_default
+from ..utils import NoDefault, arrow_type_from_str, no_default, str_to_bool
 
 # resolve pandas pickle compatibility between <1.2 and >=1.3
 try:
@@ -98,14 +101,50 @@ cdef:
 cdef dict _type_cache = dict()
 
 
-cpdef object load_type(str class_name, object parent_class):
+cdef object pickle_serial_hook = contextvars.ContextVar("pickle_serial_hook", default=None)
+cdef object pickle_deserial_hook = contextvars.ContextVar("pickle_deserial_hook", default=None)
+
+cdef class PickleHookOptions:
+    cdef:
+        object _serial_hook
+        object _pre_serial_hook
+        object _deserial_hook
+        object _pre_deserial_hook
+
+    def __init__(self, serial_hook: object = None, deserial_hook: object = None):
+        self._serial_hook = serial_hook
+        self._deserial_hook = deserial_hook
+
+    def __enter__(self):
+        self._pre_serial_hook = pickle_serial_hook.set(self._serial_hook)
+        self._pre_deserial_hook = pickle_deserial_hook.set(self._deserial_hook)
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        pickle_serial_hook.reset(self._pre_serial_hook)
+        pickle_deserial_hook.reset(self._pre_deserial_hook)
+
+
+cdef bint unpickle_allowed
+
+
+def reload_unpickle_flag():
+    global unpickle_allowed
+    unpickle_allowed = str_to_bool(
+        os.getenv("MAXFRAME_SERIALIZE_UNPICKLE_ALLOWED", "1")
+    )
+
+
+reload_unpickle_flag()
+
+
+cdef object _load_by_name(str class_name):
     if class_name in _type_cache:
         cls = _type_cache[class_name]
     else:
         try:
-            from .deserializer import safe_load_type
+            from .deserializer import safe_load_by_name
 
-            cls = safe_load_type(class_name, parent_class)
+            cls = safe_load_by_name(class_name)
         except ImportError:
             if pickle.is_unpickle_forbidden():
                 raise
@@ -123,12 +162,27 @@ cpdef object load_type(str class_name, object parent_class):
             for sub_cls_name in cls_name.split("."):
                 cls = getattr(cls, sub_cls_name)
         _type_cache[class_name] = cls
+    return cls
+
 
+cpdef object load_type(str class_name, object parent_class):
+    cls = _load_by_name(class_name)
+    if not isinstance(cls, type):
+        raise ValueError(f"Class {class_name} not a type, cannot be deserialized")
     if not issubclass(cls, parent_class):
         raise ValueError(f"Class {class_name} not a {parent_class}")
     return cls
 
 
+cpdef object load_member(str class_name, object restrict_type):
+    member = _load_by_name(class_name)
+    if not isinstance(member, restrict_type):
+        raise ValueError(
+            f"Class {class_name} not a {restrict_type}, cannot be deserialized"
+        )
+    return member
+
+
 cpdef void clear_type_cache():
     _type_cache.clear()
 
@@ -358,17 +412,37 @@ cdef class PickleContainer:
         self.buffers = buffers
 
     cpdef get(self):
+        if not unpickle_allowed:
+            raise ValueError("Unpickle not allowed in this environment")
         return unpickle_buffers(self.buffers)
 
     cpdef list get_buffers(self):
         return self.buffers
 
+    def __copy__(self):
+        return PickleContainer(self.buffers)
+
+    def __deepcopy__(self, memo=None):
+        return PickleContainer(copy.deepcopy(self.buffers, memo))
+
+    def __maxframe_tokenize__(self):
+        return self.buffers
+
+    def __reduce__(self):
+        return PickleContainer, (self.buffers, )
+
 
 cdef class PickleSerializer(Serializer):
     serializer_id = PICKLE_SERIALIZER
 
     cpdef serial(self, obj: Any, dict context):
         cdef uint64_t obj_id
+        cdef object serial_hook
+
+        serial_hook = pickle_serial_hook.get()
+        if serial_hook is not None:
+            serial_hook()
+
         obj_id = _fast_id(<PyObject*>obj)
         if obj_id in context:
             return Placeholder(obj_id)
@@ -380,7 +454,11 @@ cdef class PickleSerializer(Serializer):
 
     cpdef deserial(self, list serialized, dict context, list subs):
         from .deserializer import deserial_pickle
+        cdef object deserial_hook
 
+        deserial_hook = pickle_deserial_hook.get()
+        if deserial_hook is not None:
+            deserial_hook()
         return deserial_pickle(serialized, context, subs)
 
 

maxframe/serialization/pandas.py

@@ -39,7 +39,11 @@ class DataFrameSerializer(Serializer):
         self, serialized: List, context: Dict, subs: List[Any]
     ) -> pd.DataFrame:
         dtypes, idx = subs[:2]
-        df = pd.concat([pd.Series(d, index=idx) for d in subs[2:]], axis=1)
+        seriess = [pd.Series(d, index=idx) for d in subs[2:]]
+        if seriess:
+            df = pd.concat([pd.Series(d, index=idx) for d in subs[2:]], axis=1)
+        else:
+            df = pd.DataFrame([], index=idx)
         df.columns = dtypes.index
         df.index = idx
         return df.astype(dtypes)

maxframe/serialization/serializables/core.py

@@ -21,15 +21,15 @@ import msgpack
 
 from ...errors import MaxFrameDeprecationError
 from ...lib.mmh3 import hash
-from ...utils import no_default
+from ...utils import extract_class_name, no_default
 from ..core import Placeholder, Serializer, buffered, load_type
 from .field import Field
 from .field_type import DictType, ListType, PrimitiveFieldType, TupleType
 
 try:
-    from ..deserializer import get_legacy_module_name
+    from ..deserializer import get_legacy_class_name
 except ImportError:
-    get_legacy_module_name = lambda x: x
+    get_legacy_class_name = lambda x: x
 
 logger = logging.getLogger(__name__)
 _deprecate_log_key = "_SER_DEPRECATE_LOGGED"
@@ -62,8 +62,9 @@ def _is_field_primitive_compound(field: Field):
 class SerializableMeta(type):
     def __new__(mcs, name: str, bases: Tuple[Type], properties: Dict):
         # All the fields including misc fields.
+        legacy_name = properties.get("_legacy_name", name)
         legacy_name_hash = hash(
-            f"{get_legacy_module_name(properties.get('__module__'))}.{name}"
+            get_legacy_class_name(f"{properties.get('__module__')}.{legacy_name}")
         )
         name_hash = hash(
             f"{properties.get('__module__')}.{properties.get('__qualname__')}"
@@ -300,7 +301,7 @@ class SerializableSerializer(Serializer):
                 _primitive_serial_cache[obj] = primitive_vals
 
         compound_vals = self._get_field_values(obj, obj._NON_PRIMITIVE_FIELDS)
-        cls_module = f"{type(obj).__module__}#{type(obj).__qualname__}"
+        cls_module = extract_class_name(type(obj))
 
         field_count_key = self._get_obj_field_count_key(obj)
         if not self.is_public_data_exist(context, field_count_key):

maxframe/serialization/serializables/field.py

@@ -20,7 +20,7 @@ import os
 from abc import ABC, ABCMeta, abstractmethod
 from typing import Any, Callable, Optional, Type, Union
 
-from ...utils import no_default
+from ...utils import no_default, str_to_bool
 from .field_type import (
     AbstractFieldType,
     DictType,
@@ -30,7 +30,7 @@ from .field_type import (
     TupleType,
 )
 
-_is_ci = (os.environ.get("CI") or "0").lower() in ("1", "true")
+_is_ci = bool(str_to_bool(os.environ.get("CI")))
 
 
 class Field(ABC):

maxframe/serialization/serializables/tests/test_field_type.py

@@ -69,8 +69,8 @@ fields_values = [
     [FieldTypes.reference(MyClass), [MyClass()], [object()]],
     [
         FieldTypes.tuple(FieldTypes.int64, ...),
-        [tuple(), tuple([1, 2])],
-        [list(), tuple([1, 2.0])],
+        [(), (1, 2)],
+        [list(), (1, 2.0)],
     ],
     [
         FieldTypes.list(FieldTypes.int64, FieldTypes.float64),
@@ -101,9 +101,7 @@ def test_field_type(field_type, valid_values, invalid_values):
 
 def test_collction_field_error():
     with pytest.raises(ValueError):
-        FieldTypes.tuple(FieldTypes.int64, FieldTypes.float32).validate(
-            tuple([1, 3.0, 3.0])
-        )
+        FieldTypes.tuple(FieldTypes.int64, FieldTypes.float32).validate((1, 3.0, 3.0))
 
 
 def test_field_name():