Changeset 7752d1f in ammosreader for doc


Ignore:
Timestamp:
05/20/23 20:56:15 (2 years ago)
Author:
Enrico Schwass <ennoausberlin@…>
Branches:
AmmosSource, guix
Children:
f3b78e8
Parents:
4eb8a2f
Message:

mostly style changes after running pylint

Location:
doc/ammosreader
Files:
16 edited

Legend:

Unmodified
Added
Removed

  • doc/ammosreader/AbstractAmmosReader.html

    r4eb8a2f r7752d1f  
    3737from ammosreader.AmmosConstants import FrameType
    3838from ammosreader import logger
    39 from ammosreader import logger
     39
    4040
    4141class AbstractAmmosReader(ABC):
    … …  
    114114        header_size = AmmosGlobalFrameHeader.HEADER_SIZE
    115115
    116         bytes = self.ammos_file.read(header_size)
     116        in_bytes = self.ammos_file.read(header_size)
    117117        logger.info(&#34;Reading next global frame header&#34;)
    118         if ((not bytes) or (len(bytes) &lt; header_size)):
     118        if ((not in_bytes) or (len(in_bytes) &lt; header_size)):
    119119            logger.debug(&#34;Can not read all %s bytes of global frame header&#34;, header_size)
    120120            return None
    121121
    122         current_global_frame_header = AmmosGlobalFrameHeader.from_bytes(bytes)
     122        current_global_frame_header = AmmosGlobalFrameHeader.from_bytes(in_bytes)
    123123
    124124        if current_global_frame_header is None:
    … …  
    286286        header_size = AmmosGlobalFrameHeader.HEADER_SIZE
    287287
    288         bytes = self.ammos_file.read(header_size)
     288        in_bytes = self.ammos_file.read(header_size)
    289289        logger.info(&#34;Reading next global frame header&#34;)
    290         if ((not bytes) or (len(bytes) &lt; header_size)):
     290        if ((not in_bytes) or (len(in_bytes) &lt; header_size)):
    291291            logger.debug(&#34;Can not read all %s bytes of global frame header&#34;, header_size)
    292292            return None
    293293
    294         current_global_frame_header = AmmosGlobalFrameHeader.from_bytes(bytes)
     294        current_global_frame_header = AmmosGlobalFrameHeader.from_bytes(in_bytes)
    295295
    296296        if current_global_frame_header is None:
    … …  
    507507    header_size = AmmosGlobalFrameHeader.HEADER_SIZE
    508508
    509     bytes = self.ammos_file.read(header_size)
     509    in_bytes = self.ammos_file.read(header_size)
    510510    logger.info(&#34;Reading next global frame header&#34;)
    511     if ((not bytes) or (len(bytes) &lt; header_size)):
     511    if ((not in_bytes) or (len(in_bytes) &lt; header_size)):
    512512        logger.debug(&#34;Can not read all %s bytes of global frame header&#34;, header_size)
    513513        return None
    514514
    515     current_global_frame_header = AmmosGlobalFrameHeader.from_bytes(bytes)
     515    current_global_frame_header = AmmosGlobalFrameHeader.from_bytes(in_bytes)
    516516
    517517    if current_global_frame_header is None:

  • doc/ammosreader/AmmosAudioDataHeader.html

    r4eb8a2f r7752d1f  
    4040
    4141    @classmethod
    42     def from_bytes(cls, bytes):
     42    def from_bytes(cls, in_bytes):
    4343        &#34;&#34;&#34;I return an AMMOS data header from given bytes.&#34;&#34;&#34;
    44         assert len(bytes) == cls.HEADER_SIZE
    45         elements = struct.unpack(&#39;&lt;IIQIIIII&#39;, bytes)
     44        assert len(in_bytes) == cls.HEADER_SIZE
     45        elements = struct.unpack(&#39;&lt;IIQIIIII&#39;, in_bytes)
    4646        sample_rate = elements[0]
    4747        status = elements[1]
    … …  
    106106
    107107    @classmethod
    108     def from_bytes(cls, bytes):
     108    def from_bytes(cls, in_bytes):
    109109        &#34;&#34;&#34;I return an AMMOS data header from given bytes.&#34;&#34;&#34;
    110         assert len(bytes) == cls.HEADER_SIZE
    111         elements = struct.unpack(&#39;&lt;IIQIIIII&#39;, bytes)
     110        assert len(in_bytes) == cls.HEADER_SIZE
     111        elements = struct.unpack(&#39;&lt;IIQIIIII&#39;, in_bytes)
    112112        sample_rate = elements[0]
    113113        status = elements[1]
    … …  
    155155<dl>
    156156<dt id="ammosreader.AmmosAudioDataHeader.AmmosAudioDataHeader.from_bytes"><code class="name flex">
    157 <span>def <span class="ident">from_bytes</span></span>(<span>bytes)</span>
     157<span>def <span class="ident">from_bytes</span></span>(<span>in_bytes)</span>
    158158</code></dt>
    159159<dd>
    … …  
    164164</summary>
    165165<pre><code class="python">@classmethod
    166 def from_bytes(cls, bytes):
     166def from_bytes(cls, in_bytes):
    167167    &#34;&#34;&#34;I return an AMMOS data header from given bytes.&#34;&#34;&#34;
    168     assert len(bytes) == cls.HEADER_SIZE
    169     elements = struct.unpack(&#39;&lt;IIQIIIII&#39;, bytes)
     168    assert len(in_bytes) == cls.HEADER_SIZE
     169    elements = struct.unpack(&#39;&lt;IIQIIIII&#39;, in_bytes)
    170170    sample_rate = elements[0]
    171171    status = elements[1]

  • doc/ammosreader/AmmosAudioReader.html

    r4eb8a2f r7752d1f  
    3737from ammosreader import logger
    3838
     39
    3940class AmmosAudioReader(AbstractAmmosReader):
    4041    &#34;&#34;&#34;I read the audio data embedded in an R&amp;S AMMOS recording.&#34;&#34;&#34;
    41 
    42     def __init__(self, file_name):
    43         &#34;&#34;&#34;
    44         I return an instance of AmmosAudioReader initialized with a given file name.
    45 
    46         :param file_name: the file to read from
    47         :type file_name: str
    48         &#34;&#34;&#34;
    49         super().__init__(file_name)
    5042
    5143    def read_next_global_frame_body_data_header(self):
    … …  
    6052        header_size = AmmosAudioDataHeader.HEADER_SIZE
    6153
    62         bytes = self.ammos_file.read(header_size)
     54        in_bytes = self.ammos_file.read(header_size)
    6355
    6456        logger.info(&#34;\nReading global frame body standard data header\n&#34;)
    65         if ((not bytes) or (len(bytes) &lt; header_size)):
     57        if ((not in_bytes) or (len(in_bytes) &lt; header_size)):
    6658            logger.debug(&#34;Can not read all %s bytes of global frame body data header&#34;, header_size)
    6759            return None
    68         return AmmosAudioDataHeader.from_bytes(bytes)
     60        return AmmosAudioDataHeader.from_bytes(in_bytes)
    6961
    7062    def read_next_global_frame_body_extended_data_header(self):
    … …  
    7769        header_size = AmmosExtendedAudioDataHeader.HEADER_SIZE
    7870
    79         bytes = self.ammos_file.read(header_size)
    80 
    81         if ((not bytes) or (len(bytes) &lt; header_size)):
     71        in_bytes = self.ammos_file.read(header_size)
     72
     73        if ((not in_bytes) or (len(in_bytes) &lt; header_size)):
    8274            logger.debug(&#34;Can not read all %s bytes of global frame extended data header&#34;, header_size)
    8375            return None
    84         return AmmosExtendedAudioDataHeader.from_bytes(bytes)
     76        return AmmosExtendedAudioDataHeader.from_bytes(in_bytes)
    8577
    8678    def read_next_audio_data_body(self, number_of_samples, number_of_channels, sample_size):
    … …  
    150142        :rtype: bytes
    151143        &#34;&#34;&#34;
    152         return b&#34;&#34;.join([each.global_frame_body.data_body.pcm_for_channel(a_channel) for each in self.container.global_frames])</code></pre>
     144        return (b&#34;&#34;.join([each.global_frame_body.data_body.pcm_for_channel(a_channel)
     145                          for each in self.container.global_frames]))</code></pre>
    153146</details>
    154147</section>
    … …  
    168161<dd>
    169162<div class="desc"><p>I read the audio data embedded in an R&amp;S AMMOS recording.</p>
    170 <p>I return an instance of AmmosAudioReader initialized with a given file name.</p>
    171 <p>:param file_name: the file to read from
     163<p>I am the standard constructor for Ammos Readers.</p>
     164<p>Additional information about the file can be added as key/value pairs in tags</p>
     165<p>:param file_name: The file to read Ammos data from
    172166:type file_name: str</p></div>
    173167<details class="source">
    … …  
    177171<pre><code class="python">class AmmosAudioReader(AbstractAmmosReader):
    178172    &#34;&#34;&#34;I read the audio data embedded in an R&amp;S AMMOS recording.&#34;&#34;&#34;
    179 
    180     def __init__(self, file_name):
    181         &#34;&#34;&#34;
    182         I return an instance of AmmosAudioReader initialized with a given file name.
    183 
    184         :param file_name: the file to read from
    185         :type file_name: str
    186         &#34;&#34;&#34;
    187         super().__init__(file_name)
    188173
    189174    def read_next_global_frame_body_data_header(self):
    … …  
    198183        header_size = AmmosAudioDataHeader.HEADER_SIZE
    199184
    200         bytes = self.ammos_file.read(header_size)
     185        in_bytes = self.ammos_file.read(header_size)
    201186
    202187        logger.info(&#34;\nReading global frame body standard data header\n&#34;)
    203         if ((not bytes) or (len(bytes) &lt; header_size)):
     188        if ((not in_bytes) or (len(in_bytes) &lt; header_size)):
    204189            logger.debug(&#34;Can not read all %s bytes of global frame body data header&#34;, header_size)
    205190            return None
    206         return AmmosAudioDataHeader.from_bytes(bytes)
     191        return AmmosAudioDataHeader.from_bytes(in_bytes)
    207192
    208193    def read_next_global_frame_body_extended_data_header(self):
    … …  
    215200        header_size = AmmosExtendedAudioDataHeader.HEADER_SIZE
    216201
    217         bytes = self.ammos_file.read(header_size)
    218 
    219         if ((not bytes) or (len(bytes) &lt; header_size)):
     202        in_bytes = self.ammos_file.read(header_size)
     203
     204        if ((not in_bytes) or (len(in_bytes) &lt; header_size)):
    220205            logger.debug(&#34;Can not read all %s bytes of global frame extended data header&#34;, header_size)
    221206            return None
    222         return AmmosExtendedAudioDataHeader.from_bytes(bytes)
     207        return AmmosExtendedAudioDataHeader.from_bytes(in_bytes)
    223208
    224209    def read_next_audio_data_body(self, number_of_samples, number_of_channels, sample_size):
    … …  
    288273        :rtype: bytes
    289274        &#34;&#34;&#34;
    290         return b&#34;&#34;.join([each.global_frame_body.data_body.pcm_for_channel(a_channel) for each in self.container.global_frames])</code></pre>
     275        return (b&#34;&#34;.join([each.global_frame_body.data_body.pcm_for_channel(a_channel)
     276                          for each in self.container.global_frames]))</code></pre>
    291277</details>
    292278<h3>Ancestors</h3>
    … …  
    318304    :rtype: bytes
    319305    &#34;&#34;&#34;
    320     return b&#34;&#34;.join([each.global_frame_body.data_body.pcm_for_channel(a_channel) for each in self.container.global_frames])</code></pre>
     306    return (b&#34;&#34;.join([each.global_frame_body.data_body.pcm_for_channel(a_channel)
     307                      for each in self.container.global_frames]))</code></pre>
    321308</details>
    322309</dd>
    … …  
    432419    header_size = AmmosAudioDataHeader.HEADER_SIZE
    433420
    434     bytes = self.ammos_file.read(header_size)
     421    in_bytes = self.ammos_file.read(header_size)
    435422
    436423    logger.info(&#34;\nReading global frame body standard data header\n&#34;)
    437     if ((not bytes) or (len(bytes) &lt; header_size)):
     424    if ((not in_bytes) or (len(in_bytes) &lt; header_size)):
    438425        logger.debug(&#34;Can not read all %s bytes of global frame body data header&#34;, header_size)
    439426        return None
    440     return AmmosAudioDataHeader.from_bytes(bytes)</code></pre>
     427    return AmmosAudioDataHeader.from_bytes(in_bytes)</code></pre>
    441428</details>
    442429</dd>
    … …  
    461448    header_size = AmmosExtendedAudioDataHeader.HEADER_SIZE
    462449
    463     bytes = self.ammos_file.read(header_size)
    464 
    465     if ((not bytes) or (len(bytes) &lt; header_size)):
     450    in_bytes = self.ammos_file.read(header_size)
     451
     452    if ((not in_bytes) or (len(in_bytes) &lt; header_size)):
    466453        logger.debug(&#34;Can not read all %s bytes of global frame extended data header&#34;, header_size)
    467454        return None
    468     return AmmosExtendedAudioDataHeader.from_bytes(bytes)</code></pre>
     455    return AmmosExtendedAudioDataHeader.from_bytes(in_bytes)</code></pre>
    469456</details>
    470457</dd>

  • doc/ammosreader/AmmosAudioSocketReader.html

    r4eb8a2f r7752d1f  
    3030<pre><code class="python">&#34;&#34;&#34;I read a Ammos datastream from a socket.&#34;&#34;&#34;
    3131
    32 import select
     32# import select
    3333import socket
    3434from collections import deque
    … …  
    3737from ammosreader.AmmosExtendedAudioDataHeader import AmmosExtendedAudioDataHeader
    3838from ammosreader.AmmosGlobalFrameHeader import AmmosGlobalFrameHeader
     39from ammosreader.AmmosConstants import AmmosAudioDemodType
    3940from ammosreader import logger
    4041
     42
    4143class AmmosAudioSocketReader:
    42     def __init__(self, socket:socket.socket):
     44    &#34;&#34;&#34;I read Ammos Audio data from a socket&#34;&#34;&#34;
     45
     46    def __init__(self, in_socket: socket.socket):
    4347        &#34;&#34;&#34;
    4448        Initializes the AmmosAudioSocketReader
    … …  
    4852        &#34;&#34;&#34;
    4953
    50         #buffer for reading socket bytewise und check for the magic word
     54        # buffer for reading socket bytewise und check for the magic word
    5155        self.__magic_word_buffer = deque(maxlen=4)
    5256
    53         #input socket to read from
    54         self.__socket = socket
     57        # input socket to read from
     58        self.__socket = in_socket
    5559
    5660    def __get_next_data(self, byte_count: int) -&gt; bytearray:
    … …  
    6973
    7074        byte_array = []
    71        
     75
    7276        while len(b&#39;&#39;.join(byte_array)) &lt; byte_count:
    73             logger.info(f&#34;Remaining Bytes: {byte_count - len(b&#39;&#39;.join(byte_array))}&#34;)
     77            logger.info(&#34;Remaining Bytes: %s&#34;, byte_count - len(b&#39;&#39;.join(byte_array)))
     78            # logger.info(f&#34;Remaining Bytes: {byte_count - len(b&#39;&#39;.join(byte_array))}&#34;)
    7479            self.__socket.settimeout(5)
    7580            new_bytes = self.__socket.recv(byte_count - len(b&#39;&#39;.join(byte_array)), socket.MSG_WAITALL)
    … …  
    7782            if not new_bytes:
    7883                raise TimeoutError(&#34;Socket timed out while reading data&#34;)
    79 
    80             logger.info(f&#34;Got {len(new_bytes)} bytes of {byte_count - len(b&#39;&#39;.join(byte_array))} ramining&#34;)
     84            logger.info(&#34;Got %s bytes of %s remaining&#34;, len(new_bytes), byte_count - len(b&#39;&#39;.join(byte_array)))
     85            # logger.info(f&#34;Got {len(new_bytes)} bytes of {byte_count - len(b&#39;&#39;.join(byte_array))} remaining&#34;)
    8186
    8287            byte_array.append(new_bytes)
    … …  
    8489        return b&#39;&#39;.join(byte_array)
    8590
    86     def __audio_data_body_to_numpy(self, audio_data_body:bytearray) -&gt; np.ndarray:
     91    def __audio_data_body_to_numpy(self, audio_data_body: bytearray) -&gt; np.ndarray:
    8792        &#34;&#34;&#34;
    8893        converts the audio data body to a numpy array
    … …  
    101106
    102107        Raises:
    103             TimeoutError: Raisees TimeoutError if the socket does not serve data anymore
     108            TimeoutError: Raises TimeoutError if the socket does not serve data anymore
    104109
    105110        Returns:
    … …  
    113118        # raise Exception if socket does not return anything
    114119        if len(new_byte) &lt; 1:
    115             raise TimeoutError     
    116 
    117         #read loop
     120            raise TimeoutError
     121
     122        # read loop
    118123        while new_byte:
    119124            #
    … …  
    121126            byte_array = b&#39;&#39;.join(self.__magic_word_buffer)
    122127
    123             if byte_array.hex() == &#39;726574fb&#39;:
    124                 #print(byte_array.hex())
     128            if byte_array.hex() == AmmosGlobalFrameHeader.MAGIC_WORD:
     129                # print(byte_array.hex())
    125130
    126131                ammos_global_header_buffer = list(self.__magic_word_buffer)
    127132                ammos_global_header_buffer.append(self.__get_next_data(20))
    128                 #while len(b&#39;&#39;.join(ammos_global_header_buffer)) &lt; 24:
     133                # while len(b&#39;&#39;.join(ammos_global_header_buffer)) &lt; 24:
    129134                #    ammos_global_header_buffer.append(self.__socket.recv(24 - len(b&#39;&#39;.join(ammos_global_header_buffer))))
    130                    
     135
    131136                ammos_global_header = AmmosGlobalFrameHeader.from_bytes(b&#39;&#39;.join(ammos_global_header_buffer))
    132137                logger.info(ammos_global_header)
    133138
    134                 if ammos_global_header.data_header_length == 44 and ammos_global_header.frame_type == 256:
    135                     byte_array_header = self.__get_next_data(44)
    136                     #while len(b&#39;&#39;.join(byte_array_header)) &lt; 44:
     139                if (ammos_global_header.data_header_length == AmmosExtendedAudioDataHeader.HEADER_SIZE and ammos_global_header.frame_type == AmmosAudioDemodType.DIGITAL):
     140
     141                    byte_array_header = self.__get_next_data(AmmosExtendedAudioDataHeader.HEADER_SIZE)
     142                    # while len(b&#39;&#39;.join(byte_array_header)) &lt; 44:
    137143                    #    byte_array_header.append(self.__socket.recv(44 - len(b&#39;&#39;.join(byte_array_header))))
    138144
    139145                    ammos_extended_audio_data_header = AmmosExtendedAudioDataHeader.from_bytes(byte_array_header)
    140                     logger.info(ammos_extended_audio_data_header.number_of_samples, ammos_extended_audio_data_header.number_of_channels, ammos_extended_audio_data_header.sample_size)
    141                     audio_body = self.__get_next_data(ammos_extended_audio_data_header.number_of_samples*
    142                                                       ammos_extended_audio_data_header.number_of_channels*
     146                    logger.debug(str(ammos_extended_audio_data_header.number_of_samples or &#39;&#39;),
     147                                 str(ammos_extended_audio_data_header.number_of_channels or &#39;&#39;),
     148                                 str(ammos_extended_audio_data_header.sample_size or &#39;&#39;))
     149
     150                    audio_body = self.__get_next_data(ammos_extended_audio_data_header.number_of_samples *
     151                                                      ammos_extended_audio_data_header.number_of_channels *
    143152                                                      ammos_extended_audio_data_header.sample_size)
    144153
    145154                    audio_array = self.__audio_data_body_to_numpy(audio_body)
    146                     logger.info(len(audio_array), len(audio_array)/ammos_extended_audio_data_header.sample_rate)
     155                    # print(&#34;44,256&#34;, len(audio_array), len(audio_array)/ammos_extended_audio_data_header.sample_rate)
     156                    logger.debug(&#34;%s, %s&#34;, len(audio_array), len(audio_array) / ammos_extended_audio_data_header.sample_rate)
    147157
    148158                    return [audio_array, ammos_extended_audio_data_header.sample_rate]
    149159
    150                 elif ammos_global_header.data_header_length == 36 and ammos_global_header.frame_type == 256:
    151                     byte_array_header = self.__get_next_data(36)
    152                     #while len(b&#39;&#39;.join(byte_array_header)) &lt; 36:
     160                elif (ammos_global_header.data_header_length == AmmosAudioDataHeader.HEADER_SIZE and ammos_global_header.frame_type == AmmosAudioDemodType.DIGITAL):
     161                    byte_array_header = self.__get_next_data(AmmosAudioDataHeader.HEADER_SIZE)
     162                    # while len(b&#39;&#39;.join(byte_array_header)) &lt; 36:
    153163                    #    byte_array_header.append(self.__socket.recv(36 - len(b&#39;&#39;.join(byte_array_header))))
    154164
    155165                    ammos_audio_data_header = AmmosAudioDataHeader.from_bytes(byte_array_header)
    156                     logger.info(ammos_audio_data_header.number_of_samples, ammos_audio_data_header.number_of_channels, ammos_audio_data_header.sample_size)
    157                     audio_body = self.__get_next_data(ammos_extended_audio_data_header.number_of_samples*
    158                                                       ammos_extended_audio_data_header.number_of_channels*
     166                    logger.debug(str(ammos_audio_data_header.number_of_samples or &#39;&#39;),
     167                                 str(ammos_audio_data_header.number_of_channels or &#39;&#39;),
     168                                 str(ammos_audio_data_header.sample_size or &#39;&#39;))
     169
     170                    audio_body = self.__get_next_data(ammos_extended_audio_data_header.number_of_samples *
     171                                                      ammos_extended_audio_data_header.number_of_channels *
    159172                                                      ammos_extended_audio_data_header.sample_size)
    160173
    161174                    audio_array = self.__audio_data_body_to_numpy(audio_body)
    162                     logger.info(len(audio_array), len(audio_array)/ammos_audio_data_header.sample_rate)
     175                    logger.debug(&#34;%s, %s&#34;, len(audio_array), len(audio_array)/ammos_audio_data_header.sample_rate)
    163176
    164177                    return [audio_array, ammos_audio_data_header.sample_rate]
    … …  
    170183            # raise Exception if socket does not return anything
    171184            if len(new_byte) &lt; 1:
    172                 raise TimeoutError   
     185                raise TimeoutError
    173186
    174187        return None</code></pre>
    … …  
    186199<dt id="ammosreader.AmmosAudioSocketReader.AmmosAudioSocketReader"><code class="flex name class">
    187200<span>class <span class="ident">AmmosAudioSocketReader</span></span>
    188 <span>(</span><span>socket: socket.socket)</span>
     201<span>(</span><span>in_socket: socket.socket)</span>
    189202</code></dt>
    190203<dd>
    191 <div class="desc"><p>Initializes the AmmosAudioSocketReader</p>
     204<div class="desc"><p>I read Ammos Audio data from a socket</p>
     205<p>Initializes the AmmosAudioSocketReader</p>
    192206<h2 id="args">Args</h2>
    193207<dl>
    … …  
    200214</summary>
    201215<pre><code class="python">class AmmosAudioSocketReader:
    202     def __init__(self, socket:socket.socket):
     216    &#34;&#34;&#34;I read Ammos Audio data from a socket&#34;&#34;&#34;
     217
     218    def __init__(self, in_socket: socket.socket):
    203219        &#34;&#34;&#34;
    204220        Initializes the AmmosAudioSocketReader
    … …  
    208224        &#34;&#34;&#34;
    209225
    210         #buffer for reading socket bytewise und check for the magic word
     226        # buffer for reading socket bytewise und check for the magic word
    211227        self.__magic_word_buffer = deque(maxlen=4)
    212228
    213         #input socket to read from
    214         self.__socket = socket
     229        # input socket to read from
     230        self.__socket = in_socket
    215231
    216232    def __get_next_data(self, byte_count: int) -&gt; bytearray:
    … …  
    229245
    230246        byte_array = []
    231        
     247
    232248        while len(b&#39;&#39;.join(byte_array)) &lt; byte_count:
    233             logger.info(f&#34;Remaining Bytes: {byte_count - len(b&#39;&#39;.join(byte_array))}&#34;)
     249            logger.info(&#34;Remaining Bytes: %s&#34;, byte_count - len(b&#39;&#39;.join(byte_array)))
     250            # logger.info(f&#34;Remaining Bytes: {byte_count - len(b&#39;&#39;.join(byte_array))}&#34;)
    234251            self.__socket.settimeout(5)
    235252            new_bytes = self.__socket.recv(byte_count - len(b&#39;&#39;.join(byte_array)), socket.MSG_WAITALL)
    … …  
    237254            if not new_bytes:
    238255                raise TimeoutError(&#34;Socket timed out while reading data&#34;)
    239 
    240             logger.info(f&#34;Got {len(new_bytes)} bytes of {byte_count - len(b&#39;&#39;.join(byte_array))} ramining&#34;)
     256            logger.info(&#34;Got %s bytes of %s remaining&#34;, len(new_bytes), byte_count - len(b&#39;&#39;.join(byte_array)))
     257            # logger.info(f&#34;Got {len(new_bytes)} bytes of {byte_count - len(b&#39;&#39;.join(byte_array))} remaining&#34;)
    241258
    242259            byte_array.append(new_bytes)
    … …  
    244261        return b&#39;&#39;.join(byte_array)
    245262
    246     def __audio_data_body_to_numpy(self, audio_data_body:bytearray) -&gt; np.ndarray:
     263    def __audio_data_body_to_numpy(self, audio_data_body: bytearray) -&gt; np.ndarray:
    247264        &#34;&#34;&#34;
    248265        converts the audio data body to a numpy array
    … …  
    261278
    262279        Raises:
    263             TimeoutError: Raisees TimeoutError if the socket does not serve data anymore
     280            TimeoutError: Raises TimeoutError if the socket does not serve data anymore
    264281
    265282        Returns:
    … …  
    273290        # raise Exception if socket does not return anything
    274291        if len(new_byte) &lt; 1:
    275             raise TimeoutError     
    276 
    277         #read loop
     292            raise TimeoutError
     293
     294        # read loop
    278295        while new_byte:
    279296            #
    … …  
    281298            byte_array = b&#39;&#39;.join(self.__magic_word_buffer)
    282299
    283             if byte_array.hex() == &#39;726574fb&#39;:
    284                 #print(byte_array.hex())
     300            if byte_array.hex() == AmmosGlobalFrameHeader.MAGIC_WORD:
     301                # print(byte_array.hex())
    285302
    286303                ammos_global_header_buffer = list(self.__magic_word_buffer)
    287304                ammos_global_header_buffer.append(self.__get_next_data(20))
    288                 #while len(b&#39;&#39;.join(ammos_global_header_buffer)) &lt; 24:
     305                # while len(b&#39;&#39;.join(ammos_global_header_buffer)) &lt; 24:
    289306                #    ammos_global_header_buffer.append(self.__socket.recv(24 - len(b&#39;&#39;.join(ammos_global_header_buffer))))
    290                    
     307
    291308                ammos_global_header = AmmosGlobalFrameHeader.from_bytes(b&#39;&#39;.join(ammos_global_header_buffer))
    292309                logger.info(ammos_global_header)
    293310
    294                 if ammos_global_header.data_header_length == 44 and ammos_global_header.frame_type == 256:
    295                     byte_array_header = self.__get_next_data(44)
    296                     #while len(b&#39;&#39;.join(byte_array_header)) &lt; 44:
     311                if (ammos_global_header.data_header_length == AmmosExtendedAudioDataHeader.HEADER_SIZE and ammos_global_header.frame_type == AmmosAudioDemodType.DIGITAL):
     312
     313                    byte_array_header = self.__get_next_data(AmmosExtendedAudioDataHeader.HEADER_SIZE)
     314                    # while len(b&#39;&#39;.join(byte_array_header)) &lt; 44:
    297315                    #    byte_array_header.append(self.__socket.recv(44 - len(b&#39;&#39;.join(byte_array_header))))
    298316
    299317                    ammos_extended_audio_data_header = AmmosExtendedAudioDataHeader.from_bytes(byte_array_header)
    300                     logger.info(ammos_extended_audio_data_header.number_of_samples, ammos_extended_audio_data_header.number_of_channels, ammos_extended_audio_data_header.sample_size)
    301                     audio_body = self.__get_next_data(ammos_extended_audio_data_header.number_of_samples*
    302                                                       ammos_extended_audio_data_header.number_of_channels*
     318                    logger.debug(str(ammos_extended_audio_data_header.number_of_samples or &#39;&#39;),
     319                                 str(ammos_extended_audio_data_header.number_of_channels or &#39;&#39;),
     320                                 str(ammos_extended_audio_data_header.sample_size or &#39;&#39;))
     321
     322                    audio_body = self.__get_next_data(ammos_extended_audio_data_header.number_of_samples *
     323                                                      ammos_extended_audio_data_header.number_of_channels *
    303324                                                      ammos_extended_audio_data_header.sample_size)
    304325
    305326                    audio_array = self.__audio_data_body_to_numpy(audio_body)
    306                     logger.info(len(audio_array), len(audio_array)/ammos_extended_audio_data_header.sample_rate)
     327                    # print(&#34;44,256&#34;, len(audio_array), len(audio_array)/ammos_extended_audio_data_header.sample_rate)
     328                    logger.debug(&#34;%s, %s&#34;, len(audio_array), len(audio_array) / ammos_extended_audio_data_header.sample_rate)
    307329
    308330                    return [audio_array, ammos_extended_audio_data_header.sample_rate]
    309331
    310                 elif ammos_global_header.data_header_length == 36 and ammos_global_header.frame_type == 256:
    311                     byte_array_header = self.__get_next_data(36)
    312                     #while len(b&#39;&#39;.join(byte_array_header)) &lt; 36:
     332                elif (ammos_global_header.data_header_length == AmmosAudioDataHeader.HEADER_SIZE and ammos_global_header.frame_type == AmmosAudioDemodType.DIGITAL):
     333                    byte_array_header = self.__get_next_data(AmmosAudioDataHeader.HEADER_SIZE)
     334                    # while len(b&#39;&#39;.join(byte_array_header)) &lt; 36:
    313335                    #    byte_array_header.append(self.__socket.recv(36 - len(b&#39;&#39;.join(byte_array_header))))
    314336
    315337                    ammos_audio_data_header = AmmosAudioDataHeader.from_bytes(byte_array_header)
    316                     logger.info(ammos_audio_data_header.number_of_samples, ammos_audio_data_header.number_of_channels, ammos_audio_data_header.sample_size)
    317                     audio_body = self.__get_next_data(ammos_extended_audio_data_header.number_of_samples*
    318                                                       ammos_extended_audio_data_header.number_of_channels*
     338                    logger.debug(str(ammos_audio_data_header.number_of_samples or &#39;&#39;),
     339                                 str(ammos_audio_data_header.number_of_channels or &#39;&#39;),
     340                                 str(ammos_audio_data_header.sample_size or &#39;&#39;))
     341
     342                    audio_body = self.__get_next_data(ammos_extended_audio_data_header.number_of_samples *
     343                                                      ammos_extended_audio_data_header.number_of_channels *
    319344                                                      ammos_extended_audio_data_header.sample_size)
    320345
    321346                    audio_array = self.__audio_data_body_to_numpy(audio_body)
    322                     logger.info(len(audio_array), len(audio_array)/ammos_audio_data_header.sample_rate)
     347                    logger.debug(&#34;%s, %s&#34;, len(audio_array), len(audio_array)/ammos_audio_data_header.sample_rate)
    323348
    324349                    return [audio_array, ammos_audio_data_header.sample_rate]
    … …  
    330355            # raise Exception if socket does not return anything
    331356            if len(new_byte) &lt; 1:
    332                 raise TimeoutError   
     357                raise TimeoutError
    333358
    334359        return None</code></pre>
    … …  
    344369<dl>
    345370<dt><code>TimeoutError</code></dt>
    346 <dd>Raisees TimeoutError if the socket does not serve data anymore</dd>
     371<dd>Raises TimeoutError if the socket does not serve data anymore</dd>
    347372</dl>
    348373<h2 id="returns">Returns</h2>
    … …  
    359384
    360385    Raises:
    361         TimeoutError: Raisees TimeoutError if the socket does not serve data anymore
     386        TimeoutError: Raises TimeoutError if the socket does not serve data anymore
    362387
    363388    Returns:
    … …  
    371396    # raise Exception if socket does not return anything
    372397    if len(new_byte) &lt; 1:
    373         raise TimeoutError     
    374 
    375     #read loop
     398        raise TimeoutError
     399
     400    # read loop
    376401    while new_byte:
    377402        #
    … …  
    379404        byte_array = b&#39;&#39;.join(self.__magic_word_buffer)
    380405
    381         if byte_array.hex() == &#39;726574fb&#39;:
    382             #print(byte_array.hex())
     406        if byte_array.hex() == AmmosGlobalFrameHeader.MAGIC_WORD:
     407            # print(byte_array.hex())
    383408
    384409            ammos_global_header_buffer = list(self.__magic_word_buffer)
    385410            ammos_global_header_buffer.append(self.__get_next_data(20))
    386             #while len(b&#39;&#39;.join(ammos_global_header_buffer)) &lt; 24:
     411            # while len(b&#39;&#39;.join(ammos_global_header_buffer)) &lt; 24:
    387412            #    ammos_global_header_buffer.append(self.__socket.recv(24 - len(b&#39;&#39;.join(ammos_global_header_buffer))))
    388                
     413
    389414            ammos_global_header = AmmosGlobalFrameHeader.from_bytes(b&#39;&#39;.join(ammos_global_header_buffer))
    390415            logger.info(ammos_global_header)
    391416
    392             if ammos_global_header.data_header_length == 44 and ammos_global_header.frame_type == 256:
    393                 byte_array_header = self.__get_next_data(44)
    394                 #while len(b&#39;&#39;.join(byte_array_header)) &lt; 44:
     417            if (ammos_global_header.data_header_length == AmmosExtendedAudioDataHeader.HEADER_SIZE and ammos_global_header.frame_type == AmmosAudioDemodType.DIGITAL):
     418
     419                byte_array_header = self.__get_next_data(AmmosExtendedAudioDataHeader.HEADER_SIZE)
     420                # while len(b&#39;&#39;.join(byte_array_header)) &lt; 44:
    395421                #    byte_array_header.append(self.__socket.recv(44 - len(b&#39;&#39;.join(byte_array_header))))
    396422
    397423                ammos_extended_audio_data_header = AmmosExtendedAudioDataHeader.from_bytes(byte_array_header)
    398                 logger.info(ammos_extended_audio_data_header.number_of_samples, ammos_extended_audio_data_header.number_of_channels, ammos_extended_audio_data_header.sample_size)
    399                 audio_body = self.__get_next_data(ammos_extended_audio_data_header.number_of_samples*
    400                                                   ammos_extended_audio_data_header.number_of_channels*
     424                logger.debug(str(ammos_extended_audio_data_header.number_of_samples or &#39;&#39;),
     425                             str(ammos_extended_audio_data_header.number_of_channels or &#39;&#39;),
     426                             str(ammos_extended_audio_data_header.sample_size or &#39;&#39;))
     427
     428                audio_body = self.__get_next_data(ammos_extended_audio_data_header.number_of_samples *
     429                                                  ammos_extended_audio_data_header.number_of_channels *
    401430                                                  ammos_extended_audio_data_header.sample_size)
    402431
    403432                audio_array = self.__audio_data_body_to_numpy(audio_body)
    404                 logger.info(len(audio_array), len(audio_array)/ammos_extended_audio_data_header.sample_rate)
     433                # print(&#34;44,256&#34;, len(audio_array), len(audio_array)/ammos_extended_audio_data_header.sample_rate)
     434                logger.debug(&#34;%s, %s&#34;, len(audio_array), len(audio_array) / ammos_extended_audio_data_header.sample_rate)
    405435
    406436                return [audio_array, ammos_extended_audio_data_header.sample_rate]
    407437
    408             elif ammos_global_header.data_header_length == 36 and ammos_global_header.frame_type == 256:
    409                 byte_array_header = self.__get_next_data(36)
    410                 #while len(b&#39;&#39;.join(byte_array_header)) &lt; 36:
     438            elif (ammos_global_header.data_header_length == AmmosAudioDataHeader.HEADER_SIZE and ammos_global_header.frame_type == AmmosAudioDemodType.DIGITAL):
     439                byte_array_header = self.__get_next_data(AmmosAudioDataHeader.HEADER_SIZE)
     440                # while len(b&#39;&#39;.join(byte_array_header)) &lt; 36:
    411441                #    byte_array_header.append(self.__socket.recv(36 - len(b&#39;&#39;.join(byte_array_header))))
    412442
    413443                ammos_audio_data_header = AmmosAudioDataHeader.from_bytes(byte_array_header)
    414                 logger.info(ammos_audio_data_header.number_of_samples, ammos_audio_data_header.number_of_channels, ammos_audio_data_header.sample_size)
    415                 audio_body = self.__get_next_data(ammos_extended_audio_data_header.number_of_samples*
    416                                                   ammos_extended_audio_data_header.number_of_channels*
     444                logger.debug(str(ammos_audio_data_header.number_of_samples or &#39;&#39;),
     445                             str(ammos_audio_data_header.number_of_channels or &#39;&#39;),
     446                             str(ammos_audio_data_header.sample_size or &#39;&#39;))
     447
     448                audio_body = self.__get_next_data(ammos_extended_audio_data_header.number_of_samples *
     449                                                  ammos_extended_audio_data_header.number_of_channels *
    417450                                                  ammos_extended_audio_data_header.sample_size)
    418451
    419452                audio_array = self.__audio_data_body_to_numpy(audio_body)
    420                 logger.info(len(audio_array), len(audio_array)/ammos_audio_data_header.sample_rate)
     453                logger.debug(&#34;%s, %s&#34;, len(audio_array), len(audio_array)/ammos_audio_data_header.sample_rate)
    421454
    422455                return [audio_array, ammos_audio_data_header.sample_rate]
    … …  
    428461        # raise Exception if socket does not return anything
    429462        if len(new_byte) &lt; 1:
    430             raise TimeoutError   
     463            raise TimeoutError
    431464
    432465    return None</code></pre>

  • doc/ammosreader/AmmosContainer.html

    r4eb8a2f r7752d1f  
    66<meta name="generator" content="pdoc 0.10.0" />
    77<title>ammosreader.AmmosContainer API documentation</title>
    8 <meta name="description" content="I store the content of an R&amp;S Ammos file in a more accessible way." />
     8<meta name="description" content="I provide an Ammos container." />
    99<link rel="preload stylesheet" as="style" href="https://cdnjs.cloudflare.com/ajax/libs/10up-sanitize.css/11.0.1/sanitize.min.css" integrity="sha256-PK9q560IAAa6WVRRh76LtCaI8pjTJ2z11v0miyNNjrs=" crossorigin>
    1010<link rel="preload stylesheet" as="style" href="https://cdnjs.cloudflare.com/ajax/libs/10up-sanitize.css/11.0.1/typography.min.css" integrity="sha256-7l/o7C8jubJiy74VsKTidCy1yBkRtiUGbVkYBylBqUg=" crossorigin>
    … …  
    2323</header>
    2424<section id="section-intro">
    25 <p>I store the content of an R&amp;S Ammos file in a more accessible way.</p>
    26 <details class="source">
    27 <summary>
    28 <span>Expand source code</span>
    29 </summary>
    30 <pre><code class="python">&#34;&#34;&#34;I store the content of an R&amp;S Ammos file in a more accessible way.&#34;&#34;&#34;
     25<p>I provide an Ammos container.</p>
     26<details class="source">
     27<summary>
     28<span>Expand source code</span>
     29</summary>
     30<pre><code class="python">&#34;&#34;&#34;I provide an Ammos container.&#34;&#34;&#34;
     31
    3132
    3233class AmmosContainer():
    33 
     34    &#34;&#34;&#34;I store the content of an R&amp;S Ammos file in a more accessible way.&#34;&#34;&#34;
    3435    def __init__(self, name, frames):
    3536        self.__name = name
    … …  
    5657
    5758    def size(self):
    58         return sum([each.global_frame_header.frame_length for each in self.__global_frames])
     59        # return sum([each.global_frame_header.frame_length for each in self.__global_frames])
     60        return sum(each.global_frame_header.frame_length for each in self.__global_frames)
    5961
    6062    def frequencies(self):
    … …  
    101103</code></dt>
    102104<dd>
    103 <div class="desc"></div>
     105<div class="desc"><p>I store the content of an R&amp;S Ammos file in a more accessible way.</p></div>
    104106<details class="source">
    105107<summary>
    … …  
    107109</summary>
    108110<pre><code class="python">class AmmosContainer():
    109 
     111    &#34;&#34;&#34;I store the content of an R&amp;S Ammos file in a more accessible way.&#34;&#34;&#34;
    110112    def __init__(self, name, frames):
    111113        self.__name = name
    … …  
    132134
    133135    def size(self):
    134         return sum([each.global_frame_header.frame_length for each in self.__global_frames])
     136        # return sum([each.global_frame_header.frame_length for each in self.__global_frames])
     137        return sum(each.global_frame_header.frame_length for each in self.__global_frames)
    135138
    136139    def frequencies(self):
    … …  
    293296</summary>
    294297<pre><code class="python">def size(self):
    295     return sum([each.global_frame_header.frame_length for each in self.__global_frames])</code></pre>
     298    # return sum([each.global_frame_header.frame_length for each in self.__global_frames])
     299    return sum(each.global_frame_header.frame_length for each in self.__global_frames)</code></pre>
    296300</details>
    297301</dd>

  • doc/ammosreader/AmmosExtendedAudioDataHeader.html

    r4eb8a2f r7752d1f  
    3939
    4040    @classmethod
    41     def from_bytes(cls, bytes):
     41    def from_bytes(cls, in_bytes):
    4242        &#34;&#34;&#34;I return a new AMMOS extended data header for audio frames built from given bytes.&#34;&#34;&#34;
    43         assert len(bytes) == cls.HEADER_SIZE
    44         standard_header = AmmosAudioDataHeader.from_bytes(bytes[0:AmmosAudioDataHeader.HEADER_SIZE])
    45         extended_header_elements = struct.unpack(&#39;&lt;Q&#39;, bytes[AmmosAudioDataHeader.HEADER_SIZE:])
     43        assert len(in_bytes) == cls.HEADER_SIZE
     44        standard_header = AmmosAudioDataHeader.from_bytes(in_bytes[0:AmmosAudioDataHeader.HEADER_SIZE])
     45        extended_header_elements = struct.unpack(&#39;&lt;Q&#39;, in_bytes[AmmosAudioDataHeader.HEADER_SIZE:])
    4646        timestamp = extended_header_elements[0]
    4747        sample_rate = standard_header.sample_rate
    … …  
    9494
    9595    @classmethod
    96     def from_bytes(cls, bytes):
     96    def from_bytes(cls, in_bytes):
    9797        &#34;&#34;&#34;I return a new AMMOS extended data header for audio frames built from given bytes.&#34;&#34;&#34;
    98         assert len(bytes) == cls.HEADER_SIZE
    99         standard_header = AmmosAudioDataHeader.from_bytes(bytes[0:AmmosAudioDataHeader.HEADER_SIZE])
    100         extended_header_elements = struct.unpack(&#39;&lt;Q&#39;, bytes[AmmosAudioDataHeader.HEADER_SIZE:])
     98        assert len(in_bytes) == cls.HEADER_SIZE
     99        standard_header = AmmosAudioDataHeader.from_bytes(in_bytes[0:AmmosAudioDataHeader.HEADER_SIZE])
     100        extended_header_elements = struct.unpack(&#39;&lt;Q&#39;, in_bytes[AmmosAudioDataHeader.HEADER_SIZE:])
    101101        timestamp = extended_header_elements[0]
    102102        sample_rate = standard_header.sample_rate
    … …  
    134134<dl>
    135135<dt id="ammosreader.AmmosExtendedAudioDataHeader.AmmosExtendedAudioDataHeader.from_bytes"><code class="name flex">
    136 <span>def <span class="ident">from_bytes</span></span>(<span>bytes)</span>
     136<span>def <span class="ident">from_bytes</span></span>(<span>in_bytes)</span>
    137137</code></dt>
    138138<dd>
    … …  
    143143</summary>
    144144<pre><code class="python">@classmethod
    145 def from_bytes(cls, bytes):
     145def from_bytes(cls, in_bytes):
    146146    &#34;&#34;&#34;I return a new AMMOS extended data header for audio frames built from given bytes.&#34;&#34;&#34;
    147     assert len(bytes) == cls.HEADER_SIZE
    148     standard_header = AmmosAudioDataHeader.from_bytes(bytes[0:AmmosAudioDataHeader.HEADER_SIZE])
    149     extended_header_elements = struct.unpack(&#39;&lt;Q&#39;, bytes[AmmosAudioDataHeader.HEADER_SIZE:])
     147    assert len(in_bytes) == cls.HEADER_SIZE
     148    standard_header = AmmosAudioDataHeader.from_bytes(in_bytes[0:AmmosAudioDataHeader.HEADER_SIZE])
     149    extended_header_elements = struct.unpack(&#39;&lt;Q&#39;, in_bytes[AmmosAudioDataHeader.HEADER_SIZE:])
    150150    timestamp = extended_header_elements[0]
    151151    sample_rate = standard_header.sample_rate

  • doc/ammosreader/AmmosExtendedIFDataHeader.html

    r4eb8a2f r7752d1f  
    3838
    3939    @classmethod
    40     def from_bytes(cls, bytes):
     40    def from_bytes(cls, in_bytes):
    4141        &#34;&#34;&#34;I return an AMMOS extended data header from given bytes.&#34;&#34;&#34;
    42         standard_header = AmmosIFDataHeader.from_bytes(bytes[0:AmmosIFDataHeader.HEADER_SIZE])
    43         extended_header_elements = struct.unpack(&#39;&lt;QQI&#39;, bytes[AmmosIFDataHeader.HEADER_SIZE:cls.HEADER_SIZE])
     42        standard_header = AmmosIFDataHeader.from_bytes(in_bytes[0:AmmosIFDataHeader.HEADER_SIZE])
     43        extended_header_elements = struct.unpack(&#39;&lt;QQI&#39;, in_bytes[AmmosIFDataHeader.HEADER_SIZE:cls.HEADER_SIZE])
    4444        block_count = standard_header.block_count
    4545        block_length = standard_header.block_length
    … …  
    5757        sample_counter = extended_header_elements[1]
    5858        antenna_correction = extended_header_elements[2]
    59         size = len(bytes)
     59        size = len(in_bytes)
    6060        return AmmosExtendedIFDataHeader(size, block_count, block_length, timestamp, status, source_id,
    6161                                         source_state, frequency, bandwidth, sample_rate, interpolation,
    … …  
    126126
    127127    @classmethod
    128     def from_bytes(cls, bytes):
     128    def from_bytes(cls, in_bytes):
    129129        &#34;&#34;&#34;I return an AMMOS extended data header from given bytes.&#34;&#34;&#34;
    130         standard_header = AmmosIFDataHeader.from_bytes(bytes[0:AmmosIFDataHeader.HEADER_SIZE])
    131         extended_header_elements = struct.unpack(&#39;&lt;QQI&#39;, bytes[AmmosIFDataHeader.HEADER_SIZE:cls.HEADER_SIZE])
     130        standard_header = AmmosIFDataHeader.from_bytes(in_bytes[0:AmmosIFDataHeader.HEADER_SIZE])
     131        extended_header_elements = struct.unpack(&#39;&lt;QQI&#39;, in_bytes[AmmosIFDataHeader.HEADER_SIZE:cls.HEADER_SIZE])
    132132        block_count = standard_header.block_count
    133133        block_length = standard_header.block_length
    … …  
    145145        sample_counter = extended_header_elements[1]
    146146        antenna_correction = extended_header_elements[2]
    147         size = len(bytes)
     147        size = len(in_bytes)
    148148        return AmmosExtendedIFDataHeader(size, block_count, block_length, timestamp, status, source_id,
    149149                                         source_state, frequency, bandwidth, sample_rate, interpolation,
    … …  
    197197<dl>
    198198<dt id="ammosreader.AmmosExtendedIFDataHeader.AmmosExtendedIFDataHeader.from_bytes"><code class="name flex">
    199 <span>def <span class="ident">from_bytes</span></span>(<span>bytes)</span>
     199<span>def <span class="ident">from_bytes</span></span>(<span>in_bytes)</span>
    200200</code></dt>
    201201<dd>
    … …  
    206206</summary>
    207207<pre><code class="python">@classmethod
    208 def from_bytes(cls, bytes):
     208def from_bytes(cls, in_bytes):
    209209    &#34;&#34;&#34;I return an AMMOS extended data header from given bytes.&#34;&#34;&#34;
    210     standard_header = AmmosIFDataHeader.from_bytes(bytes[0:AmmosIFDataHeader.HEADER_SIZE])
    211     extended_header_elements = struct.unpack(&#39;&lt;QQI&#39;, bytes[AmmosIFDataHeader.HEADER_SIZE:cls.HEADER_SIZE])
     210    standard_header = AmmosIFDataHeader.from_bytes(in_bytes[0:AmmosIFDataHeader.HEADER_SIZE])
     211    extended_header_elements = struct.unpack(&#39;&lt;QQI&#39;, in_bytes[AmmosIFDataHeader.HEADER_SIZE:cls.HEADER_SIZE])
    212212    block_count = standard_header.block_count
    213213    block_length = standard_header.block_length
    … …  
    225225    sample_counter = extended_header_elements[1]
    226226    antenna_correction = extended_header_elements[2]
    227     size = len(bytes)
     227    size = len(in_bytes)
    228228    return AmmosExtendedIFDataHeader(size, block_count, block_length, timestamp, status, source_id,
    229229                                     source_state, frequency, bandwidth, sample_rate, interpolation,

  • doc/ammosreader/AmmosGlobalFrameHeader.html

    r4eb8a2f r7752d1f  
    3939
    4040    @classmethod
    41     def from_bytes(cls, bytes):
     41    def from_bytes(cls, in_bytes):
    4242        &#34;&#34;&#34;I create a new AmmosGlobalFrameHeader from bytes.&#34;&#34;&#34;
    43         assert len(bytes) == cls.HEADER_SIZE
    44 
    45         elements = struct.unpack(&#39;&lt;4s4s4s4s4s4s&#39;, bytes)
     43        assert len(in_bytes) == cls.HEADER_SIZE
     44
     45        elements = struct.unpack(&#39;&lt;4s4s4s4s4s4s&#39;, in_bytes)
    4646
    4747        magic_word = elements[0].hex()
    … …  
    116116
    117117    @classmethod
    118     def from_bytes(cls, bytes):
     118    def from_bytes(cls, in_bytes):
    119119        &#34;&#34;&#34;I create a new AmmosGlobalFrameHeader from bytes.&#34;&#34;&#34;
    120         assert len(bytes) == cls.HEADER_SIZE
    121 
    122         elements = struct.unpack(&#39;&lt;4s4s4s4s4s4s&#39;, bytes)
     120        assert len(in_bytes) == cls.HEADER_SIZE
     121
     122        elements = struct.unpack(&#39;&lt;4s4s4s4s4s4s&#39;, in_bytes)
    123123
    124124        magic_word = elements[0].hex()
    … …  
    179179<dl>
    180180<dt id="ammosreader.AmmosGlobalFrameHeader.AmmosGlobalFrameHeader.from_bytes"><code class="name flex">
    181 <span>def <span class="ident">from_bytes</span></span>(<span>bytes)</span>
     181<span>def <span class="ident">from_bytes</span></span>(<span>in_bytes)</span>
    182182</code></dt>
    183183<dd>
    … …  
    188188</summary>
    189189<pre><code class="python">@classmethod
    190 def from_bytes(cls, bytes):
     190def from_bytes(cls, in_bytes):
    191191    &#34;&#34;&#34;I create a new AmmosGlobalFrameHeader from bytes.&#34;&#34;&#34;
    192     assert len(bytes) == cls.HEADER_SIZE
    193 
    194     elements = struct.unpack(&#39;&lt;4s4s4s4s4s4s&#39;, bytes)
     192    assert len(in_bytes) == cls.HEADER_SIZE
     193
     194    elements = struct.unpack(&#39;&lt;4s4s4s4s4s4s&#39;, in_bytes)
    195195
    196196    magic_word = elements[0].hex()

  • doc/ammosreader/AmmosIFDataBlockHeader.html

    r4eb8a2f r7752d1f  
    3636
    3737    @classmethod
    38     def from_bytes(cls, bytes):
     38    def from_bytes(cls, in_bytes):
    3939        &#34;&#34;&#34;I return an AMMOS IF data block header built from bytes.&#34;&#34;&#34;
    40         assert len(bytes) == cls.HEADER_SIZE
    41         elements = struct.unpack(&#39;&lt;ccH&#39;, bytes)
     40        assert len(in_bytes) == cls.HEADER_SIZE
     41        elements = struct.unpack(&#39;&lt;ccH&#39;, in_bytes)
    4242        header = cls()
    4343        first_entry = int.from_bytes(elements[0], byteorder=&#39;little&#39;)
    … …  
    125125
    126126    @classmethod
    127     def from_bytes(cls, bytes):
     127    def from_bytes(cls, in_bytes):
    128128        &#34;&#34;&#34;I return an AMMOS IF data block header built from bytes.&#34;&#34;&#34;
    129         assert len(bytes) == cls.HEADER_SIZE
    130         elements = struct.unpack(&#39;&lt;ccH&#39;, bytes)
     129        assert len(in_bytes) == cls.HEADER_SIZE
     130        elements = struct.unpack(&#39;&lt;ccH&#39;, in_bytes)
    131131        header = cls()
    132132        first_entry = int.from_bytes(elements[0], byteorder=&#39;little&#39;)
    … …  
    198198<dl>
    199199<dt id="ammosreader.AmmosIFDataBlockHeader.AmmosIFDataBlockHeader.from_bytes"><code class="name flex">
    200 <span>def <span class="ident">from_bytes</span></span>(<span>bytes)</span>
     200<span>def <span class="ident">from_bytes</span></span>(<span>in_bytes)</span>
    201201</code></dt>
    202202<dd>
    … …  
    207207</summary>
    208208<pre><code class="python">@classmethod
    209 def from_bytes(cls, bytes):
     209def from_bytes(cls, in_bytes):
    210210    &#34;&#34;&#34;I return an AMMOS IF data block header built from bytes.&#34;&#34;&#34;
    211     assert len(bytes) == cls.HEADER_SIZE
    212     elements = struct.unpack(&#39;&lt;ccH&#39;, bytes)
     211    assert len(in_bytes) == cls.HEADER_SIZE
     212    elements = struct.unpack(&#39;&lt;ccH&#39;, in_bytes)
    213213    header = cls()
    214214    first_entry = int.from_bytes(elements[0], byteorder=&#39;little&#39;)

  • doc/ammosreader/AmmosIFDataHeader.html

    r4eb8a2f r7752d1f  
    4040
    4141    @classmethod
    42     def from_bytes(cls, bytes):
     42    def from_bytes(cls, in_bytes):
    4343        &#34;&#34;&#34;I return an AMMOS data header from given bytes.&#34;&#34;&#34;
    44         assert len(bytes) == cls.HEADER_SIZE
    45         elements = struct.unpack(&#39;&lt;IIQIIIQIIIIi&#39;, bytes)
     44        assert len(in_bytes) == cls.HEADER_SIZE
     45        elements = struct.unpack(&#39;&lt;IIQIIIQIIIIi&#39;, in_bytes)
    4646        block_count = elements[0]
    4747        block_length = int(elements[1])*4
    … …  
    7777        self.voltage_ref = voltage_ref
    7878
    79     def __str_(self):
     79    def __str__(self):
    8080        output = (&#34;\nGlobal frame body data header\n&#34; +
    8181                  &#34;-----------------------------\n&#34; +
    … …  
    115115
    116116    @classmethod
    117     def from_bytes(cls, bytes):
     117    def from_bytes(cls, in_bytes):
    118118        &#34;&#34;&#34;I return an AMMOS data header from given bytes.&#34;&#34;&#34;
    119         assert len(bytes) == cls.HEADER_SIZE
    120         elements = struct.unpack(&#39;&lt;IIQIIIQIIIIi&#39;, bytes)
     119        assert len(in_bytes) == cls.HEADER_SIZE
     120        elements = struct.unpack(&#39;&lt;IIQIIIQIIIIi&#39;, in_bytes)
    121121        block_count = elements[0]
    122122        block_length = int(elements[1])*4
    … …  
    152152        self.voltage_ref = voltage_ref
    153153
    154     def __str_(self):
     154    def __str__(self):
    155155        output = (&#34;\nGlobal frame body data header\n&#34; +
    156156                  &#34;-----------------------------\n&#34; +
    … …  
    173173<dl>
    174174<dt id="ammosreader.AmmosIFDataHeader.AmmosIFDataHeader.from_bytes"><code class="name flex">
    175 <span>def <span class="ident">from_bytes</span></span>(<span>bytes)</span>
     175<span>def <span class="ident">from_bytes</span></span>(<span>in_bytes)</span>
    176176</code></dt>
    177177<dd>
    … …  
    182182</summary>
    183183<pre><code class="python">@classmethod
    184 def from_bytes(cls, bytes):
     184def from_bytes(cls, in_bytes):
    185185    &#34;&#34;&#34;I return an AMMOS data header from given bytes.&#34;&#34;&#34;
    186     assert len(bytes) == cls.HEADER_SIZE
    187     elements = struct.unpack(&#39;&lt;IIQIIIQIIIIi&#39;, bytes)
     186    assert len(in_bytes) == cls.HEADER_SIZE
     187    elements = struct.unpack(&#39;&lt;IIQIIIQIIIIi&#39;, in_bytes)
    188188    block_count = elements[0]
    189189    block_length = int(elements[1])*4

  • doc/ammosreader/AmmosIFReader.html

    r4eb8a2f r7752d1f  
    3939from ammosreader import logger
    4040
     41
    4142class AmmosIFReader(AbstractAmmosReader):
    4243    &#34;&#34;&#34;I read the IF data embedded in an R&amp;S AMMOS recording.&#34;&#34;&#34;
    4344
    44     def __init__(self, file_name):
    45         super().__init__(file_name)
    46 
    4745    def read_next_global_frame_body_data_header(self):
    48 
     46        &#34;&#34;&#34;I read the next data header of a global frame body from current position in file.&#34;&#34;&#34;
    4947        header_size = AmmosIFDataHeader.HEADER_SIZE
    5048
    51         bytes = self.ammos_file.read(header_size)
     49        in_bytes = self.ammos_file.read(header_size)
    5250
    5351        logger.info(&#34;\nReading global frame body standard data header\n&#34;)
    54         if ((not bytes) or (len(bytes) &lt; header_size)):
     52        if ((not in_bytes) or (len(in_bytes) &lt; header_size)):
    5553            logger.debug(&#34;Can not read all %s bytes of global frame body data header&#34;, header_size)
    5654            return None
    57         return AmmosIFDataHeader.from_bytes(bytes)
     55        return AmmosIFDataHeader.from_bytes(in_bytes)
    5856
    5957    def read_next_global_frame_body_extended_data_header(self):
    … …  
    6664        header_size = AmmosExtendedIFDataHeader.HEADER_SIZE
    6765
    68         bytes = self.ammos_file.read(header_size)
     66        in_bytes = self.ammos_file.read(header_size)
    6967
    7068        logger.info(&#34;\nReading global frame body extended data header\n&#34;)
    71         if ((not bytes) or (len(bytes) &lt; header_size)):
     69        if ((not in_bytes) or (len(in_bytes) &lt; header_size)):
    7270            logger.debug(&#34;Can not read all %s bytes of global frame extended data header&#34;, header_size)
    7371            return None
    74         return AmmosExtendedIFDataHeader.from_bytes(bytes)
     72        return AmmosExtendedIFDataHeader.from_bytes(in_bytes)
    7573
    7674    def read_next_if_data_body(self, number_of_data_blocks, data_length):
    … …  
    132130
    133131    def payload(self):
     132        &#34;&#34;&#34;I return just the pure date (payload) from my container.&#34;&#34;&#34;
    134133        return b&#34;&#34;.join([each.global_frame_body.data_body.payload for each in self.container.global_frames])</code></pre>
    135134</details>
    … …  
    161160    &#34;&#34;&#34;I read the IF data embedded in an R&amp;S AMMOS recording.&#34;&#34;&#34;
    162161
    163     def __init__(self, file_name):
    164         super().__init__(file_name)
    165 
    166162    def read_next_global_frame_body_data_header(self):
    167 
     163        &#34;&#34;&#34;I read the next data header of a global frame body from current position in file.&#34;&#34;&#34;
    168164        header_size = AmmosIFDataHeader.HEADER_SIZE
    169165
    170         bytes = self.ammos_file.read(header_size)
     166        in_bytes = self.ammos_file.read(header_size)
    171167
    172168        logger.info(&#34;\nReading global frame body standard data header\n&#34;)
    173         if ((not bytes) or (len(bytes) &lt; header_size)):
     169        if ((not in_bytes) or (len(in_bytes) &lt; header_size)):
    174170            logger.debug(&#34;Can not read all %s bytes of global frame body data header&#34;, header_size)
    175171            return None
    176         return AmmosIFDataHeader.from_bytes(bytes)
     172        return AmmosIFDataHeader.from_bytes(in_bytes)
    177173
    178174    def read_next_global_frame_body_extended_data_header(self):
    … …  
    185181        header_size = AmmosExtendedIFDataHeader.HEADER_SIZE
    186182
    187         bytes = self.ammos_file.read(header_size)
     183        in_bytes = self.ammos_file.read(header_size)
    188184
    189185        logger.info(&#34;\nReading global frame body extended data header\n&#34;)
    190         if ((not bytes) or (len(bytes) &lt; header_size)):
     186        if ((not in_bytes) or (len(in_bytes) &lt; header_size)):
    191187            logger.debug(&#34;Can not read all %s bytes of global frame extended data header&#34;, header_size)
    192188            return None
    193         return AmmosExtendedIFDataHeader.from_bytes(bytes)
     189        return AmmosExtendedIFDataHeader.from_bytes(in_bytes)
    194190
    195191    def read_next_if_data_body(self, number_of_data_blocks, data_length):
    … …  
    251247
    252248    def payload(self):
     249        &#34;&#34;&#34;I return just the pure date (payload) from my container.&#34;&#34;&#34;
    253250        return b&#34;&#34;.join([each.global_frame_body.data_body.payload for each in self.container.global_frames])</code></pre>
    254251</details>
    … …  
    264261</code></dt>
    265262<dd>
    266 <div class="desc"></div>
     263<div class="desc"><p>I return just the pure date (payload) from my container.</p></div>
    267264<details class="source">
    268265<summary>
    … …  
    270267</summary>
    271268<pre><code class="python">def payload(self):
     269    &#34;&#34;&#34;I return just the pure date (payload) from my container.&#34;&#34;&#34;
    272270    return b&#34;&#34;.join([each.global_frame_body.data_body.payload for each in self.container.global_frames])</code></pre>
    273271</details>
    … …  
    315313</code></dt>
    316314<dd>
    317 <div class="desc"></div>
     315<div class="desc"><p>I read the next data header of a global frame body from current position in file.</p></div>
    318316<details class="source">
    319317<summary>
    … …  
    321319</summary>
    322320<pre><code class="python">def read_next_global_frame_body_data_header(self):
    323 
     321    &#34;&#34;&#34;I read the next data header of a global frame body from current position in file.&#34;&#34;&#34;
    324322    header_size = AmmosIFDataHeader.HEADER_SIZE
    325323
    326     bytes = self.ammos_file.read(header_size)
     324    in_bytes = self.ammos_file.read(header_size)
    327325
    328326    logger.info(&#34;\nReading global frame body standard data header\n&#34;)
    329     if ((not bytes) or (len(bytes) &lt; header_size)):
     327    if ((not in_bytes) or (len(in_bytes) &lt; header_size)):
    330328        logger.debug(&#34;Can not read all %s bytes of global frame body data header&#34;, header_size)
    331329        return None
    332     return AmmosIFDataHeader.from_bytes(bytes)</code></pre>
     330    return AmmosIFDataHeader.from_bytes(in_bytes)</code></pre>
    333331</details>
    334332</dd>
    … …  
    353351    header_size = AmmosExtendedIFDataHeader.HEADER_SIZE
    354352
    355     bytes = self.ammos_file.read(header_size)
     353    in_bytes = self.ammos_file.read(header_size)
    356354
    357355    logger.info(&#34;\nReading global frame body extended data header\n&#34;)
    358     if ((not bytes) or (len(bytes) &lt; header_size)):
     356    if ((not in_bytes) or (len(in_bytes) &lt; header_size)):
    359357        logger.debug(&#34;Can not read all %s bytes of global frame extended data header&#34;, header_size)
    360358        return None
    361     return AmmosExtendedIFDataHeader.from_bytes(bytes)</code></pre>
     359    return AmmosExtendedIFDataHeader.from_bytes(in_bytes)</code></pre>
    362360</details>
    363361</dd>

  • doc/ammosreader/AmmosSingleFrame.html

    r4eb8a2f r7752d1f  
    4848                                                          (self.global_frame_body.data_header.block_count *
    4949                                                           (self.global_frame_body.data_header.block_length + 4))))
    50     # FIXME: Use str method instead
    51 
    5250    def __str__(self):
    5351        output = (
    … …  
    102100                                                          (self.global_frame_body.data_header.block_count *
    103101                                                           (self.global_frame_body.data_header.block_length + 4))))
    104     # FIXME: Use str method instead
    105 
    106102    def __str__(self):
    107103        output = (

  • doc/ammosreader/IQDWTXBlock.html

    r4eb8a2f r7752d1f  
    3434    @classmethod
    3535    def from_bytes(cls, byte_string):
    36         pdw = PDW.from_bytes(bytes[0:32])
    37         return IQDWTXBLOCK(pdw, bytes[32:])
     36        pdw = PDW.from_bytes(byte_string[0:32])
     37        return IQDWTXBLOCK(pdw, byte_string[32:])
    3838
    3939    def __init__(self, pdw, iq):
    … …  
    6666    @classmethod
    6767    def from_bytes(cls, byte_string):
    68         pdw = PDW.from_bytes(bytes[0:32])
    69         return IQDWTXBLOCK(pdw, bytes[32:])
     68        pdw = PDW.from_bytes(byte_string[0:32])
     69        return IQDWTXBLOCK(pdw, byte_string[32:])
    7070
    7171    def __init__(self, pdw, iq):
    … …  
    8787<pre><code class="python">@classmethod
    8888def from_bytes(cls, byte_string):
    89     pdw = PDW.from_bytes(bytes[0:32])
    90     return IQDWTXBLOCK(pdw, bytes[32:])</code></pre>
     89    pdw = PDW.from_bytes(byte_string[0:32])
     90    return IQDWTXBLOCK(pdw, byte_string[32:])</code></pre>
    9191</details>
    9292</dd>

  • doc/ammosreader/PPDWContainer.html

    r4eb8a2f r7752d1f  
    2727<span>Expand source code</span>
    2828</summary>
    29 <pre><code class="python">import numpy as np
    30 from datetime import datetime
    31 
     29<pre><code class="python">from datetime import datetime
     30import numpy as np
    3231
    3332class PPDWContainer():
    … …  
    9392
    9493    def start_time(self):
    95         return min([each.time_of_arrival for each in self.signals])
     94        return min(each.time_of_arrival for each in self.signals)
    9695
    9796    def end_time(self):
    98         return max([each.time_of_arrival for each in self.signals])
     97        return max(each.time_of_arrival for each in self.signals)
    9998
    10099    def to_json(self):
    … …  
    196195
    197196    def start_time(self):
    198         return min([each.time_of_arrival for each in self.signals])
     197        return min(each.time_of_arrival for each in self.signals)
    199198
    200199    def end_time(self):
    201         return max([each.time_of_arrival for each in self.signals])
     200        return max(each.time_of_arrival for each in self.signals)
    202201
    203202    def to_json(self):
    … …  
    295294</summary>
    296295<pre><code class="python">def end_time(self):
    297     return max([each.time_of_arrival for each in self.signals])</code></pre>
     296    return max(each.time_of_arrival for each in self.signals)</code></pre>
    298297</details>
    299298</dd>
    … …  
    362361</summary>
    363362<pre><code class="python">def start_time(self):
    364     return min([each.time_of_arrival for each in self.signals])</code></pre>
     363    return min(each.time_of_arrival for each in self.signals)</code></pre>
    365364</details>
    366365</dd>

  • doc/ammosreader/PPDWReader.html

    r4eb8a2f r7752d1f  
    2727<span>Expand source code</span>
    2828</summary>
    29 <pre><code class="python">from pathlib import Path
     29<pre><code class="python">from ammosreader.PDW import PDW
     30from ammosreader.PPDWContainer import PPDWContainer
     31from ammosreader import logger
    3032
    31 from ammosreader.PDW import PDW
    32 from ammosreader.PPDWContainer import PPDWContainer
    3333
    3434class PPDWReader():
     35    &#34;&#34;&#34;I read data from a file and return a PPDWContainer.&#34;&#34;&#34;
    3536
    3637    def __init__(self, a_file):
    … …  
    4849                assert len(current_bytes) == 32
    4950                if not current_bytes:
    50                     # print(&#39;End of file detected&#39;)
     51                    logger.info(&#39;End of file detected&#39;)
    5152                    break
    5253                if self.cursor + 32 &gt;= len(self.content):
    53                     # print(&#39;Can not read all 32 bytes of next PDW. EOF&#39;)
     54                    logger.info(&#39;Can not read all 32 bytes of next PDW. EOF&#39;)
    5455                    break
    5556                self.container.add(PDW.from_bytes(current_bytes))
    … …  
    7475</code></dt>
    7576<dd>
    76 <div class="desc"></div>
     77<div class="desc"><p>I read data from a file and return a PPDWContainer.</p></div>
    7778<details class="source">
    7879<summary>
    … …  
    8081</summary>
    8182<pre><code class="python">class PPDWReader():
     83    &#34;&#34;&#34;I read data from a file and return a PPDWContainer.&#34;&#34;&#34;
    8284
    8385    def __init__(self, a_file):
    … …  
    9597                assert len(current_bytes) == 32
    9698                if not current_bytes:
    97                     # print(&#39;End of file detected&#39;)
     99                    logger.info(&#39;End of file detected&#39;)
    98100                    break
    99101                if self.cursor + 32 &gt;= len(self.content):
    100                     # print(&#39;Can not read all 32 bytes of next PDW. EOF&#39;)
     102                    logger.info(&#39;Can not read all 32 bytes of next PDW. EOF&#39;)
    101103                    break
    102104                self.container.add(PDW.from_bytes(current_bytes))
    … …  
    123125            assert len(current_bytes) == 32
    124126            if not current_bytes:
    125                 # print(&#39;End of file detected&#39;)
     127                logger.info(&#39;End of file detected&#39;)
    126128                break
    127129            if self.cursor + 32 &gt;= len(self.content):
    128                 # print(&#39;Can not read all 32 bytes of next PDW. EOF&#39;)
     130                logger.info(&#39;Can not read all 32 bytes of next PDW. EOF&#39;)
    129131                break
    130132            self.container.add(PDW.from_bytes(current_bytes))

  • doc/ammosreader/index.html

    r4eb8a2f r7752d1f  
    8181<dt><code class="name"><a title="ammosreader.AmmosContainer" href="AmmosContainer.html">ammosreader.AmmosContainer</a></code></dt>
    8282<dd>
    83 <div class="desc"><p>I store the content of an R&amp;S Ammos file in a more accessible way.</p></div>
     83<div class="desc"><p>I provide an Ammos container.</p></div>
    8484</dd>
    8585<dt><code class="name"><a title="ammosreader.AmmosExtendedAudioDataHeader" href="AmmosExtendedAudioDataHeader.html">ammosreader.AmmosExtendedAudioDataHeader</a></code></dt>
Note: See TracChangeset for help on using the changeset viewer.