holado 0.4.2__tar.gz → 0.5.3__tar.gz

holado-0.5.3/.gitlab-ci.yml

@@ -0,0 +1,82 @@
+stages:
+  - dockerhub-build-publish
+  - gitlab-docker-build-publish
+#  - pypi-build-publish
+
+variables:
+  DOCKER_IMAGE_TAG: "26.1"
+  PYTHON_IMAGE_TAG: "3.12"
+
+
+dockerhub-build-publish-latest:
+  stage: dockerhub-build-publish
+
+  image:
+    name: docker:${DOCKER_IMAGE_TAG}
+    
+  variables:
+    IMAGE_TAG: index.docker.io/holado/python:latest
+
+  script:
+    - docker build -t ${IMAGE_TAG} .
+    - echo "$DOCKERHUB_TOKEN" | docker login docker.io -u holado --password-stdin
+    - docker push ${IMAGE_TAG}
+  
+  rules:
+    - if: $CI_COMMIT_TAG
+      when: never
+    - if: $CI_COMMIT_BRANCH == "main"
+
+
+dockerhub-build-publish-tag:
+  stage: dockerhub-build-publish
+
+  image:
+    name: docker:${DOCKER_IMAGE_TAG}
+    
+  variables:
+    IMAGE_TAG: index.docker.io/holado/python:$CI_COMMIT_TAG
+
+  script:
+    - docker build -t ${IMAGE_TAG} .
+    - echo "$DOCKERHUB_TOKEN" | docker login docker.io -u holado --password-stdin
+    - docker push ${IMAGE_TAG}
+  
+  rules:
+    - if: $CI_COMMIT_TAG
+
+
+gitlab-docker-build-publish:
+  stage: gitlab-docker-build-publish
+
+  image:
+    name: docker:${DOCKER_IMAGE_TAG}
+
+  variables:
+    IMAGE_TAG: $CI_REGISTRY_IMAGE:$CI_COMMIT_REF_SLUG
+  script:
+    - docker build -t ${IMAGE_TAG} .
+    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
+    - docker push ${IMAGE_TAG}
+    
+
+# pypi-build-publish:
+#   stage: pypi-build-publish
+# 
+#   image:
+#     name: python:${PYTHON_IMAGE_TAG}
+# 
+#   script:
+#     - apt-get update -q -y
+#     - apt-get install -y python-pip
+#     - shopt -s expand_aliases
+#     - alias python=python3
+# #     - echo "$CI_COMMIT_TAG" > ./packaging/VERSION
+#     - ./packaging/generate_distribution_archive.sh
+#     - TWINE_PASSWORD=${PYPI_TOKEN} TWINE_USERNAME=__token__ ./packaging/publish_distribution_archive.sh
+#     
+#  rules:
+#    - if: $CI_COMMIT_TAG =~ /\d+\.\d+\.\d+.*/
+
+
+  

{holado-0.4.2 → holado-0.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: holado
-Version: 0.4.2
+Version: 0.5.3
 Summary: HolAdo framework
 Project-URL: Homepage, https://gitlab.com/holado_framework/python
 Project-URL: Issues, https://gitlab.com/holado_framework/python/-/issues
@@ -58,8 +58,8 @@ Requires-Dist: pysftp; extra == 'sftp'
 Requires-Dist: sftpserver; extra == 'sftp'
 Provides-Extra: ssl
 Requires-Dist: certifi; extra == 'ssl'
-Requires-Dist: pip-system-certs; extra == 'ssl'
 Requires-Dist: pyopenssl; extra == 'ssl'
+Requires-Dist: truststore; extra == 'ssl'
 Provides-Extra: ws-suds
 Requires-Dist: suds; extra == 'ws-suds'
 Provides-Extra: ws-zeep

holado-0.5.3/packaging/VERSION

@@ -0,0 +1 @@
+0.5.3

{holado-0.4.2 → holado-0.5.3}/packaging/generate_distribution_archive.sh

@@ -3,7 +3,7 @@
 SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
 cd ${SCRIPT_DIR}/..
 
-if ! python -m pip install --upgrade build; then
+if ! pip install --upgrade build; then
     echo "ERROR: Failed to update 'build' package"
     exit 1;
 fi

{holado-0.4.2 → holado-0.5.3}/pyproject.toml

@@ -44,7 +44,7 @@ rabbitmq = ["pika"]
 redis = ["redis", "redis-om"]
 s3 = ["minio", "boto3", "moto", "flask", "flask_cors"]
 sftp = ["pysftp", "sftpserver"]
-ssl = ["pip-system-certs", "certifi", "pyOpenSSL"]
+ssl = ["truststore", "certifi", "pyOpenSSL"]
 ws-suds = ["suds"]
 ws-zeep = ["zeep"]
 yaml = ["pyyaml"]

{holado-0.4.2 → holado-0.5.3}/requirements_docker.txt

@@ -4,6 +4,7 @@ behave==1.2.7.dev6
 
 python-dateutil
 psutil
+prettytable
 
 # For RabbitMQ module
 pika
@@ -68,7 +69,8 @@ pympler     # memory profiling
 pyyaml
 
 # For ssl: next packages have sometimes to be updated
-pip-system-certs
+#pip-system-certs  #Note: [28/07/2025] since recent modifications in urllib, pip-system-certs is broken, it is recommended to use truststore instead
+truststore
 certifi
 pyOpenSSL
 

{holado-0.4.2 → holado-0.5.3}/src/holado/common/context/session_context.py

@@ -168,6 +168,9 @@ class SessionContext(Context):
         with self.__multitask_lock:
             self.behave_manager.set_main_context(behave_context)
             self.report_manager.before_all()
+        
+        # Set variable with session context instance
+        self.variable_manager.register_variable("SESSION_CONTEXT", self)
     
     def after_all(self):
         with self.__multitask_lock:
@@ -201,6 +204,9 @@ class SessionContext(Context):
             feature_context = FeatureContext(feature)
             self.__set_feature_context(feature_context)
             
+            # Set variable with feature context instance
+            self.variable_manager.register_variable("FEATURE_CONTEXT", feature_context)
+            
             # Report
             try:
                 self.report_manager.before_feature(feature_context, feature)

{holado-0.4.2 → holado-0.5.3}/src/holado_ais/ais/ais_messages.py

@@ -23,13 +23,15 @@ from holado_core.common.tools.tools import Tools
 from holado_python.standard_library.typing import Typing
 import copy
 from holado_core.common.exceptions.functional_exception import FunctionalException
+from holado_ais.ais.enums import AISMessageType
 
 logger = logging.getLogger(__name__)
 
 try:
     import pyais
     from bitarray import bitarray
-    from holado_ais.ais.patch_pyais import HATagBlock, HA_ais_to_nmea_0183
+    from pyais.encode import ais_to_nmea_0183
+    from pyais.messages import TagBlock
     with_pyais = True
     
     # Patch pyais with some fixes
@@ -55,23 +57,27 @@ class AISMessages(object):
         def __init__(self):
             self.__tag_block_group_id = 0
         
-        def default_message_data(self, msg_type:int):
+        def default_message_data(self, msg_type:Union[int,str]):
             """Return default data values for required data by pyais but not functionnaly required.
             It is useful when generating custom messages, for example for tests.
             """
             return {}
         
-        def new_message_as_bitarray_bytes(self, msg_type:int, data:Union[dict,TableWithHeader]):
+        def new_message_as_bitarray_bytes(self, msg_type:Union[int,str], data:Union[dict,TableWithHeader]):
             msg = self.new_message(msg_type, data)
             res = self.convert_message_to_bytes(msg)
             return res
         
-        def new_message(self, msg_type:int, data:Union[dict,TableWithHeader]):
+        def new_message(self, msg_type:Union[int,str], data:Union[dict,TableWithHeader]):
             if isinstance(data, TableWithHeader):
                 data = self.__convert_table_to_dict(data)
             if not isinstance(data, dict):
                 raise TechnicalException(f"Unexpected data type '{Typing.get_object_class_fullname(data)}'")
             
+            # Add data key 'msg_type' if missing
+            if 'msg_type' not in data:
+                data['msg_type'] = self.__get_message_type_int(msg_type)
+            
             message_type = self.__get_message_type(msg_type)
             res = message_type.create(**data)
             return res
@@ -87,7 +93,7 @@ class AISMessages(object):
                 args = encoded_bytes.split(parts_separator)
             return pyais.decode(*args, error_if_checksum_invalid=True)
         
-        def decode_message(self, msg_type:int, bit_array:Union[str,bitarray]):
+        def decode_message(self, msg_type:Union[int,str], bit_array:Union[str,bitarray]):
             if isinstance(bit_array, str):
                 if StrTools.is_hex(bit_array) and not StrTools.is_bitarray(bit_array):
                     bit_array = Binary.convert_hex_str_to_bin_str(bit_array)
@@ -98,21 +104,29 @@ class AISMessages(object):
             message_type = self.__get_message_type(msg_type)
             return message_type.from_bitarray(bit_array)
         
-        def encode_raw_payload(self, payload_hex: str, tag_block: HATagBlock = None, with_tag_block=True, talker_id: str = "AIVDM", **kwargs):
+        def encode_raw_payload(self, payload:Union[str,bytes], tag_block: TagBlock = None, with_tag_block=True, talker_id: str = "AIVDM", **kwargs):
             from pyais.util import encode_ascii_6
             
+            if isinstance(payload, bytes):
+                payload_bytes = payload
+            elif isinstance(payload, str):
+                payload_bytes = bytes.fromhex(payload)
+            else:
+                raise TechnicalException(f"Unmanaged payload type '{Typing.get_object_class_fullname(payload)}'")
+            
             payload_bitarray = bitarray()
-            payload_bitarray.frombytes(bytes.fromhex(payload_hex))
+            payload_bitarray.frombytes(payload_bytes)
             payload_ascii6, fill_bits = encode_ascii_6(payload_bitarray)
             
             seq_id = kwargs.pop('seq_id') if 'seq_id' in kwargs else self.__tag_block_group_id % 10
             radio_channel = kwargs['radio_channel'] if 'radio_channel' in kwargs else 'A'
             group_id = kwargs.pop('group_id') if 'group_id' in kwargs else None
             
-            sentences = HA_ais_to_nmea_0183(payload_ascii6, talker_id, radio_channel, fill_bits, seq_id)
+            # sentences = HA_ais_to_nmea_0183(payload_ascii6, talker_id, radio_channel, fill_bits, seq_id)
+            sentences = ais_to_nmea_0183(payload_ascii6, talker_id, radio_channel, fill_bits, seq_id)
             return self.__encode_add_tag_block(sentences, tag_block, with_tag_block=with_tag_block, group_id=group_id)
             
-        def encode(self, data, tag_block: HATagBlock = None, with_tag_block=True, talker_id: str = "AIVDM", **kwargs):
+        def encode(self, data, tag_block: TagBlock = None, with_tag_block=True, talker_id: str = "AIVDM", **kwargs):
             if isinstance(data, pyais.messages.Payload):
                 return self.encode_msg(data, tag_block=tag_block, with_tag_block=with_tag_block, talker_id=talker_id, **kwargs)
             elif isinstance(data, dict):
@@ -122,17 +136,18 @@ class AISMessages(object):
             else:
                 raise TechnicalException(f"Unexpected data type '{Typing.get_object_class_fullname(data)}'")
         
-        def encode_msg(self, msg, tag_block: HATagBlock = None, with_tag_block=True, talker_id: str = "AIVDM", **kwargs):
+        def encode_msg(self, msg, tag_block: TagBlock = None, with_tag_block=True, talker_id: str = "AIVDM", **kwargs):
             if not isinstance(msg, pyais.messages.Payload):
                 raise TechnicalException(f"Parameter 'msg' is not an AIS message (obtained type: {Typing.get_object_class_fullname(msg)})")
             
             seq_id = kwargs.pop('seq_id') if 'seq_id' in kwargs else self.__tag_block_group_id % 10
             group_id = kwargs.pop('group_id') if 'group_id' in kwargs else None
             
+            logger.print(f"+++++++ encode_msg: {msg=} ; {talker_id=} ; {kwargs=}")
             sentences = pyais.encode_msg(msg, seq_id=seq_id, talker_id=talker_id, **kwargs)
             return self.__encode_add_tag_block(sentences, tag_block, with_tag_block=with_tag_block, group_id=group_id)
         
-        def encode_data(self, data, tag_block: HATagBlock = None, with_tag_block=True, talker_id: str = "AIVDM", **kwargs):
+        def encode_data(self, data, tag_block: TagBlock = None, with_tag_block=True, talker_id: str = "AIVDM", **kwargs):
             if not isinstance(data, dict):
                 raise TechnicalException(f"Parameter 'data' is not a dict (obtained type: {Typing.get_object_class_fullname(data)})")
             
@@ -142,11 +157,11 @@ class AISMessages(object):
             sentences = pyais.encode_dict(data, seq_id=seq_id, talker_id=talker_id, **kwargs)
             return self.__encode_add_tag_block(sentences, tag_block, with_tag_block=with_tag_block, group_id=group_id)
         
-        def encode_table(self, table, tag_block: HATagBlock = None, with_tag_block=True, talker_id: str = "AIVDM", **kwargs):
+        def encode_table(self, table, tag_block: TagBlock = None, with_tag_block=True, talker_id: str = "AIVDM", **kwargs):
             data = self.__convert_table_to_dict(table)
             return self.encode_data(data, tag_block=tag_block, with_tag_block=with_tag_block, talker_id=talker_id, **kwargs)
         
-        def __encode_add_tag_block(self, encoded_sentences, tag_block: HATagBlock = None, with_tag_block=True, group_id=None):
+        def __encode_add_tag_block(self, encoded_sentences, tag_block: TagBlock = None, with_tag_block=True, group_id=None):
             from pyais.messages import TagBlockGroup
             
             if not with_tag_block:
@@ -166,7 +181,7 @@ class AISMessages(object):
                 sentence_tag_block = copy.deepcopy(tag_block) if index == 0 else None
                 if group_id is not None:
                     if sentence_tag_block is None:
-                        sentence_tag_block = HATagBlock()
+                        sentence_tag_block = TagBlock(None)
                     sentence_tag_block._group = TagBlockGroup(msg_id=index+1, total=nb_sentences, group_id=group_id)
                 
                 if sentence_tag_block is not None:
@@ -182,11 +197,25 @@ class AISMessages(object):
         def convert_message_to_bytes(self, msg):
             return msg.to_bitarray().tobytes()
         
-        def __get_message_type(self, msg_type:int):
+        def __get_message_type(self, msg_type:Union[int,str]):
             import importlib
+            
+            if isinstance(msg_type, str):
+                msg_type = AISMessageType[msg_type].value
+            
             module = importlib.import_module('pyais.messages')
             res = getattr(module, f"MessageType{msg_type}")
             return res
+        
+        def __get_message_type_int(self, msg_type:Union[int,str]):
+            if isinstance(msg_type, int):
+                return msg_type
+            
+            if isinstance(msg_type, str):
+                msg_type = AISMessageType[msg_type]
+            if not isinstance(msg_type, AISMessageType):
+                raise TechnicalException(f"Unmanaged message type of class '{Typing.get_object_class_fullname(msg_type)}'")
+            return msg_type.value
             
         def __convert_table_to_dict(self, table):
             if not ValueTableManager.is_table_with_header(table):

{holado-0.4.2 → holado-0.5.3}/src/holado_ais/ais/patch_pyais.py

@@ -25,112 +25,23 @@ from bitarray import bitarray
 import attr
 import typing
 import pyais
-from pyais.messages import Payload, bit_field, from_mmsi, NMEA_VALUE, CommunicationStateMixin, TagBlock, ASTERISK, from_turn, to_turn, from_speed, to_speed,\
-    from_lat_lon, to_lat_lon, from_10th, to_10th, from_lat_lon_600, to_lat_lon_600
-from pyais.util import get_int, from_bytes_signed, from_bytes, bits2bytes, checksum, chunks, compute_checksum, str_to_bin, bytes2bits
+from pyais.messages import Payload, bit_field, from_mmsi, NMEA_VALUE, CommunicationStateMixin, from_speed, to_speed,\
+    from_lat_lon, to_lat_lon, from_10th, to_10th, from_lat_lon_600, to_lat_lon_600,\
+    from_turn, to_turn, ANY_MESSAGE
+from pyais.util import get_int, from_bytes_signed, from_bytes, bits2bytes, chunks, str_to_bin, bytes2bits
 from pyais.exceptions import InvalidDataTypeException
-from pyais.encode import AIS_SENTENCES, DATA_DICT, get_ais_type, data_to_payload
-import math
-from pyais.constants import NavigationStatus, TurnRate, ManeuverIndicator, EpfdType, ShipType, NavAid, StationType, TransmitMode, StationIntervals
+from pyais.constants import NavigationStatus, EpfdType, ShipType, NavAid, StationType, TransmitMode, StationIntervals,\
+    TurnRate, ManeuverIndicator
 import functools
 
 logger = logging.getLogger(__name__)
 
 
 
-# Add possibility to specify the seq_id in AIS sentence
-# Note: parameter seq_id is just added in some methods of pyais.encode module
-
-def HA_ais_to_nmea_0183(payload: str, ais_talker_id: str, radio_channel: str, fill_bits: int, seq_id: str = None) -> AIS_SENTENCES:
-    """
-    Splits the AIS payload into sentences, ASCII encodes the payload, creates
-    and sends the relevant NMEA 0183 sentences. Messages have a maximum length
-    of 82 characters, including the $ or ! starting character and the ending <LF>.
-
-    HINT:
-        This method takes care of splitting large payloads (larger than 60 characters)
-        into multiple sentences. With a total of 80 maximum chars excluding end of line
-        per sentence, and 20 chars head + tail in the nmea 0183 carrier protocol, 60
-        chars remain for the actual payload.
-
-    @param payload:         Armored AIs payload.
-    @param ais_talker_id:   AIS talker ID (AIVDO or AIVDM)
-    @param radio_channel:   Radio channel (either A or B)
-    @param fill_bits:       The number of fill bits requires to pad the data payload to a 6 bit boundary.
-    @return:                A list of relevant AIS sentences.
-    """
-    messages = []
-    max_len = 60
-    frag_cnt = math.ceil(len(payload) / max_len)
-    if seq_id is None:
-        seq_id = '0' if frag_cnt > 1 else ''
-    elif frag_cnt == 1:
-        seq_id = ''
-
-    if len(ais_talker_id) != 5:
-        raise ValueError("AIS talker is must have exactly 6 characters. E.g. AIVDO")
-
-    if len(radio_channel) != 1:
-        raise ValueError("Radio channel must be a single character")
-
-    for frag_num, chunk in enumerate(chunks(payload, max_len), start=1):
-        tpl = "!{},{},{},{},{},{},{}*{:02X}"
-        fill_bits_frag = fill_bits if frag_num == frag_cnt else 0  # Make sure we set fill bits only for last fragment
-        dummy_message = tpl.format(ais_talker_id, frag_cnt, frag_num, seq_id, radio_channel, chunk, fill_bits_frag, 0)
-        checksum = compute_checksum(dummy_message)
-        msg = tpl.format(ais_talker_id, frag_cnt, frag_num, seq_id, radio_channel, chunk, fill_bits_frag, checksum)
-        messages.append(msg)
-
-    return messages
-
-pyais.ais_to_nmea_0183 = HA_ais_to_nmea_0183
-
-
-def HA_encode_dict(data: DATA_DICT, talker_id: str = "AIVDO", radio_channel: str = "A", seq_id: str = None) -> AIS_SENTENCES:
-    """
-    Takes a dictionary of data and some NMEA specific kwargs and returns the NMEA 0183 encoded AIS sentence.
-
-    Notes:
-        - the data dict should also contain the AIS message type (1-27) under the `type` key.
-        - different messages take different keywords. Refer to the payload classes above to get a glimpse
-          on what fields each AIS message can take.
-
-    @param data: The AIS data as a dictionary.
-    @param talker_id: AIS packets have the introducer "AIVDM" or "AIVDO";
-                      AIVDM packets are reports from other ships and AIVDO packets are reports from your own ship.
-    @param radio_channel: The radio channel. Can be either 'A' (default) or 'B'.
-    @return: NMEA 0183 encoded AIS sentences.
-
-    """
-    if talker_id not in ("AIVDM", "AIVDO"):
-        raise ValueError("talker_id must be any of ['AIVDM', 'AIVDO']")
-
-    if radio_channel not in ('A', 'B'):
-        raise ValueError("radio_channel must be any of ['A', 'B']")
-
-    ais_type = get_ais_type(data)
-    payload = data_to_payload(ais_type, data)
-    armored_payload, fill_bits = payload.encode()
-    return pyais.ais_to_nmea_0183(armored_payload, talker_id, radio_channel, fill_bits, seq_id=seq_id)
-
-pyais.encode_dict = HA_encode_dict
-
-
-def HA_encode_msg(msg: Payload, talker_id: str = "AIVDO", radio_channel: str = "A", seq_id: str = None) -> AIS_SENTENCES:
-    if talker_id not in ("AIVDM", "AIVDO"):
-        raise ValueError("talker_id must be any of ['AIVDM', 'AIVDO']")
-
-    if radio_channel not in ('A', 'B'):
-        raise ValueError("radio_channel must be any of ['A', 'B']")
-
-    armored_payload, fill_bits = msg.encode()
-    return pyais.ais_to_nmea_0183(armored_payload, talker_id, radio_channel, fill_bits, seq_id=seq_id)
-
-pyais.encode_msg = HA_encode_msg
-
+### Fix conversion of message types to/from bitarray
 
 # All @ at end of string are considered padding.
-# Note: in pyais implementation, decode is stopped at first @.
+# Note: in pyais implementation, decode is stopped at first @, which can be a regular field information, and following regular characters are skipped.
 def HA_decode_bin_as_ascii6(bit_arr: bitarray) -> str:
     """
     Decode binary data as 6 bit ASCII.
@@ -166,7 +77,7 @@ def HA_int_to_bin(val: typing.Union[int, bool], width: int, signed: bool = True)
     Compared to pyais implementation, the behaviour is changed if the value is too great to fit into
     `width` bits: 
       - in pyais, the maximum possible number that still fits is used,
-      - in this implementation, an exception is raised.
+      - in this implementation, a ValueError is raised.
 
     @param val:     Any integer or boolean value.
     @param width:   The bit width. If less than width bits are required, leading zeros are added.
@@ -191,52 +102,11 @@ pyais.util.int_to_bin = HA_int_to_bin
 pyais.messages.int_to_bin = HA_int_to_bin
 
 
-# Add spare field management
-
-def bit_field(width: int, d_type: typing.Type[typing.Any],
-              from_converter: typing.Optional[typing.Callable[[typing.Any], typing.Any]] = None,
-              to_converter: typing.Optional[typing.Callable[[typing.Any], typing.Any]] = None,
-              default: typing.Optional[typing.Any] = None,
-              signed: bool = False,
-              variable_length: bool = False,
-              is_spare: bool = False,
-              **kwargs: typing.Any) -> typing.Any:
-    """Same as pyais bit_field function, but adds a metadata 'is_spare' at True.
-    Metadata 'is_spare' is used to know which fields must not be exported when converting message to dict or json.
-    """
-    return attr.ib(
-        metadata={
-            'width': width,
-            'd_type': d_type,
-            'from_converter': from_converter,
-            'to_converter': to_converter,
-            'signed': signed,
-            'default': default,
-            'variable_length': variable_length,
-            'is_spare': is_spare
-        },
-        **kwargs
-    )
-    
-pyais.messages.bit_field = bit_field
-
-
 @attr.s(slots=True)
 class HAPayload(Payload):
-    """Payload class with spare fields management.
+    """Payload class with fix in to/from bitarray conversion.
     """
 
-    def asdict(self, enum_as_int: bool = False, with_spare: bool = False) -> typing.Dict[str, typing.Optional[NMEA_VALUE]]:
-        res = super().asdict(enum_as_int)
-        
-        # Remove spare fields
-        if not with_spare:
-            for field in self.fields():
-                if 'is_spare' in field.metadata and field.metadata['is_spare']:
-                    del res[field.name]
-        
-        return res
-
     @classmethod
     def from_bitarray(cls, bit_arr: bitarray) -> "ANY_MESSAGE":
         cur: int = 0
@@ -367,7 +237,7 @@ class HAPayload(Payload):
 
 
 # Fix message types:
-# - almost all types with new spare management
+# - Use fixes of Payload implemented in HAPayload, in all message types
 # - type 21: exclude full_name property from asdict result
 # - type 26: fix create and from_bitarray methods
 
@@ -736,6 +606,38 @@ pyais.messages.MessageType17 = HAMessageType17
 pyais.messages.MSG_CLASS[17] = pyais.messages.MessageType17
 
 
+@attr.s(slots=True)
+class HAMessageType18(HAPayload, CommunicationStateMixin):
+    """
+    Standard Class B CS Position Report
+    Src: https://gpsd.gitlab.io/gpsd/AIVDM.html#_type_18_standard_class_b_cs_position_report
+    """
+    msg_type = bit_field(6, int, default=18, signed=False)
+    repeat = bit_field(2, int, default=0, signed=False)
+    mmsi = bit_field(30, int, from_converter=from_mmsi)
+
+    reserved_1 = bit_field(8, int, default=0, signed=False)
+    speed = bit_field(10, float, from_converter=from_speed, to_converter=to_speed, default=0, signed=False)
+    accuracy = bit_field(1, bool, default=0, signed=False)
+    lon = bit_field(28, float, from_converter=from_lat_lon, to_converter=to_lat_lon, signed=True, default=0)
+    lat = bit_field(27, float, from_converter=from_lat_lon, to_converter=to_lat_lon, signed=True, default=0)
+    course = bit_field(12, float, from_converter=from_10th, to_converter=to_10th, default=0, signed=False)
+    heading = bit_field(9, int, default=0, signed=False)
+    second = bit_field(6, int, default=0, signed=False)
+    reserved_2 = bit_field(2, int, default=0, signed=False)
+    cs = bit_field(1, bool, default=0, signed=False)
+    display = bit_field(1, bool, default=0)
+    dsc = bit_field(1, bool, default=0)
+    band = bit_field(1, bool, default=0)
+    msg22 = bit_field(1, bool, default=0)
+    assigned = bit_field(1, bool, default=0)
+    raim = bit_field(1, bool, default=0)
+    radio = bit_field(20, int, default=0)
+
+pyais.messages.MessageType18 = HAMessageType18
+pyais.messages.MSG_CLASS[18] = pyais.messages.MessageType18
+
+
 @attr.s(slots=True)
 class HAMessageType19(HAPayload):
     """
@@ -1064,7 +966,7 @@ class HAMessageType24PartA(HAPayload):
     mmsi = bit_field(30, int, from_converter=from_mmsi)
 
     # partno = bit_field(2, int, default=0, signed=False)
-    reserved = bit_field(1, int, default=0, signed=False)
+    reserved = bit_field(1, int, default=0, signed=False, is_spare=True)
     partno = bit_field(1, int, default=0, signed=False)
     shipname = bit_field(120, str, default='')
     spare_1 = bit_field(8, bytes, default=b'', is_spare=True)
@@ -1078,7 +980,9 @@ class HAMessageType24PartB(HAPayload):
     repeat = bit_field(2, int, default=0, signed=False)
     mmsi = bit_field(30, int, from_converter=from_mmsi)
 
-    partno = bit_field(2, int, default=0, signed=False)
+    # partno = bit_field(2, int, default=0, signed=False)
+    reserved = bit_field(1, int, default=0, signed=False, is_spare=True)
+    partno = bit_field(1, int, default=0, signed=False)
     ship_type = bit_field(8, int, default=0, signed=False)
     vendorid = bit_field(18, str, default='', signed=False)
     model = bit_field(4, int, default=0, signed=False)
@@ -1266,38 +1170,5 @@ pyais.messages.MessageType27 = HAMessageType27
 pyais.messages.MSG_CLASS[27] = pyais.messages.MessageType27
 
 
-# Manage tag blocks
-
-class HATagBlock(TagBlock):
-    def __init__(self, raw: bytes = None) -> None:
-        super().__init__(raw)
-        
-    def to_raw(self):
-        fields = []
-        if self._group is not None:
-            fields.append(f"g:{self._group}")
-        if self._source_station is not None:
-            fields.append(f"s:{self._source_station}")
-        if self._receiver_timestamp is not None:
-            fields.append(f"c:{self._receiver_timestamp}")
-        if self._destination_station is not None:
-            fields.append(f"d:{self._destination_station}")
-        if self._line_count is not None:
-            fields.append(f"n:{self._line_count}")
-        if self._relative_time is not None:
-            fields.append(f"r:{self._relative_time}")
-        if self._text is not None:
-            fields.append(f"t:{self._text}")
-        
-        payload_str = ','.join(fields)
-        payload = payload_str.encode()
-        
-        chk_int = checksum(payload)
-        chk = f"{chk_int:02X}".encode()
-        
-        return payload + ASTERISK + chk
-
-pyais.messages.TagBlock = HATagBlock
-
 
 

{holado-0.4.2 → holado-0.5.3}/src/holado_ais/tests/behave/steps/ais/ais_messages_steps.py

@@ -56,7 +56,7 @@ if AISMessages.is_available():
         Encode an AIS message to NMEA format
         """
         var_name = StepTools.evaluate_variable_name(var_name)
-        table = BehaveStepTools.convert_step_table_2_value_table_with_header(context.table)
+        table = BehaveStepTools.get_step_table(context)
         
         res = __get_ais_messages().encode(table)
         
@@ -69,7 +69,7 @@ if AISMessages.is_available():
         """
         var_name = StepTools.evaluate_variable_name(var_name)
         msg = StepTools.evaluate_scenario_parameter(message)
-        table = BehaveStepTools.convert_step_table_2_value_table_with_header(context.table)
+        table = BehaveStepTools.get_step_table(context)
         
         if table is not None:
             kwargs = ValueTableConverter.convert_table_with_header_to_dict(table)
@@ -101,12 +101,8 @@ if AISMessages.is_available():
         var_name = StepTools.evaluate_variable_name(var_name)
         msg_type = StepTools.evaluate_scenario_parameter(ais_message_type)
         
-        if isinstance(msg_type, str):
-            msg_type = AISMessageType[msg_type].value
-        
         if hasattr(context, 'table') and context.table is not None:
             table = BehaveStepTools.convert_step_table_2_value_table_with_header(context.table)
-            table.add_column(name='msg_type', cells_content=[msg_type])
         else:
             table = {}