Initial commit

Author: Nobutaka Horie

__init__.py

@@ -0,0 +1,3 @@
+from qzss_dcr_lib.exception import QzssDcrDecoderException
+from qzss_dcr_lib.interface import decode
+from qzss_dcr_lib.interface import decode_stream

__main__.py

@@ -0,0 +1,5 @@
+from .qzss_dcr_lib.main import main
+
+
+if __name__ == '__main__':
+    main()

build.sh

@@ -0,0 +1,4 @@
+#!/bin/sh
+
+cd `dirname "$0"`
+python setup.py bdist_wheel

qzss_dcr_lib/__init__.py

@@ -0,0 +1,19 @@
+from .hex_qzss_dcr_decoder import *
+from .qzss_dcr_decoder import *
+from .qzss_dcr_decoder_base import *
+from .qzss_dcr_decoder_jma import *
+from .qzss_dcr_decoder_jma_ash_fall import *
+from .qzss_dcr_decoder_jma_common import *
+from .qzss_dcr_decoder_jma_earthquake_early_warning import *
+from .qzss_dcr_decoder_jma_flood import *
+from .qzss_dcr_decoder_jma_hypocenter import *
+from .qzss_dcr_decoder_jma_marine import *
+from .qzss_dcr_decoder_jma_northwest_pacific_tsunami import *
+from .qzss_dcr_decoder_jma_seismic_intensity import *
+from .qzss_dcr_decoder_jma_tsunami import *
+from .qzss_dcr_decoder_jma_typhoon import *
+from .qzss_dcr_decoder_jma_volcano import *
+from .qzss_dcr_decoder_jma_weather import *
+from .qzss_dcr_decoder_other_organization import *
+from .spresense_qzss_dcr_decoder import *
+from .ublox_qzss_dcr_decoder import *

qzss_dcr_lib/decoder/__init__.py

@@ -0,0 +1,34 @@
+from .qzss_dcr_decoder_base import QzssDcrDecoderBase
+from .qzss_dcr_decoder import QzssDcrDecoder
+from qzss_dcr_lib.exception import QzssDcrDecoderException
+from qzss_dcr_lib.report import QzssDcReportBase
+
+
+class HexQzssDcrDecoder(QzssDcrDecoderBase):
+    schema = QzssDcReportBase
+
+    def decode(self):
+        if not self.sentence:
+            raise EOFError('Encountered EOF')
+
+        self.sentence = self.sentence.split()[0]
+
+        if len(self.sentence) < 63:
+            raise QzssDcrDecoderException(
+                    'Too Short Sentence',
+                    self.sentence)
+        if len(self.sentence) > 63:
+            raise QzssDcrDecoderException(
+                    'Too Long Sentence',
+                    self.sentence)
+
+        # converts the message to bytes type
+        try:
+            self.message = bytes.fromhex(self.sentence+'0')
+        except:
+            raise QzssDcrDecoderException(
+                    'Invalid Message',
+                    self.sentence)
+
+        # stacks the next decoder
+        return QzssDcrDecoder(**self.get_params()).decode()

qzss_dcr_lib/decoder/hex_qzss_dcr_decoder.py

@@ -0,0 +1,74 @@
+from .qzss_dcr_decoder_base import QzssDcrDecoderBase
+from .qzss_dcr_decoder_jma import QzssDcrDecoderJma
+from .qzss_dcr_decoder_other_organization import QzssDcrDecoderOtherOrganization
+from qzss_dcr_lib.exception import QzssDcrDecoderException
+from qzss_dcr_lib.report import QzssDcReportMessagePartial
+from qzss_dcr_lib.definition import qzss_dcr_preamble
+from qzss_dcr_lib.definition import qzss_dcr_message_type
+from qzss_dcr_lib.definition import qzss_dcr_report_classification
+from qzss_dcr_lib.definition import qzss_dcr_report_classification_en
+
+
+class QzssDcrDecoder(QzssDcrDecoderBase):
+    schema = QzssDcReportMessagePartial
+
+    def decode(self):
+        # checks the preamble
+        pab = self.extract_field(0, 8)
+        try:
+            self.preamble = qzss_dcr_preamble[pab]
+        except:
+            raise QzssDcrDecoderException(
+                    f'Invalid Preamble: {pab}',
+                    self.sentence)
+
+        # checks the crc
+        crc = 0
+        crc_remaining_len = 226
+        data = bytearray(self.message[:29])
+        data[-1] &= 0xc0 # clears the last 6 bits
+        for byte in data:
+            crc ^= (byte << 16)
+            for _ in range(8):
+                crc <<= 1
+                if crc & 0x1000000:
+                    crc ^= 0x1864cfb # polynomial
+                crc_remaining_len -= 1
+                if crc_remaining_len == 0:
+                    break
+        crc &= 0xffffff
+        if crc != self.extract_field(226, 24):
+            raise QzssDcrDecoderException(
+                    'CRC Mismatch',
+                    self.sentence)
+
+        # checks the message type
+        mt = self.extract_field(8, 6) # 6 bits
+        try:
+            self.message_type = qzss_dcr_message_type[mt]
+        except:
+            raise QzssDcrDecoderException(
+                    f'Undefined Message Type: {mt}',
+                    self.sentence)
+
+        if mt == 43:
+            next_decoder = QzssDcrDecoderJma
+        elif mt == 44:
+            next_decoder = QzssDcrDecoderOtherOrganization
+        else:
+            raise QzssDcrDecoderException(
+                    f'Unsupported Message Type: {mt}',
+                    self.sentence)
+
+        rc = self.extract_field(14, 3)
+        try:
+            self.report_classification = qzss_dcr_report_classification[rc]
+            self.report_classification_en = qzss_dcr_report_classification_en[rc]
+        except:
+            raise QzssDcrDecoderException(
+                    f'Undefined Report Classification: {rc}',
+                    self.sentence)
+        self.report_classification_no = rc
+
+        # stacks the next decoder
+        return next_decoder(**self.get_params()).decode()

qzss_dcr_lib/decoder/qzss_dcr_decoder.py

@@ -0,0 +1,23 @@
+from qzss_dcr_lib.exception import QzssDcrDecoderException
+
+
+class QzssDcrDecoderBase:
+    schema = None
+
+    def __init__(self, sentence, **kwargs):
+        self.set_params(sentence=sentence,
+                        **kwargs)
+
+    def decode(self):
+        raise NotImplemented()
+
+    def extract_field(self, slider, size):
+        field = bytearray(self.message[slider >> 3:(slider + size >> 3) + 1])
+        field[0] = field[0] & (2 ** (8 - (slider & 7)) - 1)
+        return int.from_bytes(field, 'big') >> (8 - (slider + size & 7))
+
+    def set_params(self, **kwargs):
+        self.__dict__.update(self.schema(**kwargs).get_params())
+
+    def get_params(self):
+        return self.__dict__

qzss_dcr_lib/decoder/qzss_dcr_decoder_base.py

@@ -0,0 +1,120 @@
+from .qzss_dcr_decoder_base import QzssDcrDecoderBase
+from .qzss_dcr_decoder_jma_earthquake_early_warning import QzssDcrDecoderJmaEarthquakeEarlyWarning
+from .qzss_dcr_decoder_jma_seismic_intensity import QzssDcrDecoderJmaSeismicIntensity
+from .qzss_dcr_decoder_jma_hypocenter import QzssDcrDecoderJmaHypocenter
+from .qzss_dcr_decoder_jma_tsunami import QzssDcrDecoderJmaTsunami
+from .qzss_dcr_decoder_jma_northwest_pacific_tsunami import QzssDcrDecoderJmaNorthwestPacificTsunami
+from .qzss_dcr_decoder_jma_volcano import QzssDcrDecoderJmaVolcano
+from .qzss_dcr_decoder_jma_ash_fall import QzssDcrDecoderJmaAshFall
+from .qzss_dcr_decoder_jma_weather import QzssDcrDecoderJmaWeather
+from .qzss_dcr_decoder_jma_flood import QzssDcrDecoderJmaFlood
+from .qzss_dcr_decoder_jma_typhoon import QzssDcrDecoderJmaTyphoon
+from .qzss_dcr_decoder_jma_marine import QzssDcrDecoderJmaMarine
+from qzss_dcr_lib.report import QzssDcReportMessageBase
+from qzss_dcr_lib.exception import QzssDcrDecoderException
+from qzss_dcr_lib.definition import qzss_dcr_jma_disaster_category
+from qzss_dcr_lib.definition import qzss_dcr_jma_disaster_category_en
+from qzss_dcr_lib.definition import qzss_dcr_jma_information_type
+from qzss_dcr_lib.definition import qzss_dcr_jma_information_type_en
+from datetime import datetime
+
+
+class QzssDcrDecoderJma(QzssDcrDecoderBase):
+    schema = QzssDcReportMessageBase
+
+    def decode(self):
+        self.version = self.extract_field(214, 6)
+        if self.version != 1:
+            raise QzssDcrDecoderException(
+                    f'Unsupported JMA-DC Report Version: {self.version}',
+                    self.sentence)
+
+        dc = self.extract_field(17, 4)
+        try:
+            self.disaster_category = qzss_dcr_jma_disaster_category[dc]
+            self.disaster_category_en = qzss_dcr_jma_disaster_category_en[dc]
+        except:
+            raise QzssDcrDecoderException(
+                    f'Undefined Disaster Category: {dc}',
+                    self.sentence)
+        self.disaster_category_no = dc
+
+        at_mo = self.extract_field(21, 4)
+        if at_mo < 1 or at_mo > 12:
+            raise QzssDcrDecoderException(
+                    f'Invalid Report Time: {at_mo} as month',
+                    self.sentence)
+        at_d = self.extract_field(25, 5)
+        if at_d < 1 or at_d > 31:
+            raise QzssDcrDecoderException(
+                    f'Invalid Report Time: {at_d} as day',
+                    self.sentence)
+        at_h = self.extract_field(30, 5)
+        if at_h > 23:
+            raise QzssDcrDecoderException(
+                    f'Invalid Report Time: {at_h} as hour',
+                    self.sentence)
+        at_mi = self.extract_field(35, 6)
+        if at_mi > 59:
+            raise QzssDcrDecoderException(
+                    f'Invalid Report Time: {at_mi} as minute',
+                    self.sentence)
+
+        at_y = self.now.year
+        if at_mo - self.now.month > 6:
+            at_y -= 1
+        elif self.now.month - at_mo > 6:
+            at_y += 1
+
+        if at_mo == 2 and at_d == 29:
+            while at_y % 4 != 0 or (at_y % 100 == 0 and at_y % 400 != 0):
+                at_y += 1
+
+        self.report_time = datetime(year=at_y,
+                                    month=at_mo,
+                                    day=at_d,
+                                    hour=at_h,
+                                    minute=at_mi)
+
+        it = self.extract_field(41, 2)
+        try:
+            self.information_type = qzss_dcr_jma_information_type[it]
+            self.information_type_en = qzss_dcr_jma_information_type_en[it]
+        except:
+            raise QzssDcrDecoderException(
+                    'Undefined Information Type: {it}',
+                    self.sentence)
+        self.information_type_no = it
+
+        if dc == 1:
+            next_decoder = QzssDcrDecoderJmaEarthquakeEarlyWarning
+        elif dc == 2:
+            next_decoder = QzssDcrDecoderJmaHypocenter
+        elif dc == 3:
+            next_decoder = QzssDcrDecoderJmaSeismicIntensity
+        elif dc == 4:
+            raise QzssDcrDecoderException(
+                    'Decoder Not Implemented: JMA Nankai Trough Earthquake Information',
+                    self.sentence)
+        elif dc == 5:
+            next_decoder = QzssDcrDecoderJmaTsunami
+        elif dc == 6:
+            next_decoder = QzssDcrDecoderJmaNorthwestPacificTsunami
+        elif dc == 8:
+            next_decoder = QzssDcrDecoderJmaVolcano
+        elif dc == 9:
+            next_decoder = QzssDcrDecoderJmaAshFall
+        elif dc == 10:
+            next_decoder = QzssDcrDecoderJmaWeather
+        elif dc == 11:
+            next_decoder = QzssDcrDecoderJmaFlood
+        elif dc == 12:
+            next_decoder = QzssDcrDecoderJmaTyphoon
+        elif dc == 14:
+            next_decoder = QzssDcrDecoderJmaMarine
+        else:
+            raise QzssDcrDecoderException(
+                    f'Unsupported Disaster Category: {self.disaster_category}',
+                    self.sentence)
+
+        return next_decoder(**self.get_params()).decode()

qzss_dcr_lib/decoder/qzss_dcr_decoder_jma.py

@@ -0,0 +1,58 @@
+from .qzss_dcr_decoder_jma_common import QzssDcrDecoderJmaCommon
+from qzss_dcr_lib.exception import QzssDcrDecoderException
+from qzss_dcr_lib.report import QzssDcReportJmaBase
+from qzss_dcr_lib.report import QzssDcReportJmaAshFall
+from qzss_dcr_lib.definition import qzss_dcr_jma_volcano_name
+from qzss_dcr_lib.definition import qzss_dcr_jma_ash_fall_warning_code
+
+
+class QzssDcrDecoderJmaAshFall(QzssDcrDecoderJmaCommon):
+    schema = QzssDcReportJmaBase
+
+    def decode(self):
+        self.activity_time = self.extract_day_hour_min_field(53)
+
+        dw1 = self.extract_field(69, 2)
+        if dw1 == 1:
+            self.ash_fall_warning_type = '速報'
+        elif dw1 == 2:
+            self.ash_fall_warning_type = '詳細'
+        else:
+            raise QzssDcrDecoderException(
+                    f'Undefined JMA Ash Fall Warning Type: {dw1}',
+                    self.sentence)
+
+        vo = self.extract_field(71, 12)
+        try:
+            self.volcano_name = qzss_dcr_jma_volcano_name[vo]
+        except:
+            raise QzssDcrDecoderException(
+                    f'Undefined JMA Volcano Name: {vo}',
+                    self.sentence)
+
+        self.expected_ash_fall_times = []
+        self.ash_fall_warning_codes = []
+        self.local_governments = []
+        for i in range(4):
+            offset = 83 + i * 29
+            if self.extract_field(offset, 29) == 0:
+                break
+
+            ho = self.extract_field(offset, 3)
+            if ho < 1 and ho > 6:
+                raise QzssDcrDecoderException(
+                        f'Invalid JMA Expected Ash Fall Time: {ho}',
+                        self.sentence)
+            self.expected_ash_fall_times.append(ho)
+
+            dw2 = self.extract_field(offset+3, 3)
+            try:
+                self.ash_fall_warning_codes.append(qzss_dcr_jma_ash_fall_warning_code[dw2])
+            except:
+                raise QzssDcrDecoderException(
+                        f'Undefined JMA Ash Fall Warning Code: {dw2}',
+                        self.sentence)
+
+            self.local_governments.append(self.extract_local_government(offset+6))
+
+        return QzssDcReportJmaAshFall(**self.get_params())