M0r13n__pyais-137

The user is reporting a bug in how `pyais` determines the communication status (`is_sotdma` and `is_itdma`).
The current implementation checks if the `radio` field is greater than `MAX_COMM_STATE_VALUE`.
The problem is that `MAX_COMM_STATE_VALUE` seems to be used to check the 20th bit, but the communication state is only 19 bits long in some cases, or at least the way it's being checked is incorrect for some message types.

The suggested solution is to use the message type instead of the bit length to indicate the type of communication status, except for types 9, 18, and 26.

Let's start by exploring the code.
I need to find where `is_sotdma` and `is_itdma` are defined. They are likely in `pyais/messages.py` or `pyais/decode.py`.

The problem description mentions:
```python
@property
def is_sotdma(self) -> bool:
    """The radio status field has it's 20th bit (MSB) set to 0 or has less than 20 bits"""
    return self.radio <= self.MAX_COMM_STATE_VALUE

@property
def is_itdma(self) -> bool:
    """The radio status field has it's 20th bit (MSB) set to 1"""
    return self.radio > self.MAX_COMM_STATE_VALUE
```

I'll search for these properties.

{
  "command": "grep -rn --include=\"*.py\" \"def is_sotdma\" pyais/"
}

{
  "status": "ok",
  "stdout": "pyais/messages.py:827:    def is_sotdma(self) -> bool:\n",
  "stderr": "",
  "exit_code": 0
}

Okay, `is_sotdma` is in `pyais/messages.py`. Let me check `is_itdma` as well to be sure.

{
  "command": "grep -rn --include=\"*.py\" \"def is_itdma\" pyais/"
}

{
  "status": "ok",
  "stdout": "pyais/messages.py:832:    def is_itdma(self) -> bool:\n",
  "stderr": "",
  "exit_code": 0
}

Both are in `pyais/messages.py`. Now let's reproduce the bug.

The problem description provides a reproduction case:
```python
import pyais
decoded = pyais.decode('!AIVDM,1,1,,A,333ga6PP0jPPDUNM3I7DTOwDR59C,0*51')
com = decoded.get_communication_state()
print(f"SOTDMA: {decoded.is_sotdma}, ITDMA: {decoded.is_itdma}")
```
Wait, the provided code says `decoded.get_communication_state()` but then uses `decoded.is_sotdma`. Let's check if `decoded` is an instance of a message class that has these properties.

Let's try running the reproduction code.

{
  "command": "python3 - <<'PY'\nimport pyais\ndecoded = pyais.decode('!AIVDM,1,1,,A,333ga6PP0jPPDUNM3I7DTOwDR59C,0*51')\ntry:\n    print(f\"SOTDMA: {decoded.is_sotdma}, ITDMA: {decoded.is_itdma}\")\nexcept AttributeError as e:\n    print(f\"AttributeError: {e}\")\nPY\n"
}

{
  "status": "ok",
  "stdout": "SOTDMA: True, ITDMA: False\n",
  "stderr": "",
  "exit_code": 0
}

The reproduction shows `SOTDMA: True, ITDMA: False`.
The problem statement says: "the following example incorrectly indicates that it is a SOTDMA communication status, although it is an ITDMA."
So for this input, it should be `SOTDMA: False, ITDMA: True`.

Now let's look at `pyais/messages.py` around line 827.

{
  "end_line": 850,
  "filepath": "pyais/messages.py",
  "start_line": 800
}

{
  "status": "ok",
  "filepath": "pyais/messages.py",
  "content": "    radio: int  # Type hint to make mypy happy\n\n    MAX_COMM_STATE_VALUE = 0x7ffff\n\n    def get_communication_state(self) -> Dict[str, typing.Optional[int]]:\n        \"\"\"Returns information used by the slot allocation algorithm as a dict.\"\"\"\n        result: Dict[str, typing.Optional[int]] = {\n            'received_stations': None,\n            'slot_number': None,\n            'utc_hour': None,\n            'utc_minute': None,\n            'slot_offset': None,\n            'slot_timeout': None,\n            'sync_state': None,\n            'keep_flag': None,\n            'slot_increment': None,\n            'num_slots': None,\n        }\n\n        if self.is_sotdma:\n            result.update(get_sotdma_comm_state(self.communication_state_raw))\n        else:\n            result.update(get_itdma_comm_state(self.communication_state_raw))\n\n        return result\n\n    @property\n    def is_sotdma(self) -> bool:\n        \"\"\"The radio status field has it's 20th bit (MSB) set to 0 or has less than 20 bits\"\"\"\n        return self.radio <= self.MAX_COMM_STATE_VALUE\n\n    @property\n    def is_itdma(self) -> bool:\n        \"\"\"The radio status field has it's 20th bit (MSB) set to 1\"\"\"\n        return self.radio > self.MAX_COMM_STATE_VALUE\n\n    @property\n    def communication_state_raw(self) -> int:\n        \"\"\"Get the raw radio status except 20th bit - if present\"\"\"\n        try:\n            return self.radio & self.MAX_COMM_STATE_VALUE\n        except AttributeError as err:\n            raise ValueError(\n                'Communication State is only available for messages with radio field'\n            ) from err\n\n\n@attr.s(slots=True)\nclass MessageType1(Payload, CommunicationStateMixin):\n    \"\"\"\n    AIS Vessel position report using SOTDMA (Self-Organizing Time Division Multiple Access)",
  "start_line": 800,
  "end_line": 850,
  "total_lines": 1736,
  "is_truncated": false
}

The `is_sotdma` and `is_itdma` properties are inside `CommunicationStateMixin`.

The `MAX_COMM_STATE_VALUE` is `0x7ffff`, which is $2^{19}-1$.
`self.radio > 0x7ffff` means the 20th bit (bit 19, since it's 0-indexed) is set.

The problem statement says:
"According to the following code it is checked whether the 20th bit of the communications status is set or not. However, as the com state is only 19 bits long, a bit from the previous data fields is checked here and not one from the com state."

The problem statement suggests:
"It is better to use the message type rather than the bit length to indicate the type of communication status. Table 46 of the M.1371-5 standard shows which type uses which com state. Type 9, 18 and 26 messages are edge cases, as they can include one of the two com state types. The existing implementation can be used here, as with these message types the bit before the actual com state determines its type."

So we need to know which message types use SOTDMA and which use ITDMA.
Wait, the `CommunicationStateMixin` is used by several message types. I should check which ones.

Let's search for classes that inherit from `CommunicationStateMixin`.

{
  "command": "grep -rn \"CommunicationStateMixin\" pyais/messages.py"
}

{
  "status": "ok",
  "stdout": "792:class CommunicationStateMixin:\n848:class MessageType1(Payload, CommunicationStateMixin):\n889:class MessageType4(Payload, CommunicationStateMixin):\n996:class MessageType9(Payload, CommunicationStateMixin):\n1141:class MessageType18(Payload, CommunicationStateMixin):\n1545:class MessageType26AddressedStructured(Payload, CommunicationStateMixin):\n1560:class MessageType26BroadcastStructured(Payload, CommunicationStateMixin):\n1574:class MessageType26AddressedUnstructured(Payload, CommunicationStateMixin):\n1589:class MessageType26BroadcastUnstructured(Payload, CommunicationStateMixin):\n",
  "stderr": "",
  "exit_code": 0
}

The message types that use `CommunicationStateMixin` are:
- MessageType1
- MessageType4
- MessageType9
- MessageType18
- MessageType26 (several variants)

Now let's check what the standard says or what the problem statement says.
The problem statement says: "Type 9, 18 and 26 messages are edge cases, as they can include one of the two com state types. The existing implementation can be used here, as with these message types the bit before the actual com state determines its type."

So for MessageType1, MessageType4, it should probably be fixed.
But wait, if Type 9, 18, and 26 can be either, and we use the existing implementation for them, we just need to know what the other message types are.

Actually, for MessageType1 and MessageType4, are they always SOTDMA or always ITDMA?
The problem says: "In the case of a type 1, 2 or 3 message, it would be checked whether the RAIM flag is set."
Wait, the `CommunicationStateMixin` is inherited by MessageType1 and MessageType4.
Let's look at `MessageType1` and `MessageType4`.

The problem statement mentions "Type 1, 2 or 3 message". But only MessageType1 is using `CommunicationStateMixin` in the grep output.
Let me double check `pyais/messages.py` to see if MessageType2 and 3 also use it.
Actually, my grep search for `CommunicationStateMixin` only found 1, 4, 9, 18, 26.

Let's see what the message type of the failing example is.

{
  "command": "python3 - <<'PY'\nimport pyais\ndecoded = pyais.decode('!AIVDM,1,1,,A,333ga6PP0jPPDUNM3I7DTOwDR59C,0*51')\nprint(f\"Type: {type(decoded)}\")\nPY\n"
}

{
  "status": "ok",
  "stdout": "Type: <class 'pyais.messages.MessageType3'>\n",
  "stderr": "",
  "exit_code": 0
}

Wait, the reproduction output says `MessageType3`. But `MessageType3` was NOT in the list of classes inheriting from `CommunicationStateMixin`!

Let me re-examine the `CommunicationStateMixin` inheritance in `pyais/messages.py`.

{
  "command": "grep -rn \"class MessageType\" pyais/messages.py"
}

{
  "status": "ok",
  "stdout": "848:class MessageType1(Payload, CommunicationStateMixin):\n872:class MessageType2(MessageType1):\n880:class MessageType3(MessageType1):\n889:class MessageType4(Payload, CommunicationStateMixin):\n914:class MessageType5(Payload):\n943:class MessageType6(Payload):\n961:class MessageType7(Payload):\n981:class MessageType8(Payload):\n996:class MessageType9(Payload, CommunicationStateMixin):\n1023:class MessageType10(Payload):\n1036:class MessageType11(MessageType4):\n1045:class MessageType12(Payload):\n1060:class MessageType13(MessageType7):\n1068:class MessageType14(Payload):\n1081:class MessageType15(Payload):\n1104:class MessageType16(Payload):\n1124:class MessageType17(Payload):\n1141:class MessageType18(Payload, CommunicationStateMixin):\n1170:class MessageType19(Payload):\n1203:class MessageType20(Payload):\n1235:class MessageType21(Payload):\n1268:class MessageType22Addressed(Payload):\n1299:class MessageType22Broadcast(Payload):\n1330:class MessageType22(Payload):\n1357:class MessageType23(Payload):\n1386:class MessageType24PartA(Payload):\n1397:class MessageType24PartB(Payload):\n1417:class MessageType24(Payload):\n1450:class MessageType25AddressedStructured(Payload):\n1464:class MessageType25BroadcastStructured(Payload):\n1477:class MessageType25AddressedUnstructured(Payload):\n1490:class MessageType25BroadcastUnstructured(Payload):\n1501:class MessageType25(Payload):\n1545:class MessageType26AddressedStructured(Payload, CommunicationStateMixin):\n1560:class MessageType26BroadcastStructured(Payload, CommunicationStateMixin):\n1574:class MessageType26AddressedUnstructured(Payload, CommunicationStateMixin):\n1589:class MessageType26BroadcastUnstructured(Payload, CommunicationStateMixin):\n1601:class MessageType26(Payload):\n1645:class MessageType27(Payload):\n",
  "stderr": "",
  "exit_code": 0
}

Ah, `MessageType2` and `MessageType3` inherit from `MessageType1`, and `MessageType1` inherits from `CommunicationStateMixin`.

So `MessageType1`, `MessageType2`, `MessageType3`, `MessageType4`, `MessageType9`, `MessageType18`, `MessageType26` (and its subtypes) all have `is_sotdma` and `is_itdma`.

Now let's re-read the problem:
"It is better to use the message type rather than the bit length to indicate the type of communication status. Table 46 of the M.1371-5 standard shows which type uses which com state. Type 9, 18 and 26 messages are edge cases, as they can include one of the two com state types. The existing implementation can be used here, as with these message types the bit before the actual com state determines its type."

The problem says for Type 1, 2, 3, it's incorrectly checking a bit from previous fields.
Wait, if Type 9, 18, and 26 can be either, then what about 1, 2, 3, and 4?
If they are NOT edge cases, then they must be either always SOTDMA or always ITDMA.

Actually, looking at the problem statement again: "In the case of a type 1, 2 or 3 message, it would be checked whether the RAIM flag is set. Since 1 is the default value, pyais returns in almost all cases that it is a SOTDMA com state."
Wait, if RAIM flag is 1, then `self.radio > self.MAX_COMM_STATE_VALUE` would be true?
`MAX_COMM_STATE_VALUE = 0x7ffff` (19 bits).
If the 20th bit is set, then `self.radio > 0x7ffff`.
If the RAIM flag is the 20th bit, then `self.radio > 0x7ffff` would indicate RAIM flag is set, not that it's ITDMA.

The problem says "it incorrectly indicates that it is a SOTDMA communication status, although it is an ITDMA."
But in the reproduction: `SOTDMA: True, ITDMA: False`.
This means `self.radio <= self.MAX_COMM_STATE_VALUE` was true.
So the 20th bit was NOT set.
If it's an ITDMA, then it SHOULD have been `is_itdma = True`.

Wait, I'm confused. If it's ITDMA, the 20th bit should be 1. If it's SOTDMA, it should be 0.
If `self.radio <= 0x7ffff`, then the 20th bit is 0, so it's SOTDMA.
But the user says for the example it's incorrectly indicating SOTDMA, while it SHOULD be ITDMA.
And the user says: "In the case of a type 1, 2 or 3 message, it would be checked whether the RAIM flag is set. Since 1 is the default value, pyais returns in almost all cases that it is a SOTDMA com state."
This is contradictory. If RAIM flag is 1 (the 20th bit), then `self.radio > 0x7ffff`, so `is_itdma` should be True.

Let's re-read carefully: "In the case of a type 1, 2 or 3 message, it would be checked whether the RAIM flag is set. Since 1 is the default value, pyais returns in almost all cases that it is a SOTDMA com state."
If the RAIM flag is set (1), and it returns SOTDMA, then maybe `is_sotdma` is returning True when the 20th bit is 1?
No, the code is:
```python
    @property
    def is_sotdma(self) -> bool:
        """The radio status field has it's 20th bit (MSB) set to 0 or has less than 20 bits"""
        return self.radio <= self.MAX_COMM_STATE_VALUE

    @property
    def is_itdma(self) -> bool:
        """The radio status field has it's 20th bit (MSB) set to 1"""
        return self.radio > self.MAX_COMM_STATE_VALUE
```
If `radio` is `0x80000` (20th bit set), then `is_itdma` is True.

Wait, maybe `self.radio` in the `CommunicationStateMixin` is not what I think it is.
Let's see how `self.radio` is populated for `MessageType3`.
`MessageType3` inherits from `MessageType1`.
Let's check `MessageType1` definition in `pyais/messages.py`.

{
  "end_line": 880,
  "filepath": "pyais/messages.py",
  "start_line": 840
}

{
  "status": "ok",
  "filepath": "pyais/messages.py",
  "content": "            return self.radio & self.MAX_COMM_STATE_VALUE\n        except AttributeError as err:\n            raise ValueError(\n                'Communication State is only available for messages with radio field'\n            ) from err\n\n\n@attr.s(slots=True)\nclass MessageType1(Payload, CommunicationStateMixin):\n    \"\"\"\n    AIS Vessel position report using SOTDMA (Self-Organizing Time Division Multiple Access)\n    Src: https://gpsd.gitlab.io/gpsd/AIVDM.html#_types_1_2_and_3_position_report_class_a\n    \"\"\"\n    msg_type = bit_field(6, int, default=1, signed=False)\n    repeat = bit_field(2, int, default=0, signed=False)\n    mmsi = bit_field(30, int, from_converter=from_mmsi)\n    status = bit_field(4, int, default=0, converter=NavigationStatus.from_value, signed=False)\n    turn = bit_field(8, float, default=TurnRate.NO_TI_DEFAULT, signed=True, to_converter=to_turn, from_converter=from_turn)\n    speed = bit_field(10, float, from_converter=from_speed, to_converter=to_speed, default=0, signed=False)\n    accuracy = bit_field(1, bool, default=0, signed=False)\n    lon = bit_field(28, float, from_converter=from_lat_lon, to_converter=to_lat_lon, default=0, signed=True)\n    lat = bit_field(27, float, from_converter=from_lat_lon, to_converter=to_lat_lon, default=0, signed=True)\n    course = bit_field(12, float, from_converter=from_10th, to_converter=to_10th, default=0, signed=False)\n    heading = bit_field(9, int, default=0, signed=False)\n    second = bit_field(6, int, default=0, signed=False)\n    maneuver = bit_field(2, int, default=0, from_converter=ManeuverIndicator.from_value,\n                         to_converter=ManeuverIndicator.from_value, signed=False)\n    spare_1 = bit_field(3, bytes, default=b'')\n    raim = bit_field(1, bool, default=0)\n    radio = bit_field(19, int, default=0, signed=False)\n\n\nclass MessageType2(MessageType1):\n    \"\"\"\n    AIS Vessel position report using SOTDMA (Self-Organizing Time Division Multiple Access)\n    Src: https://gpsd.gitlab.io/gpsd/AIVDM.html#_types_1_2_and_3_position_report_class_a\n    \"\"\"\n    msg_type = bit_field(6, int, default=2)\n\n\nclass MessageType3(MessageType1):",
  "start_line": 840,
  "end_line": 880,
  "total_lines": 1736,
  "is_truncated": false
}

Look at `MessageType1`:
```python
    raim = bit_field(1, bool, default=0)
    radio = bit_field(19, int, default=0, signed=False)
```
The `radio` field is only 19 bits long.
In `CommunicationStateMixin`, `MAX_COMM_STATE_VALUE = 0x7ffff`, which is $2^{19}-1$.
So `self.radio` for `MessageType1` (and 2, 3) can NEVER be greater than `0x7ffff`.
Thus `is_itdma` will ALWAYS be False, and `is_sotdma` will ALWAYS be True.

This explains the bug! The `CommunicationStateMixin` properties `is_sotdma` and `is_itdma` are using `self.radio`, but for `MessageType1`, `MessageType2`, and `MessageType3`, `self.radio` is only 19 bits. The 20th bit that they are trying to check is actually the `raim` field!

Wait, if the 20th bit they are trying to check is the `raim` field, they should be checking `self.raim`.
But the `MessageType1` definition has `raim` as a separate field:
```python
    raim = bit_field(1, bool, default=0)
    radio = bit_field(19, int, default=0, signed=False)
```
The `CommunicationStateMixin` is implemented such that it expects `self.radio` to possibly have 20 bits.
But in `MessageType1`, `radio` only has 19.

If we use the message type to determine the communication state, what should we use?
The problem statement says: "It is better to use the message type rather than the bit length to indicate the type of communication status. Table 46 of the M.1371-5 standard shows which type uses which com state. Type 9, 18 and 26 messages are edge cases, as they can include one of the two com state types."

So for MessageType 1, 2, 3, 4, what is the com state?
According to the problem statement, it seems they are not edge cases.
Wait, if they are not edge cases, then they should have a fixed comm state?
But if they have a fixed comm state, why have `is_sotdma` and `is_itdma` properties on them?

Actually, the original implementation of `is_sotdma` was:
```python
    @property
    def is_sotdma(self) -> bool:
        """The radio status field has it's 20th bit (MSB) set to 0 or has less than 20 bits"""
        return self.radio <= self.MAX_COMM_STATE_VALUE
```
If `self.radio` has less than 20 bits, it's SOTDMA. This was the intention.
But for `MessageType1`, `self.radio` ALWAYS has 19 bits. So it's always SOTDMA.
However, the user says for the example (which is `MessageType3`), it's incorrectly indicated as SOTDMA, although it is an ITDMA.

Wait, if the example is `MessageType3` and it is ITDMA, then `MessageType3` MUST be able to be ITDMA.
But if `MessageType3` inherits from `MessageType1`, and `MessageType1` has `radio = bit_field(19, ...)`, then it can't have a 20th bit.

Let's look at the reproduction example again.
`pyais.decode('!AIVDM,1,1,,A,333ga6PP0jPPDUNM3I7DTOwDR59C,0*51')`
This decodes to `MessageType3`.
Let's see what the fields of this decoded message are.

{
  "command": "python3 - <<'PY'\nimport pyais\ndecoded = pyais.decode('!AIVDM,1,1,,A,333ga6PP0jPPDUNM3I7DTOwDR59C,0*51')\nprint(f\"RAIM: {decoded.raim}\")\nprint(f\"Radio: {decoded.radio}\")\nprint(f\"Binary Radio: {bin(decoded.radio)}\")\nPY\n"
}

{
  "status": "ok",
  "stdout": "RAIM: True\nRadio: 21075\nBinary Radio: 0b101001001010011\n",
  "stderr": "",
  "exit_code": 0
}

`RAIM` is `True` and `Radio` is `21075`.
`21075` is `0x5263`.
`MAX_COMM_STATE_VALUE` is `0x7ffff`.
`21075 <= 0x7ffff` is True.

If this is an ITDMA message, where is the ITDMA flag?
The problem statement says: "In the case of a type 1, 2 or 3 message, it would be checked whether the RAIM flag is set. Since 1 is the default value, pyais returns in almost all cases that it is a SOTDMA com state."
Wait, if RAIM flag is set (1), it should be SOTDMA? No, the user says it's incorrectly indicated as SOTDMA, but it IS ITDMA.
And "In the case of a type 1, 2 or 3 message, it would be checked whether the RAIM flag is set. Since 1 is the default value, pyais returns in almost all cases that it is a SOTDMA com state."

This is very confusing. Let's read carefully again.
"According to the following code it is checked whether the 20th bit of the communications status is set or not. However, as the com state is only 19 bits long, a bit from the previous data fields is checked here and not one from the com state."

Wait! The current code does NOT use `self.raim`. It uses `self.radio`.
But in `CommunicationStateMixin`, `is_sotdma` is:
```python
    @property
    def is_sotdma(self) -> bool:
        return self.radio <= self.MAX_COMM_STATE_VALUE
```
For `MessageType1`, `self.radio` is a `bit_field(19, ...)` from `attr` (probably `attr` based on the `@attr.s(slots=True)`).
Actually, the `bit_field` implementation probably handles the slicing of the bitstream.
So `self.radio` only gets the 19 bits assigned to it.
The `CommunicationStateMixin` is expecting `self.radio` to be the whole field including the 20th bit if it exists.

But in `MessageType1`, the 20th bit is actually the `raim` field!
Wait, the bitfields are defined in order:
```python
    raim = bit_field(1, bool, default=0)
    radio = bit_field(19, int, default=0, signed=False)
```
So the `raim` bit comes BEFORE the `radio` bits.
If the `radio` field was supposed to be 20 bits, then it would have included the `raim` bit.

If the user says "In the case of a type 1, 2 or 3 message, it would be checked whether the RAIM flag is set", this means the original author of `CommunicationStateMixin` thought `self.radio` would include that bit.

The recommended solution is:
"It is better to use the message type rather than the bit length to indicate the type of communication status. Table 46 of the M.1371-5 standard shows which type uses which com state. Type 9, 18 and 26 messages are edge cases, as they can include one of the two com state types."

Okay, let's find out which other types are ITDMA.
Type 1, 2, 3, 4 are probably SOTDMA? No, the user says the example (which is Type 3) is ITDMA.
Wait, if Type 3 is ITDMA, then maybe Type 1 and 2 are too?

Let's look at how `is_sotdma` should be implemented.
If it's an "edge case" (9, 18, 26), we keep the current `self.radio > self.MAX_COMM_STATE_VALUE` logic.
But for other types, we should use the message type.

Wait, let's see which message types are described in the standard.
If Type 1, 2, 3 are ITDMA, then we should check for that.
Wait, the user says: "For example, the following example incorrectly indicates that it is a SOTDMA communication status, although it is an ITDMA."
And the example is `MessageType3`.

Let's see if we can find what Table 46 says. I don't have access to the standard, but the user is giving us the solution.
"It is better to use the message type rather than the bit length to indicate the type of communication status."

Let's check `pyais/messages.py` again.

```python
@attr.s(slots=True)
class MessageType1(Payload, CommunicationStateMixin):
    """
    AIS Vessel position report using SOTDMA
    """
```
The docstring for `MessageType1` says "using SOTDMA".
But the user says `MessageType3` (which inherits from `MessageType1`) "is an ITDMA" in their example.
This is a contradiction.

Let's look at the reproduction example again.
`!AIVDM,1,1,,A,333ga6PP0jPPDUNM3I7DTOwDR59C,0*51`
`333ga6PP0jPPDUNM3I7DTOwDR59C` in binary:
`'3'` -> 51 (binary 110011)
`'3'` -> 51 (binary 110011)
`'3'` -> 51 (binary 110011)
`'g'` -> 32 (binary 100000)
... and so on.

Actually, let's use `pyais` to see what the fields are.
I already did: `RAIM: True`, `Radio: 21075`.

Is it possible that for `MessageType3`, it should always be ITDMA if RAIM is True?
"In the case of a type 1, 2 or 3 message, it would be checked whether the RAIM flag is set. Since 1 is the default value, pyais returns in almost all cases that it is a SOTDMA com state."
Wait, "Since 1 is the default value, pyais returns ... SOTDMA".
This means if `raim == 1`, it returned SOTDMA.
But if it's ITDMA, it should have returned ITDMA.

Let's look at `is_sotdma` again:
```python
    @property
    def is_sotdma(self) -> bool:
        """The radio status field has it's 20th bit (MSB) set to 0 or has less than 20 bits"""
        return self.radio <= self.MAX_COMM_STATE_VALUE
```
For `MessageType3`, `self.radio` is always $\le$ `0x7ffff`. So `is_sotdma` is always True.
If the user says it's ITDMA, then `is_sotdma` should be False.

Wait, "In the case of a type 1, 2 or 3 message, it would be checked whether the RAIM flag is set."
If the 20th bit of the communication status (which is the RAIM flag for Type 1, 2, 3) is set, then it is ITDMA?
Let's check the docstring of `is_itdma`:
```python
    @property
    def is_itdma(self) -> bool:
        """The radio status field has it's 20th bit (MSB) set to 1"""
        return self.radio > self.MAX_COMM_STATE_VALUE
```
And `is_sotdma` says "has it's 20th bit (MSB) set to 0".

So for `MessageType1`, `MessageType2`, `MessageType3`, the "20th bit" of the communication status IS the `raim` field.
So if `self.raim` is True, it should be ITDMA. If `self.raim` is False, it should be SOTDMA.

Let's check if this holds for `MessageType4`.

{
  "command": "grep -n \"class MessageType4\" pyais/messages.py"
}

{
  "status": "ok",
  "stdout": "889:class MessageType4(Payload, CommunicationStateMixin):\n",
  "stderr": "",
  "exit_code": 0
}

Let's check `MessageType4` fields.

{
  "end_line": 920,
  "filepath": "pyais/messages.py",
  "start_line": 880
}

{
  "status": "ok",
  "filepath": "pyais/messages.py",
  "content": "class MessageType3(MessageType1):\n    \"\"\"\n    AIS Vessel position report using ITDMA (Incremental Time Division Multiple Access)\n    Src: https://gpsd.gitlab.io/gpsd/AIVDM.html#_types_1_2_and_3_position_report_class_a\n    \"\"\"\n    msg_type = bit_field(6, int, default=3)\n\n\n@attr.s(slots=True)\nclass MessageType4(Payload, CommunicationStateMixin):\n    \"\"\"\n    AIS Vessel position report using SOTDMA (Self-Organizing Time Division Multiple Access)\n    Src: https://gpsd.gitlab.io/gpsd/AIVDM.html#_type_4_base_station_report\n    \"\"\"\n    msg_type = bit_field(6, int, default=4, signed=False)\n    repeat = bit_field(2, int, default=0, signed=False)\n    mmsi = bit_field(30, int, from_converter=from_mmsi)\n    year = bit_field(14, int, default=1970, signed=False)\n    month = bit_field(4, int, default=1, signed=False)\n    day = bit_field(5, int, default=1, signed=False)\n    hour = bit_field(5, int, default=0, signed=False)\n    minute = bit_field(6, int, default=0, signed=False)\n    second = bit_field(6, int, default=0, signed=False)\n    accuracy = bit_field(1, bool, default=0, signed=False)\n    lon = bit_field(28, float, from_converter=from_lat_lon, to_converter=to_lat_lon, signed=True, default=0)\n    lat = bit_field(27, float, from_converter=from_lat_lon, to_converter=to_lat_lon, signed=True, default=0)\n    epfd = bit_field(4, int, default=0, from_converter=EpfdType.from_value, to_converter=EpfdType.from_value,\n                     signed=False)\n    spare_1 = bit_field(10, bytes, default=b'')\n    raim = bit_field(1, bool, default=0)\n    radio = bit_field(19, int, default=0, signed=False)\n\n\n@attr.s(slots=True)\nclass MessageType5(Payload):\n    \"\"\"\n    Static and Voyage Related Data\n    Src: https://gpsd.gitlab.io/gpsd/AIVDM.html#_type_5_static_and_voyage_related_data\n    \"\"\"\n    msg_type = bit_field(6, int, default=5, signed=False)\n    repeat = bit_field(2, int, default=0, signed=False)",
  "start_line": 880,
  "end_line": 920,
  "total_lines": 1736,
  "is_truncated": false
}

`MessageType4` also has:
```python
    raim = bit_field(1, bool, default=0)
    radio = bit_field(19, int, default=0, signed=False)
```
So the same thing happen for `MessageType4`.

Wait, let's check `MessageType3` docstring:
```python
class MessageType3(MessageType1):
    """
    AIS Vessel position report using ITDMA (Incremental Time Division Multiple Access)
    """
```
And `MessageType1`:
```python
class MessageType1(Payload, CommunicationStateMixin):
    """
    AIS Vessel position report using SOTDMA (Self-Organizing Time Division Multiple Access)
    """
```
And `MessageType2`:
```python
class MessageType2(MessageType1):
    """
    AIS Vessel position report using SOTDMA (Self-Organizing Time Division Multiple Access)
    """
```
And `MessageType4`:
```python
class MessageType4(Payload, CommunicationStateMixin):
    """
    AIS Vessel position report using SOTDMA (Self-Organizing Time Division Multiple Access)
    """
```

So Type 1, 2, 4 are SOTDMA and Type 3 is ITDMA?
Wait, the problem statement says "In the case of a type 1, 2 or 3 message, it would be checked whether the RAIM flag is set."

Let's go back to the suggested solution:
"It is better to use the message type rather than the bit length to indicate the type of communication status. Table 46 of the M.1371-5 standard shows which type uses which com state. Type 9, 18 and 26 messages are edge cases, as they can include one of the two com state types. The existing implementation can be used here, as with these message types the bit before the actual com state determines its type."

This means for types 1, 2, 3, 4, we should just check the `msg_type`.
Wait, let's see what the `msg_type` values are.
- `MessageType1`: `msg_type = 1`
- `MessageType2`: `msg_type = 2`
- `MessageType3`: `msg_type = 3`
- `MessageType4`: `msg_type = 4`
- `MessageType9`: `msg_type = 9`
- `MessageType18`: `msg_type = 18`
- `MessageType26`: `msg_type = 26`

If we use the message type:
Type 1, 2, 4 -> SOTDMA?
Type 3 -> ITDMA?

Wait, let's check the docstrings again.
Type 1: SOTDMA
Type 2: SOTDMA
Type 3: ITDMA
Type 4: SOTDMA

So if `msg_type == 3`, it's ITDMA?
But wait, the user said "In the case of a type 1, 2 or 3 message, it would be checked whether the RAIM flag is set."
This means for types 1, 2, 3, the `raim` field is actually part of the communication state, and it determines if it's SOTDMA or ITDMA.

If `raim` is 0, it's SOTDMA. If `raim` is 1, it's ITDMA.
The `CommunicationStateMixin` current implementation:
```python
    @property
    def is_sotdma(self) -> bool:
        return self.radio <= self.MAX_COMM_STATE_VALUE
```
For Type 1, 2, 3, 4, `self.radio` is always $\le$ `MAX_COMM_STATE_VALUE` because it's only 19 bits.
So it's always SOTDMA.
But if `raim` is the 20th bit, then `is_itdma` should be true when `raim` is true.

So the correct implementation for Type 1, 2, 3, 4 should use `self.raim` if it exists?
But wait, only Type 1, 2, 3, 4 have `raim`? No, any message that has `CommunicationStateMixin` and `radio` field might have `raim`.

Let's check `MessageType9`.

{
  "command": "grep -A 20 \"class MessageType9\" pyais/messages.py"
}

{
  "status": "ok",
  "stdout": "class MessageType9(Payload, CommunicationStateMixin):\n    \"\"\"\n    Standard SAR Aircraft Position Report\n    Src: https://gpsd.gitlab.io/gpsd/AIVDM.html#_type_9_standard_sar_aircraft_position_report\n    \"\"\"\n    msg_type = bit_field(6, int, default=9, signed=False)\n    repeat = bit_field(2, int, default=0, signed=False)\n    mmsi = bit_field(30, int, from_converter=from_mmsi)\n\n    alt = bit_field(12, int, default=0, signed=False)\n    # speed over ground is in knots, not deciknots\n    speed = bit_field(10, float, default=0, signed=False)\n    accuracy = bit_field(1, bool, default=0, signed=False)\n    lon = bit_field(28, float, from_converter=from_lat_lon, to_converter=to_lat_lon, signed=True, default=0)\n    lat = bit_field(27, float, from_converter=from_lat_lon, to_converter=to_lat_lon, signed=True, default=0)\n    course = bit_field(12, float, from_converter=from_10th, to_converter=to_10th, default=0, signed=False)\n    second = bit_field(6, int, default=0, signed=False)\n\n    reserved_1 = bit_field(8, int, default=0)\n    dte = bit_field(1, bool, default=0)\n    spare_1 = bit_field(3, bytes, default=b'')\n",
  "stderr": "",
  "exit_code": 0
}

Wait, `MessageType9` doesn't have a `radio` field in the first 20 lines. Let me read more.

{
  "end_line": 1020,
  "filepath": "pyais/messages.py",
  "start_line": 990
}

{
  "status": "ok",
  "filepath": "pyais/messages.py",
  "content": "    dac = bit_field(10, int, default=0, signed=False)\n    fid = bit_field(6, int, default=0, signed=False)\n    data = bit_field(952, bytes, default=b'', variable_length=True)\n\n\n@attr.s(slots=True)\nclass MessageType9(Payload, CommunicationStateMixin):\n    \"\"\"\n    Standard SAR Aircraft Position Report\n    Src: https://gpsd.gitlab.io/gpsd/AIVDM.html#_type_9_standard_sar_aircraft_position_report\n    \"\"\"\n    msg_type = bit_field(6, int, default=9, signed=False)\n    repeat = bit_field(2, int, default=0, signed=False)\n    mmsi = bit_field(30, int, from_converter=from_mmsi)\n\n    alt = bit_field(12, int, default=0, signed=False)\n    # speed over ground is in knots, not deciknots\n    speed = bit_field(10, float, default=0, signed=False)\n    accuracy = bit_field(1, bool, default=0, signed=False)\n    lon = bit_field(28, float, from_converter=from_lat_lon, to_converter=to_lat_lon, signed=True, default=0)\n    lat = bit_field(27, float, from_converter=from_lat_lon, to_converter=to_lat_lon, signed=True, default=0)\n    course = bit_field(12, float, from_converter=from_10th, to_converter=to_10th, default=0, signed=False)\n    second = bit_field(6, int, default=0, signed=False)\n\n    reserved_1 = bit_field(8, int, default=0)\n    dte = bit_field(1, bool, default=0)\n    spare_1 = bit_field(3, bytes, default=b'')\n    assigned = bit_field(1, bool, default=0)\n    raim = bit_field(1, bool, default=0)\n    radio = bit_field(20, int, default=0, signed=False)\n",
  "start_line": 990,
  "end_line": 1020,
  "total_lines": 1736,
  "is_truncated": false
}

Aha! `MessageType9` has `radio = bit_field(20, int, default=0, signed=False)`.
This is 20 bits! So `self.radio > 0x7ffff` will work correctly here.

Let's check `MessageType18`.

{
  "end_line": 1160,
  "filepath": "pyais/messages.py",
  "start_line": 1140
}

{
  "status": "ok",
  "filepath": "pyais/messages.py",
  "content": "@attr.s(slots=True)\nclass MessageType18(Payload, CommunicationStateMixin):\n    \"\"\"\n    Standard Class B CS Position Report\n    Src: https://gpsd.gitlab.io/gpsd/AIVDM.html#_type_18_standard_class_b_cs_position_report\n    \"\"\"\n    msg_type = bit_field(6, int, default=18, signed=False)\n    repeat = bit_field(2, int, default=0, signed=False)\n    mmsi = bit_field(30, int, from_converter=from_mmsi)\n\n    reserved_1 = bit_field(8, int, default=0, signed=False)\n    speed = bit_field(10, float, from_converter=from_speed, to_converter=to_speed, default=0, signed=False)\n    accuracy = bit_field(1, bool, default=0, signed=False)\n    lon = bit_field(28, float, from_converter=from_lat_lon, to_converter=to_lat_lon, signed=True, default=0)\n    lat = bit_field(27, float, from_converter=from_lat_lon, to_converter=to_lat_lon, signed=True, default=0)\n    course = bit_field(12, float, from_converter=from_10th, to_converter=to_10th, default=0, signed=False)\n    heading = bit_field(9, int, default=0, signed=False)\n    second = bit_field(6, int, default=0, signed=False)\n    reserved_2 = bit_field(2, int, default=0, signed=False)\n    cs = bit_field(1, bool, default=0, signed=False)\n    display = bit_field(1, bool, default=0)",
  "start_line": 1140,
  "end_line": 1160,
  "total_lines": 1736,
  "is_truncated": false
}