Add files via upload

Author: ReikaNekoUwU

morsecode.py

@@ -0,0 +1,211 @@
+# -*- coding: utf-8 -*-
+"""
+Morse binary framing (Python 2 + 3 compatible)
+
+Frame:
+  STX (0x02)  ...payload...  ETX (0x03)
+
+Within payload:
+  Each character is encoded as a "binary Morse" string using '1' and '0'
+  Characters are separated by GS (0x1D)
+
+Binary Morse timing (classic units):
+  dot  = "1"
+  dash = "111"
+  intra-element gap (between dots/dashes within a character) = "0"
+
+Word separation:
+  If you include spaces in plaintext, this code uses RS (0x1E) between words.
+  (You can remove that if you don't want word support.)
+"""
+
+from __future__ import print_function
+import io
+
+STX = b"\x02"
+ETX = b"\x03"
+GS  = b"\x1D"   # Group Separator: between characters
+RS  = b"\x1E"   # Record Separator: between words (optional)
+
+# International Morse (basic set). Add more punctuation if you want.
+_TEXT_TO_MORSE = {
+    "A": ".-",    "B": "-...",  "C": "-.-.",  "D": "-..",   "E": ".",
+    "F": "..-.",  "G": "--.",   "H": "....",  "I": "..",    "J": ".---",
+    "K": "-.-",   "L": ".-..",  "M": "--",    "N": "-.",    "O": "---",
+    "P": ".--.",  "Q": "--.-",  "R": ".-.",   "S": "...",   "T": "-",
+    "U": "..-",   "V": "...-",  "W": ".--",   "X": "-..-",  "Y": "-.--",
+    "Z": "--..",
+    "0": "-----", "1": ".----", "2": "..---", "3": "...--", "4": "....-",
+    "5": ".....", "6": "-....", "7": "--...", "8": "---..", "9": "----.",
+    ".": ".-.-.-", ",": "--..--", "?": "..--..", "'": ".----.",
+    "!": "-.-.--", "/": "-..-.",  "(": "-.--.",  ")": "-.--.-",
+    "&": ".-...",  ":": "---...", ";": "-.-.-.", "=": "-...-",
+    "+": ".-.-.",  "-": "-....-", "_": "..--.-", '"': ".-..-.",
+    "$": "...-..-", "@": ".--.-."
+}
+
+_MORSE_TO_TEXT = {v: k for (k, v) in _TEXT_TO_MORSE.items()}
+
+
+def _to_bytes(s):
+    """Accepts str/bytes in Py2/3; returns bytes."""
+    if isinstance(s, bytes):
+        return s
+    # Python 2: unicode, Python 3: str
+    return s.encode("utf-8")
+
+
+def _to_text(s):
+    """Accepts str/bytes in Py2/3; returns text (unicode in Py2, str in Py3)."""
+    if isinstance(s, bytes):
+        return s.decode("utf-8", "strict")
+    return s
+
+
+def _morse_to_binary(morse):
+    """
+    Convert ".-" to binary using:
+      dot="1", dash="111", intra-element gap="0"
+    Example: ".-" -> "1" + "0" + "111" = "10111"
+    """
+    parts = []
+    for i, sym in enumerate(morse):
+        if sym == ".":
+            parts.append("1")
+        elif sym == "-":
+            parts.append("111")
+        else:
+            raise ValueError("Invalid Morse symbol: %r" % sym)
+        if i != len(morse) - 1:
+            parts.append("0")
+    return "".join(parts)
+
+
+def _binary_to_morse(bits):
+    """
+    Convert binary back to ".-" by reading runs of 1s separated by 0s:
+      "1"   => dot
+      "111" => dash
+    """
+    if not bits:
+        raise ValueError("Empty character payload")
+
+    # Validate characters
+    for ch in bits:
+        if ch not in ("0", "1"):
+            raise ValueError("Non-binary character in payload: %r" % ch)
+
+    # Split into runs of 1s (elements) by 0 gaps
+    elems = [run for run in bits.split("0") if run != ""]
+    morse = []
+    for run in elems:
+        if run == "1":
+            morse.append(".")
+        elif run == "111":
+            morse.append("-")
+        else:
+            raise ValueError("Invalid 1-run length %d in %r (expected 1 or 3)" %
+                             (len(run), bits))
+    return "".join(morse)
+
+
+def encode_text_to_morse_binary(text, use_word_sep=True):
+    """
+    Encode plaintext to framed bytes:
+      STX + (charbits joined by GS, words by RS) + ETX
+
+    Returns: bytes
+    """
+    t = _to_text(text).upper()
+
+    words = t.split(" ") if use_word_sep else [t.replace(" ", "")]
+    encoded_words = []
+
+    for w in words:
+        char_chunks = []
+        for ch in w:
+            if ch not in _TEXT_TO_MORSE:
+                raise ValueError("Unsupported character: %r" % ch)
+            morse = _TEXT_TO_MORSE[ch]
+            bits = _morse_to_binary(morse)
+            char_chunks.append(bits)
+        # Join characters with GS
+        encoded_words.append(GS.join(_to_bytes(c) for c in char_chunks))
+
+    payload = (RS.join(encoded_words) if use_word_sep else encoded_words[0])
+    return STX + payload + ETX
+
+
+def decode_morse_binary_to_text(data, use_word_sep=True):
+    """
+    Decode framed bytes back to plaintext.
+    Expects:
+      STX ... ETX
+      characters separated by GS
+      words separated by RS (if use_word_sep=True)
+
+    Returns: text (unicode in Py2, str in Py3)
+    """
+    b = _to_bytes(data)
+
+    # Find first STX and the next ETX after it
+    stx_i = b.find(STX)
+    if stx_i < 0:
+        raise ValueError("Missing STX framing byte")
+    etx_i = b.find(ETX, stx_i + 1)
+    if etx_i < 0:
+        raise ValueError("Missing ETX framing byte")
+
+    payload = b[stx_i + 1:etx_i]
+
+    if payload == b"":
+        return _to_text(b"")
+
+    word_blobs = payload.split(RS) if use_word_sep else [payload]
+    out_words = []
+
+    for wb in word_blobs:
+        if wb == b"":
+            out_words.append("")
+            continue
+
+        char_blobs = [x for x in wb.split(GS) if x != b""]
+        chars = []
+        for cb in char_blobs:
+            bits = _to_text(cb)
+            morse = _binary_to_morse(bits)
+            if morse not in _MORSE_TO_TEXT:
+                raise ValueError("Unknown Morse sequence: %r (from bits %r)" % (morse, bits))
+            chars.append(_MORSE_TO_TEXT[morse])
+        out_words.append("".join(chars))
+
+    return " ".join(out_words) if use_word_sep else "".join(out_words)
+
+def send_morse_code(url, text, use_word_sep=True):
+    outfile = io.BytesIO(encode_text_to_morse_binary(text, use_word_sep))
+    outfile.seek(0)
+    return pywwwget.upload_file_to_internet_file(outfile, url)
+
+def recv_morse_code(url, use_word_sep=True):
+    infile = pywwwget.download_file_from_internet_file(url)
+    infile.seek(0)
+    return decode_morse_binary_to_text(infile.read(), use_word_sep)
+    
+
+# --- Optional helpers for debugging/printing ---
+def pretty_show(encoded_bytes):
+    """
+    Make control characters visible:
+      STX -> <STX>, ETX -> <ETX>, GS -> <GS>, RS -> <RS>
+    """
+    b = _to_bytes(encoded_bytes)
+    s = b.replace(STX, b"<STX>").replace(ETX, b"<ETX>").replace(GS, b"<GS>").replace(RS, b"<RS>")
+    return _to_text(s)
+
+
+if __name__ == "__main__":
+    msg = "SOS HELP"
+    enc = encode_text_to_morse_binary(msg, use_word_sep=True)
+    print("Encoded:", pretty_show(enc))
+    dec = decode_morse_binary_to_text(enc, use_word_sep=True)
+    print("Decoded:", dec)