def decode(self, ctext: T) -> Optional[U]:
"""
Performs Octal decoding
"""
str_converted = []
octal_seq = ctext.split(" ")
if len(octal_seq) == 1:
# Concatted octal must be formed of octal triplets
if len(ctext) % 3 != 0:
return None
octal_seq = [ctext[i : i + 3] for i in range(0, len(ctext), 3)]
logger.trace(f"Trying chunked octal {octal_seq}")
try:
for octal_char in octal_seq:
if len(octal_char) > 3:
logger.trace("Octal subseq too long")
return None
n = int(octal_char, 8)
if (
n < 0
): # n cannot be greater than 255, as we checked that with the earlier length check
logger.trace(f"Non octal char {octal_char}")
return None
str_converted.append(n)
return bytes(str_converted)
# Catch bad octal chars
except ValueError:
return None
def decode(self, ctext: T) -> Optional[U]:
result = ""
switch_to_digit_map = 0
if re.search("^[01]{5}$", ctext.split()[0]):
for i in ctext.split():
if i == "11011":
switch_to_digit_map = 1
if i == "11111":
switch_to_digit_map = 0
if switch_to_digit_map == 1:
result += self.BAUDOT_DICT["+" + i]
if switch_to_digit_map == 0:
result += self.BAUDOT_DICT[i]
return result
else:
return None
def decode(self, ctext: T) -> Optional[U]:
try:
output = ""
combinations = ctext.split(" ")
for fragment in combinations:
output += self.TABLE.get(fragment)
return output
except Exception as e:
return None
def decode(self, ctext: T) -> Optional[U]:
logger.trace("Attempting Morse code decoder")
char_boundary = word_boundary = None
char_boundary = word_boundary = None
char_priority = word_priority = 0
# Custom loop allows early break
for i in ctext:
i_priority = self.BOUNDARIES.get(i)
if i_priority is None:
if i in self.ALLOWED:
continue
logger.trace(f"Non-morse char '{i}' found")
return None
if i_priority <= char_priority or i == char_boundary or i == word_boundary:
continue
# Default to having a char boundary over a word boundary
if (i_priority > word_priority and word_boundary is None
and char_boundary is not None):
word_priority = i_priority
word_boundary = i
continue
char_priority = i_priority
char_boundary = i
logger.trace(
f"Char boundary is unicode {ord(char_boundary)}, and word boundary is unicode {ord(word_boundary) if word_boundary is not None else None}"
)
result = ""
for word in ctext.split(word_boundary) if word_boundary else [ctext]:
logger.trace(f"Attempting to decode word {word}")
for char in word.split(char_boundary):
char = char.translate(self.PURGE)
if len(char) == 0:
continue
try:
m = self.MORSE_CODE_DICT_INV[char]
except KeyError:
logger.trace(f"Invalid codeword '{char}' found")
return None
result = result + m
# after every word add a space
result = result + " "
if len(result) == 0:
logger.trace("Morse code failed to match")
return None
# Remove trailing space
result = result[:-1]
logger.debug(f"Morse code successful, returning {result}")
return result.strip().upper()
def decode(self, ctext: T) -> Optional[U]:
"""
Performs Tap code decoding
"""
try:
result = ""
combinations = ctext.split(" ")
for fragment in combinations:
result += self.TABLE.get(fragment)
return result
except Exception:
return None
def decode(self, ctext: T) -> Optional[U]:
"""Write the code that decodes here
ctext -> the input to the function
returns string
"""
ret = ""
switch_to_digit_map = 0
if type(ctext) == str:
if re.search("^[01]{5}$", ctext.split()[0]):
for i in ctext.split():
if i == "11011":
switch_to_digit_map = 1
if i == "11111":
switch_to_digit_map = 0
if switch_to_digit_map == 1:
ret += self.BAUDOT_DICT["+" + i]
if switch_to_digit_map == 0:
ret += self.BAUDOT_DICT[i]
return ret
else:
return None
def decode(self, ctext: T) -> Optional[U]:
"""
Performs DNA decoding
"""
logger.trace("Attempting DNA decoder")
ctext_decoded = ""
ctext = re.sub(r"[,;:\-\s]", "", ctext)
ctext = " ".join(ctext[i:i + 3] for i in range(0, len(ctext), 3))
ctext_split = ctext.split(" ")
dna_keys = self.DNA_DICT.keys()
for i in ctext_split:
if i in dna_keys:
ctext_decoded += self.DNA_DICT[i]
else:
return None
logger.debug(f"DNA successful, returning '{ctext_decoded}'")
return ctext_decoded
def decode(self, ctext: T) -> Optional[U]:
"""
Performs DTMF decoding
"""
logging.debug("Attempting DTMF decoder")
ctext_decoded = ""
ctext = re.sub(r"[,;:\-\/\s]", "", ctext)
ctext = " ".join(ctext[i:i + 7] for i in range(0, len(ctext), 7))
ctext_split = ctext.split(" ")
dtmf_keys = self.DTMF_DICT.keys()
for i in ctext_split:
if i in dtmf_keys:
ctext_decoded += self.DTMF_DICT[i]
else:
return None
logging.info(f"DTMF successful, returning '{ctext_decoded}'")
return ctext_decoded
def decode(self, ctext: T) -> Optional[U]:
try:
ctext = re.sub(r"[^\S \n]", " ", ctext, flags=re.UNICODE)
ctext = ctext.replace("\n", " ")
existing_split = self.try_split(ctext.split(" "))
if existing_split is not None:
return existing_split
# Now we try our own grouping
# Remove final bit of whitespace
ctext = ctext.replace(" ", "")
# Split into bytes, and test
return self.try_split([ctext[i : i + 8] for i in range(0, len(ctext), 8)])
# Catch bad octal chars
except ValueError:
return None
def decode(self, ctext: T) -> Optional[U]:
"""
Performs Braille decoding
"""
logger.trace("Attempting Braille")
ctext_decoded = ""
braille_matches = 0
for symbol in self.BRAILLE_DICT_INV.values():
if symbol in ctext:
braille_matches += 1
else:
continue
if braille_matches == 0:
logger.trace("Failed to decode Braille due to invalid characters")
return None
for pattern, value in self.BRAILLE_DICT.items():
ctext = re.sub(pattern, value, ctext)
wordArr = []
for word in ctext.split(" "):
# If two commas are in front of a word, uppercase the word and remove the comma
if word[:2].find(",,") != -1:
wordArr.append(word.replace(",,", "").upper())
else:
wordArr.append(word)
result = []
for word in wordArr:
# If one comma is in front of a word, capitalize the word and remove the comma
if word[0].find(",") != -1:
result.append(word.replace(",", "").capitalize())
else:
result.append(word)
ctext_decoded = " ".join(result)
logger.debug(f"Braille successful, returning '{ctext_decoded}'")
return ctext_decoded