enigmapython 0.1.0__tar.gz

enigmapython-0.1.0/PKG-INFO

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

enigmapython-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/enigmapython/EtwPassthrough.py

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

enigmapython-0.1.0/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-0.1.0/enigmapython/Observer.py

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

enigmapython-0.1.0/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-0.1.0/enigmapython/PlugboardPassthrough.py

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

enigmapython-0.1.0/enigmapython/Reflector.py

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

enigmapython-0.1.0/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-0.1.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-0.1.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-0.1.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-0.1.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-0.1.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-0.1.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-0.1.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-0.1.0/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-0.1.0/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-0.1.0/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/enigmapython.egg-info/PKG-INFO

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

enigmapython-0.1.0/enigmapython.egg-info/SOURCES.txt

@@ -0,0 +1,60 @@
+setup.py
+enigmapython/Enigma.py
+enigmapython/EnigmaI.py
+enigmapython/EnigmaINorway.py
+enigmapython/EnigmaINorwayRotorI.py
+enigmapython/EnigmaINorwayRotorII.py
+enigmapython/EnigmaINorwayRotorIII.py
+enigmapython/EnigmaINorwayRotorIV.py
+enigmapython/EnigmaINorwayRotorV.py
+enigmapython/EnigmaIRotorI.py
+enigmapython/EnigmaIRotorII.py
+enigmapython/EnigmaIRotorIII.py
+enigmapython/EnigmaIRotorIV.py
+enigmapython/EnigmaIRotorV.py
+enigmapython/EnigmaISonder.py
+enigmapython/EnigmaISonderRotorI.py
+enigmapython/EnigmaISonderRotorII.py
+enigmapython/EnigmaISonderRotorIII.py
+enigmapython/EnigmaM3.py
+enigmapython/EnigmaM3RotorI.py
+enigmapython/EnigmaM3RotorII.py
+enigmapython/EnigmaM3RotorIII.py
+enigmapython/EnigmaM3RotorIV.py
+enigmapython/EnigmaM3RotorV.py
+enigmapython/EnigmaM3RotorVI.py
+enigmapython/EnigmaM3RotorVII.py
+enigmapython/EnigmaM3RotorVIII.py
+enigmapython/EnigmaM4.py
+enigmapython/EnigmaM4RotorBeta.py
+enigmapython/EnigmaM4RotorGamma.py
+enigmapython/EnigmaM4RotorI.py
+enigmapython/EnigmaM4RotorII.py
+enigmapython/EnigmaM4RotorIII.py
+enigmapython/EnigmaM4RotorIV.py
+enigmapython/EnigmaM4RotorV.py
+enigmapython/EnigmaM4RotorVI.py
+enigmapython/EnigmaM4RotorVII.py
+enigmapython/EnigmaM4RotorVIII.py
+enigmapython/Etw.py
+enigmapython/EtwPassthrough.py
+enigmapython/Observable.py
+enigmapython/Observer.py
+enigmapython/Plugboard.py
+enigmapython/PlugboardPassthrough.py
+enigmapython/Reflector.py
+enigmapython/ReflectorNorwayUKW.py
+enigmapython/ReflectorSonderUKW.py
+enigmapython/ReflectorUKWA.py
+enigmapython/ReflectorUKWB.py
+enigmapython/ReflectorUKWBThin.py
+enigmapython/ReflectorUKWC.py
+enigmapython/ReflectorUKWCThin.py
+enigmapython/Rotor.py
+enigmapython/SwappablePlugboard.py
+enigmapython/Utils.py
+enigmapython/__init__.py
+enigmapython.egg-info/PKG-INFO
+enigmapython.egg-info/SOURCES.txt
+enigmapython.egg-info/dependency_links.txt
+enigmapython.egg-info/top_level.txt

enigmapython-0.1.0/enigmapython.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

enigmapython-0.1.0/enigmapython.egg-info/top_level.txt

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

enigmapython-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

enigmapython-0.1.0/setup.py

@@ -0,0 +1,14 @@
+from setuptools import setup, find_packages
+
+
+setup(
+    name="enigmapython",
+    version="0.1.0",
+    packages=find_packages(
+        # All keyword arguments below are optional:
+        where='.',  # '.' by default
+        include=['enigmapython'],  # ['*'] by default
+    ),
+    long_description=open('./enigmapython/README.txt').read(),
+    long_description_content_type='text/markdown'
+)