rpps 0.0.1__tar.gz

rpps-0.0.1/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2024 Anonoei
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

rpps-0.0.1/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.1
+Name: rpps
+Version: 0.0.1
+Summary: RF Parameter Processor Suite
+Author-email: Anonoei <dev@anonoei.com>
+Project-URL: Homepage, https://github.com/anonoei/RPPS
+Project-URL: Documentation, https://anonoei.github.io/RPPS/
+Project-URL: Repository, https://github.com/Anonoei/RPPS.git
+Project-URL: Issues, https://github.com/Anonoei/RPPS/issues
+Project-URL: Source, https://github.com/anonoei/RPPS
+Keywords: anonoei,dsp,sdr
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: twine; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: bumpver; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pdoc3; extra == "dev"
+
+# RPPS
+ RF Parameter Processor Suite
+
+RPPS is a generic signal processor/generator library.
+
+ - [Documentation](https://anonoei.github.io/RPPS/)
+ - [PyPI](https://pypi.org/project/rpps/)
+
+## Install
+1. Run `python3 -m pip install rpps`
+2. In your project, `import rpps as rp`
+
+## Roadmap
+ - [ ] Pre-processing
+ - [ ] Modulation
+   - [ ] PSK
+     - [X] QPSK
+   - [ ] QAM
+   - [ ] APSK
+   - [ ] ASK
+   - [ ] FSK
+ - [ ] Coding
+   - [ ] Block
+     - [X] Repetition
+     - [ ] LDPC
+     - [ ] TPC
+   - [ ] Convolutional
+     - [ ] Viterbi
+ - [ ] De-scramble
+   - [ ] v.35
+ - [ ] De-frame
+   - [ ] HDLC
+   - [ ] PPP

rpps-0.0.1/README.md

@@ -0,0 +1,33 @@
+# RPPS
+ RF Parameter Processor Suite
+
+RPPS is a generic signal processor/generator library.
+
+ - [Documentation](https://anonoei.github.io/RPPS/)
+ - [PyPI](https://pypi.org/project/rpps/)
+
+## Install
+1. Run `python3 -m pip install rpps`
+2. In your project, `import rpps as rp`
+
+## Roadmap
+ - [ ] Pre-processing
+ - [ ] Modulation
+   - [ ] PSK
+     - [X] QPSK
+   - [ ] QAM
+   - [ ] APSK
+   - [ ] ASK
+   - [ ] FSK
+ - [ ] Coding
+   - [ ] Block
+     - [X] Repetition
+     - [ ] LDPC
+     - [ ] TPC
+   - [ ] Convolutional
+     - [ ] Viterbi
+ - [ ] De-scramble
+   - [ ] v.35
+ - [ ] De-frame
+   - [ ] HDLC
+   - [ ] PPP

rpps-0.0.1/pyproject.toml

@@ -0,0 +1,54 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "rpps"
+version = "0.0.1"
+description = "RF Parameter Processor Suite"
+dependencies = []
+requires-python = ">=3.6"
+authors = [
+    {name = "Anonoei", email="dev@anonoei.com"}
+]
+readme = "README.md"
+keywords = ["anonoei", "dsp", "sdr"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+
+    "Intended Audience :: Developers",
+
+    "License :: OSI Approved :: MIT License",
+
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+
+[project.urls]
+Homepage = "https://github.com/anonoei/RPPS"
+Documentation = "https://anonoei.github.io/RPPS/"
+Repository = "https://github.com/Anonoei/RPPS.git"
+Issues = "https://github.com/Anonoei/RPPS/issues"
+Source = "https://github.com/anonoei/RPPS"
+
+[project.optional-dependencies]
+dev = ["twine", "build", "black", "bumpver", "pytest", "pdoc3"]
+
+[tool.bumpver]
+current_version = "0.0.1"
+version_pattern = "MAJOR.MINOR.PATCH"
+commit_message = "bump version {old_version} -> {new_version}"
+tag_message = "{new_version}"
+tag_scope = "default"
+pre_commit_hook = ""
+post_commit_hook = ""
+commit = true
+tag = true
+push = false
+
+[tool.bumpver.file_patterns]
+"pyproject.toml" = [
+    'current_version = "{version}"',
+    'version = "{version}"'
+]
+"src/RPPS/__init__.py" = ["{version}"]

rpps-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

rpps-0.0.1/src/rpps/__init__.py

@@ -0,0 +1,20 @@
+"""
+Initialize RPPS
+"""
+
+__version__ = "0.0.1"
+__author__ = "Anonoei <dev@anonoei.com>"
+
+
+from pyboiler.logger import Logger, Level
+
+Logger("RPPS", Level.TRACE)
+
+# Import helpers/globals
+from .helpers import bitarray, Stream
+from .meta import Meta
+
+
+from . import coding
+from . import mod
+from . import viz

rpps-0.0.1/src/rpps/coding/__init__.py

@@ -0,0 +1,14 @@
+# Import helpers/globals
+from ..helpers.bitarray import bitarray
+from ..helpers.stream import Stream
+from ..meta import Meta
+
+# -----
+
+from .coding import Coding
+
+from .block import Block
+from .convolutional import Convolutional
+
+from ._blk import *
+from ._cnv import *

rpps-0.0.1/src/rpps/coding/_blk/__init__.py

@@ -0,0 +1 @@
+from .repetition import Repetition

rpps-0.0.1/src/rpps/coding/_blk/repetition.py

@@ -0,0 +1,27 @@
+from ..block import Block
+from .. import Stream
+from .. import bitarray
+
+import numpy as np
+
+class Repetition(Block):
+    def __init__(self, num, den):
+        super().__init__(num, den, den)
+
+    def encode(self, data: Stream):
+        encoded_data = bitarray()
+        for bit in data.bitarray:
+            for _ in range(self.length):
+                encoded_data.append(bit)
+        return encoded_data
+
+    def decode(self, encoded_data: bitarray):
+        decoded_data = bitarray()
+        for i in range(0, len(encoded_data), self.length):
+            bits = encoded_data[i:i+self.length]
+            diff = self.length - sum(bits)
+            if self.length/2 > diff:
+                decoded_data.append(1)
+            else:
+                decoded_data.append(0)
+        return decoded_data

rpps-0.0.1/src/rpps/coding/_cnv/__init__.py

@@ -0,0 +1 @@
+from .viterbi import Viterbi

rpps-0.0.1/src/rpps/coding/_cnv/viterbi.py

@@ -0,0 +1,77 @@
+from ..convolutional import Convolutional
+from .. import Stream
+from .. import bitarray
+
+import numpy as np
+
+class Viterbi(Convolutional):
+    def encode(self, data: Stream):
+        """
+        SOVA (Soft-Output Viterbi Algorithm) encoding
+        :param data: stream of arbitrary data
+        :param rate: encoding rate (e.g. 7/8)
+        :return: encoded data and trellis diagram
+        """
+        # Calculate the number of systematic bits and redundant bits
+        N_systematic = int(self._rate * len(data.bitarray))
+        N_redundant = len(data.bitarray) - N_systematic
+
+        # Initialize the trellis diagram
+        T = np.zeros((2, 2), dtype=int)
+        T[0, :] = [1, 0]  # initial state
+
+        # Encode the data
+        encoded_data = bitarray()
+        for i in range(len(data.bitarray)):
+            if i < N_systematic:
+                x = data.bitarray[i]
+            else:
+                x = np.random.randint(2)  # add a random bit for redundancy
+            y = T[:, -1].copy()  # get the previous state
+            T[:, -1] = [x, x ^ y[0]]  # update the trellis diagram
+            encoded_data.append(int(y[0]))
+            encoded_data.append(int(y[1]))
+            #encoded_data.extend([int(y[0]), int(y[1])])
+
+        return encoded_data, T
+
+    def decode(self, encoded_data):
+        """
+        SOVA (Soft-Output Viterbi Algorithm) decoding
+        :param encoded_data: encoded data
+        :param rate: encoding rate (e.g. 7/8)
+        :return: decoded data
+        """
+        # Calculate the number of systematic bits and redundant bits
+        N_systematic = int(self._rate * len(encoded_data.bitarray))
+        N_redundant = len(encoded_data.bitarray) - N_systematic
+
+        # Initialize the trellis diagram
+        T = np.zeros((2, 2), dtype=int)
+        T[0, :] = [1, 0]  # initial state
+
+        # Define the transition probabilities (trellis diagram)
+        P = np.array([[1/2, 1/2], [1/2, 1/2]])  # for a rate-1/2 convolutional code
+        P = np.kron(P, np.ones((2, 2)))  # repeat the transition probabilities
+
+
+        # Initialize the likelihoods and state sequences
+        L = np.zeros((len(encoded_data.bitarray), 2))  # likelihoods
+        S = np.zeros(len(encoded_data.bitarray), dtype=int)  # state sequence
+
+        # Iterate over the codeword
+        for i in range(len(encoded_data.bitarray)):
+            # Calculate the likelihoods for each possible state
+            #L[i, :] = P[T[:, -1].copy(), :] * (encoded_data.bitarray[i] == T[-1, :])
+            L[i, :] = P[:, S[i]] * (encoded_data.bitarray[i] == T[0, :])
+
+            # Update the state sequence and trellis diagram
+            S[i] = np.argmax(L[i])
+            T[:, -1] = T[S[i], :]  # update the trellis diagram
+
+        # Extract the decoded data from the state sequence
+        decoded_data = bitarray()
+        for i in range(N_systematic):
+            decoded_data.append(S[N_systematic + i])
+
+        return decoded_data

rpps-0.0.1/src/rpps/coding/block.py

@@ -0,0 +1,7 @@
+
+from .coding import Coding
+
+class Block(Coding):
+    def __init__(self, num, den, length):
+        super().__init__(num, den)
+        self.length = length

rpps-0.0.1/src/rpps/coding/coding.py

@@ -0,0 +1,11 @@
+class Coding:
+    def __init__(self, num, den):
+        self.num = num
+        self.den = den
+        self._rate = self.num/self.den
+
+    def encode(self, data):
+        pass
+
+    def decode(self, data):
+        pass

rpps-0.0.1/src/rpps/coding/convolutional.py

@@ -0,0 +1,5 @@
+
+from .coding import Coding
+
+class Convolutional(Coding):
+    pass

rpps-0.0.1/src/rpps/helpers/__init__.py

@@ -0,0 +1,3 @@
+from . import binary
+from .bitarray import bitarray
+from .stream import Stream

rpps-0.0.1/src/rpps/helpers/binary.py

@@ -0,0 +1,43 @@
+# Encoding
+
+def bytes_to_hex(data: bytes):
+    return data.hex()
+
+def hex_to_bits(data):
+    bits = ""
+    for i in range(0, len(data), 2):
+        int_data = int(data[i:i+2], 16)
+        bit_data = bin(int_data)[2:]
+        padding = (len(bit_data) % 8)
+        if not padding == 0:
+            bit_data = "0" * (8 - padding) + bit_data
+        bits += bit_data
+        #input(f"0x{data[i:i+2]} = 0i{int_data}, 0b{bit_data}")
+    return bits
+
+def bytes_to_bits(data):
+    return hex_to_bits(bytes_to_hex(data))
+
+
+# Decoding
+
+def bits_to_hex(bits):
+    data_hex = ""
+    for i in range(0, len(bits), 8):
+        int_data = int(bits[i:i+8], 2)
+        hex_data = hex(int_data)[2:]
+        padding = (len(hex_data) % 2)
+        if not padding == 0:
+            hex_data = "0" * (2 - padding) + hex_data
+        data_hex += hex_data
+        #input(f"0b{bits[i:i+8]} = 0i{int_data}, 0x{hex_data}")
+    return data_hex
+
+def hex_to_bytes(data):
+    return bytes.fromhex(data)
+
+def bits_to_bytes(data):
+    return hex_to_bytes(bits_to_hex(data))
+
+class Encoding:
+    pass

rpps-0.0.1/src/rpps/helpers/bitarray.py

@@ -0,0 +1,48 @@
+import numpy as np
+
+class bitarray:
+    def __init__(self, arr=None):
+        if arr is None:
+            arr = np.array([], dtype=np.bool)
+        self.arr = arr
+
+    def __str__(self):
+        return str(self.arr)
+
+    def __len__(self):
+        return len(self.arr)
+
+    def append(self, bit):
+        self.arr = np.append(self.arr, bit)
+
+    @staticmethod
+    def from_encoding(enc):
+        return bitarray(
+            np.unpackbits(
+                np.array(bytearray(enc.bytes), dtype=np.uint8)
+            )
+        )
+
+    def to_bytes(self) -> bytes:
+        return bytes(np.packbits(self.arr))
+
+    def bits(self):
+        return self.arr
+
+    def bytes(self):
+        return np.packbits(self.arr)
+
+    def astype(self, *args, **kwargs):
+        return self.arr.astype(*args, **kwargs)
+
+    def __iter__(self):
+        return self.arr.__iter__()
+
+    def __getattr__(self, key):
+        return self.arr
+
+    def __getitem__(self, key):
+        return self.arr[key]
+
+    def __setitem__(self, key, val):
+        self.arr[key] = val

rpps-0.0.1/src/rpps/helpers/stream.py

@@ -0,0 +1,107 @@
+from .bitarray import bitarray
+
+class Stream:
+    __slots__ = ("cache", "length")
+
+    def __init__(self):
+        self.cache = {
+            "bin": None,
+            "hex": None,
+            "bytes": None,
+            "int": None,
+            "bitarray": None,
+        }
+        self.length = None
+
+    def __str__(self):
+        return f"0x{self.hex}"
+
+    def __repr__(self):
+        return f"<Encoded data>"
+
+    @property
+    def bin(self):
+        if self.cache["bin"] is None:
+            #self.cache["bin"] = Encoding._pad(bin(self.cache["int"])[2:], 8)
+            self.cache["bin"] = "".join([item for item in self.bitarray.astype(str)])
+        return self.cache["bin"]
+
+    @bin.setter
+    def bin(self, data):
+        self.cache["bin"] = data
+
+    @property
+    def hex(self):
+        if self.cache["hex"] is None:
+            self.cache["hex"] = Stream._pad(hex(self.cache["int"])[2:], 2)
+        return self.cache["hex"]
+
+    @hex.setter
+    def hex(self, data):
+        self.cache["hex"] = data
+
+    @property
+    def bytes(self):
+        if self.cache["bytes"] is None:
+            if self.cache["hex"] is None:
+                self.hex
+            self.cache["bytes"] = bytes.fromhex(self.cache["hex"])
+        return self.cache["bytes"]
+
+    @bytes.setter
+    def bytes(self, data):
+        self.cache["bytes"] = data
+
+    @property
+    def int(self):
+        return self.cache["int"]
+
+    @property
+    def bitarray(self):
+        if self.cache["bitarray"] is None:
+            self.cache["bitarray"] = bitarray.from_encoding(self)
+        return self.cache["bitarray"]
+
+    @staticmethod
+    def from_bin(binary, length = None):
+        enc = Stream()
+        enc.cache["bin"] = Stream._pad(binary, 8)
+        enc.cache["int"] = int(binary, 2)
+        enc.length = length
+        return enc
+
+    @classmethod
+    def from_hex(hexadecimal, length = None):
+        enc = Stream()
+        enc.cache["hex"] = Stream._pad(hexadecimal, 2)
+        enc.cache["int"] = int(hexadecimal, 16)
+        enc.length = length
+        return enc
+
+    @staticmethod
+    def from_bytes(byte, length = None):
+        enc = Stream()
+        enc.cache["bytes"] = byte
+        enc.cache["int"] = int.from_bytes(byte)
+        enc.length = length
+        return enc
+
+    @staticmethod
+    def from_int(int, length = None):
+        enc = Stream()
+        enc.cache["int"] = int
+        enc.length = length
+        return enc
+
+    @staticmethod
+    def _pad(data, mod, fill = "0"):
+        padding = len(data) % mod
+        if not padding == 0:
+            data = fill * (mod - padding) + data
+        return data
+
+    def slice(self, field, size):
+        idx = 0
+        while idx < len(self.cache[field]):
+            yield self.cache[field][idx:idx+size]
+            idx += size

rpps-0.0.1/src/rpps/meta.py

@@ -0,0 +1,38 @@
+import pathlib
+
+class Meta:
+    mod = ""
+    fmt = ""
+    fec = ""
+
+    def serialize(self, data):
+        path = pathlib.Path(f"data/{self.to_name()}")
+        data.tofile(path) # Save to file
+        return path
+
+    def to_name(self):
+        fields = [
+            self.mod.lower(),
+            self.fmt,
+            "rpps",
+            "iq",
+        ]
+        return ".".join(fields)
+
+    @staticmethod
+    def from_name(name: str, meta = None):
+        if meta is None:
+            meta = Meta()
+        fields = name.split(".")
+        meta.mod = fields[0].upper()
+        meta.fmt = fields[1]
+        return meta
+
+    @staticmethod
+    def from_file(path, meta = None):
+        import numpy as np
+        if isinstance(path, str):
+            path = pathlib.Path(path)
+        meta = Meta.from_name(path.name, meta)
+        symbols = np.fromfile(path, getattr(np, meta.fmt))
+        return meta, symbols

rpps-0.0.1/src/rpps/mod/__init__.py

@@ -0,0 +1,11 @@
+# Import helpers/globals
+from ..helpers.bitarray import bitarray
+from ..helpers.stream import Stream
+from ..meta import Meta
+
+# -----
+
+from .modulation import Modulation
+from .constellation import Mapping, Maps, Points, Constellation
+
+from ._psk import *

rpps-0.0.1/src/rpps/mod/_psk/__init__.py

@@ -0,0 +1 @@
+from .qpsk import QPSK

rpps-0.0.1/src/rpps/mod/_psk/qpsk.py

@@ -0,0 +1,31 @@
+from ..psk import PSK
+
+from ..constellation import Mapping, Maps, Points
+
+class QPSK(PSK):
+    points = Points(
+        [
+            .7 - .7j, -.7 - .7j,
+            .7 + .7j, -.7 + .7j
+        ]
+    )
+    maps = Maps(
+        [
+            Mapping([
+                0, 1,
+                2, 3,
+            ]),
+            Mapping([
+                0, 2,
+                1, 3,
+            ]),
+            Mapping([
+                3, 1,
+                2, 0,
+            ]),
+            Mapping([
+                3, 2,
+                1, 0,
+            ]),
+        ]
+    )

rpps-0.0.1/src/rpps/mod/constellation.py

@@ -0,0 +1,239 @@
+import math
+import numpy as np
+
+from pyboiler.logger import Logger, Level
+
+from . import Stream
+from . import Meta
+
+
+class Mapping:
+    __slots__ = ("arr")
+
+    def __init__(self, map=None):
+        if isinstance(map, int):
+            map = np.array([0] * map)
+        elif not isinstance(map, np.ndarray):
+            map = np.array(map)
+        elif map is None:
+            map = np.array([])
+        self.arr = map
+
+    @staticmethod
+    def new(map):
+        return Mapping(map)
+
+    @staticmethod
+    def empty(length: int):
+        return Mapping(length)
+
+    def __len__(self):
+        return len(self.arr)
+
+    def __str__(self):
+        return str(self.arr)
+
+    def __getitem__(self, item):
+        return self.arr[item]
+
+    def __setitem__(self, item, val):
+        self.arr[item] = val
+
+
+class Maps:
+    __slots__ = ("maps")
+
+    def __init__(self, maps):
+        self.maps = maps
+
+    def __len__(self):
+        return len(self.maps)
+
+    def __getitem__(self, item):
+        return self.maps[item]
+
+    def __setitem__(self, item, val):
+        self.maps[item] = val
+
+class Points:
+    __slots__ = ("arr")
+
+    def __init__(self, points):
+        self.arr = np.array(points)
+
+    def __len__(self):
+        return len(self.arr)
+
+    def __str__(self):
+        return str(self.arr)
+
+    def __getitem__(self, item):
+        return self.arr[item]
+
+    def __setitem__(self, item, val):
+        self.arr[item] = val
+
+
+class Constellation:
+    __slots__ = ("log", "_points", "_mapping", "_bps")
+
+    def __init__(self, points: Points, mapping = None, log=Logger().Child("Modulation")):
+        self.log = log.Child("Constellation", Level.WARN)
+        if not isinstance(points, Points):
+            points = Points(points)
+        self._points = points
+
+        if mapping is None:
+            mapping = Mapping()
+        self._mapping = mapping
+
+        self._bps = int(math.log2(len(self.points))) # Bits per symbol
+
+    def __str__(self) -> str:
+        return f"Points: {self._points}, Map: {self._mapping}"
+
+    def __repr__(self) -> str:
+        return f"<Constellation: {self._bps}>"
+
+    def __len__(self) -> int:
+        return len(self._points)
+
+    @property
+    def points(self):
+        return self._points
+
+    @points.setter
+    def points(self, points):
+        self._points = np.array(points)
+        self._bps = len(self.points) // 2
+
+    @property
+    def mapping(self):
+        return self._mapping
+
+    @mapping.setter
+    def mapping(self, map):
+        self._mapping = np.array(map)
+
+    @property
+    def bits_per_symbol(self):
+        return self._bps
+
+
+    def modulate(self, data: Stream, meta: Meta, noise: bool = True):
+        indexes = self.index(data, meta)
+        points = self.map(indexes, meta)
+        symbols = self.to_symbols(points, meta, noise=noise)
+        return symbols
+
+    def demodulate(self, symbols, meta: Meta):
+        points = self.from_symbols(symbols, meta)
+        indexes = self.unmap(points, meta)
+        data = self.unindex(indexes, meta)
+        return data
+
+
+    ##############################
+    #  Modulate
+    ##############################
+
+    def index(self, data: Stream, meta):
+        self.log.trace(f"Data is {data}")
+        self.log.trace(f"Data bitarray is {data.bitarray}")
+
+        padding = len(data.bin) % self._bps
+        if not padding == 0:
+            self.log.trace(f"Padding by {padding}")
+            for _ in range(0, (self._bps - padding)):
+                data.bitarray.append(0)
+        num_symbols = len(data.bitarray) // self._bps
+
+        self.log.trace(f"Data requires {num_symbols} indexes to encode")
+
+        indexes = np.split(data.bitarray.arr, num_symbols)
+        indexes = [int(f"{data[0]}{data[1]}", 2) for data in indexes]
+        #for i in range(0, len(data.bin), self._bps):
+        #    bit_int = int(data.bin[i:i+self._bps], 2)
+        #    indexes.append(int(bit_int))
+
+        self.log.trace(f"Indexes are {indexes}")
+        return indexes
+
+    def map(self, indexes, meta):
+        self.log.trace(f"Using mapping: {self.mapping}")
+        points = []
+        for idx in indexes:
+            points.append(
+                int(
+                    np.where(self.mapping.arr == idx)[0][0]
+                )
+            )
+        self.log.trace(f"Points are {points}")
+        return points
+
+    def to_symbols(self, points, meta, noise: bool = True):
+        points = np.array(points)
+        symbols = self.points[points]
+        self.log.trace(f"Symbols are:\n{symbols}")
+        # Add noise
+        if noise:
+            n = (np.random.randn(len(symbols)) + 1j*np.random.randn(len(symbols)))/np.sqrt(2) # AWGN with unity power
+            symbols = symbols + n * np.sqrt(0.01) # noise power of 0.01
+
+        symbols = symbols.astype(np.complex64)
+        meta.fmt = type(symbols[0]).__name__
+        self.log.trace(f"Symbols are: {symbols}")
+        return symbols
+
+    ##############################
+    #  Demodulate
+    ##############################
+
+    def from_symbols(self, symbols, meta, clean: bool=True):
+        #self.log.trace(f"Symbols are:\n{symbols}")
+        points = []
+        if clean:
+            syms = []
+            for symbol in symbols: # Clean up the symbols
+                diff = np.abs(self.points - symbol)
+                index = np.argmin(diff)
+                closest = self.points[index]
+                syms.append(closest)
+            syms = np.array(syms)
+            self.log.trace(f"Symbols are:\n{syms}")
+
+            for symbol in syms:
+                points.append(int(np.where(self.points == symbol)[0][0]))
+        else:
+            self.log.trace(f"Symbols are:\n{symbols}")
+            for symbol in symbols: # Clean up the symbols
+                diff = np.abs(self.points - symbol)
+                index = np.argmin(diff)
+                points.append(int(index))
+        self.log.trace(f"Points are {points}")
+        return points
+
+    def unmap(self, points, meta):
+        self.log.trace(f"Using mapping: {self.mapping}")
+        indexes = []
+        for pnt in points:
+            indexes.append(int(self.mapping[pnt]))
+        self.log.trace(f"Indexes are {indexes}")
+        return indexes
+
+    def unindex(self, indexes, meta):
+        bits = ""
+        for i in range(0, len(indexes), 1):
+            cur_bits = bin(indexes[i])[2:]
+            if len(cur_bits) == 1:
+                cur_bits = "0" + cur_bits
+            bits += cur_bits
+
+        data = Stream.from_bin(bits)
+
+        self.log.trace(f"Data bits are {data.bin}")
+
+        self.log.trace(f"Data hex is {data.hex}")
+        self.log.trace(f"Data is {data.bytes}")
+
+        return data

rpps-0.0.1/src/rpps/mod/identify.py

@@ -0,0 +1,3 @@
+
+def Identify():
+    pass

rpps-0.0.1/src/rpps/mod/modulation.py

@@ -0,0 +1,61 @@
+import numpy as np
+
+from pyboiler.logger import Logger, Level
+
+from . import Meta
+from . import Stream
+
+from .constellation import Maps, Points
+from .constellation import Constellation
+
+
+class Modulation:
+    __slots__ = ("log", "constellation", "map")
+    points = Points([])
+    maps = Maps([])
+
+    def __init__(self, map_idx: int = None):  # type: ignore
+        self.log = Logger().Child("Modulation").Child(type(self).__name__)
+        self.map = map_idx
+        if self.map is not None:
+            self.constellation = Constellation(
+                type(self).points,
+                type(self).maps[self.map],
+                log=self.log)
+        else:
+            self.constellation = Constellation(
+                type(self).points,
+                log=self.log)
+
+    def demodulate(self, symbols: np.ndarray, meta=Meta()):
+        if self.map is None:
+            raise Exception("A map must be provided to demodulate!")
+
+        data = self.constellation.demodulate(symbols, meta)
+
+        return data, meta
+
+    def modulate(self, data: Stream, meta=Meta()):
+        if self.map is None:
+            raise Exception("A map must be provided to modulate!")
+
+        symbols = self.constellation.modulate(data, meta)
+
+        meta.mod = type(self).__name__
+        return symbols, meta
+
+
+class ASK(Modulation):
+    pass
+
+
+class FSK(Modulation):
+    pass
+
+
+class APSK(Modulation):
+    pass
+
+
+class QAM(Modulation):
+    pass

rpps-0.0.1/src/rpps/mod/psk.py

@@ -0,0 +1,4 @@
+from . import Modulation
+
+class PSK(Modulation):
+    pass

rpps-0.0.1/src/rpps/viz/__init__.py

@@ -0,0 +1,9 @@
+# Import helpers/globals
+from ..helpers.bitarray import bitarray
+from ..helpers.stream import Stream
+from ..meta import Meta
+
+# -----
+
+from .generic import show
+from .constellation import draw as DrawConstellation

rpps-0.0.1/src/rpps/viz/constellation.py

@@ -0,0 +1,22 @@
+import numpy as np
+import matplotlib.pyplot as plt
+
+from . import Meta
+
+def draw(data, meta: Meta):
+    fig = plt.figure()
+    ax = fig.add_subplot()
+    plt.plot(np.real(data), np.imag(data), '.')
+
+    plt.grid(True)
+    plt.title(f"{meta.mod} encoded data")
+    plt.xlim(1.2, -1.2)
+    plt.ylim(1.2, -1.2)
+    ax.set_aspect('equal', adjustable='box')
+
+    # Draw unit circle
+    angle = np.linspace( 0 , 2 * np.pi , 150 )
+    radius = 1
+    x = radius * np.cos( angle )
+    y = radius * np.sin( angle )
+    plt.plot(x, y)

rpps-0.0.1/src/rpps/viz/generic.py

@@ -0,0 +1,4 @@
+import matplotlib.pyplot as plt
+
+def show():
+    plt.show()

rpps-0.0.1/src/rpps.egg-info/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.1
+Name: rpps
+Version: 0.0.1
+Summary: RF Parameter Processor Suite
+Author-email: Anonoei <dev@anonoei.com>
+Project-URL: Homepage, https://github.com/anonoei/RPPS
+Project-URL: Documentation, https://anonoei.github.io/RPPS/
+Project-URL: Repository, https://github.com/Anonoei/RPPS.git
+Project-URL: Issues, https://github.com/Anonoei/RPPS/issues
+Project-URL: Source, https://github.com/anonoei/RPPS
+Keywords: anonoei,dsp,sdr
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: twine; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: bumpver; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pdoc3; extra == "dev"
+
+# RPPS
+ RF Parameter Processor Suite
+
+RPPS is a generic signal processor/generator library.
+
+ - [Documentation](https://anonoei.github.io/RPPS/)
+ - [PyPI](https://pypi.org/project/rpps/)
+
+## Install
+1. Run `python3 -m pip install rpps`
+2. In your project, `import rpps as rp`
+
+## Roadmap
+ - [ ] Pre-processing
+ - [ ] Modulation
+   - [ ] PSK
+     - [X] QPSK
+   - [ ] QAM
+   - [ ] APSK
+   - [ ] ASK
+   - [ ] FSK
+ - [ ] Coding
+   - [ ] Block
+     - [X] Repetition
+     - [ ] LDPC
+     - [ ] TPC
+   - [ ] Convolutional
+     - [ ] Viterbi
+ - [ ] De-scramble
+   - [ ] v.35
+ - [ ] De-frame
+   - [ ] HDLC
+   - [ ] PPP

rpps-0.0.1/src/rpps.egg-info/SOURCES.txt

@@ -0,0 +1,32 @@
+LICENSE
+README.md
+pyproject.toml
+src/rpps/__init__.py
+src/rpps/meta.py
+src/rpps.egg-info/PKG-INFO
+src/rpps.egg-info/SOURCES.txt
+src/rpps.egg-info/dependency_links.txt
+src/rpps.egg-info/requires.txt
+src/rpps.egg-info/top_level.txt
+src/rpps/coding/__init__.py
+src/rpps/coding/block.py
+src/rpps/coding/coding.py
+src/rpps/coding/convolutional.py
+src/rpps/coding/_blk/__init__.py
+src/rpps/coding/_blk/repetition.py
+src/rpps/coding/_cnv/__init__.py
+src/rpps/coding/_cnv/viterbi.py
+src/rpps/helpers/__init__.py
+src/rpps/helpers/binary.py
+src/rpps/helpers/bitarray.py
+src/rpps/helpers/stream.py
+src/rpps/mod/__init__.py
+src/rpps/mod/constellation.py
+src/rpps/mod/identify.py
+src/rpps/mod/modulation.py
+src/rpps/mod/psk.py
+src/rpps/mod/_psk/__init__.py
+src/rpps/mod/_psk/qpsk.py
+src/rpps/viz/__init__.py
+src/rpps/viz/constellation.py
+src/rpps/viz/generic.py

rpps-0.0.1/src/rpps.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

rpps-0.0.1/src/rpps.egg-info/requires.txt

@@ -0,0 +1,8 @@
+
+[dev]
+twine
+build
+black
+bumpver
+pytest
+pdoc3

rpps-0.0.1/src/rpps.egg-info/top_level.txt

@@ -0,0 +1 @@
+rpps