SYMBOL INDEX (632 symbols across 76 files)

FILE: ciphey/basemods/Checkers/any.py
  class Any (line 7) | class Any(PolymorphicChecker):
    method getExpectedRuntime (line 10) | def getExpectedRuntime(self, text) -> float:
    method __init__ (line 13) | def __init__(self, config: Config):
    method check (line 16) | def check(self, text: str) -> Optional[str]:
    method getParams (line 20) | def getParams() -> Optional[Dict[str, ParamSpec]]:

FILE: ciphey/basemods/Checkers/brandon.py
  class Brandon (line 69) | class Brandon(Checker[str]):
    method getExpectedRuntime (line 81) | def getExpectedRuntime(self, text: T) -> float:
    method clean_text (line 88) | def clean_text(self, text: str) -> set:
    method checker (line 108) | def checker(self, text: str, threshold: float, text_length: int, var: ...
    method __init__ (line 165) | def __init__(self, config: Config):
    method check (line 181) | def check(self, text: str) -> Optional[str]:
    method calculateWhatChecker (line 241) | def calculateWhatChecker(self, length_text, key):
    method getParams (line 270) | def getParams() -> Optional[Dict[str, ParamSpec]]:

FILE: ciphey/basemods/Checkers/entropy.py
  class Entropy (line 10) | class Entropy(Checker[str]):
    method check (line 16) | def check(self, text: T) -> Optional[str]:
    method getExpectedRuntime (line 20) | def getExpectedRuntime(self, text: T) -> float:
    method __init__ (line 25) | def __init__(self, config: Config):
    method getParams (line 29) | def getParams() -> Optional[Dict[str, ParamSpec]]:

FILE: ciphey/basemods/Checkers/ezcheck.py
  class EzCheck (line 14) | class EzCheck(Checker[str]):
    method check (line 19) | def check(self, text: str) -> Optional[str]:
    method getExpectedRuntime (line 29) | def getExpectedRuntime(self, text: T) -> float:
    method __init__ (line 34) | def __init__(self, config: Config):
    method getParams (line 59) | def getParams() -> Optional[Dict[str, ParamSpec]]:

FILE: ciphey/basemods/Checkers/format.py
  class JsonChecker (line 11) | class JsonChecker(Checker[str]):
    method check (line 17) | def check(self, text: T) -> Optional[str]:
    method getExpectedRuntime (line 30) | def getExpectedRuntime(self, text: T) -> float:
    method __init__ (line 34) | def __init__(self, config: Config):
    method getParams (line 38) | def getParams() -> Optional[Dict[str, ParamSpec]]:

FILE: ciphey/basemods/Checkers/gtest.py
  class GTestChecker (line 10) | class GTestChecker(Checker[str]):
    method check (line 16) | def check(self, text: T) -> Optional[str]:
    method getExpectedRuntime (line 20) | def getExpectedRuntime(self, text: T) -> float:
    method __init__ (line 24) | def __init__(self, config: Config):
    method getParams (line 28) | def getParams() -> Optional[Dict[str, ParamSpec]]:

FILE: ciphey/basemods/Checkers/human.py
  class HumanChecker (line 11) | class HumanChecker(Checker[str]):
    method check (line 17) | def check(self, ctext: str) -> Optional[str]:
    method getExpectedRuntime (line 29) | def getExpectedRuntime(self, text: str) -> float:
    method getParams (line 33) | def getParams() -> Optional[Dict[str, ParamSpec]]:
    method __init__ (line 36) | def __init__(self, config: Config):

FILE: ciphey/basemods/Checkers/quadgrams.py
  class Quadgrams (line 11) | class Quadgrams(Checker[str]):
    method check (line 17) | def check(self, ctext: T) -> Optional[str]:
    method getExpectedRuntime (line 42) | def getExpectedRuntime(self, text: T) -> float:
    method getParams (line 47) | def getParams() -> Optional[Dict[str, ParamSpec]]:
    method __init__ (line 61) | def __init__(self, config: Config):

FILE: ciphey/basemods/Checkers/quorum.py
  class Quorum (line 6) | class Quorum(Generic[T], Checker[T]):
    method check (line 7) | def check(self, text: T) -> Optional[str]:
    method __init__ (line 19) | def __init__(self, config: Config):
    method getParams (line 36) | def getParams() -> Optional[Dict[str, ParamSpec]]:

FILE: ciphey/basemods/Checkers/regex.py
  class Regex (line 11) | class Regex(Checker[str]):
    method getExpectedRuntime (line 12) | def getExpectedRuntime(self, text: T) -> float:
    method __init__ (line 15) | def __init__(self, config: Config):
    method check (line 20) | def check(self, text: str) -> Optional[str]:
    method getParams (line 29) | def getParams() -> Optional[Dict[str, ParamSpec]]:
  class RegexList (line 40) | class RegexList(Checker[str]):
    method getExpectedRuntime (line 41) | def getExpectedRuntime(self, text: T) -> float:
    method __init__ (line 44) | def __init__(self, config: Config):
    method check (line 51) | def check(self, text: str) -> Optional[str]:
    method getParams (line 60) | def getParams() -> Optional[Dict[str, ParamSpec]]:

FILE: ciphey/basemods/Checkers/what.py
  class What (line 13) | class What(Checker[str]):
    method check (line 20) | def check(self, ctext: T) -> Optional[str]:
    method getExpectedRuntime (line 50) | def getExpectedRuntime(self, text: T) -> float:
    method getParams (line 55) | def getParams() -> Optional[Dict[str, ParamSpec]]:
    method __init__ (line 58) | def __init__(self, config: Config):

FILE: ciphey/basemods/Crackers/affine.py
  class Affine (line 16) | class Affine(Cracker[str]):
    method getInfo (line 27) | def getInfo(self, ctext: str) -> CrackInfo:
    method getTarget (line 35) | def getTarget() -> str:
    method attemptCrack (line 38) | def attemptCrack(self, ctext: str) -> List[CrackResult]:
    method plaintext_probability (line 74) | def plaintext_probability(self, translated: str) -> float:
    method decrypt (line 82) | def decrypt(self, text: str, a_inv: int, b: int, m: int) -> str:
    method decryptChar (line 90) | def decryptChar(self, char: str, a_inv: int, b: int, m: int) -> str:
    method getParams (line 105) | def getParams() -> Optional[Dict[str, ParamSpec]]:
    method __init__ (line 119) | def __init__(self, config: Config):

FILE: ciphey/basemods/Crackers/ascii_shift.py
  class Ascii_shift (line 21) | class Ascii_shift(Cracker[str]):
    method getInfo (line 22) | def getInfo(self, ctext: str) -> CrackInfo:
    method getTarget (line 37) | def getTarget() -> str:
    method attemptCrack (line 40) | def attemptCrack(self, ctext: str) -> List[CrackResult]:
    method getParams (line 76) | def getParams() -> Optional[Dict[str, ParamSpec]]:
    method __init__ (line 96) | def __init__(self, config: Config):

FILE: ciphey/basemods/Crackers/baconian.py
  class Baconian (line 18) | class Baconian(Cracker[str]):
    method getInfo (line 19) | def getInfo(self, ctext: str) -> CrackInfo:
    method getTarget (line 27) | def getTarget() -> str:
    method attemptCrack (line 30) | def attemptCrack(self, ctext: str) -> List[CrackResult]:
    method getParams (line 83) | def getParams() -> Optional[Dict[str, ParamSpec]]:
    method __init__ (line 97) | def __init__(self, config: Config):

FILE: ciphey/basemods/Crackers/caesar.py
  class Caesar (line 22) | class Caesar(Cracker[str]):
    method getInfo (line 23) | def getInfo(self, ctext: str) -> CrackInfo:
    method getTarget (line 38) | def getTarget() -> str:
    method attemptCrack (line 41) | def attemptCrack(self, ctext: str) -> List[CrackResult]:
    method getParams (line 86) | def getParams() -> Optional[Dict[str, ParamSpec]]:
    method __init__ (line 111) | def __init__(self, config: Config):

FILE: ciphey/basemods/Crackers/hash.py
  function alpha (line 21) | def alpha(ctext, hashtype):
  function beta (line 25) | def beta(ctext, hashtype):
  function gamma (line 38) | def gamma(ctext, hashtype):
  function delta (line 51) | def delta(ctext, hashtype):
  function theta (line 55) | def theta(ctext, hashtype):
  function crack (line 80) | def crack(ctext):
  function threaded (line 84) | def threaded(ctext):
  class HashBuster (line 92) | class HashBuster(Cracker[str]):
    method getTarget (line 94) | def getTarget() -> str:
    method getParams (line 98) | def getParams() -> Optional[Dict[str, ParamSpec]]:
    method priority (line 102) | def priority() -> float:
    method getInfo (line 105) | def getInfo(self, ctext: T) -> CrackInfo:
    method attemptCrack (line 113) | def attemptCrack(self, ctext: T) -> List[CrackResult]:
    method __init__ (line 154) | def __init__(self, config: Config):

FILE: ciphey/basemods/Crackers/rot47.py
  class Rot47 (line 21) | class Rot47(Cracker[str]):
    method getInfo (line 22) | def getInfo(self, ctext: str) -> CrackInfo:
    method getTarget (line 37) | def getTarget() -> str:
    method attemptCrack (line 40) | def attemptCrack(self, ctext: str) -> List[CrackResult]:
    method getParams (line 76) | def getParams() -> Optional[Dict[str, ParamSpec]]:
    method __init__ (line 96) | def __init__(self, config: Config):

FILE: ciphey/basemods/Crackers/soundex.py
  class Soundex (line 19) | class Soundex(Cracker[str]):
    method getInfo (line 20) | def getInfo(self, ctext: str) -> CrackInfo:
    method getTarget (line 28) | def getTarget() -> str:
    method attemptCrack (line 31) | def attemptCrack(self, ctext: str) -> List[CrackResult]:
    method sortlistwithdict (line 85) | def sortlistwithdict(self, listtosort, hashes):
    method getSentenceCombo (line 92) | def getSentenceCombo(
    method getParams (line 121) | def getParams() -> Optional[Dict[str, ParamSpec]]:
    method __init__ (line 135) | def __init__(self, config: Config):

FILE: ciphey/basemods/Crackers/vigenere.py
  class Vigenere (line 22) | class Vigenere(Cracker[str]):
    method getInfo (line 23) | def getInfo(self, ctext: str) -> CrackInfo:
    method getTarget (line 80) | def getTarget() -> str:
    method crackOne (line 83) | def crackOne(
    method attemptCrack (line 106) | def attemptCrack(self, ctext: str) -> List[CrackResult]:
    method getParams (line 157) | def getParams() -> Optional[Dict[str, ParamSpec]]:
    method __init__ (line 195) | def __init__(self, config: Config):

FILE: ciphey/basemods/Crackers/xandy.py
  class Xandy (line 11) | class Xandy(Cracker[str]):
    method getInfo (line 12) | def getInfo(self, ctext: str) -> CrackInfo:
    method binary_to_ascii (line 20) | def binary_to_ascii(variant):
    method getTarget (line 36) | def getTarget() -> str:
    method attemptCrack (line 39) | def attemptCrack(self, ctext: str) -> List[CrackResult]:
    method getParams (line 100) | def getParams() -> Optional[Dict[str, ParamSpec]]:
    method __init__ (line 109) | def __init__(self, config: Config):

FILE: ciphey/basemods/Crackers/xortool.py
  class XorTool (line 21) | class XorTool(Cracker[str]):
    method getInfo (line 22) | def getInfo(self, ctext: str) -> CrackInfo:
    method getTarget (line 31) | def getTarget() -> str:
    method attemptCrack (line 34) | def attemptCrack(self, ctext: str) -> List[CrackResult]:
    method getParams (line 54) | def getParams() -> Optional[Dict[str, ParamSpec]]:
    method score_utility (line 69) | def score_utility() -> float:
    method __init__ (line 72) | def __init__(self, config: Config):

FILE: ciphey/basemods/Decoders/a1z26.py
  class A1z26 (line 11) | class A1z26(Decoder[str]):
    method decode (line 12) | def decode(self, ctext: T) -> Optional[U]:
    method priority (line 44) | def priority() -> float:
    method __init__ (line 47) | def __init__(self, config: Config):
    method getParams (line 51) | def getParams() -> Optional[Dict[str, ParamSpec]]:
    method getTarget (line 55) | def getTarget() -> str:

FILE: ciphey/basemods/Decoders/atbash.py
  class Atbash (line 8) | class Atbash(Decoder[str]):
    method decode (line 9) | def decode(self, ctext: T) -> Optional[U]:
    method priority (line 32) | def priority() -> float:
    method __init__ (line 36) | def __init__(self, config: Config):
    method getParams (line 41) | def getParams() -> Optional[Dict[str, ParamSpec]]:
    method getTarget (line 51) | def getTarget() -> str:

FILE: ciphey/basemods/Decoders/base58_bitcoin.py
  class Base58_bitcoin (line 9) | class Base58_bitcoin(Decoder[str]):
    method decode (line 10) | def decode(self, ctext: T) -> Optional[U]:
    method priority (line 20) | def priority() -> float:
    method __init__ (line 24) | def __init__(self, config: Config):
    method getParams (line 28) | def getParams() -> Optional[Dict[str, ParamSpec]]:
    method getTarget (line 32) | def getTarget() -> str:

FILE: ciphey/basemods/Decoders/base58_flickr.py
  class Base58_flickr (line 9) | class Base58_flickr(Decoder[str]):
    method decode (line 10) | def decode(self, ctext: T) -> Optional[U]:
    method priority (line 21) | def priority() -> float:
    method __init__ (line 25) | def __init__(self, config: Config):
    method getParams (line 29) | def getParams() -> Optional[Dict[str, ParamSpec]]:
    method getTarget (line 33) | def getTarget() -> str:

FILE: ciphey/basemods/Decoders/base58_ripple.py
  class Base58_ripple (line 9) | class Base58_ripple(Decoder[str]):
    method decode (line 10) | def decode(self, ctext: T) -> Optional[U]:
    method priority (line 22) | def priority() -> float:
    method __init__ (line 26) | def __init__(self, config: Config):
    method getParams (line 30) | def getParams() -> Optional[Dict[str, ParamSpec]]:
    method getTarget (line 34) | def getTarget() -> str:

FILE: ciphey/basemods/Decoders/base62.py
  class Base62 (line 9) | class Base62(Decoder[str]):
    method decode (line 10) | def decode(self, ctext: T) -> Optional[U]:
    method priority (line 20) | def priority() -> float:
    method __init__ (line 24) | def __init__(self, config: Config):
    method getParams (line 28) | def getParams() -> Optional[Dict[str, ParamSpec]]:
    method getTarget (line 32) | def getTarget() -> str:

FILE: ciphey/basemods/Decoders/base64_url.py
  class Base64_url (line 8) | class Base64_url(Decoder[str]):
    method decode (line 9) | def decode(self, ctext: T) -> Optional[U]:
    method priority (line 20) | def priority() -> float:
    method __init__ (line 24) | def __init__(self, config: Config):
    method getParams (line 28) | def getParams() -> Optional[Dict[str, ParamSpec]]:
    method getTarget (line 32) | def getTarget() -> str:

FILE: ciphey/basemods/Decoders/base65536.py
  class Base65536 (line 9) | class Base65536(Decoder[str]):
    method decode (line 10) | def decode(self, ctext: T) -> Optional[U]:
    method priority (line 20) | def priority() -> float:
    method __init__ (line 24) | def __init__(self, config: Config):
    method getParams (line 28) | def getParams() -> Optional[Dict[str, ParamSpec]]:
    method getTarget (line 32) | def getTarget() -> str:

FILE: ciphey/basemods/Decoders/base69.py
  class Base69 (line 12) | class Base69(Decoder[str]):
    method decode (line 13) | def decode(self, ctext: T) -> Optional[U]:
    method decode_chunk (line 43) | def decode_chunk(self, s: str):
    method chars_to_byte (line 61) | def chars_to_byte(self, s: str):
    method priority (line 65) | def priority() -> float:
    method __init__ (line 70) | def __init__(self, config: Config):
    method getParams (line 75) | def getParams() -> Optional[Dict[str, ParamSpec]]:
    method getTarget (line 85) | def getTarget() -> str:

FILE: ciphey/basemods/Decoders/base91.py
  class Base91 (line 9) | class Base91(Decoder[str]):
    method decode (line 10) | def decode(self, ctext: T) -> Optional[U]:
    method priority (line 20) | def priority() -> float:
    method __init__ (line 24) | def __init__(self, config: Config):
    method getParams (line 28) | def getParams() -> Optional[Dict[str, ParamSpec]]:
    method getTarget (line 32) | def getTarget() -> str:

FILE: ciphey/basemods/Decoders/bases.py
  function _dispatch (line 13) | def _dispatch(self: Any, ctext: str, func: Callable[[str], bytes]) -> Op...
  function gen_class (line 36) | def gen_class(name, decoder, priority, ns):

FILE: ciphey/basemods/Decoders/baudot.py
  class Baudot (line 8) | class Baudot(Decoder[str]):
    method decode (line 9) | def decode(self, ctext: T) -> Optional[U]:
    method priority (line 27) | def priority() -> float:
    method __init__ (line 30) | def __init__(self, config: Config):
    method getParams (line 35) | def getParams() -> Optional[Dict[str, ParamSpec]]:
    method getTarget (line 45) | def getTarget() -> str:

FILE: ciphey/basemods/Decoders/binary.py
  class Binary (line 11) | class Binary(Decoder[str]):
    method decode (line 12) | def decode(self, ctext: T) -> Optional[U]:
    method try_split (line 31) | def try_split(self, split_text: List[str]):
    method priority (line 48) | def priority() -> float:
    method __init__ (line 51) | def __init__(self, config: Config):
    method getParams (line 55) | def getParams() -> Optional[Dict[str, ParamSpec]]:
    method getTarget (line 59) | def getTarget() -> str:

FILE: ciphey/basemods/Decoders/braille.py
  class Braille (line 10) | class Braille(Decoder[str]):
    method decode (line 11) | def decode(self, ctext: T) -> Optional[U]:
    method priority (line 50) | def priority() -> float:
    method __init__ (line 53) | def __init__(self, config: Config):
    method getParams (line 59) | def getParams() -> Optional[Dict[str, ParamSpec]]:
    method getTarget (line 69) | def getTarget() -> str:

FILE: ciphey/basemods/Decoders/brainfuck.py
  class Brainfuck (line 12) | class Brainfuck(Decoder[str]):
    method decode (line 13) | def decode(self, ctext: T) -> Optional[U]:
    method bracemap_and_check (line 102) | def bracemap_and_check(self, program: str) -> Tuple[Optional[Dict], bo...
    method priority (line 150) | def priority() -> float:
    method __init__ (line 154) | def __init__(self, config: Config):
    method getParams (line 159) | def getParams() -> Optional[Dict[str, ParamSpec]]:
    method getTarget (line 169) | def getTarget() -> str:

FILE: ciphey/basemods/Decoders/decimal.py
  class Decimal (line 11) | class Decimal(Decoder[str]):
    method decode (line 12) | def decode(self, ctext: T) -> Optional[U]:
    method priority (line 43) | def priority() -> float:
    method __init__ (line 46) | def __init__(self, config: Config):
    method getParams (line 50) | def getParams() -> Optional[Dict[str, ParamSpec]]:
    method getTarget (line 54) | def getTarget() -> str:

FILE: ciphey/basemods/Decoders/dna.py
  class Dna (line 11) | class Dna(Decoder[str]):
    method decode (line 12) | def decode(self, ctext: T) -> Optional[U]:
    method priority (line 32) | def priority() -> float:
    method __init__ (line 35) | def __init__(self, config: Config):
    method getParams (line 40) | def getParams() -> Optional[Dict[str, ParamSpec]]:
    method getTarget (line 50) | def getTarget() -> str:

FILE: ciphey/basemods/Decoders/dtmf.py
  class Dtmf (line 11) | class Dtmf(Decoder[str]):
    method decode (line 12) | def decode(self, ctext: T) -> Optional[U]:
    method priority (line 32) | def priority() -> float:
    method __init__ (line 35) | def __init__(self, config: Config):
    method getParams (line 40) | def getParams() -> Optional[Dict[str, ParamSpec]]:
    method getTarget (line 50) | def getTarget() -> str:

FILE: ciphey/basemods/Decoders/galactic.py
  class Galactic (line 10) | class Galactic(Decoder[str]):
    method decode (line 11) | def decode(self, ctext: T) -> Optional[U]:
    method priority (line 61) | def priority() -> float:
    method __init__ (line 65) | def __init__(self, config: Config):
    method getParams (line 70) | def getParams() -> Optional[Dict[str, ParamSpec]]:
    method getTarget (line 80) | def getTarget() -> str:

FILE: ciphey/basemods/Decoders/gzip.py
  class Gzip (line 8) | class Gzip(Decoder[bytes]):
    method decode (line 9) | def decode(self, ctext: T) -> Optional[U]:
    method priority (line 19) | def priority() -> float:
    method __init__ (line 23) | def __init__(self, config: Config):
    method getParams (line 27) | def getParams() -> Optional[Dict[str, ParamSpec]]:
    method getTarget (line 31) | def getTarget() -> str:

FILE: ciphey/basemods/Decoders/hexadecimal.py
  class Hexadecimal (line 7) | class Hexadecimal(Decoder[str]):
    method decode (line 8) | def decode(self, ctext: T) -> Optional[U]:
    method priority (line 20) | def priority() -> float:
    method __init__ (line 23) | def __init__(self, config: Config):
    method getParams (line 27) | def getParams() -> Optional[Dict[str, ParamSpec]]:
    method getTarget (line 31) | def getTarget() -> str:

FILE: ciphey/basemods/Decoders/leetspeak.py
  class Leetspeak (line 7) | class Leetspeak(Decoder[str]):
    method decode (line 8) | def decode(self, ctext: T) -> Optional[U]:
    method priority (line 14) | def priority() -> float:
    method __init__ (line 17) | def __init__(self, config: Config):
    method getParams (line 22) | def getParams() -> Optional[Dict[str, ParamSpec]]:
    method getTarget (line 32) | def getTarget() -> str:

FILE: ciphey/basemods/Decoders/morse_code.py
  class Morse_code (line 10) | class Morse_code(Decoder[str]):
    method decode (line 19) | def decode(self, ctext: T) -> Optional[U]:
    method priority (line 78) | def priority() -> float:
    method __init__ (line 81) | def __init__(self, config: Config):
    method getParams (line 87) | def getParams() -> Optional[Dict[str, ParamSpec]]:
    method getTarget (line 97) | def getTarget() -> str:

FILE: ciphey/basemods/Decoders/multi_tap.py
  class Multi_tap (line 7) | class Multi_tap(Decoder[str]):
    method decode (line 8) | def decode(self, ctext: T) -> Optional[U]:
    method valid_code_part (line 21) | def valid_code_part(code: str) -> bool:
    method decode_num_to_char (line 38) | def decode_num_to_char(number: str) -> str:
    method is_all_dup (line 43) | def is_all_dup(code):
    method calculate_index (line 47) | def calculate_index(number: str) -> int:
    method number_index_to_char (line 59) | def number_index_to_char(index_number: int) -> str:
    method get_index_from_first_digit (line 64) | def get_index_from_first_digit(first_digit: int) -> int:
    method priority (line 76) | def priority() -> float:
    method __init__ (line 79) | def __init__(self, config: Config):
    method getParams (line 84) | def getParams() -> Optional[Dict[str, ParamSpec]]:
    method getTarget (line 88) | def getTarget() -> str:

FILE: ciphey/basemods/Decoders/octal.py
  class Octal (line 10) | class Octal(Decoder[str]):
    method decode (line 11) | def decode(self, ctext: T) -> Optional[U]:
    method priority (line 42) | def priority() -> float:
    method __init__ (line 45) | def __init__(self, config: Config):
    method getParams (line 49) | def getParams() -> Optional[Dict[str, ParamSpec]]:
    method getTarget (line 53) | def getTarget() -> str:

FILE: ciphey/basemods/Decoders/reverse.py
  class Reverse (line 7) | class Reverse(Decoder[str]):
    method decode (line 8) | def decode(self, ctext: T) -> Optional[U]:
    method priority (line 12) | def priority() -> float:
    method __init__ (line 15) | def __init__(self, config: Config):
    method getParams (line 19) | def getParams() -> Optional[Dict[str, ParamSpec]]:
    method getTarget (line 23) | def getTarget() -> str:

FILE: ciphey/basemods/Decoders/tap_code.py
  class Tap_code (line 9) | class Tap_code(Decoder[str]):
    method decode (line 10) | def decode(self, ctext: T) -> Optional[U]:
    method priority (line 24) | def priority() -> float:
    method __init__ (line 27) | def __init__(self, config: Config):
    method getParams (line 32) | def getParams() -> Optional[Dict[str, ParamSpec]]:
    method getTarget (line 42) | def getTarget() -> str:

FILE: ciphey/basemods/Decoders/unicode.py
  class Utf8 (line 10) | class Utf8(Decoder[bytes]):
    method decode (line 11) | def decode(self, ctext: T) -> Optional[U]:
    method priority (line 28) | def priority() -> float:
    method __init__ (line 31) | def __init__(self, config: Config):
    method getParams (line 35) | def getParams() -> Optional[Dict[str, ParamSpec]]:
    method getTarget (line 39) | def getTarget() -> str:

FILE: ciphey/basemods/Decoders/url.py
  class Url (line 11) | class Url(Decoder[str]):
    method decode (line 12) | def decode(self, ctext: T) -> Optional[U]:
    method priority (line 30) | def priority() -> float:
    method __init__ (line 33) | def __init__(self, config: Config):
    method getParams (line 37) | def getParams() -> Optional[Dict[str, ParamSpec]]:
    method getTarget (line 41) | def getTarget() -> str:

FILE: ciphey/basemods/Decoders/uuencode.py
  class Uuencode (line 12) | class Uuencode(Decoder[str]):
    method decode (line 13) | def decode(self, ctext: T) -> Optional[U]:
    method priority (line 42) | def priority() -> float:
    method __init__ (line 46) | def __init__(self, config: Config):
    method getParams (line 50) | def getParams() -> Optional[Dict[str, ParamSpec]]:
    method getTarget (line 54) | def getTarget() -> str:

FILE: ciphey/basemods/Decoders/z85.py
  class Z85 (line 11) | class Z85(Decoder[str]):
    method decode (line 12) | def decode(self, ctext: T) -> Optional[U]:
    method priority (line 28) | def priority() -> float:
    method __init__ (line 32) | def __init__(self, config: Config):
    method getParams (line 36) | def getParams() -> Optional[Dict[str, ParamSpec]]:
    method getTarget (line 40) | def getTarget() -> str:

FILE: ciphey/basemods/Resources/cipheydists.py
  class CipheyDists (line 19) | class CipheyDists(ResourceLoader):
    method whatResources (line 31) | def whatResources(self) -> Optional[Set[str]]:
    method getResource (line 35) | def getResource(self, name: str) -> Any:
    method __init__ (line 40) | def __init__(self, config: Config):
    method getParams (line 44) | def getParams() -> Optional[Dict[str, ParamSpec]]:

FILE: ciphey/basemods/Resources/files.py
  class Json (line 19) | class Json(ResourceLoader):
    method whatResources (line 20) | def whatResources(self) -> T:
    method getResource (line 24) | def getResource(self, name: str) -> T:
    method getName (line 31) | def getName() -> str:
    method getParams (line 35) | def getParams() -> Optional[Dict[str, ParamSpec]]:
    method __init__ (line 38) | def __init__(self, config: Config):
  class Csv (line 46) | class Csv(Generic[T], ResourceLoader[T]):
    method whatResources (line 47) | def whatResources(self) -> Set[str]:
    method getResource (line 51) | def getResource(self, name: str) -> T:
    method getName (line 59) | def getName() -> str:
    method getParams (line 63) | def getParams() -> Optional[Dict[str, ParamSpec]]:
    method __init__ (line 66) | def __init__(self, config: Config):

FILE: ciphey/basemods/Searchers/astar.py
  class Node (line 4) | class Node:
    method __init__ (line 10) | def __init__(
    method __le__ (line 29) | def __le__(self, node2):
    method __lt__ (line 33) | def __lt__(self, node2):
    method append_edge (line 36) | def append_edge(self, edge):
    method get_edges (line 39) | def get_edges(self):
  class Graph (line 43) | class Graph:
    method __init__ (line 51) | def __init__(self, adjacency_list):
    method get_neighbors (line 58) | def get_neighbors(self, v):
    method heuristic (line 66) | def heuristic(self, n: Node):
    method a_star_algorithm (line 69) | def a_star_algorithm(self, start_node: Node, stop_node: Node):

FILE: ciphey/basemods/Searchers/ausearch.py
  class DuplicateNode (line 33) | class DuplicateNode(Exception):
  class AuSearchSuccessful (line 38) | class AuSearchSuccessful(Exception):
  class Node (line 44) | class Node:
    method decoding (line 51) | def decoding(
    method cracker (line 73) | def cracker(config: Config, edge_template: "Edge", result: CrackResult...
    method root (line 92) | def root(config: Config, ctext: Any):
    method get_path (line 98) | def get_path(self):
  class AusearchEdge (line 105) | class AusearchEdge:
    method __init__ (line 112) | def __init__(self, success_probability, success_time, failure_time):
  class AusearchResult (line 120) | class AusearchResult:
  function calculate_score (line 125) | def calculate_score(info: CrackInfo):
  class Edge (line 131) | class Edge:
  class PriorityWorkQueue (line 142) | class PriorityWorkQueue(Generic[PriorityType, T]):
    method add_work (line 146) | def add_work(self, priority: PriorityType, work: List[T]) -> None:
    method get_work (line 157) | def get_work(self) -> T:
    method get_work_chunk (line 165) | def get_work_chunk(self) -> List[T]:
    method empty (line 172) | def empty(self):
    method __init__ (line 175) | def __init__(self):
  class AuSearch (line 181) | class AuSearch(Searcher):
    method get_crackers_for (line 186) | def get_crackers_for(t: type):
    method get_decoders_for (line 190) | def get_decoders_for(self, t: type):
    method expand_crackers (line 199) | def expand_crackers(self, node: Node) -> None:
    method expand_decodings (line 221) | def expand_decodings(self, node: Node) -> None:
    method recursive_expand (line 239) | def recursive_expand(self, node: Node, nested: bool = True) -> None:
    method search (line 251) | def search(self, ctext: Any) -> Optional[SearchResult]:
    method __init__ (line 302) | def __init__(self, config: Config):
    method getParams (line 322) | def getParams() -> Optional[Dict[str, ParamSpec]]:

FILE: ciphey/basemods/Searchers/imperfection.py
  class Imperfection (line 4) | class Imperfection:
    method __init__ (line 50) | def __init__(self):
    method findBestNode (line 53) | def findBestNode(self, nodes):
    method aStar (line 153) | def aStar(self, graph, current, end):
  class Node (line 197) | class Node:
    method __init__ (line 203) | def __init__(self, h):
    method __le__ (line 208) | def __le__(self, node2):
    method __lt__ (line 212) | def __lt__(self, node2):

FILE: ciphey/basemods/Searchers/perfection.py
  class Perfection (line 9) | class Perfection(AuSearch):
    method getParams (line 11) | def getParams() -> Optional[Dict[str, ParamSpec]]:
    method findBestNode (line 14) | def findBestNode(self, nodes: Set[Node]) -> Node:
    method __init__ (line 17) | def __init__(self, config: Config):

FILE: ciphey/ciphey.py
  function decrypt (line 31) | def decrypt(config: iface.Config, ctext: Any) -> Union[str, bytes]:
  function get_name (line 42) | def get_name(ctx, param, value):
  function print_help (line 51) | def print_help(ctx):
  function main (line 133) | def main(**kwargs):

FILE: ciphey/common.py
  function id_lambda (line 5) | def id_lambda(value: Any):
  function fix_case (line 12) | def fix_case(target: str, base: str) -> str:

FILE: ciphey/iface/_config.py
  class Cache (line 15) | class Cache:
    method __init__ (line 18) | def __init__(self):
    method mark_ctext (line 21) | def mark_ctext(self, ctext: Any) -> bool:
    method get_or_update (line 35) | def get_or_update(self, ctext: Any, keyname: str, get_value: Callable[...
    method try_get (line 46) | def try_get(self, ctext: Any, keyname: str):
  function split_resource_name (line 50) | def split_resource_name(full_name: str) -> (str, str):
  class Config (line 54) | class Config:
    method __init__ (line 55) | def __init__(self):
    method get_default_dir (line 69) | def get_default_dir() -> str:
    method merge_dict (line 72) | def merge_dict(self, config_file: Optional[Dict[str, Any]]):
    method load_file (line 78) | def load_file(
    method instantiate (line 90) | def instantiate(self, t: type) -> Any:
    method __call__ (line 102) | def __call__(self, t: type) -> Any:
    method update (line 105) | def update(self, attrname: str, value: Optional[Any]):
    method update_param (line 109) | def update_param(self, owner: str, name: str, value: Optional[Any]):
    method update_format (line 120) | def update_format(self, value: Optional[str]):
    method load_objs (line 124) | def load_objs(self):
    method update_log_level (line 138) | def update_log_level(self, verbosity: Optional[int]):
    method load_modules (line 161) | def load_modules(self):
    method complete_config (line 171) | def complete_config(self) -> "Config":
    method get_resource (line 178) | def get_resource(self, res_name: str, t: Optional[Type] = None) -> Any:
    method set_verbosity (line 189) | def set_verbosity(self, i):
    method set_spinner (line 193) | def set_spinner(self, spinner):
    method pause_spinner_handle (line 196) | def pause_spinner_handle(self):
    method library_default (line 211) | def library_default():
    method __str__ (line 215) | def __str__(self):

FILE: ciphey/iface/_modules.py
  class ParamSpec (line 17) | class ParamSpec(NamedTuple):
  class ConfigurableModule (line 36) | class ConfigurableModule(ABC):
    method getParams (line 39) | def getParams() -> Optional[Dict[str, ParamSpec]]:
    method _checkParams (line 45) | def _checkParams(self):
    method _params (line 73) | def _params(self):
    method _config (line 76) | def _config(self):
    method __init__ (line 80) | def __init__(self, config: Config):
  class Targeted (line 87) | class Targeted(ABC):
    method getTarget (line 90) | def getTarget() -> str:
  class PolymorphicChecker (line 95) | class PolymorphicChecker(ConfigurableModule):
    method check (line 97) | def check(self, text) -> Optional[str]:
    method getExpectedRuntime (line 102) | def getExpectedRuntime(self, text) -> float:
    method __call__ (line 105) | def __call__(self, *args):
    method __init__ (line 109) | def __init__(self, config: Config):
  class Checker (line 113) | class Checker(Generic[T], ConfigurableModule):
    method check (line 115) | def check(self, text: T) -> Optional[str]:
    method getExpectedRuntime (line 120) | def getExpectedRuntime(self, text: T) -> float:
    method __call__ (line 123) | def __call__(self, *args):
    method __init__ (line 127) | def __init__(self, config: Config):
    method convert (line 131) | def convert(cls, expected: Set[type]):
  class Decoder (line 172) | class Decoder(Generic[T], ConfigurableModule, Targeted):
    method decode (line 176) | def decode(self, ctext: T) -> Optional[U]:
    method priority (line 181) | def priority() -> float:
    method __call__ (line 185) | def __call__(self, *args):
    method __init__ (line 189) | def __init__(self, config: Config):
  class DecoderComparer (line 193) | class DecoderComparer:
    method __le__ (line 196) | def __le__(self, other: "DecoderComparer"):
    method __ge__ (line 199) | def __ge__(self, other: "DecoderComparer"):
    method __lt__ (line 202) | def __lt__(self, other: "DecoderComparer"):
    method __gt__ (line 205) | def __gt__(self, other: "DecoderComparer"):
    method __init__ (line 208) | def __init__(self, value: Type[Decoder]):
    method __repr__ (line 211) | def __repr__(self):
  class CrackResult (line 215) | class CrackResult(NamedTuple):
  class CrackInfo (line 223) | class CrackInfo(NamedTuple):
  class Cracker (line 229) | class Cracker(Generic[T], ConfigurableModule, Targeted):
    method getInfo (line 231) | def getInfo(self, ctext: T) -> CrackInfo:
    method attemptCrack (line 236) | def attemptCrack(self, ctext: T) -> List[CrackResult]:
    method __call__ (line 243) | def __call__(self, *args):
    method __init__ (line 247) | def __init__(self, config: Config):
  class ResourceLoader (line 251) | class ResourceLoader(Generic[T], ConfigurableModule):
    method whatResources (line 253) | def whatResources(self) -> Optional[Set[str]]:
    method getResource (line 265) | def getResource(self, name: str) -> T:
    method __call__ (line 273) | def __call__(self, *args):
    method __getitem__ (line 276) | def __getitem__(self, *args):
    method __init__ (line 280) | def __init__(self, config: Config):
  class SearchLevel (line 284) | class SearchLevel(NamedTuple):
    method input (line 289) | def input(ctext: Any):
  class SearchResult (line 293) | class SearchResult(NamedTuple):
  class Searcher (line 298) | class Searcher(ConfigurableModule):
    method search (line 302) | def search(self, ctext: Any) -> Optional[SearchResult]:
    method __init__ (line 307) | def __init__(self, config: Config):
  function pretty_search_results (line 311) | def pretty_search_results(res: SearchResult, display_intermediate: bool ...

FILE: ciphey/iface/_registry.py
  class Registry (line 12) | class Registry:
    method _register_one (line 23) | def _register_one(self, input_type, module_base, module_args):
    method _real_register (line 34) | def _real_register(self, input_type: type, *args) -> Type:
    method register (line 119) | def register(self, input_type):
    method register_multi (line 122) | def register_multi(self, *x):
    method __getitem__ (line 125) | def __getitem__(self, i: type) -> Optional[Any]:
    method get_named (line 137) | def get_named(self, name: str, type_constraint: Type = None) -> Any:
    method get_targeted (line 143) | def get_targeted(
    method get_all_names (line 151) | def get_all_names(self) -> List[str]:
    method __str__ (line 154) | def __str__(self):

FILE: ciphey/mathsHelper.py
  class mathsHelper (line 23) | class mathsHelper:
    method __init__ (line 26) | def __init__(self):
    method gcd (line 32) | def gcd(a, b) -> int:
    method mod_inv (line 51) | def mod_inv(a: int, m: int) -> Optional[int]:
    method percentage (line 68) | def percentage(part: float, whole: float) -> float:
    method sort_prob_table (line 86) | def sort_prob_table(self, prob_table: dict) -> dict:
    method new_sort (line 157) | def new_sort(new_dict: dict) -> dict:
    method is_ascii (line 179) | def is_ascii(s: str) -> bool:
    method strip_punctuation (line 196) | def strip_punctuation(text: str) -> str:

FILE: noxfile.py
  function install_with_constraints (line 14) | def install_with_constraints(session: Session, *args: str, **kwargs: Any...
  function black (line 40) | def black(session):
  function coverage (line 47) | def coverage(session: Session) -> None:
  function docs (line 57) | def docs(session: Session) -> None:
  function tests (line 64) | def tests(session):

FILE: tests/dict.py
  class testDictionary (line 14) | class testDictionary(unittest.TestCase):
    method test_english_yes (line 15) | def test_english_yes(self):
    method test_english_yes_two (line 22) | def test_english_yes_two(self):
    method test_english_false (line 30) | def test_english_false(self):
    method test_english_false_two (line 35) | def test_english_false_two(self):
    method test_english_perfect (line 50) | def test_english_perfect(self):

FILE: tests/enciphey.py
  class encipher (line 15) | class encipher:
    method __init__ (line 19) | def __init__(self):  # pragma: no cover
    method read_text (line 25) | def read_text(self):  # pragma: no cover
    method getRandomSentence (line 31) | def getRandomSentence(self, size):  # pragma: no cover
    method getRandomEncryptedSentence (line 36) | def getRandomEncryptedSentence(self, size):  # pragma: no cover
  class encipher_crypto (line 43) | class encipher_crypto:  # pragma: no cover
    method __init__ (line 54) | def __init__(self):  # pragma: no cover
    method random_key (line 74) | def random_key(self, text) -> str:  # pragma: no cover
    method random_string (line 81) | def random_string(self, length) -> str:  # pragma: no cover
    method randomEncrypt (line 84) | def randomEncrypt(self, text: str) -> str:  # pragma: no cover
    method Base64 (line 92) | def Base64(self, text: str) -> str:  # pragma: no cover
    method Caesar (line 102) | def Caesar(self, s, k):  # pragma: no cover
    method apply_rotation (line 110) | def apply_rotation(self, c, facr):  # pragma: no cover
    method Base32 (line 117) | def Base32(self, text: str) -> str:  # pragma: no cover
    method Base16 (line 127) | def Base16(self, text: str) -> str:  # pragma: no cover
    method Binary (line 137) | def Binary(self, text: str) -> str:  # pragma: no cover
    method Ascii (line 141) | def Ascii(self, text: str) -> str:  # pragma: no cover
    method Hex (line 145) | def Hex(self, text: str) -> str:  # pragma: no cover
    method MorseCode (line 148) | def MorseCode(self, text: str) -> str:  # pragma: :wno cover
    method Reverse (line 161) | def Reverse(self, text: str) -> str:
    method Vigenere (line 164) | def Vigenere(self, plaintext):
    method vig_key (line 168) | def vig_key(self, msg, key):
    method base58_bitcoin (line 179) | def base58_bitcoin(self, text: str):
    method base58_ripple (line 182) | def base58_ripple(self, text: str):
    method b62 (line 187) | def b62(self, text: str):

FILE: tests/generate_tests.py
  class test_generator (line 35) | class test_generator:
    method __init__ (line 36) | def __init__(self):
    method main (line 40) | def main(self):
    method make_test_true_template (line 54) | def make_test_true_template(self, cipher):
    method make_test_lc_true_template (line 63) | def make_test_lc_true_template(self, cipher):
    method randomString (line 75) | def randomString(self, stringLength):

FILE: tests/integration.py
  class testIntegration (line 11) | class testIntegration(unittest.TestCase):
    method test_basics (line 16) | def test_basics(self):
    method test_basics_german (line 23) | def test_basics_german(self):
    method test_basics_quickbrownfox (line 28) | def test_basics_quickbrownfox(self):
    method test_basics_quickbrownfox (line 36) | def test_basics_quickbrownfox(self):
    method test_chi_maxima_true (line 44) | def test_chi_maxima_true(self):
    method test_integration_unusual_one (line 71) | def test_integration_unusual_one(self):
    method test_integration_unusual_two (line 76) | def test_integration_unusual_two(self):
    method test_integration_unusual_three (line 81) | def test_integration_unusual_three(self):
    method test_integration_unusual_three (line 86) | def test_integration_unusual_three(self):
    method test_integration_unusual_four (line 91) | def test_integration_unusual_four(self):
    method test_integration_unusual_five (line 96) | def test_integration_unusual_five(self):
    method test_integration_unusual_7 (line 101) | def test_integration_unusual_7(self):
    method test_integration_unusual_7 (line 108) | def test_integration_unusual_7(self):
    method test_integration_addition (line 113) | def test_integration_addition(self):
    method test_integration_charlesBabbage (line 130) | def test_integration_charlesBabbage(self):

FILE: tests/lukas.py
  class galactic_encode (line 6) | class galactic_encode:
    method __init__ (line 11) | def __init__(self, text: str):
    method encode (line 18) | def encode(self):
  class atbash_encode (line 27) | class atbash_encode:
    method __init__ (line 32) | def __init__(self, text: str):
    method encode (line 38) | def encode(self):
  class XY_encrypt (line 50) | class XY_encrypt:
    method __init__ (line 60) | def __init__(
    method randomizer (line 74) | def randomizer(self):
    method to_binary (line 81) | def to_binary(self):
    method encrypt (line 84) | def encrypt(self):

FILE: tests/test_advanced_ciphers.py
  function test_xor (line 11) | def test_xor():
  function test_xor_tui_multi_byte (line 17) | def test_xor_tui_multi_byte(mock_click):
  function test_xor_tui (line 27) | def test_xor_tui(mock_click):
  function test_xor_tui_verbose_mode_doesnt_break (line 36) | def test_xor_tui_verbose_mode_doesnt_break(mock_click):
  function test_xor_atbash (line 45) | def test_xor_atbash():

FILE: tests/test_click.py
  function test_hello_world (line 7) | def test_hello_world():
  function test_ip_address (line 14) | def test_ip_address():
  function test_quick_visual_output (line 22) | def test_quick_visual_output(mock_click):

FILE: tests/test_click_printing.py
  function test_fix_for_655 (line 8) | def test_fix_for_655(mock_click):

FILE: tests/test_main.py
  function test_a1z26 (line 9) | def test_a1z26():
  function test_affine (line 17) | def test_affine():
  function test_ascii_shift (line 25) | def test_ascii_shift():
  function test_atbash (line 33) | def test_atbash():
  function test_baconian_complete_variant (line 41) | def test_baconian_complete_variant():
  function test_baconian_standard_variant (line 49) | def test_baconian_standard_variant():
  function test_base32 (line 57) | def test_base32():
  function test_base58_bitcoin (line 65) | def test_base58_bitcoin():
  function test_base58_ripple (line 73) | def test_base58_ripple():
  function test_base62 (line 81) | def test_base62():
  function test_base64 (line 89) | def test_base64():
  function test_base69 (line 98) | def test_base69():
  function test_base85 (line 106) | def test_base85():
  function test_base91 (line 114) | def test_base91():
  function test_baudot (line 122) | def test_baudot():
  function test_binary (line 130) | def test_binary():
  function test_binary_base64_caesar (line 142) | def test_binary_base64_caesar():
  function test_braille (line 151) | def test_braille():
  function test_brainfuck (line 159) | def test_brainfuck():
  function test_brandon (line 167) | def test_brandon():
  function test_caesar (line 175) | def test_caesar():
  function test_decimal (line 183) | def test_decimal():
  function test_dna (line 191) | def test_dna():
  function test_dtmf (line 199) | def test_dtmf():
  function test_galactic (line 207) | def test_galactic():
  function test_galactic_Xproblem (line 215) | def test_galactic_Xproblem():
  function test_gzip (line 223) | def test_gzip():
  function test_hexadecimal (line 231) | def test_hexadecimal():
  function test_json_problem (line 240) | def test_json_problem():
  function test_leetspeak (line 248) | def test_leetspeak():
  function test_morse_code (line 256) | def test_morse_code():
  function test_multi_tap (line 264) | def test_multi_tap():
  function test_new_line_at_start_returns (line 272) | def test_new_line_at_start_returns():
  function test_new_line_strip_and_return (line 280) | def test_new_line_strip_and_return():
  function test_octal (line 288) | def test_octal():
  function test_plaintext (line 296) | def test_plaintext():
  function test_quadgrams_messed_up_spacing (line 301) | def test_quadgrams_messed_up_spacing():
  function test_quadgrams_no_spaces (line 311) | def test_quadgrams_no_spaces():
  function test_quadgrams_space_between_every_letter (line 319) | def test_quadgrams_space_between_every_letter():
  function test_reversed_text (line 330) | def test_reversed_text():
  function test_rot47 (line 338) | def test_rot47():
  function test_soundex (line 346) | def test_soundex():
  function test_tap_code (line 354) | def test_tap_code():
  function test_url (line 362) | def test_url():
  function test_uuencode (line 370) | def test_uuencode():
  function test_vigenere (line 383) | def test_vigenere():
  function test_xandy (line 392) | def test_xandy():

FILE: tests/test_quick.py
  function test_quick_base32 (line 13) | def test_quick_base32():
  function test_quick_base58_ripple (line 21) | def test_quick_base58_ripple():
  function test_quick_greppable_works_with_ip_address (line 29) | def test_quick_greppable_works_with_ip_address():
  function test_quick_visual_output (line 37) | def test_quick_visual_output(mock_click):

FILE: tests/test_regex.py
  function test_regex_ip (line 7) | def test_regex_ip():
  function test_regex_domain (line 15) | def test_regex_domain():
  function test_regex_bitcoin (line 23) | def test_regex_bitcoin():