enigmapython 0.1.0__py3-none-any.whl

enigmapython/Enigma.py

@@ -0,0 +1,86 @@
+from .Observer import Observer
+from string import ascii_lowercase
+import logging
+
+
+class Enigma(Observer):
+    
+    plugboard = None
+    rotors = None
+    reflector = None
+    etw = None
+    auto_increment_rotors = False
+
+    alphabet = list(ascii_lowercase)
+
+    def __init__(self, plugboard, rotors, reflector,etw,auto_increment_rotors=False):
+        self.plugboard = plugboard
+        self.rotors = rotors
+        self.reflector = reflector
+        self.etw = etw
+        self.auto_increment_rotors = auto_increment_rotors
+        if auto_increment_rotors == True:
+            for rotor in rotors:
+                rotor.add_observer(self)
+
+    def input_string(self,str):
+        output_string = ""
+        for char in str:
+            output_string += self.input_char(char)
+        return output_string
+
+    def input_char(self,char):
+        logging.info("Input char: {}".format(char))
+        ## Triggering rotors extra rotation due to double step issue
+        for rotor in self.rotors:
+            ## Rotor extra rotation should be done only if the rotor is not the last one in the list
+            if rotor.double_step_triggered == True and self.rotors.index(rotor) < len(self.rotors)-1:
+                    rotor.increment_position()
+                    rotor.double_step_triggered = False
+        if self.auto_increment_rotors == True:
+            self.rotors[0].increment_position()
+        scrambled_char = self.process_char(char)
+        return scrambled_char           
+
+    def process_char(self, char):
+        scrambled_char = self.plugboard.switch_char(char)
+        logging.debug("Scrambled letter from plugboard: {}".format(scrambled_char))
+        iteration = 0
+        for rotor in self.rotors:
+            if iteration == 0:
+                scrambled_char = rotor.scramble_letter_index(rotor.wiring,Enigma.alphabet.index(scrambled_char))
+            else:
+                scrambled_char = rotor.scramble_letter_index(rotor.wiring,Enigma.alphabet.index(scrambled_char)-self.rotors[iteration-1].position) 
+            iteration +=1
+            logging.debug("Scrambled letter from rotor{}: {}".format(str(iteration),scrambled_char))
+        scrambled_char = self.reflector.scramble_letter_index(self.reflector.wiring,(Enigma.alphabet.index(scrambled_char)-self.rotors[iteration-1].position))
+        logging.debug("Scrambled letter from reflector: {}".format(scrambled_char))
+        for rotor in reversed(self.rotors):
+            if iteration == len(self.rotors):
+                scrambled_char = rotor.scramble_letter_index(Enigma.alphabet,(rotor.wiring.index(Enigma.shift_letter(scrambled_char,rotor.position))-rotor.position))
+            else:
+                scrambled_char = rotor.scramble_letter_index(Enigma.alphabet,(rotor.wiring.index(Enigma.shift_letter(scrambled_char, (rotor.position - self.rotors[iteration].position))) - rotor.position))
+            iteration -=1
+            logging.debug("Scrambled letter from rotor{}: {}".format(str(iteration+1),scrambled_char))   
+        scrambled_char = self.etw.switch_char(scrambled_char,-self.rotors[iteration].position)
+        logging.debug("Scrambled letter from ETW: {}".format(scrambled_char))
+        scrambled_char = self.plugboard.switch_char(scrambled_char)
+        logging.debug("Scrambled letter from plugboard: {}".format(scrambled_char))
+        logging.info("Scrambled letter to lamp: {}".format(scrambled_char))
+        return scrambled_char
+    
+    def update(self, observable, *args, **kwargs):
+        # If there is rotor N+1, increment its position by 1
+        if observable in self.rotors and self.rotors.index(observable) < len(self.rotors)-1:
+            self.rotors[self.rotors.index(observable)+1].increment_position()
+            # Engaging the enigma double step issue, only if the next rotor position is in its notch indexe/s
+            if self.rotors[self.rotors.index(observable)+1].position in self.rotors[self.rotors.index(observable)+1].notch_indexes:
+                self.rotors[self.rotors.index(observable)+1].double_step_triggered = True
+        
+    @staticmethod        
+    def shift_letter(letter,shift):
+	    return Enigma.alphabet[(Enigma.alphabet.index(letter)+shift) % len(Enigma.alphabet)]
+    
+
+
+

enigmapython/EnigmaI.py

@@ -0,0 +1,8 @@
+from .Enigma import Enigma
+
+
+class EnigmaI(Enigma):
+   
+    def __init__(self,plugboard,rotor1, rotor2, rotor3,reflector,etw,auto_increment_rotors=False):
+         rotors = [rotor1, rotor2, rotor3]
+         super().__init__(plugboard,rotors,reflector,etw,auto_increment_rotors)

enigmapython/EnigmaINorway.py

@@ -0,0 +1,8 @@
+from .Enigma import Enigma
+
+
+class EnigmaINorway(Enigma):
+   
+    def __init__(self,plugboard,rotor1, rotor2, rotor3,reflector,etw,auto_increment_rotors=False):
+         rotors = [rotor1, rotor2, rotor3]
+         super().__init__(plugboard,rotors,reflector,etw,auto_increment_rotors)

enigmapython/EnigmaINorwayRotorI.py

@@ -0,0 +1,11 @@
+from .Rotor import Rotor
+
+class EnigmaINorwayRotorI(Rotor):
+    
+    wiring = 'wtokasuyvrbxjhqcpzefmdinlg'
+    notch_indexes = [16]
+    tag = "IN_I"
+    
+    def __init__(self, position = 0, ring = 0):
+        super().__init__(self.wiring, position, ring, self.notch_indexes)
+    

enigmapython/EnigmaINorwayRotorII.py

@@ -0,0 +1,11 @@
+from .Rotor import Rotor
+
+
+class EnigmaINorwayRotorII(Rotor):
+    
+    wiring = 'gjlpubswemctqvhxaofzdrkyni'
+    notch_indexes = [4]
+    tag = "IN_II"
+    
+    def __init__(self, position = 0, ring = 0):
+        super().__init__(self.wiring, position, ring, self.notch_indexes)

enigmapython/EnigmaINorwayRotorIII.py

@@ -0,0 +1,12 @@
+from .Rotor import Rotor
+
+
+class EnigmaINorwayRotorIII(Rotor):
+    
+    wiring = 'jwfmhnbpusdytixvzgrqlaoekc'
+    notch_indexes = [21]
+    tag = "IN_III"
+
+    def __init__(self, position = 0, ring = 0):
+        super().__init__(self.wiring, position, ring, self.notch_indexes)
+

enigmapython/EnigmaINorwayRotorIV.py

@@ -0,0 +1,12 @@
+from .Rotor import Rotor
+
+
+class EnigmaINorwayRotorIV(Rotor):
+    
+    wiring = 'fgzjmvxepbwshqtliudykcnrao'
+    notch_indexes = [21]
+    tag = "IN_IV"
+
+    def __init__(self, position = 0, ring = 0):
+        super().__init__(self.wiring, position, ring, self.notch_indexes)
+

enigmapython/EnigmaINorwayRotorV.py

@@ -0,0 +1,12 @@
+from .Rotor import Rotor
+
+
+class EnigmaINorwayRotorV(Rotor):
+    
+    wiring = 'hejxqotzbvfdascilwpgynmurk'
+    notch_indexes = [25]
+    tag = "IN_V"
+
+    def __init__(self, position = 0, ring = 0):
+        super().__init__(self.wiring, position, ring, self.notch_indexes)
+

enigmapython/EnigmaIRotorI.py

@@ -0,0 +1,11 @@
+from .Rotor import Rotor
+
+class EnigmaIRotorI(Rotor):
+    
+    wiring = 'ekmflgdqvzntowyhxuspaibrcj'
+    notch_indexes = [16]
+    tag = "I_I"
+    
+    def __init__(self, position = 0, ring = 0):
+        super().__init__(self.wiring, position, ring, self.notch_indexes)
+    

enigmapython/EnigmaIRotorII.py

@@ -0,0 +1,11 @@
+from .Rotor import Rotor
+
+class EnigmaIRotorII(Rotor):
+    
+    wiring = 'ajdksiruxblhwtmcqgznpyfvoe'
+    notch_indexes = [4]
+    tag = "I_II"
+    
+    def __init__(self, position = 0, ring = 0):
+        super().__init__(self.wiring, position, ring, self.notch_indexes)
+    

enigmapython/EnigmaIRotorIII.py

@@ -0,0 +1,11 @@
+from .Rotor import Rotor
+
+class EnigmaIRotorIII(Rotor):
+    
+    wiring = 'bdfhjlcprtxvznyeiwgakmusqo'
+    notch_indexes = [21]
+    tag = "I_III"
+    
+    def __init__(self, position = 0, ring = 0):
+        super().__init__(self.wiring, position, ring, self.notch_indexes)
+    

enigmapython/EnigmaIRotorIV.py

@@ -0,0 +1,12 @@
+from .Rotor import Rotor
+
+
+class EnigmaIRotorIV(Rotor):
+    
+    wiring = 'esovpzjayquirhxlnftgkdcmwb'
+    notch_indexes = [9]
+    tag = "I_IV"
+
+    def __init__(self, position = 0, ring = 0):
+        super().__init__(self.wiring, position, ring, self.notch_indexes)
+

enigmapython/EnigmaIRotorV.py

@@ -0,0 +1,12 @@
+from .Rotor import Rotor
+
+
+class EnigmaIRotorV(Rotor):
+    
+    wiring = 'vzbrgityupsdnhlxawmjqofeck'
+    notch_indexes = [25]
+    tag = "I_V"
+
+    def __init__(self, position = 0, ring = 0):
+        super().__init__(self.wiring, position, ring, self.notch_indexes)
+

enigmapython/EnigmaISonder.py

@@ -0,0 +1,8 @@
+from .Enigma import Enigma
+
+
+class EnigmaISonder(Enigma):
+   
+    def __init__(self,plugboard,rotor1, rotor2, rotor3,reflector,etw,auto_increment_rotors=False):
+         rotors = [rotor1, rotor2, rotor3]
+         super().__init__(plugboard,rotors,reflector,etw,auto_increment_rotors)

enigmapython/EnigmaISonderRotorI.py

@@ -0,0 +1,11 @@
+from .Rotor import Rotor
+
+class EnigmaISonderRotorI(Rotor):
+    
+    wiring = 'veosirzujdqckgwypnxaflthmb'
+    notch_indexes = [16]
+    tag = "IS_I"
+    
+    def __init__(self, position = 0, ring = 0):
+        super().__init__(self.wiring, position, ring, self.notch_indexes)
+    

enigmapython/EnigmaISonderRotorII.py

@@ -0,0 +1,12 @@
+from .Rotor import Rotor
+
+
+class EnigmaISonderRotorII(Rotor):
+    
+    #wiring = 'uemoatqlshpkcyfwjzbgvxindr'
+    wiring = 'uemoatqlshpkcyfwjzbgvxidnr'
+    notch_indexes = [4]
+    tag = "IS_II"
+    
+    def __init__(self, position = 0, ring = 0):
+        super().__init__(self.wiring, position, ring, self.notch_indexes)

enigmapython/EnigmaISonderRotorIII.py

@@ -0,0 +1,12 @@
+from .Rotor import Rotor
+
+
+class EnigmaISonderRotorIII(Rotor):
+    
+    wiring = 'tzhxmbsipnurjfdkeqvcwglaoy'
+    notch_indexes = [21]
+    tag = "IS_III"
+
+    def __init__(self, position = 0, ring = 0):
+        super().__init__(self.wiring, position, ring, self.notch_indexes)
+

enigmapython/EnigmaM3.py

@@ -0,0 +1,8 @@
+from .Enigma import Enigma
+
+
+class EnigmaM3(Enigma):
+   
+    def __init__(self,plugboard,rotor1, rotor2, rotor3,reflector,etw,auto_increment_rotors=False):
+         rotors = [rotor1, rotor2, rotor3]
+         super().__init__(plugboard,rotors,reflector,etw,auto_increment_rotors)

enigmapython/EnigmaM3RotorI.py

@@ -0,0 +1,10 @@
+from .Rotor import Rotor
+from .EnigmaIRotorI import EnigmaIRotorI
+
+class EnigmaM3RotorI(EnigmaIRotorI):
+
+    tag = "M3_I"
+
+    def __init__(self, position = 0, ring = 0):
+        super().__init__(position, ring)
+    

enigmapython/EnigmaM3RotorII.py

@@ -0,0 +1,10 @@
+from .Rotor import Rotor
+from .EnigmaIRotorII import EnigmaIRotorII
+
+class EnigmaM3RotorII(EnigmaIRotorII):
+
+    tag = "M3_II"
+
+    def __init__(self, position = 0, ring = 0):
+        super().__init__(position, ring)
+    

enigmapython/EnigmaM3RotorIII.py

@@ -0,0 +1,10 @@
+from .Rotor import Rotor
+from .EnigmaIRotorIII import EnigmaIRotorIII
+
+class EnigmaM3RotorIII(EnigmaIRotorIII):
+
+    tag = "M3_III"
+
+    def __init__(self, position = 0, ring = 0):
+        super().__init__(position, ring)
+    

enigmapython/EnigmaM3RotorIV.py

@@ -0,0 +1,10 @@
+from .Rotor import Rotor
+from .EnigmaIRotorIV import EnigmaIRotorIV
+
+class EnigmaM3RotorIV(EnigmaIRotorIV):
+
+    tag = "M3_IV"
+
+    def __init__(self, position = 0, ring = 0):
+        super().__init__(position, ring)
+    

enigmapython/EnigmaM3RotorV.py

@@ -0,0 +1,10 @@
+from .Rotor import Rotor
+from .EnigmaIRotorV import EnigmaIRotorV
+
+class EnigmaM3RotorV(EnigmaIRotorV):
+
+    tag = "M3_V"
+
+    def __init__(self, position = 0, ring = 0):
+        super().__init__(position, ring)
+    

enigmapython/EnigmaM3RotorVI.py

@@ -0,0 +1,12 @@
+from .Rotor import Rotor
+
+
+class EnigmaM3RotorVI(Rotor):
+    
+    wiring = 'jpgvoumfyqbenhzrdkasxlictw'
+    notch_indexes = [12,25]
+    tag = "M3_VI"
+
+    def __init__(self, position = 0, ring = 0):
+        super().__init__(self.wiring, position, ring, self.notch_indexes)
+

enigmapython/EnigmaM3RotorVII.py

@@ -0,0 +1,12 @@
+from .Rotor import Rotor
+
+
+class EnigmaM3RotorVII(Rotor):
+    
+    wiring = 'nzjhgrcxmyswboufaivlpekqdt'
+    notch_indexes = [12,25]
+    tag = "M3_VII"
+
+    def __init__(self, position = 0, ring = 0):
+        super().__init__(self.wiring, position, ring, self.notch_indexes)
+

enigmapython/EnigmaM3RotorVIII.py

@@ -0,0 +1,12 @@
+from .Rotor import Rotor
+
+
+class EnigmaM3RotorVIII(Rotor):
+    
+    wiring = 'fkqhtlxocbjspdzramewniuygv'
+    notch_indexes = [12,25]
+    tag = "M3_VIII"
+
+    def __init__(self, position = 0, ring = 0):
+        super().__init__(self.wiring, position, ring, self.notch_indexes)
+

enigmapython/EnigmaM4.py

@@ -0,0 +1,8 @@
+from .Enigma import Enigma
+
+
+class EnigmaM4(Enigma):
+   
+    def __init__(self, plugboard, rotor1, rotor2, rotor3, rotor4, reflector, etw, auto_increment_rotors=False):
+         rotors = [rotor1, rotor2, rotor3, rotor4]
+         super().__init__(plugboard,rotors,reflector,etw,auto_increment_rotors)

enigmapython/EnigmaM4RotorBeta.py

@@ -0,0 +1,12 @@
+from .Rotor import Rotor
+
+
+class EnigmaM4RotorBeta(Rotor):
+    
+    wiring = 'leyjvcnixwpbqmdrtakzgfuhos'
+    notch_indexes = []
+    tag = "M4_Beta"
+
+    def __init__(self, position = 0, ring = 0):
+        super().__init__(self.wiring, position, ring, self.notch_indexes)
+

enigmapython/EnigmaM4RotorGamma.py

@@ -0,0 +1,12 @@
+from .Rotor import Rotor
+
+
+class EnigmaM4RotorGamma(Rotor):
+    
+    wiring = 'fsokanuerhmbtiycwlqpzxvgjd'
+    notch_indexes = []
+    tag = "M4_Gamma"
+
+    def __init__(self, position = 0, ring = 0):
+        super().__init__(self.wiring, position, ring, self.notch_indexes)
+

enigmapython/EnigmaM4RotorI.py

@@ -0,0 +1,10 @@
+from .Rotor import Rotor
+from .EnigmaM3RotorI import EnigmaM3RotorI
+
+class EnigmaM4RotorI(EnigmaM3RotorI):
+
+    tag = "M4_I"
+
+    def __init__(self, position = 0, ring = 0):
+        super().__init__(position, ring)
+    

enigmapython/EnigmaM4RotorII.py

@@ -0,0 +1,10 @@
+from .Rotor import Rotor
+from .EnigmaM3RotorII import EnigmaM3RotorII
+
+class EnigmaM4RotorII(EnigmaM3RotorII):
+
+    tag = "M4_II"
+
+    def __init__(self, position = 0, ring = 0):
+        super().__init__(position, ring)
+    

enigmapython/EnigmaM4RotorIII.py

@@ -0,0 +1,10 @@
+from .Rotor import Rotor
+from .EnigmaM3RotorIII import EnigmaM3RotorIII
+
+class EnigmaM4RotorIII(EnigmaM3RotorIII):
+
+    tag = "M4_III"
+
+    def __init__(self, position = 0, ring = 0):
+        super().__init__(position, ring)
+    

enigmapython/EnigmaM4RotorIV.py

@@ -0,0 +1,9 @@
+from .EnigmaM3RotorIV import EnigmaM3RotorIV
+
+class EnigmaM4RotorIV(EnigmaM3RotorIV):
+
+    tag = "M4_IV"
+
+    def __init__(self, position = 0, ring = 0):
+        super().__init__(position, ring)
+    

enigmapython/EnigmaM4RotorV.py

@@ -0,0 +1,9 @@
+from .EnigmaM3RotorV import EnigmaM3RotorV
+
+class EnigmaM4RotorV(EnigmaM3RotorV):
+
+    tag = "M4_V"
+
+    def __init__(self, position = 0, ring = 0):
+        super().__init__(position, ring)
+    

enigmapython/EnigmaM4RotorVI.py

@@ -0,0 +1,9 @@
+from .EnigmaM3RotorVI import EnigmaM3RotorVI
+
+class EnigmaM4RotorVI(EnigmaM3RotorVI):
+
+    tag = "M4_VI"
+
+    def __init__(self, position = 0, ring = 0):
+        super().__init__(position, ring)
+

enigmapython/EnigmaM4RotorVII.py

@@ -0,0 +1,9 @@
+from .EnigmaM3RotorVII import EnigmaM3RotorVII
+
+class EnigmaM4RotorVII(EnigmaM3RotorVII):
+
+    tag = "M4_VII"
+
+    def __init__(self, position = 0, ring = 0):
+        super().__init__(position, ring)
+

enigmapython/EnigmaM4RotorVIII.py

@@ -0,0 +1,10 @@
+from .EnigmaM3RotorVIII import EnigmaM3RotorVIII
+
+class EnigmaM4RotorVIII(EnigmaM3RotorVIII):
+
+    tag = "M4_VIII"
+
+    def __init__(self, position = 0, ring = 0):
+        super().__init__(position, ring)
+
+

enigmapython/Etw.py

@@ -0,0 +1,14 @@
+
+from string import ascii_lowercase
+
+class Etw:
+    wiring = None
+
+    def switch_char(self,char,shift):
+        return self.wiring[self.wiring.index(char)+shift]
+
+    def __init__(self, wiring):
+        self.wiring = wiring
+
+    def __str__(self):
+        return self.wiring

enigmapython/EtwPassthrough.py

@@ -0,0 +1,7 @@
+from .Etw import Etw
+
+class EtwPassthrough(Etw):
+    wiring = "abcdefghijklmnopqrstuvwxyz"
+
+    def __init__(self):
+         super().__init__(self.wiring)

enigmapython/Observable.py

@@ -0,0 +1,18 @@
+class Observable:
+
+    observers = []
+
+    def __init__(self):
+        self.observers = []
+
+    def add_observer(self, observer):
+        if observer not in self.observers:
+            self.observers.append(observer)
+
+    def remove_observer(self, observer):
+        if observer in self.observers:
+            self.observers.remove(observer)
+
+    def notify_observers(self, *args, **kwargs):
+        for observer in self.observers:
+            observer.update(self, *args, **kwargs)

enigmapython/Observer.py

@@ -0,0 +1,3 @@
+class Observer:
+    def update(self, observable, *args, **kwargs):
+        pass

enigmapython/Plugboard.py

@@ -0,0 +1,15 @@
+
+from string import ascii_lowercase
+
+class Plugboard:
+    wiring = None
+
+    def switch_char(self,char):
+        alphabet = list(ascii_lowercase)
+        return self.wiring[alphabet.index(char)]
+
+    def __init__(self, wiring):
+        self.wiring = wiring
+
+    def __str__(self):
+        return self.wiring

enigmapython/PlugboardPassthrough.py

@@ -0,0 +1,7 @@
+from .Plugboard import Plugboard
+
+class PlugboardPassthrough(Plugboard):
+    wiring = "abcdefghijklmnopqrstuvwxyz"
+
+    def __init__(self):
+         super().__init__(self.wiring)

enigmapython/Reflector.py

@@ -0,0 +1,4 @@
+from .Rotor import Rotor
+
+class Reflector(Rotor):
+    tag = None

enigmapython/ReflectorNorwayUKW.py

@@ -0,0 +1,9 @@
+from .Rotor import Rotor
+from .Reflector import Reflector
+class ReflectorNorwayUKW(Reflector):
+    
+    wiring = 'mowjypuxndsraibfvlkzgqchet'
+    tag = "IN_UKW"
+    
+    def __init__(self):
+        super().__init__(self.wiring,0)

enigmapython/ReflectorSonderUKW.py

@@ -0,0 +1,9 @@
+from .Rotor import Rotor
+from .Reflector import Reflector
+class ReflectorSonderUKW(Reflector):
+    
+    wiring = 'ciagsndrbytpzfulvhekoqxwjm'
+    tag = "IS_UKW"
+    
+    def __init__(self):
+        super().__init__(self.wiring,0)

enigmapython/ReflectorUKWA.py

@@ -0,0 +1,9 @@
+from .Rotor import Rotor
+from .Reflector import Reflector
+class ReflectorUKWA(Reflector):
+    
+    wiring = 'ejmzalyxvbwfcrquontspikhgd'
+    tag = "UKW-A"
+    
+    def __init__(self):
+        super().__init__(self.wiring,0)

enigmapython/ReflectorUKWB.py

@@ -0,0 +1,9 @@
+from .Rotor import Rotor
+from .Reflector import Reflector
+class ReflectorUKWB(Reflector):
+    
+    wiring = 'yruhqsldpxngokmiebfzcwvjat'
+    tag = "UKW-B"
+    
+    def __init__(self):
+        super().__init__(self.wiring,0)

enigmapython/ReflectorUKWBThin.py

@@ -0,0 +1,9 @@
+from .Rotor import Rotor
+from .Reflector import Reflector
+class ReflectorUKWBThin(Reflector):
+    
+    wiring = 'enkqauywjicopblmdxzvfthrgs'
+    tag = "UKW-BT"
+    
+    def __init__(self):
+        super().__init__(self.wiring,0)

enigmapython/ReflectorUKWC.py

@@ -0,0 +1,10 @@
+from .Rotor import Rotor
+from .Reflector import Reflector
+
+class ReflectorUKWC(Reflector):
+    
+    wiring = 'fvpjiaoyedrzxwgctkuqsbnmhl'
+    tag = "UKW-C"
+    
+    def __init__(self):
+        super().__init__(self.wiring,0)

enigmapython/ReflectorUKWCThin.py

@@ -0,0 +1,10 @@
+from .Rotor import Rotor
+from .Reflector import Reflector
+
+class ReflectorUKWCThin(Reflector):
+    
+    wiring = 'rdobjntkvehmlfcwzaxgyipsuq'
+    tag = "UKW-CT"
+    
+    def __init__(self):
+        super().__init__(self.wiring,0)

enigmapython/Rotor.py

@@ -0,0 +1,93 @@
+from .Observable import Observable
+from .Utils import Utils
+from string import ascii_lowercase
+import logging
+
+class Rotor(Observable):
+    original_wiring = None
+    wiring = None
+    position = None
+    rotations_counter = None
+    notch_indexes = None
+    double_step_triggered = None
+    ring = None
+    dot_position = None
+    lookup = {}
+
+    @staticmethod
+    def register(tag, class_name):
+        Rotor.lookup[tag] = class_name
+
+    def reset_position(self):
+        self.position = 0
+    
+    def increment_position(self):
+        self.position = ((self.position + 1) % len(self.wiring))
+        self.rotations_counter = self.rotations_counter + 1
+        for notch_index in self.notch_indexes:
+            logging.debug("Evaluating notch_index {} against position {}".format(notch_index+1,self.position))
+            if (self.position == ((notch_index+1) % len(self.wiring))):
+                logging.debug("Found that rotor position {} is equals to notch {}, notifying observers".format(self.position, ((notch_index+1) % len(self.wiring))))
+                self.notify_observers(None,None)
+
+    def set_position(self,position):
+        self.position = position % len(self.wiring)
+        self.rotations_counter = 0
+        
+    def scramble_letter_index(self, dictionary, letter_index):
+        scrambled_letter_index_from_rotor = dictionary.index(dictionary[(self.position + letter_index) % len(dictionary)])
+        return dictionary[scrambled_letter_index_from_rotor]
+
+    def __init__(self, wiring, position = 0, ring = 0, notch_indexes=[]):
+        self.wiring = wiring
+        self.position = position % len(wiring)
+        self.notch_indexes = notch_indexes
+        self.double_step_triggered = False
+        self.rotations_counter = 0
+        self.original_wiring = self.wiring
+        self.ring = ring
+        self.set_rotor_ring(ring)
+
+    def __str__(self):
+        pointer = ' ' * self.position + '^'
+        return self.wiring + '\n' + pointer 
+    
+    def __eq__(self, __value: object) -> bool:
+        return id(self) == id(object)
+
+    def set_rotor_ring(self, ring):
+        self.wiring = self.original_wiring
+        self.dot_position = list(self.wiring).index("a")
+        logging.debug("Dot position: " + str(self.dot_position))
+        alphabet = list(ascii_lowercase)
+        for i in range(0, ring):
+        # Set temporary wiring variable
+            temp_wiring = self.wiring
+            # Set actual wiring to empty string
+            wiring = ""
+            # Loop over chars in temporary wiring
+            for char in temp_wiring:
+                # Shift the char by one and add that shifted char to wiring variable
+                wiring += Rotor.shift(char, 1, alphabet)
+            # Add one to dot position, make sure we don't exceed the lenght of the alphabet
+            self.wiring = wiring
+            self.dot_position = (self.dot_position + 1) % len(alphabet)
+            logging.debug("Wiring shifted up the alphabet: " + wiring)
+            logging.debug("New dot position: " + str(self.dot_position))
+        i = 0
+        # While the letter at the dot position doesn't match with the ringstellung
+        while not self.wiring[self.dot_position] == alphabet[ring % len(self.wiring)]:
+            i += 1
+            # Rotate the wiring
+            self.wiring = self.wiring[-1:] + self.wiring[:-1]
+            logging.debug("Rotation " + str(i).zfill(2) + "; Wiring: " + self.wiring)
+         
+    @staticmethod
+    def shift(letter, shift, alphabet):
+        for i in range(0, len(alphabet)):
+            if alphabet[i] == letter:
+                return alphabet[(i + shift) % len(alphabet)]
+            
+    @staticmethod
+    def get_instance_from_tag(tag: str):
+        return Utils.get_class_instance(Rotor.lookup[tag].__module__+"."+Rotor.lookup[tag].__name__)()

enigmapython/SwappablePlugboard.py

@@ -0,0 +1,19 @@
+from .Plugboard import Plugboard
+from .Utils import Utils
+from .PlugboardPassthrough import PlugboardPassthrough
+
+class SwappablePlugboard(PlugboardPassthrough):
+
+    def __init__(self, chars=None):
+        super().__init__()
+        self.bulk_swap(chars)
+
+    def bulk_swap(self,chars):
+        if chars != None and isinstance(chars, dict):
+            for key, value in chars.items():
+                self.swap(key,value)
+
+    def swap(self, c1, c2):
+        if c1 != None and self.wiring.__contains__(c1) and c2 != None and self.wiring.__contains__(c2):
+            self.wiring = Utils.swap_chars(self.wiring, c1, c2)
+        

enigmapython/Utils.py

@@ -0,0 +1,31 @@
+from importlib import import_module
+
+class Utils:
+
+    @staticmethod
+    def find_all_subclasses(cls):
+        return set(cls.__subclasses__()).union(
+            [s for c in cls.__subclasses__() for s in Utils.find_all_subclasses(c)])
+
+    @staticmethod
+    def get_class_instance(cls):
+        try:
+            module_path, class_name = cls.rsplit('.', 1)
+            module = import_module(module_path)
+            return getattr(module, class_name)
+        except (ImportError, AttributeError) as e:
+            raise ImportError(cls)
+
+    @staticmethod    
+    def swap_chars(string, ch1, ch2):
+        if ch1 == ch2: return string
+        str_list = []
+        for char in string:
+            if char == ch1:
+                str_list.append(ch2)
+            elif char == ch2:
+                str_list.append(ch1)
+            else:
+                str_list.append(char)
+        return ''.join(str_list)
+    

enigmapython/__init__.py

@@ -0,0 +1,58 @@
+__all__ = [
+        'EnigmaIRotorI',
+        'EnigmaIRotorII',
+        'EnigmaIRotorIII',
+        'EnigmaIRotorIV',
+        'EnigmaIRotorV',
+        'EnigmaINorwayRotorI',
+        'EnigmaINorwayRotorII',
+        'EnigmaINorwayRotorIII',
+        'EnigmaINorwayRotorIV',
+        'EnigmaINorwayRotorV',
+        'EnigmaISonderRotorI',
+        'EnigmaISonderRotorII',
+        'EnigmaISonderRotorIII',
+        'EnigmaM3RotorI',
+        'EnigmaM3RotorII',
+        'EnigmaM3RotorIII',
+        'EnigmaM3RotorIV',
+        'EnigmaM3RotorV',
+        'EnigmaM3RotorVI',
+        'EnigmaM3RotorVII',
+        'EnigmaM3RotorVIII',
+        'EnigmaM4RotorI',
+        'EnigmaM4RotorII',
+        'EnigmaM4RotorIII',
+        'EnigmaM4RotorIV',
+        'EnigmaM4RotorV',
+        'EnigmaM4RotorVI',
+        'EnigmaM4RotorVII',
+        'EnigmaM4RotorVIII',
+        'EnigmaM4RotorBeta',
+        'EnigmaM4RotorGamma',
+        'Utils',
+        'Rotor',
+        'Plugboard',
+        'PlugboardPassthrough',
+        'Etw',
+        'EtwPassthrough',
+        'Reflector',
+        'ReflectorNorwayUKW',
+        'ReflectorSonderUKW',
+        'ReflectorUKWA',
+        'ReflectorUKWB',
+        'ReflectorUKWBThin',
+        'ReflectorUKWC',
+        'ReflectorUKWCThin',
+        'EnigmaI',
+        'EnigmaINorway',
+        'EnigmaISonder',
+        'EnigmaM3',
+        'EnigmaM4',
+        ]
+from .Rotor import Rotor
+from .Utils import Utils
+from . import *
+
+for sub in Utils.find_all_subclasses(Rotor):
+    Rotor.register(sub.tag,sub)

enigmapython-0.1.0.dist-info/METADATA

@@ -0,0 +1,5 @@
+Metadata-Version: 2.1
+Name: enigmapython
+Version: 0.1.0
+Description-Content-Type: text/markdown
+

enigmapython-0.1.0.dist-info/RECORD

@@ -0,0 +1,59 @@
+enigmapython/Enigma.py,sha256=ZoWGcAuJBI6LxXSmizimR9VMLhV18lQwFEsKr2kdYmI,4230
+enigmapython/EnigmaI.py,sha256=hpttzjWTqpaW8vLljn1TRTmg4KECHUgPtwBQAi5snXc,278
+enigmapython/EnigmaINorway.py,sha256=E6jkja7xNvC7xoBuwe3qrKlcPBFLSEeZcFxCT2-6fsg,284
+enigmapython/EnigmaINorwayRotorI.py,sha256=xWMWIYq5rzoCl8kYhmffHUiZmp1muPWly7DD5BCs-3o,281
+enigmapython/EnigmaINorwayRotorII.py,sha256=eBpmVpDc40iYohuyPhkxPuKBl5tk4kaL0eaGhR6VPvo,277
+enigmapython/EnigmaINorwayRotorIII.py,sha256=WnbY6UqKI2aYGrqYjU53wnMJg4mJHVGtNFqVvQThzbw,278
+enigmapython/EnigmaINorwayRotorIV.py,sha256=TeZfWpwcvrLG6bwoQ0VnQZtt4YFTxdqMiR8M-YYmwFI,276
+enigmapython/EnigmaINorwayRotorV.py,sha256=5czOZqiM0XIVBcZASCAe8wMcnJxeDZsv-AdyMgaB1qE,274
+enigmapython/EnigmaIRotorI.py,sha256=WSyssFcYLjYI2yrZKlxcvZ1Qcfllua3MOHzDQg9ZiZU,274
+enigmapython/EnigmaIRotorII.py,sha256=OHOsJNdZukUi4Po1YqV_n8d7eiMGj-weE5MRgur4PEQ,275
+enigmapython/EnigmaIRotorIII.py,sha256=LDeRBwOY0bqkVJn0Sd6asaswi72Gb7keG6mDa1pr1gw,278
+enigmapython/EnigmaIRotorIV.py,sha256=KlFIozCjg98YZQ4oAW3KOLumDkJ9NovA3AgG1166q54,268
+enigmapython/EnigmaIRotorV.py,sha256=PPNh0CWYO6kbctdRaoV251eTQKCym_acT_4HmTJM9OU,267
+enigmapython/EnigmaISonder.py,sha256=EdS90URItG-q4qzdcItRvb_rf8W6cJlq9NrCM2cgcCM,284
+enigmapython/EnigmaISonderRotorI.py,sha256=h2KtjKPPYUu3ZWxuXwUyClBjbcvx_gJEkM9KzyLcGRo,281
+enigmapython/EnigmaISonderRotorII.py,sha256=kjUoSSY68ndS5V76npDhVtvBtQaiuEub5siZ_YEUIyM,320
+enigmapython/EnigmaISonderRotorIII.py,sha256=Kg3SKbJtRriQG63dEwKLs8IzYxHAD0yGYJRy1yzQi0U,278
+enigmapython/EnigmaM3.py,sha256=vQEE0RBblXLODs-T-4k621XB4Urm1U8x0DViSSDmmRM,279
+enigmapython/EnigmaM3RotorI.py,sha256=RkWfcp97UEcxBI6BZTBdGE1MzsGdbDdqNCbPb3Z2nrA,217
+enigmapython/EnigmaM3RotorII.py,sha256=kzqHIke1urNjJfQ5n08OPrVeTaj8DtvGiq_rSs6Tqc8,222
+enigmapython/EnigmaM3RotorIII.py,sha256=DAHxFwj9GlYZ5DbJUyvS1ENwAPc7YwJgQQwqemYdIzg,227
+enigmapython/EnigmaM3RotorIV.py,sha256=WALWJYS9XDRnoNaQ3x3NXI7nuOEB31kzwZhA4h4M9pA,222
+enigmapython/EnigmaM3RotorV.py,sha256=2jHZNc51Ho4RLP1yownx9gxO-IMuUzjx9Ff7zzZ2Q9Q,217
+enigmapython/EnigmaM3RotorVI.py,sha256=5vtNAz7MTj2rYa387WsOAp9C8b7Tl8AISLsEQbStTIM,274
+enigmapython/EnigmaM3RotorVII.py,sha256=p628P-ud50LmJPl0QV3rnBjUaX37QzKrDpS2eljuGk8,276
+enigmapython/EnigmaM3RotorVIII.py,sha256=KYOS4tOGljpHY2TtvBqR3KiwgQOxoWNydSKkPh2piKk,278
+enigmapython/EnigmaM4.py,sha256=h_DGwJF9BUo-km4BLL6OFTVHUZbE48rCPxORA5jBE70,300
+enigmapython/EnigmaM4RotorBeta.py,sha256=wBygpofb4m7t9KL80RQ5H2ifwHxFRb6c4FNeP0ucKNA,273
+enigmapython/EnigmaM4RotorGamma.py,sha256=rO2uY7Fw3aS5JPOZX0zVIduSvXmCObWh-DeT9rS2lj0,275
+enigmapython/EnigmaM4RotorI.py,sha256=px_MXfYFX_mN--bpqTu5IO_9aqveSeAEkQUn2jeHBZo,220
+enigmapython/EnigmaM4RotorII.py,sha256=Gma6TZUhwU83sTgiwZYZVEeJUenOdN3--dmP3zbkH2c,225
+enigmapython/EnigmaM4RotorIII.py,sha256=HrZsP-jrwRcssrtB9-2RAYJZIrL5mbGoUCvodCySjak,230
+enigmapython/EnigmaM4RotorIV.py,sha256=IxQv4x9h7zSpK4XcYR3ImgpKWyZrxUilwz8nFUAWZAg,200
+enigmapython/EnigmaM4RotorV.py,sha256=73UWfrM2iETZDHIQhKGPuwi2yD78CBJbISliBgDrdSo,195
+enigmapython/EnigmaM4RotorVI.py,sha256=tjiFDQE0BZkn3DwRU3ItdDXLIH6BPiDHFAhPlZVKW1Q,196
+enigmapython/EnigmaM4RotorVII.py,sha256=pX8k-Ow2WqHuHZdNDKaFy7t2qRhGDZPTLmV26ZzBq4g,201
+enigmapython/EnigmaM4RotorVIII.py,sha256=xIpFDFHw8C5E-rYKASGR6uRuQQcOUt90MNSmYsY1tkY,207
+enigmapython/Etw.py,sha256=PI1EwG0IgEAwOrZbkZ_MhWAqcSsM84Cj-PuII1I-6hM,275
+enigmapython/EtwPassthrough.py,sha256=FEk7aIF0CAKebBZzz0CAFCevTMxwE2deCy9tSLJU3Zo,154
+enigmapython/Observable.py,sha256=9zFynI_gQuZDIR-1NZVq1T9lykaInCwtPa53_f3l3oM,482
+enigmapython/Observer.py,sha256=0KBmvK4g00ag0w0CX1Ly9HAWSE2Dsn9fGKua2LUQQ-o,79
+enigmapython/Plugboard.py,sha256=hjnabPPGhMW2XAHVEhua9dfFWiRCBGa-Q2JamJn1Z9A,307
+enigmapython/PlugboardPassthrough.py,sha256=k6VUayOgqYL6-9XnK-F8PUwubyzRZF4xxVTmmmtOS1s,179
+enigmapython/Reflector.py,sha256=T2iUu-4YIXhrH6-os7GW0tmnDlmJMWkw_yTI7pLfwqU,64
+enigmapython/ReflectorNorwayUKW.py,sha256=dbUXVbdD5P_9FrTICdqKkRIgP7VBNh7-yW-9bb27rvk,229
+enigmapython/ReflectorSonderUKW.py,sha256=WMOaSdQiwuWlCzAV6dKrjYwhut4vLiyaP50f1eBd98k,229
+enigmapython/ReflectorUKWA.py,sha256=sRGIjXnULBZKPXKD5ZXE5LGZVwk8m7QD7UEUBdLAieA,223
+enigmapython/ReflectorUKWB.py,sha256=ZMgwvnP-kOjXoGWdJ86946AllgTwRsMvtvaY-9WejAo,223
+enigmapython/ReflectorUKWBThin.py,sha256=GVySP8f0tnoKa0mhFcCdTGRezIlQgcgVgh6eZcNCaLs,228
+enigmapython/ReflectorUKWC.py,sha256=hCbE79kd21MC9gX6mM0N-Hnkx9crRc88PPL0pKPyHOc,224
+enigmapython/ReflectorUKWCThin.py,sha256=50wyVP-CdqXMDkM48LbBy0A73JVXNbynFOu0d6j-084,229
+enigmapython/Rotor.py,sha256=Oe-r2Km3Cc2rTuLzhcwRlVSS5uOAzJyfxTtPeEjaQ_c,3822
+enigmapython/SwappablePlugboard.py,sha256=xsDuzTWk6qACBwi3VoKLLHvtkL4H_qMUQ1gqziC3S5M,630
+enigmapython/Utils.py,sha256=oYobnAsvrbxwWJmkJn18p8ib1mk31_6GjZThDa50AsQ,912
+enigmapython/__init__.py,sha256=UTB1GdVmwL6OKkUOK0bzWxlBh4VDAtukVfHxDi_ttaA,1495
+enigmapython-0.1.0.dist-info/METADATA,sha256=-dCGRzCyIqVjttL4m3FmsMB5JBSyWqwHTFR2JVw_H38,97
+enigmapython-0.1.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+enigmapython-0.1.0.dist-info/top_level.txt,sha256=9lDElg8HslLQqbh6IYiY2UPRwC0EdCY4AdZKm3sl0Po,13
+enigmapython-0.1.0.dist-info/RECORD,,

enigmapython-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.43.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

enigmapython-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+enigmapython