cengal.data_manipulation.remote_objects.versions.v_0.remote_objects

View Source

   1#!/usr/bin/env python
   2# coding=utf-8
   3
   4# Copyright © 2012-2024 ButenkoMS. All rights reserved. Contacts: <gtalk@butenkoms.space>
   5# 
   6# Licensed under the Apache License, Version 2.0 (the "License");
   7# you may not use this file except in compliance with the License.
   8# You may obtain a copy of the License at
   9# 
  10#     http://www.apache.org/licenses/LICENSE-2.0
  11# 
  12# Unless required by applicable law or agreed to in writing, software
  13# distributed under the License is distributed on an "AS IS" BASIS,
  14# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15# See the License for the specific language governing permissions and
  16# limitations under the License.
  17
  18
  19__all__ = [
  20    'default_serializable_data_types',
  21    'known_types',
  22    'known_data_types',
  23    'known_container_types',
  24    'DataType',
  25    'data_type',
  26    'data_type_by_type',
  27    'ClassInfoFields',
  28    'ObjectInfoFields',
  29    'CanNotAdjustToSerializableError',
  30    'CanNotAdjustFromSerializableError',
  31    'RemoteObjectsManager',
  32]
  33
  34
  35from cengal.introspection.inspect import (
  36    entity_module_importable_str_and_owning_names_path,
  37    entity_by_name_module_importable_str_and_owning_names_path,
  38    filled_slot_names_with_values_gen,
  39    is_callable, is_async,
  40    is_setable_data_descriptor,
  41)
  42from cengal.code_flow_control.smart_values import ResultExistence
  43from cengal.code_flow_control.gc import DisableGC
  44from cengal.data_generation.id_generator import IDGenerator, GeneratorType
  45from enum import IntEnum
  46from collections.abc import MutableMapping, MutableSequence, MutableSet
  47from struct import pack, unpack
  48from inspect import getattr_static
  49from typing import Any, Dict, Optional, Callable, Set, Type, Tuple, List, FrozenSet
  50
  51
  52"""
  53Module Docstring
  54Docstrings: http://www.python.org/dev/peps/pep-0257/
  55"""
  56
  57__author__ = "ButenkoMS <gtalk@butenkoms.space>"
  58__copyright__ = "Copyright © 2012-2024 ButenkoMS. All rights reserved. Contacts: <gtalk@butenkoms.space>"
  59__credits__ = ["ButenkoMS <gtalk@butenkoms.space>", ]
  60__license__ = "Apache License, Version 2.0"
  61__version__ = "4.4.1"
  62__maintainer__ = "ButenkoMS <gtalk@butenkoms.space>"
  63__email__ = "gtalk@butenkoms.space"
  64# __status__ = "Prototype"
  65__status__ = "Development"
  66# __status__ = "Production"
  67
  68
  69default_serializable_data_types: Set[Type] = {
  70    int, float, complex, str, bytes, bytearray, bool, type(None), list, tuple, set, frozenset, dict
  71}
  72
  73
  74known_types: Set[Type] = {
  75    int, float, complex, str, bytes, bytearray, bool, type(None), list, tuple, set, frozenset, dict,
  76    slice, 
  77}
  78
  79
  80known_data_types: Set[Type] = {
  81    int, float, str, bytes, bytearray, bool, type(None), slice,
  82}
  83
  84
  85known_container_types: Set[Type] = {
  86    complex, list, tuple, set, frozenset, dict,
  87}
  88
  89
  90class DataType(IntEnum):
  91    class_ = 0  # type is not in known_types and not in serializable_data_types
  92    int_ = 1
  93    float_ = 2
  94    complex_ = 3
  95    str_ = 4
  96    bytes_ = 5
  97    bytearray_ = 6
  98    bool_ = 7
  99    none_ = 8
 100    list_ = 9
 101    tuple_ = 10
 102    set_ = 11
 103    frozenset_ = 12
 104    dict_ = 13
 105    slice_ = 14
 106    unknown_serializable = 15  # type is in serializable_data_types but not in known_types
 107
 108
 109data_type: Dict[DataType, Type] = {
 110    DataType.class_: object,
 111    DataType.int_: int,
 112    DataType.float_: float,
 113    DataType.complex_: complex,
 114    DataType.str_: str,
 115    DataType.bytes_: bytes,
 116    DataType.bytearray_: bytearray,
 117    DataType.bool_: bool,
 118    DataType.none_: type(None),
 119    DataType.list_: list,
 120    DataType.tuple_: tuple,
 121    DataType.set_: set,
 122    DataType.frozenset_: frozenset,
 123    DataType.dict_: dict,
 124    DataType.slice_: slice,
 125    DataType.unknown_serializable: None,
 126}
 127
 128
 129data_type_by_type: Dict[Type, DataType] = {
 130    object: DataType.class_,
 131    int: DataType.int_,
 132    float: DataType.float_,
 133    complex: DataType.complex_,
 134    str: DataType.str_,
 135    bytes: DataType.bytes_,
 136    bytearray: DataType.bytearray_,
 137    bool: DataType.bool_,
 138    type(None): DataType.none_,
 139    list: DataType.list_,
 140    tuple: DataType.tuple_,
 141    set: DataType.set_,
 142    frozenset: DataType.frozenset_,
 143    dict: DataType.dict_,
 144    slice: DataType.slice_,
 145    None: DataType.unknown_serializable,
 146}
 147
 148
 149class ClassInfoFields(IntEnum):
 150    class_id = 0
 151    class_name = 1
 152    module_importable_str = 2
 153    owning_names_path = 3
 154
 155
 156class ObjectInfoFields(IntEnum):
 157    object_id = 0  # (type: int)
 158    type_id = 1  # (type: DataType)
 159    object_ = 2  # (Optional), (type: Any). Link to object itself if `(type(obj) in serializable_data_types)`. Not used otherwise.
 160    class_id = 3  # (Optional), (type: int). Used if `type_id == DataType.class_`
 161    clonable_slots = 4  # (Optional), (type: Tuple[Tuple[str, Any]]). Used if `type_id == DataType.class_`. Holds ID's (object_id) of slots objects.
 162    clonable_dict_items = 5  # (Optional), (type: Tuple[Tuple[str, Any]]). Used if `type_id == DataType.class_`. Holds ID's (object_id) of value objects.
 163    # contained_items = 6  # (Optional), (type: Union[Tuple, List, Set, FrozenSet, Dict]). Used if `type_id in {DataType.list_, DataType.tuple_, DataType.set_, DataType.frozenset_, DataType.dict_, DataType.slice_}`. Holds ID's (object_id) of contained items (for bothe keys and values in the case of Dict).
 164    contained_mapping = 6  # (Optional), (type: Union[Tuple, List, Set, FrozenSet, Dict]). Used if `type_id in {DataType.list_, DataType.tuple_, DataType.set_, DataType.frozenset_, DataType.dict_, DataType.slice_}`. Holds ID's (object_id) of contained items (for bothe keys and values in the case of Dict).
 165    contained_sequence = 7  # (Optional), (type: Union[Tuple, List, Set, FrozenSet, Dict]). Used if `type_id in {DataType.list_, DataType.tuple_, DataType.set_, DataType.frozenset_, DataType.dict_, DataType.slice_}`. Holds ID's (object_id) of contained items (for bothe keys and values in the case of Dict).
 166    contained_set = 8  # (Optional), (type: Union[Tuple, List, Set, FrozenSet, Dict]). Used if `type_id in {DataType.list_, DataType.tuple_, DataType.set_, DataType.frozenset_, DataType.dict_, DataType.slice_}`. Holds ID's (object_id) of contained items (for bothe keys and values in the case of Dict).
 167
 168
 169class CanNotAdjustToSerializableError(Exception):
 170    pass
 171
 172
 173class CanNotAdjustFromSerializableError(Exception):
 174    pass
 175
 176
 177class RemoteObjectsManager:
 178    def __init__(self, 
 179                 on_new_class_handler: Optional[Callable] = None,
 180                 on_new_obj_info_handler: Optional[Callable] = None,
 181                 # classess_db: Optional[Dict[int, Type]] = None, 
 182                 objects_db: Optional[Dict[int, Any]] = None, 
 183                 classes_id_gen: Optional[Callable] = None,
 184                 objects_id_gen: Optional[Callable] = None,
 185                 serializable_data_types: Optional[Set[Type]] = None,
 186                 ) -> None:
 187        # self.classess_db: Dict[int, Type] = dict() if classess_db is None else classess_db
 188        self.classes_id_gen: IDGenerator = IDGenerator() if classes_id_gen is None else classes_id_gen
 189        self.objects_db: Dict[int, Any] = dict() if objects_db is None else objects_db
 190        self.objects_id_gen: IDGenerator = IDGenerator() if objects_id_gen is None else objects_id_gen
 191        self.serializable_data_types: Set[Type] = default_serializable_data_types if serializable_data_types is None else serializable_data_types
 192        self.serializable_any: bool = not self.serializable_data_types
 193        self.serializable_int: bool = (int in self.serializable_data_types) or self.serializable_any
 194        self.serializable_float: bool = (float in self.serializable_data_types) or self.serializable_any
 195        self.serializable_complex: bool = (complex in self.serializable_data_types) or self.serializable_any
 196        self.serializable_str: bool = (str in self.serializable_data_types) or self.serializable_any
 197        self.serializable_bytes: bool = (bytes in self.serializable_data_types) or self.serializable_any
 198        self.serializable_bytearray: bool = (bytearray in self.serializable_data_types) or self.serializable_any
 199        self.serializable_bool: bool = (bool in self.serializable_data_types) or self.serializable_any
 200        self.serializable_none: bool = (type(None) in self.serializable_data_types) or self.serializable_any
 201        self.serializable_list: bool = (list in self.serializable_data_types) or self.serializable_any
 202        self.serializable_tuple: bool = (tuple in self.serializable_data_types) or self.serializable_any
 203        self.serializable_set: bool = (set in self.serializable_data_types) or self.serializable_any
 204        self.serializable_frozenset: bool = (frozenset in self.serializable_data_types) or self.serializable_any
 205        self.serializable_dict: bool = (dict in self.serializable_data_types) or self.serializable_any
 206        self.serializable_slice: bool = (slice in self.serializable_data_types) or self.serializable_any
 207        self.known_classes: Dict[Type, int] = dict()
 208        self.known_classes_by_id: Dict[int, Type] = dict()
 209        self.known_classes_info: Dict[Tuple, int] = dict()
 210        self.known_classes_info_by_id: Dict[int, Tuple] = dict()
 211        self.on_new_class_handler: Optional[Callable] = on_new_class_handler
 212        self.on_new_obj_info_handler: Optional[Callable] = on_new_obj_info_handler
 213        self.objects_ids: Dict[int, int] = dict()  # (Key: object_id, Value: id(obj))
 214        self.objects_ids_by_id: Dict[int, int] = dict()  # (Key: id(obj), Value: object_id)
 215
 216    def del_object_by_id(self, id_: int) -> None:
 217        if id_ in self.objects_ids_by_id:
 218            object_id = self.objects_ids_by_id[id_]
 219            self.objects_ids_by_id.pop(id_, None)
 220            self.objects_ids.pop(object_id, None)
 221            self.objects_db.pop(object_id, None)
 222    
 223    dobi = del_object_by_id
 224    
 225    def del_object_by_object_id(self, object_id: int) -> None:
 226        if object_id in self.objects_ids:
 227            id_ = self.objects_ids[object_id]
 228            self.objects_ids_by_id.pop(id_, None)
 229            self.objects_ids.pop(object_id, None)
 230            self.objects_db.pop(object_id, None)
 231    
 232    doboi = del_object_by_object_id
 233    
 234    def adjust_to_serializable(self, type_id: DataType, obj: Any) -> Any:
 235        if DataType.int_ == type_id:
 236            if self.serializable_int:
 237                return obj
 238            elif self.serializable_bytes:
 239                return obj.to_bytes(8, 'little')
 240            elif self.serializable_bytearray:
 241                return bytearray(obj.to_bytes(8, 'little'))
 242            elif self.serializable_str:
 243                return str(obj)
 244            else:
 245                pass
 246        elif DataType.float_ == type_id:
 247            if self.serializable_float:
 248                return obj
 249            elif self.serializable_bytes:
 250                return pack('=d', obj)
 251            elif self.serializable_bytearray:
 252                return bytearray(pack('=d', obj))
 253            elif self.serializable_str:
 254                return str(obj)
 255            else:
 256                pass
 257        elif DataType.complex_ == type_id:
 258            if self.serializable_complex:
 259                return obj
 260            elif self.serializable_bytes:
 261                return pack('=dd', obj.real, obj.imag)
 262            elif self.serializable_bytearray:
 263                return bytearray(pack('=dd', obj.real, obj.imag))
 264            elif self.serializable_str:
 265                return str(obj)
 266            elif self.serializable_float:
 267                if self.serializable_tuple:
 268                    return (obj.real, obj.imag)
 269                elif self.serializable_list:
 270                    return [obj.real, obj.imag]
 271                else:
 272                    pass
 273            else:
 274                pass
 275        elif DataType.str_ == type_id:
 276            if self.serializable_str:
 277                return obj
 278            elif self.serializable_bytes:
 279                return obj.encode('utf-8')
 280            elif self.serializable_bytearray:
 281                return bytearray(obj.encode('utf-8'))
 282            elif self.serializable_int:
 283                if self.serializable_tuple:
 284                    return tuple(ord(c) for c in obj)
 285                elif self.serializable_list:
 286                    return [ord(c) for c in obj]
 287                else:
 288                    pass
 289            elif self.serializable_float:
 290                if self.serializable_tuple:
 291                    return tuple(float(ord(c)) for c in obj)
 292                elif self.serializable_list:
 293                    return [float(ord(c)) for c in obj]
 294                else:
 295                    pass
 296            else:
 297                pass
 298        elif DataType.bytes_ == type_id:
 299            if self.serializable_bytes:
 300                return obj
 301            elif self.serializable_bytearray:
 302                return bytearray(obj)
 303            elif self.serializable_str:
 304                return obj.hex()
 305            elif self.serializable_tuple:
 306                if self.serializable_int:
 307                    return  tuple(int(c) for c in obj)
 308                if self.serializable_float:
 309                    return  tuple(float(int(c)) for c in obj)
 310                else:
 311                    pass
 312            elif self.serializable_list:
 313                if self.serializable_int:
 314                    return  [int(c) for c in obj]
 315                if self.serializable_float:
 316                    return  [float(int(c)) for c in obj]
 317                else:
 318                    pass
 319            else:
 320                pass
 321        elif DataType.bytearray_ == type_id:
 322            if self.serializable_bytearray:
 323                return obj
 324            elif self.serializable_bytes:
 325                return bytes(obj)
 326            elif self.serializable_str:
 327                return obj.hex()
 328            elif self.serializable_tuple:
 329                if self.serializable_int:
 330                    return  tuple(int(c) for c in obj)
 331                if self.serializable_float:
 332                    return  tuple(float(int(c)) for c in obj)
 333                else:
 334                    pass
 335            elif self.serializable_list:
 336                if self.serializable_int:
 337                    return  [int(c) for c in obj]
 338                if self.serializable_float:
 339                    return  [float(int(c)) for c in obj]
 340                else:
 341                    pass
 342            else:
 343                pass
 344        elif DataType.bool_ == type_id:
 345            if self.serializable_bool:
 346                return obj
 347            elif self.serializable_int:
 348                return int(obj)
 349            elif self.serializable_bytes:
 350                return obj.to_bytes(1, 'little')
 351            elif self.serializable_bytearray:
 352                return bytearray(obj.to_bytes(1, 'little'))
 353            elif self.serializable_str:
 354                return str(obj)
 355            elif self.serializable_float:
 356                return float(int(obj))
 357            else:
 358                pass
 359        elif DataType.none_ == type_id:
 360            if self.serializable_none:
 361                return obj
 362            elif self.serializable_bool:
 363                return False
 364            elif self.serializable_int:
 365                return 0
 366            elif self.serializable_bytes:
 367                return b'\x00'
 368            elif self.serializable_bytearray:
 369                return bytearray(b'\x00')
 370            elif self.serializable_str:
 371                return ''
 372            elif self.serializable_float:
 373                return 0.0
 374            else:
 375                pass
 376        elif DataType.list_ == type_id:
 377            if self.serializable_list:
 378                return obj
 379            elif self.serializable_tuple:
 380                return tuple(obj)
 381            elif self.serializable_dict:
 382                return dict({index: item for index, item in enumerate(obj)})
 383            else:
 384                pass
 385        elif DataType.tuple_ == type_id:
 386            if self.serializable_tuple:
 387                return obj
 388            elif self.serializable_list:
 389                return list(obj)
 390            elif self.serializable_dict:
 391                return dict({index: item for index, item in enumerate(obj)})
 392            else:
 393                pass
 394        elif DataType.set_ == type_id:
 395            if self.serializable_set:
 396                return obj
 397            elif self.serializable_frozenset:
 398                return frozenset(obj)
 399            elif self.serializable_tuple:
 400                return tuple(obj)
 401            elif self.serializable_list:
 402                return list(obj)
 403            elif self.serializable_dict:
 404                return dict({k: None for k in obj})
 405            else:
 406                pass
 407        elif DataType.frozenset_ == type_id:
 408            if self.serializable_frozenset:
 409                return obj
 410            elif self.serializable_set:
 411                return set(obj)
 412            elif self.serializable_tuple:
 413                return tuple(obj)
 414            elif self.serializable_list:
 415                return list(obj)
 416            elif self.serializable_dict:
 417                return dict({k: None for k in obj})
 418            else:
 419                pass
 420        elif DataType.dict_ == type_id:
 421            if self.serializable_dict:
 422                return obj
 423            elif self.serializable_tuple:
 424                return tuple(obj.items())
 425            elif self.serializable_list:
 426                return list(list(pair) for pair in obj.items())
 427            else:
 428                pass
 429        elif DataType.slice_ == type_id:
 430            if self.serializable_slice:
 431                return obj
 432            elif self.serializable_tuple:
 433                return (obj.start, obj.stop, obj.step)
 434            elif self.serializable_list:
 435                return [obj.start, obj.stop, obj.step]
 436            elif self.serializable_dict:
 437                return {0: obj.start, 1: obj.stop, 2: obj.step}
 438            else:
 439                pass
 440        else:
 441            raise RuntimeError('Unknown type_id')
 442        
 443        raise CanNotAdjustToSerializableError(f'Can not adjust to serializable. Type: {type_id}, obj: {obj}')
 444
 445    ats = adjust_to_serializable
 446
 447    def adjust_from_serializable(self, type_id: DataType, obj: Any) -> Any:
 448        if DataType.int_ == type_id:
 449            if self.serializable_int:
 450                return obj
 451            elif self.serializable_bytes:
 452                return int.from_bytes(obj, 'little')
 453            elif self.serializable_bytearray:
 454                return int.from_bytes(bytes(obj), 'little')
 455            elif self.serializable_str:
 456                return int(obj)
 457            else:
 458                pass
 459        elif DataType.float_ == type_id:
 460            if self.serializable_float:
 461                return obj
 462            elif self.serializable_bytes:
 463                return unpack('=d', obj)[0]
 464            elif self.serializable_bytearray:
 465                return unpack('=d', bytes(obj))[0]
 466            elif self.serializable_str:
 467                return float(obj)
 468            else:
 469                pass
 470        elif DataType.complex_ == type_id:
 471            if self.serializable_complex:
 472                return obj
 473            elif self.serializable_bytes:
 474                return complex(*unpack('=dd', obj))
 475            elif self.serializable_bytearray:
 476                return complex(*unpack('=dd', bytes(obj)))
 477            elif self.serializable_str:
 478                return complex(*obj)
 479            elif self.serializable_float:
 480                if self.serializable_tuple:
 481                    return complex(*obj)
 482                elif self.serializable_list:
 483                    return complex(*obj)
 484                else:
 485                    pass
 486            else:
 487                pass
 488        elif DataType.str_ == type_id:
 489            if self.serializable_str:
 490                return obj
 491            elif self.serializable_bytes:
 492                return obj.decode('utf-8')
 493            elif self.serializable_bytearray:
 494                return bytes(obj).decode('utf-8')
 495            elif self.serializable_int:
 496                if self.serializable_tuple:
 497                    return ''.join(chr(c) for c in obj)
 498                elif self.serializable_list:
 499                    return ''.join(chr(c) for c in obj)
 500                else:
 501                    pass
 502            elif self.serializable_float:
 503                if self.serializable_tuple:
 504                    return ''.join(chr(int(round(c))) for c in obj)
 505                elif self.serializable_list:
 506                    return ''.join(chr(int(round(c))) for c in obj)
 507                else:
 508                    pass
 509            else:
 510                pass
 511        elif DataType.bytes_ == type_id:
 512            if self.serializable_bytes:
 513                return obj
 514            elif self.serializable_bytearray:
 515                return bytes(obj)
 516            elif self.serializable_str:
 517                return bytes.fromhex(obj)
 518            elif self.serializable_tuple:
 519                if self.serializable_int:
 520                    return  b''.join(item.to_bytes(1, 'little') for item in obj)
 521                if self.serializable_float:
 522                    return  b''.join((int(round(item))).to_bytes(1, 'little') for item in obj)
 523                else:
 524                    pass
 525            elif self.serializable_list:
 526                if self.serializable_int:
 527                    return  b''.join(item.to_bytes(1, 'little') for item in obj)
 528                if self.serializable_float:
 529                    return  b''.join((int(round(item))).to_bytes(1, 'little') for item in obj)
 530                else:
 531                    pass
 532            else:
 533                pass
 534        elif DataType.bytearray_ == type_id:
 535            if self.serializable_bytearray:
 536                return obj
 537            elif self.serializable_bytes:
 538                return bytearray(obj)
 539            elif self.serializable_str:
 540                return bytearray(bytes.fromhex(obj))
 541            elif self.serializable_tuple:
 542                if self.serializable_int:
 543                    return  bytearray(b''.join(item.to_bytes(1, 'little') for item in obj))
 544                if self.serializable_float:
 545                    return  bytearray(b''.join((int(round(item))).to_bytes(1, 'little') for item in obj))
 546                else:
 547                    pass
 548            elif self.serializable_list:
 549                if self.serializable_int:
 550                    return  bytearray(b''.join(item.to_bytes(1, 'little') for item in obj))
 551                if self.serializable_float:
 552                    return  bytearray(b''.join((int(round(item))).to_bytes(1, 'little') for item in obj))
 553                else:
 554                    pass
 555            else:
 556                pass
 557        elif DataType.bool_ == type_id:
 558            if self.serializable_bool:
 559                return obj
 560            elif self.serializable_int:
 561                return bool(obj)
 562            elif self.serializable_bytes:
 563                return bool(int.from_bytes(obj, 'little'))
 564            elif self.serializable_bytearray:
 565                return bool(int.from_bytes(bytes(obj), 'little'))
 566            elif self.serializable_str:
 567                return bool(obj)
 568            elif self.serializable_float:
 569                return bool(int(round(obj)))
 570            else:
 571                pass
 572        elif DataType.none_ == type_id:
 573            return None
 574        elif DataType.list_ == type_id:
 575            if self.serializable_list:
 576                return obj
 577            elif self.serializable_tuple:
 578                return list(obj)
 579            elif self.serializable_dict:
 580                return [value for key, value in sorted(obj.items(), key=lambda x: x[0])]
 581            else:
 582                pass
 583        elif DataType.tuple_ == type_id:
 584            if self.serializable_tuple:
 585                return obj
 586            elif self.serializable_list:
 587                return tuple(obj)
 588            elif self.serializable_dict:
 589                return tuple(value for key, value in sorted(obj.items(), key=lambda x: x[0]))
 590            else:
 591                pass
 592        elif DataType.set_ == type_id:
 593            if self.serializable_set:
 594                return obj
 595            elif self.serializable_frozenset:
 596                return set(obj)
 597            elif self.serializable_tuple:
 598                return set(obj)
 599            elif self.serializable_list:
 600                return set(obj)
 601            elif self.serializable_dict:
 602                return set(obj.keys())
 603            else:
 604                pass
 605        elif DataType.frozenset_ == type_id:
 606            if self.serializable_frozenset:
 607                return obj
 608            elif self.serializable_set:
 609                return frozenset(obj)
 610            elif self.serializable_tuple:
 611                return frozenset(obj)
 612            elif self.serializable_list:
 613                return frozenset(obj)
 614            elif self.serializable_dict:
 615                return frozenset(obj.keys())
 616            else:
 617                pass
 618        elif DataType.dict_ == type_id:
 619            if self.serializable_dict:
 620                return obj
 621            elif self.serializable_tuple:
 622                return dict(obj)
 623            elif self.serializable_list:
 624                return dict(obj)
 625            else:
 626                pass
 627        elif DataType.slice_ == type_id:
 628            if self.serializable_slice:
 629                return obj
 630            elif self.serializable_tuple:
 631                return slice(*obj)
 632            elif self.serializable_list:
 633                return slice(*obj)
 634            elif self.serializable_dict:
 635                return slice(obj[0], obj[1], obj[2])
 636            else:
 637                pass
 638        else:
 639            raise RuntimeError('Unknown type_id')
 640        
 641        raise CanNotAdjustFromSerializableError(f'Can not adjust from serializable. Type: {type_id}, obj: {obj}')
 642    
 643    afs = adjust_from_serializable
 644    
 645    # def is_replicatable_object_attribute(self, attribute: Any) -> bool:
 646    #     if is_setable_data_descriptor(attribute):
 647    #         data = attribute.__get__(None, None)
 648    #     elif is_callable(attribute):
 649    #         return False
 650    #     else:
 651    #         return True
 652
 653    def serialize_container(self, type_id: DataType, obj: Any) -> Any:
 654        if DataType.list_ == type_id:
 655            new_obj = list()
 656            for item in obj:
 657                result: ResultExistence[int] = self.serialize_impl(item)
 658                if result:
 659                    new_obj.append(result.value)
 660        elif DataType.tuple_ == type_id:
 661            new_obj = list()
 662            for item in obj:
 663                result: ResultExistence[int] = self.serialize_impl(item)
 664                if result:
 665                    new_obj.append(result.value)
 666            
 667            new_obj = tuple(new_obj)
 668        elif DataType.set_ == type_id:
 669            new_obj = set()
 670            for item in obj:
 671                result: ResultExistence[int] = self.serialize_impl(item)
 672                if result:
 673                    new_obj.add(result.value)
 674        elif DataType.frozenset_ == type_id:
 675            new_obj = set()
 676            for item in obj:
 677                result: ResultExistence[int] = self.serialize_impl(item)
 678                if result:
 679                    new_obj.add(result.value)
 680                
 681            new_obj = frozenset(new_obj)
 682        elif DataType.dict_ == type_id:
 683            new_obj = dict()
 684            for key, value in obj.items():
 685                key_result: ResultExistence[int] = self.serialize_impl(key)
 686                value_result: ResultExistence[int] = self.serialize_impl(value)
 687                if key_result and value_result:
 688                    new_obj[key_result.value] = value_result.value
 689        
 690        return new_obj
 691    
 692    sc = serialize_container
 693
 694    def serialize_impl(self, obj: Any, ignore_empty_classes: bool = False) -> ResultExistence[int]:
 695        result_exists: bool = True
 696        id_: int = id(obj)
 697        obj_type = type(obj)
 698        if (int != obj_type) and (id_ in self.objects_ids_by_id):
 699            new_object: bool = False
 700            object_id: int = self.objects_ids_by_id[id_]
 701        else:
 702            # int object must always produce new object_id because first 256 ints are persistent across Python sessions and
 703            # this can cause issues within users of current module. For example within `cengal/hardware/memory/shared_memory`
 704            # which changes int values inline instead of producing new objects.
 705            new_object = True
 706            object_id = self.objects_id_gen()
 707            self.objects_ids[object_id] = id_
 708            self.objects_db[object_id] = obj
 709        
 710        if not new_object:
 711            return ResultExistence[int](result_exists, object_id)
 712
 713        if  self.serializable_any or (obj_type in self.serializable_data_types):
 714            serializable: bool = True
 715            type_id: DataType = data_type_by_type.get(obj_type, DataType.unknown_serializable)
 716        else:
 717            serializable = False
 718            type_id = data_type_by_type.get(obj_type, DataType.class_)
 719        
 720        if obj_type in known_container_types:
 721            known_container: bool = True
 722        else:
 723            known_container = False
 724        
 725        class_info: Dict[int, Any] = None
 726        known_data: bool = None
 727        class_id: int = None
 728        is_new_class: bool = None
 729        class_name: str = None
 730        new_obj_slots: List[Tuple[str, Any]] = None
 731        new_obj_dict: Dict[str, Any] = None
 732        obj_mapping: Dict = None
 733        obj_sequence: List = None
 734        obj_set: Set = None
 735        if serializable:
 736            if known_container:
 737                object_info = (
 738                    self.ats(DataType.int_, object_id),
 739                    self.ats(DataType.int_, type_id.value),
 740                    self.sc(type_id, obj),
 741                )
 742            else:
 743                object_info = (
 744                    self.ats(DataType.int_, object_id),
 745                    self.ats(DataType.int_, type_id.value),
 746                    obj,
 747                )
 748        else:
 749            if obj_type in known_data_types:
 750                known_data = True
 751            else:
 752                known_data = False
 753            
 754            if DataType.class_ == type_id:
 755                new_obj_slots = list()
 756                for slot_name, slot_value in filled_slot_names_with_values_gen(obj):
 757                    # if not hasattr(slot_value, '__set__'):
 758                    #     # if not setable descriptor
 759                    #     continue
 760
 761                    if self.serializable_str:
 762                        adjusted_slot_name = slot_name
 763                    else:
 764                        adjusted_slot_name = self.ats(DataType.str_, slot_name)
 765                    
 766                    item_result: ResultExistence[int] = self.serialize_impl(slot_value)
 767                    if item_result:
 768                        if self.serializable_tuple:
 769                            new_obj_slots.append((adjusted_slot_name, item_result.value))
 770                        elif self.serializable_list:
 771                            new_obj_slots.append([adjusted_slot_name, item_result.value])
 772                        else:
 773                            new_obj_slots.append(self.ats(DataType.tuple_, (adjusted_slot_name, item_result.value)))
 774                
 775                if new_obj_slots:
 776                    if self.serializable_list:
 777                        pass
 778                    elif self.serializable_tuple:
 779                        new_obj_slots = tuple(new_obj_slots)
 780                    else:
 781                        new_obj_slots = self.ats(DataType.list_, new_obj_slots)
 782                
 783                new_obj_dict = dict()
 784                if hasattr(obj, '__dict__'):
 785                    for key, value in obj.__dict__.items():
 786                        # raw_value = getattr_static(obj, key)
 787                        # if hasattr(raw_value, '__get__') and (not hasattr(raw_value, '__set__')):
 788                        #     # if not setable descriptor
 789                        #     continue
 790
 791                        if self.serializable_str:
 792                            adjusted_key = key
 793                        else:
 794                            adjusted_key = self.ats(DataType.str_, key)
 795
 796                        value_result: ResultExistence[int] = self.serialize_impl(value)
 797                        if value_result:
 798                            new_obj_dict[adjusted_key] = value_result.value
 799                        else:
 800                            continue
 801                
 802                    if new_obj_dict:
 803                        if self.serializable_dict:
 804                            pass
 805                        else:
 806                            new_obj_dict = self.ats(DataType.dict_, new_obj_dict)
 807                
 808                obj_mapping = dict()
 809                obj_sequence = list()
 810                obj_set = set()
 811                if isinstance(obj, MutableMapping):
 812                    for key, value in obj.items():
 813                        key_result: ResultExistence[int] = self.serialize_impl(value)
 814                        if not key_result:
 815                            continue
 816
 817                        value_result: ResultExistence[int] = self.serialize_impl(value)
 818                        if value_result:
 819                            obj_mapping[key_result.value] = value_result.value
 820                        else:
 821                            continue
 822                    
 823                    if obj_mapping:
 824                        if self.serializable_dict:
 825                            pass
 826                        else:
 827                            obj_mapping = self.ats(DataType.dict_, obj_mapping)
 828                elif isinstance(obj, MutableSequence):
 829                    for item in obj:
 830                        item_result: ResultExistence[int] = self.serialize_impl(item)
 831                        if item_result:
 832                            obj_sequence.append(item_result.value)
 833                        else:
 834                            continue
 835                    
 836                    if obj_sequence:
 837                        if self.serializable_list:
 838                            pass
 839                        else:
 840                            obj_sequence = self.ats(DataType.list_, obj_sequence)
 841                elif isinstance(obj, MutableSet):
 842                    for item in obj:
 843                        item_result: ResultExistence[int] = self.serialize_impl(item)
 844                        if item_result:
 845                            obj_set.add(item_result.value)
 846                        else:
 847                            continue
 848                    
 849                    if obj_set:
 850                        if self.serializable_set:
 851                            pass
 852                        else:
 853                            obj_set = self.ats(DataType.set_, obj_set)
 854                else:
 855                    pass
 856
 857                if ignore_empty_classes:
 858                    result_exists = new_obj_slots or new_obj_dict or obj_mapping or obj_sequence or obj_set
 859                
 860                if obj_type in self.known_classes:
 861                    is_new_class = False
 862                    class_id = self.known_classes[obj_type]
 863                else:
 864                    class_info = dict()
 865                    is_new_class = True
 866                    class_name = obj_type.__name__
 867                    class_id = self.classes_id_gen()
 868                    self.known_classes[obj_type] = class_id
 869                    self.known_classes_by_id[class_id] = obj_type
 870                    module_importable_str, owning_names_path = entity_module_importable_str_and_owning_names_path(obj)
 871                    adjusted_owning_names_path: List[str] = [self.ats(DataType.str_, name) for name in owning_names_path]
 872                    module_importable_str_and_owning_names_path = (class_name, module_importable_str, tuple(owning_names_path))
 873                    self.known_classes_info[module_importable_str_and_owning_names_path] = class_id
 874                    self.known_classes_info_by_id[class_id] = module_importable_str_and_owning_names_path
 875
 876                    if result_exists:
 877                        class_info = (
 878                            self.ats(DataType.int_, class_id),
 879                            self.ats(DataType.str_, class_name),
 880                            self.ats(DataType.str_, module_importable_str),
 881                            self.ats(DataType.list_, adjusted_owning_names_path),
 882                        )
 883
 884                        if self.serializable_tuple:
 885                            adjusted_class_info = class_info
 886                        else:
 887                            adjusted_class_info = self.ats(DataType.tuple_, class_info)
 888                        
 889                        if self.on_new_class_handler:
 890                            self.on_new_class_handler(
 891                                adjusted_class_info,
 892                                obj_type,
 893                                class_id,
 894                                class_name,
 895                                module_importable_str,
 896                                owning_names_path,
 897                                module_importable_str_and_owning_names_path
 898                            )
 899
 900                # will be later serialized much faster than without `if else None`
 901                object_info = (
 902                    self.ats(DataType.int_, object_id),
 903                    self.ats(DataType.int_, type_id.value),
 904                    self.ats(DataType.none_, None),
 905                    self.ats(DataType.int_, class_id),
 906                    new_obj_slots if new_obj_slots else self.ats(DataType.list_, list()),
 907                    new_obj_dict if new_obj_dict else self.ats(DataType.dict_, dict()),
 908                    obj_mapping if obj_mapping else self.ats(DataType.dict_, dict()),
 909                    obj_sequence if obj_sequence else self.ats(DataType.list_, list()),
 910                    obj_set if obj_set else self.ats(DataType.set_, set()),
 911                )
 912            elif known_data:
 913                object_info = (
 914                    self.ats(DataType.int_, object_id),
 915                    self.ats(DataType.int_, type_id.value),
 916                    self.ats(type_id, obj),
 917                )
 918            elif known_container:
 919                object_info = (
 920                    self.ats(DataType.int_, object_id),
 921                    self.ats(DataType.int_, type_id.value),
 922                    self.ats(type_id, self.sc(type_id, obj)),
 923                )
 924            else:
 925                raise RuntimeError('Unknown type_id')
 926
 927        if self.serializable_tuple:
 928            adjusted_object_info = object_info
 929        else:
 930            adjusted_object_info = self.ats(DataType.tuple_, object_info)
 931        
 932        if result_exists:
 933            if self.on_new_obj_info_handler:
 934                self.on_new_obj_info_handler(
 935                    adjusted_object_info,
 936                    obj,
 937                    object_id,
 938                    type_id,
 939                    serializable,
 940                    known_container,
 941                    known_data,
 942                    class_id,
 943                    is_new_class,
 944                    new_obj_slots,
 945                    new_obj_dict,
 946                    obj_mapping,
 947                    obj_sequence,
 948                    obj_set,
 949                )
 950        
 951        return ResultExistence[int](result_exists, object_id)
 952    
 953    si = serialize_impl
 954
 955    def serialize(self, obj: Any, ignore_empty_classes: bool = False) -> ResultExistence[int]:
 956        with DisableGC():
 957            return self.serialize_impl(obj, ignore_empty_classes)
 958    
 959    s = serialize
 960    
 961    def deserialize_class_impl(self, class_info: Tuple) -> ResultExistence[Tuple[int, Type]]:
 962        if self.serializable_tuple:
 963            pass
 964        else:
 965            class_info = self.afs(DataType.tuple_, class_info)
 966
 967        class_id: int = self.afs(DataType.int_, class_info[ClassInfoFields.class_id.value])
 968        if class_id in self.known_classes_by_id:
 969            return ResultExistence[Tuple[int, Type]](True, (class_id, self.known_classes_by_id[class_id]))
 970        else:
 971            class_name: str = self.afs(DataType.str_, class_info[ClassInfoFields.class_name.value])
 972            module_importable_str: str = self.afs(DataType.str_, class_info[ClassInfoFields.module_importable_str.value])
 973            owning_names_path: List[str] = self.afs(DataType.list_, class_info[ClassInfoFields.owning_names_path.value])
 974            adjusted_owning_names_path: List[str] = [self.afs(DataType.str_, name) for name in owning_names_path]
 975            obj_class: Type = entity_by_name_module_importable_str_and_owning_names_path(class_name, module_importable_str, adjusted_owning_names_path)
 976            self.known_classes_by_id[class_id] = obj_class
 977            self.known_classes[obj_class] = class_id
 978            class_info_tuple: Tuple = (class_name, module_importable_str, tuple(owning_names_path)) 
 979            self.known_classes_info[class_info_tuple] = class_id
 980            self.known_classes_info_by_id[class_id] = class_info_tuple
 981            return ResultExistence[Tuple[int, Type]](True, (class_id, obj_class))
 982    
 983    dcli = deserialize_class_impl
 984    
 985    def deserialize_class(self, class_info: Tuple) -> ResultExistence[Tuple[int, Type]]:
 986        with DisableGC():
 987            return self.deserialize_class_impl(class_info)
 988    
 989    dcl = deserialize_class
 990
 991    def deserialize_container_impl(self, type_id: DataType, obj: Any) -> Any:
 992        new_obj = obj
 993        if DataType.list_ == type_id:
 994            new_obj = list()
 995            for item_id in obj:
 996                new_obj.append(self.objects_db[self.afs(DataType.int_, item_id)])
 997        elif DataType.tuple_ == type_id:
 998            new_obj = list()
 999            for item_id in obj:
1000                new_obj.append(self.objects_db[self.afs(DataType.int_, item_id)])
1001            
1002            new_obj = tuple(new_obj)
1003        elif DataType.set_ == type_id:
1004            new_obj = set()
1005            for item_id in obj:
1006                new_obj.add(self.objects_db[self.afs(DataType.int_, item_id)])
1007        elif DataType.frozenset_ == type_id:
1008            new_obj = set()
1009            for item_id in obj:
1010                new_obj.add(self.objects_db[self.afs(DataType.int_, item_id)])
1011                
1012            new_obj = frozenset(new_obj)
1013        elif DataType.dict_ == type_id:
1014            new_obj = dict()
1015            for key_id, value_id in obj.items():
1016                new_obj[self.objects_db[int(self.afs(DataType.int_, key_id))]] = self.objects_db[self.afs(DataType.int_, value_id)]
1017        
1018        return new_obj
1019    
1020    dcoi = deserialize_container_impl
1021
1022    def deserialize_container(self, type_id: DataType, obj: Any) -> Any:
1023        with DisableGC():
1024            return self.deserialize_container_impl(type_id, obj)
1025    
1026    dco = deserialize_container
1027
1028    def deserialize_obj_impl(self, obj_info: Tuple) -> ResultExistence[Tuple[int, Any]]:
1029        if self.serializable_tuple:
1030            pass
1031        else:
1032            obj_info = self.afs(DataType.tuple_, obj_info)
1033        
1034        object_id: int = self.afs(DataType.int_, obj_info[ObjectInfoFields.object_id.value])
1035        if object_id in self.objects_db:
1036            return ResultExistence[Tuple[int, Any]](True, (object_id, self.objects_db[object_id]))
1037        
1038        type_id: DataType = DataType(self.afs(DataType.int_, obj_info[ObjectInfoFields.type_id.value]))
1039        
1040        obj_type = data_type[type_id] 
1041        serializable: bool = self.serializable_any or (obj_type in self.serializable_data_types)
1042        known_container: bool = obj_type in known_container_types
1043        known_data: bool = None
1044        
1045        if serializable:
1046            if known_container:
1047                obj = self.dcoi(type_id, obj_info[ObjectInfoFields.object_.value])
1048            else:
1049                obj = obj_info[ObjectInfoFields.object_.value]
1050        else:
1051            known_data = obj_type in known_data_types
1052            
1053            if DataType.class_ == type_id:
1054                class_id: int = self.afs(DataType.int_, obj_info[ObjectInfoFields.class_id.value])
1055                obj_class: Type = self.known_classes_by_id[class_id]
1056                obj: Any = obj_class.__new__(obj_class)
1057
1058                if obj_info[ObjectInfoFields.clonable_slots.value]:
1059                    clonable_slots = self.afs(DataType.list_, obj_info[ObjectInfoFields.clonable_slots.value])
1060                    for slot_name, slot_id in clonable_slots:
1061                        slot_name = self.afs(DataType.str_, slot_name)
1062                        slot_id = self.afs(DataType.int_, slot_id)
1063                        child_obj = self.objects_db[slot_id]
1064                        setattr(obj, slot_name, child_obj)
1065                
1066                if obj_info[ObjectInfoFields.clonable_dict_items.value]:
1067                    clonable_dict_items = self.afs(DataType.dict_, obj_info[ObjectInfoFields.clonable_dict_items.value])
1068                    for key, value_id in clonable_dict_items.items():
1069                        key = self.afs(DataType.str_, key)
1070                        value_id = self.afs(DataType.int_, value_id)
1071                        child_obj = self.objects_db[value_id]
1072                        setattr(obj, key, child_obj)
1073                
1074                if obj_info[ObjectInfoFields.contained_mapping.value]:
1075                    contained_mapping = self.afs(DataType.dict_, obj_info[ObjectInfoFields.contained_mapping.value])
1076                    for key_id, value_id in contained_mapping.items():
1077                        key_id = self.afs(DataType.int_, key_id)
1078                        value_id = self.afs(DataType.int_, value_id)
1079                        child_key = self.objects_db[int(key_id)]
1080                        child_value = self.objects_db[value_id]
1081                        obj[child_key] = child_value
1082                
1083                if obj_info[ObjectInfoFields.contained_sequence.value]:
1084                    contained_sequence = self.afs(DataType.list_, obj_info[ObjectInfoFields.contained_sequence.value])
1085                    for item_id in contained_sequence:
1086                        item_id = self.afs(DataType.int_, item_id)
1087                        child_item = self.objects_db[item_id]
1088                        obj.append(child_item)
1089                
1090                if obj_info[ObjectInfoFields.contained_set.value]:
1091                    contained_set = self.afs(DataType.set_, obj_info[ObjectInfoFields.contained_set.value])
1092                    for item_id in contained_set:
1093                        item_id = self.afs(DataType.int_, item_id)
1094                        child_item = self.objects_db[item_id]
1095                        obj.add(child_item)
1096            elif known_data:
1097                obj = self.afs(type_id, obj_info[ObjectInfoFields.object_.value])
1098            elif known_container:
1099                obj = self.dcoi(type_id, self.afs(type_id, obj_info[ObjectInfoFields.object_.value]))
1100            else:
1101                raise RuntimeError('Unknown type_id')
1102        
1103        self.objects_db[object_id] = obj
1104        id_: int = id(obj)
1105        self.objects_ids[object_id] = id_
1106        self.objects_ids_by_id[id_] = object_id
1107        return ResultExistence[Tuple[int, Any]](True, (object_id, obj))
1108    
1109    doi = deserialize_obj_impl
1110
1111    def deserialize_obj(self, obj_info: Tuple) -> ResultExistence[Tuple[int, Any]]:
1112        with DisableGC():
1113            return self.deserialize_obj_impl(obj_info)
1114    
1115    do = deserialize_obj

default_serializable_data_types: Set[Type] = {<class 'int'>, <class 'complex'>, <class 'NoneType'>, <class 'list'>, <class 'frozenset'>, <class 'bytes'>, <class 'str'>, <class 'tuple'>, <class 'dict'>, <class 'float'>, <class 'set'>, <class 'bool'>, <class 'bytearray'>}

known_types: Set[Type] = {<class 'int'>, <class 'complex'>, <class 'NoneType'>, <class 'list'>, <class 'frozenset'>, <class 'bytes'>, <class 'str'>, <class 'tuple'>, <class 'dict'>, <class 'float'>, <class 'set'>, <class 'slice'>, <class 'bool'>, <class 'bytearray'>}

known_data_types: Set[Type] = {<class 'int'>, <class 'NoneType'>, <class 'bytes'>, <class 'str'>, <class 'float'>, <class 'slice'>, <class 'bool'>, <class 'bytearray'>}

known_container_types: Set[Type] = {<class 'complex'>, <class 'list'>, <class 'tuple'>, <class 'dict'>, <class 'set'>, <class 'frozenset'>}

class DataType(enum.IntEnum): View Source

 91class DataType(IntEnum):
 92    class_ = 0  # type is not in known_types and not in serializable_data_types
 93    int_ = 1
 94    float_ = 2
 95    complex_ = 3
 96    str_ = 4
 97    bytes_ = 5
 98    bytearray_ = 6
 99    bool_ = 7
100    none_ = 8
101    list_ = 9
102    tuple_ = 10
103    set_ = 11
104    frozenset_ = 12
105    dict_ = 13
106    slice_ = 14
107    unknown_serializable = 15  # type is in serializable_data_types but not in known_types

An enumeration.

class_ = <DataType.class_: 0>

int_ = <DataType.int_: 1>

float_ = <DataType.float_: 2>

complex_ = <DataType.complex_: 3>

str_ = <DataType.str_: 4>

bytes_ = <DataType.bytes_: 5>

bytearray_ = <DataType.bytearray_: 6>

bool_ = <DataType.bool_: 7>

none_ = <DataType.none_: 8>

list_ = <DataType.list_: 9>

tuple_ = <DataType.tuple_: 10>

set_ = <DataType.set_: 11>

frozenset_ = <DataType.frozenset_: 12>

dict_ = <DataType.dict_: 13>

slice_ = <DataType.slice_: 14>

unknown_serializable = <DataType.unknown_serializable: 15>

Inherited Members

enum.Enum: name; value
builtins.int: conjugate; bit_length; to_bytes; from_bytes; as_integer_ratio; real; imag; numerator; denominator

data_type: Dict[DataType, Type] = {<DataType.class_: 0>: <class 'object'>, <DataType.int_: 1>: <class 'int'>, <DataType.float_: 2>: <class 'float'>, <DataType.complex_: 3>: <class 'complex'>, <DataType.str_: 4>: <class 'str'>, <DataType.bytes_: 5>: <class 'bytes'>, <DataType.bytearray_: 6>: <class 'bytearray'>, <DataType.bool_: 7>: <class 'bool'>, <DataType.none_: 8>: <class 'NoneType'>, <DataType.list_: 9>: <class 'list'>, <DataType.tuple_: 10>: <class 'tuple'>, <DataType.set_: 11>: <class 'set'>, <DataType.frozenset_: 12>: <class 'frozenset'>, <DataType.dict_: 13>: <class 'dict'>, <DataType.slice_: 14>: <class 'slice'>, <DataType.unknown_serializable: 15>: None}

data_type_by_type: Dict[Type, DataType] = {<class 'object'>: <DataType.class_: 0>, <class 'int'>: <DataType.int_: 1>, <class 'float'>: <DataType.float_: 2>, <class 'complex'>: <DataType.complex_: 3>, <class 'str'>: <DataType.str_: 4>, <class 'bytes'>: <DataType.bytes_: 5>, <class 'bytearray'>: <DataType.bytearray_: 6>, <class 'bool'>: <DataType.bool_: 7>, <class 'NoneType'>: <DataType.none_: 8>, <class 'list'>: <DataType.list_: 9>, <class 'tuple'>: <DataType.tuple_: 10>, <class 'set'>: <DataType.set_: 11>, <class 'frozenset'>: <DataType.frozenset_: 12>, <class 'dict'>: <DataType.dict_: 13>, <class 'slice'>: <DataType.slice_: 14>, None: <DataType.unknown_serializable: 15>}

class ClassInfoFields(enum.IntEnum): View Source

150class ClassInfoFields(IntEnum):
151    class_id = 0
152    class_name = 1
153    module_importable_str = 2
154    owning_names_path = 3

An enumeration.

class_id = <ClassInfoFields.class_id: 0>

class_name = <ClassInfoFields.class_name: 1>

module_importable_str = <ClassInfoFields.module_importable_str: 2>

owning_names_path = <ClassInfoFields.owning_names_path: 3>

Inherited Members

enum.Enum: name; value
builtins.int: conjugate; bit_length; to_bytes; from_bytes; as_integer_ratio; real; imag; numerator; denominator

class ObjectInfoFields(enum.IntEnum): View Source

157class ObjectInfoFields(IntEnum):
158    object_id = 0  # (type: int)
159    type_id = 1  # (type: DataType)
160    object_ = 2  # (Optional), (type: Any). Link to object itself if `(type(obj) in serializable_data_types)`. Not used otherwise.
161    class_id = 3  # (Optional), (type: int). Used if `type_id == DataType.class_`
162    clonable_slots = 4  # (Optional), (type: Tuple[Tuple[str, Any]]). Used if `type_id == DataType.class_`. Holds ID's (object_id) of slots objects.
163    clonable_dict_items = 5  # (Optional), (type: Tuple[Tuple[str, Any]]). Used if `type_id == DataType.class_`. Holds ID's (object_id) of value objects.
164    # contained_items = 6  # (Optional), (type: Union[Tuple, List, Set, FrozenSet, Dict]). Used if `type_id in {DataType.list_, DataType.tuple_, DataType.set_, DataType.frozenset_, DataType.dict_, DataType.slice_}`. Holds ID's (object_id) of contained items (for bothe keys and values in the case of Dict).
165    contained_mapping = 6  # (Optional), (type: Union[Tuple, List, Set, FrozenSet, Dict]). Used if `type_id in {DataType.list_, DataType.tuple_, DataType.set_, DataType.frozenset_, DataType.dict_, DataType.slice_}`. Holds ID's (object_id) of contained items (for bothe keys and values in the case of Dict).
166    contained_sequence = 7  # (Optional), (type: Union[Tuple, List, Set, FrozenSet, Dict]). Used if `type_id in {DataType.list_, DataType.tuple_, DataType.set_, DataType.frozenset_, DataType.dict_, DataType.slice_}`. Holds ID's (object_id) of contained items (for bothe keys and values in the case of Dict).
167    contained_set = 8  # (Optional), (type: Union[Tuple, List, Set, FrozenSet, Dict]). Used if `type_id in {DataType.list_, DataType.tuple_, DataType.set_, DataType.frozenset_, DataType.dict_, DataType.slice_}`. Holds ID's (object_id) of contained items (for bothe keys and values in the case of Dict).

An enumeration.

object_id = <ObjectInfoFields.object_id: 0>

type_id = <ObjectInfoFields.type_id: 1>

object_ = <ObjectInfoFields.object_: 2>

class_id = <ObjectInfoFields.class_id: 3>

clonable_slots = <ObjectInfoFields.clonable_slots: 4>

clonable_dict_items = <ObjectInfoFields.clonable_dict_items: 5>

contained_mapping = <ObjectInfoFields.contained_mapping: 6>

contained_sequence = <ObjectInfoFields.contained_sequence: 7>

contained_set = <ObjectInfoFields.contained_set: 8>

Inherited Members

enum.Enum: name; value
builtins.int: conjugate; bit_length; to_bytes; from_bytes; as_integer_ratio; real; imag; numerator; denominator

class CanNotAdjustToSerializableError(builtins.Exception): View Source

170class CanNotAdjustToSerializableError(Exception):
171    pass

Common base class for all non-exit exceptions.

Inherited Members

builtins.Exception: Exception
builtins.BaseException: with_traceback; args

class CanNotAdjustFromSerializableError(builtins.Exception): View Source

174class CanNotAdjustFromSerializableError(Exception):
175    pass

Common base class for all non-exit exceptions.

Inherited Members

builtins.Exception: Exception
builtins.BaseException: with_traceback; args