codava-codec/codava.py at main · v80dn/codava-codec · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
import codecs

special_encoding = {
    "\n": 0,
    " ": 34,
    "!": 59,
    "@": 60,
    "#": 61,
    "$": 62,
    "%": 63,
    "^": 110,
    "&": 98,
    "(": 47,
    ")": 48,
    "_": 99,
    "-": 54,
    "+": 53,
    "=": 45,
    "[": 49,
    "]": 50,
    "{": 100,
    "}": 101,
    ";": 102,
    ":": 46,
    "'": 57,
    '"': 58,
    "\\": 103,
    "|": 104,
    ",": 51,
    ".": 52,
    "<": 105,
    ">": 106,
    "/": 56,
    "?": 107,
    "`": 108,
    "~": 109,
    "*": 55,
    "0": 35, "1": 36, "2": 37, "3": 38, "4": 39,
    "5": 40, "6": 41, "7": 42, "8": 43, "9": 44,
}


def encode(text):
    encoded_bytes = bytearray()

    for char in text:
        if char in special_encoding:
            encoded_bytes.append(special_encoding[char])

        elif "а" <= char.lower() <= "я":
            position = ord(char.lower()) - 1071
            if char.isupper():
                encoded_bytes.append(position + 64)
            else:
                encoded_bytes.append(position)

        elif "a" <= char.lower() <= "z":
            position = ord(char.lower()) - 96
            if char.isupper():
                encoded_bytes.append(position + 192)
            else:
                encoded_bytes.append(position + 128)
    return bytes(encoded_bytes)

def decode(text_bytes):
    special_decoding = {value: key for key, value in special_encoding.items()}

    result = []

    for byte in text_bytes:

        if byte in special_decoding:
            result.append(special_decoding[byte])
        elif byte >= 128:
            leftover = byte - 128
            if leftover >= 64:
                leftover = leftover - 64
                result.append(chr(leftover + 96).upper())
            else:
                result.append(chr(leftover + 96))
        else:
            if byte >= 64:
                position = byte - 64
                result.append(chr(position + 1071).upper())
            else:
                result.append(chr(byte + 1071))

    return "".join(result)

def codec_encode(text, errors="strict"):
    return encode(text), len(text)

def codec_decode(text, errors="strict"):
    return decode(text), len(text)

def save_secret(filename, text):
    with open(filename, "w", encoding="codava") as f:
        f.write(text)

def load_secret(filename):
    try:
        with open(filename, "r", encoding="codava") as f:
            return f.read()
    except FileNotFoundError:
        return ""

class Codec(codecs.Codec):
    def encode(self, input: str, errors: str = "strict"):
        return encode(input), len(input)
    def decode(self, input, errors="strict"):
        return decode(input), len(input)

class IncrementalEncoder(codecs.IncrementalEncoder):
    def encode(self, input: str, final=False):
        return codec_encode(input, self.errors)[0]

class IncrementalDecoder(codecs.IncrementalDecoder):
    def decode(self, input, final=False):
        return codec_decode(input, self.errors)[0]

class StreamWriter(Codec, codecs.StreamWriter):
    pass
class StreamReader(Codec, codecs.StreamReader):
    pass

def function_search(encoding_name):
    if encoding_name.lower() == "codava":
        return codecs.CodecInfo(
            name="codava",
            encode=codec_encode,
            decode=codec_decode,
            incrementalencoder=IncrementalEncoder,
            incrementaldecoder=IncrementalDecoder,
            streamwriter=StreamWriter,
            streamreader=StreamReader
        )
    return None
codecs.register(function_search)