def setUp(self):
settings = Settings()
settings_4th_rotor = Settings()
self.data = EnigmaMachineData()
self.data.set_machine("example_machine")
self.gamma = self.data.get_rotor("gamma")
self.i = self.data.get_rotor("i")
self.ii = self.data.get_rotor("ii")
self.iii = self.data.get_rotor("iii")
self.gamma.update({"start_position": "A", "position": 1})
self.i.update({"start_position": "A", "position": 2})
self.ii.update({"start_position": "A", "position": 3})
self.iii.update({"start_position": "B", "position": 4})
settings.add_entry_wheel(self.data.get_entry_wheel("etw"))
settings.add_reflector(self.data.get_reflector("b"))
settings.add_rotors([self.i, self.ii, self.iii])
self.scrambler = Scrambler(settings=settings)
settings_4th_rotor.add_entry_wheel(self.data.get_entry_wheel("etw"))
settings_4th_rotor.add_rotors([self.i, self.ii, self.iii, self.gamma])
settings_4th_rotor.add_reflector(self.data.get_reflector("b"))
self.scrambler_with_fourth_rotor = Scrambler(
settings=settings_4th_rotor)
def mouseDoubleClickEvent( self, event ):
""" Ask password and move to the admin mode """
globalData = GlobalData()
keyboard = ui.findForm( 'DigitKeyboard' )
keyboard.hideInput = True
keyboard.raise_()
keyboard.exec_()
if keyboard.cancelled:
return
debugMsg( "User input: " + keyboard.userInput )
debugMsg( "Admin password: " + Settings().adminPassword )
if keyboard.userInput != Settings().adminPassword:
return
ui.hideForm( 'TopBar' )
ui.showForm( 'AdminTopBar' )
globalData.isAdmin = True
return
def example_2():
rotor_1 = machine_data.get_rotor("iv")
rotor_2 = machine_data.get_rotor("v")
rotor_3 = machine_data.get_rotor("beta")
rotor_4 = machine_data.get_rotor("i")
etw = machine_data.get_entry_wheel('etw')
reflector = machine_data.get_reflector("a")
rotor_1.update({'start_position': 'E', 'position': 1, 'ring_setting': 18})
rotor_2.update({'start_position': 'Z', 'position': 2, 'ring_setting': 24})
rotor_3.update({'start_position': 'G', 'position': 3, 'ring_setting': 3})
rotor_4.update({'start_position': 'P', 'position': 4, 'ring_setting': 5})
settings = Settings()
settings.add_entry_wheel(etw)
settings.add_rotors([rotor_1, rotor_2, rotor_3, rotor_4])
settings.add_reflector(reflector)
settings.set_switchboard_pairs(
['PC', 'XZ', 'FM', 'QA', 'ST', 'NB', 'HY', 'OR', 'EV', 'IU'])
enigma = Enigma(settings=settings)
print(
enigma.parse(
"BUPXWJCDPFASXBDHLBBIBSRNWCSZXQOLBNXYAXVHOGCUUIBCVMPUZYUUKHI"))
def test_key_states_parser(self):
settings = Settings()
data = EnigmaMachineData()
data.set_machine("m3")
i = data.get_rotor("i")
v = data.get_rotor("v")
viii = data.get_rotor("viii")
i.update({"start_position": "P", "position": 1})
v.update({"start_position": "Y", "position": 2})
viii.update({"start_position": "Z", "position": 3})
settings.add_entry_wheel(data.get_entry_wheel("etw"))
settings.add_rotors([i, v, viii])
settings.add_reflector(data.get_reflector("b"))
enigma = Enigma(settings=settings,
error_checks=True,
correct_case=False)
with self.assertRaises(TypeError):
enigma.press_key(123)
with self.assertRaises(TypeError):
enigma.press_key(['a', 23])
with self.assertRaises(SyntaxError):
enigma.press_key("abc")
with self.assertRaises(SyntaxError):
enigma.press_key("1")
def __init__(self, *args, **kwargs):
self.config = kwargs.get('config', Settings())
self.network = kwargs.get('network', None)
assert self.network is not None, 'Network is a required argument'
self.config.load_config()
def test_non_notch_rotor_preventing_rotations(self):
settings = Settings()
data = EnigmaMachineData()
data.set_machine("example_machine")
iv = data.get_rotor("iv")
v = data.get_rotor("v")
beta = data.get_rotor("beta")
i = data.get_rotor("i")
iv.update({"start_position": "E", "ring_setting": 18, "position": 1})
v.update({"start_position": "Z", "ring_setting": 24, "position": 2})
beta.update({"start_position": "G", "ring_setting": 3, "position": 3})
i.update({"start_position": "P", "ring_setting": 5, "position": 4})
settings.add_rotors([iv, v, beta, i])
settings.add_reflector(data.get_reflector("a"))
scrambler = Scrambler(settings=settings)
self.assertEqual("E", scrambler._rotors[3].get_current_position())
self.assertEqual("Z", scrambler._rotors[2].get_current_position())
self.assertEqual("G", scrambler._rotors[1].get_current_position())
self.assertEqual("P", scrambler._rotors[0].get_current_position())
scrambler.rotate_rotors()
self.assertEqual("E", scrambler._rotors[3].get_current_position())
self.assertEqual("Z", scrambler._rotors[2].get_current_position())
self.assertEqual("G", scrambler._rotors[1].get_current_position())
self.assertEqual("Q", scrambler._rotors[0].get_current_position())
def __init__(self, screen) -> None:
self.config = Settings()
self.screen = screen
self.resources_images = Path.images() + "starter" + sep
self.bg_classic = pg.image.load(
f"{self.resources_images}classic{sep}starter_screen{Path.IMAGE_SUFFIX}"
)
self.bg_halloween = pg.image.load(
f"{self.resources_images}halloween{sep}starter_screen{Path.IMAGE_SUFFIX}"
)
self.bg_vaporwave = pg.image.load(
f"{self.resources_images}vaporwave{sep}starter_screen{Path.IMAGE_SUFFIX}"
)
self.bg_christmas = pg.image.load(
f"{self.resources_images}christmas{sep}starter_screen{Path.IMAGE_SUFFIX}"
)
self.bg_old_west = pg.image.load(
f"{self.resources_images}old_west{sep}starter_screen{Path.IMAGE_SUFFIX}"
)
self.size = self.config.size
if self.size == (1280, 720):
self.bg_classic = pg.transform.scale(self.bg_classic, (1280, 720))
self.bg_halloween = pg.transform.scale(self.bg_halloween, (1280, 720))
self.bg_vaporwave = pg.transform.scale(self.bg_vaporwave, (1280, 720))
self.bg_christmas = pg.transform.scale(self.bg_christmas, (1280, 720))
self.bg_old_west = pg.transform.scale(self.bg_old_west, (1280, 720))
def __init__(self, popup: WarningPopup, stream_title: str,
auto_contro: AutomationController, *args, **kwargs):
self.auto_contro = auto_contro
self.popup = popup
self.stream_title = stream_title
self.settings = Settings()
self.platform_settings = self.settings[f"setup_" +
f"{self.settings['streaming_service']}"]
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.settings = Settings()
self.auto_contro = AutomationController(self.settings)
self.stream_running = False
self.stream_setup = False
self.file_path = pathlib2.Path(os.path.abspath(__file__)).parent
def __init__(self):
super().__init__()
self.left = 600
self.top = 400
self.width = 640
self.height = 480
self.settings = Settings()
self.settings.settings
self.setupUI()
def __init__(self, settings=Settings(), reader=Reader()):
self.settings = settings
self.reader = reader
self.train_data_loaded = False
if self.settings.epe:
self.best_epe = self.settings.epe
else:
self.best_epe = 100.0
print("Dataset Path:", self.settings.dataset)
def __init__(self, settings=Settings()):
# some variables
self.settings = settings
self.dataset = os.path.join('dataset', settings.dataset)
self.image_data = None
self.labels_data = None
self.network = None
self.model = None
# action time
self.load_data()
def upload_initial_data(self):
logger = logging.getLogger("FaceSwap.RobotApp.upload_initial_data")
try:
self.settings = Settings("data/settings.txt")
logger.info("upload data/settings.txt")
self.strings = Strings("data/strings.txt")
logger.info("upload data/strings.txt")
except Exception as e:
logger.exception(e)
raise Exception(e)
def __init__(self, settings=Settings()):
self.settings = settings
self.mkdir_images()
self.pdir = "dataset"
self.get_max_disparity()
self.load_test_data()
self.load_mask()
self.network = None
self.train_data_loaded = False
if self.settings.epe:
self.best_epe = self.settings.epe
else:
self.best_epe = 100.0
def test_m3(self):
settings = Settings()
data = EnigmaMachineData()
data.set_machine("m3")
i = data.get_rotor("i")
v = data.get_rotor("v")
viii = data.get_rotor("viii")
i.update({"start_position": "P", "position": 1})
v.update({"start_position": "Y", "position": 2})
viii.update({"start_position": "Z", "position": 3})
settings.add_entry_wheel(data.get_entry_wheel("etw"))
settings.add_rotors([i, v, viii])
settings.add_reflector(data.get_reflector("b"))
enigma = Enigma(settings=settings)
self.assertEqual("ZMOIR", enigma.parse("AAAAA"))
def test_sondermaschine(self):
settings = Settings()
data = EnigmaMachineData()
data.set_machine("sondermaschine")
i = data.get_rotor("i")
ii = data.get_rotor("ii")
iii = data.get_rotor("iii")
i.update({"start_position": "P", "position": 1})
ii.update({"start_position": "D", "position": 2})
iii.update({"start_position": "U", "position": 3})
settings.add_entry_wheel(data.get_entry_wheel("etw"))
settings.add_rotors([i, ii, iii])
settings.add_reflector(data.get_reflector("ukw"))
enigma = Enigma(settings=settings)
self.assertEqual("WEPKI", enigma.parse("AAAAA"))
def test_norenigma(self):
settings = Settings()
data = EnigmaMachineData()
data.set_machine("norenigma")
i = data.get_rotor("i")
iii = data.get_rotor("iii")
v = data.get_rotor("v")
i.update({"start_position": "A", "position": 1})
iii.update({"start_position": "A", "position": 2})
v.update({"start_position": "A", "position": 3})
settings.add_entry_wheel(data.get_entry_wheel("etw"))
settings.add_rotors([i, iii, v])
settings.add_reflector(data.get_reflector("ukw"))
enigma = Enigma(settings=settings)
self.assertEqual("DBMZX", enigma.parse("AAAAA"))
def setUp(self):
self.root_storage = tempfile.TemporaryDirectory()
settings = Settings({'tested': True})
settings.apis['Kink.com']._site_capabilities = []
if settings.apis.get('Default', None) is not None:
settings.apis['Default']._site_capabilities = []
self.kinksorter = KinkSorter(self.root_storage.name, settings)
self.kinksorter._is_video_file = MagicMock(return_value=b"video/")
self.file1 = tempfile.NamedTemporaryFile(dir=self.root_storage.name,
delete=False)
self.file2 = tempfile.NamedTemporaryFile(dir=self.root_storage.name,
delete=False)
self.dir3 = tempfile.TemporaryDirectory(dir=self.root_storage.name)
self.file3 = tempfile.NamedTemporaryFile(dir=self.dir3.name,
delete=False)
def __init__(self):
super(daySelect, self).__init__()
self.ui = Dialog()
self.ui.setupUi(self)
self.settings = Settings()
self.class_repo = self.settings.class_path
repo_children = [
str(x.name) for x in self.class_repo.expanduser().iterdir()
]
for item in repo_children:
self.ui.daySelect.addItem(item)
self.ui.fullTime.setDisabled(True)
self.ui.buttonBox.clicked.connect(self.onSelect)
self.exec_()
def test_m4_Beta_I_II_III_B_Thin_AQEV(self):
settings = Settings()
data = EnigmaMachineData()
data.set_machine("m4")
beta = data.get_rotor("beta")
i = data.get_rotor("i")
ii = data.get_rotor("ii")
iii = data.get_rotor("iii")
beta.update({"start_position": "A", "position": 1})
i.update({"start_position": "Q", "position": 2})
ii.update({"start_position": "E", "position": 3})
iii.update({"start_position": "V", "position": 4})
settings.add_entry_wheel(data.get_entry_wheel("etw"))
settings.add_rotors([beta, i, ii, iii])
settings.add_reflector(data.get_reflector("b-thin"))
self.assertEqual("LNPJG", Enigma(settings=settings).parse("AAAAA"))
def setUp(self):
self.data_obj = EnigmaMachineData()
self.data_obj.set_machine("example_machine")
self.settings = Settings()
self.I = self.data_obj.get_rotor("i")
self.II = self.data_obj.get_rotor("ii")
self.III = self.data_obj.get_rotor("iii")
self.IV = self.data_obj.get_rotor("iv")
self.V = self.data_obj.get_rotor("v")
self.Beta = self.data_obj.get_rotor("beta")
self.Gamma = self.data_obj.get_rotor("gamma")
self.A = self.data_obj.get_reflector("a")
self.B = self.data_obj.get_reflector("b")
self.C = self.data_obj.get_reflector("c")
self.etw = self.data_obj.get_entry_wheel("etw")
self.settings.add_reflector(self.B)
self.settings.add_entry_wheel(self.etw)
def multiple_rotors_3():
rotor_1 = machine_data.get_rotor("i")
rotor_2 = machine_data.get_rotor("ii")
rotor_3 = machine_data.get_rotor("iii")
etw = machine_data.get_entry_wheel('etw')
reflector = machine_data.get_reflector("b")
rotor_1.update({'start_position': 'Q', 'position': 1})
rotor_2.update({'start_position': 'E', 'position': 2})
rotor_3.update({'start_position': 'V', 'position': 3})
settings = Settings()
settings.add_entry_wheel(etw)
settings.add_rotors([rotor_1, rotor_2, rotor_3])
settings.add_reflector(reflector)
enigma = Enigma(settings=settings)
print(enigma.parse("A"))
def multiple_rotors_4():
rotor_1 = machine_data.get_rotor("iv")
rotor_2 = machine_data.get_rotor("v")
rotor_3 = machine_data.get_rotor("beta")
etw = machine_data.get_entry_wheel('etw')
reflector = machine_data.get_reflector("b")
rotor_1.update({'start_position': 'A', 'position': 1, 'ring_setting': 14})
rotor_2.update({'start_position': 'A', 'position': 2, 'ring_setting': 9})
rotor_3.update({'start_position': 'A', 'position': 3, 'ring_setting': 24})
settings = Settings()
settings.add_entry_wheel(etw)
settings.add_rotors([rotor_1, rotor_2, rotor_3])
settings.add_reflector(reflector)
enigma = Enigma(settings=settings)
print(enigma.parse("H"))
def __init__(
self,
screen,
is_controller,
option: str,
) -> None:
self.config = Settings()
self.option = option
self.screen: pg.Surface = screen
self.background_image: pg.Surface = self.config.bg_image
self.is_controller: bool = is_controller
self.sound_chip_1 = self.config.sound_chip_1
self.sound_chip_2 = self.config.sound_chip_2
self.volume = self.config.volume
self.chip_1 = self.config.chip_1
self.chip_2 = self.config.chip_2
self.ai_chip: int = 2
def __init__(self, args):
settings = Settings()
builder = settings.returnBuilder()
# Gets the methods from the classes and sets to handler.
# Then, builder connects to any signals it needs.
classes = [Signals(settings)]
handlers = {}
for c in classes:
methods = None
try:
methods = inspect.getmembers(c, predicate=inspect.ismethod)
handlers.update(methods)
except Exception as e:
pass
builder.connect_signals(handlers)
window = settings.createWindow()
window.show()
def register():
reload_topbar_menu()
for cls in classes:
try:
bpy.utils.register_class(cls)
except ValueError:
pass
try:
bpy.types.Scene.panel_props = bpy.props.PointerProperty(
type=PanelPropertyGroup)
except AttributeError:
pass
finally:
bpy.types.TOPBAR_MT_editor_menus.append(
TOPBAR_MT_google_earth_optimization_menus.draw)
if not hasattr(bpy.types.Scene, "settings"):
bpy.types.Scene.settings = Settings(get_sources_path())
def multiple_rotors_5():
rotor_1 = machine_data.get_rotor("I")
rotor_2 = machine_data.get_rotor("ii")
rotor_3 = machine_data.get_rotor("III")
rotor_4 = machine_data.get_rotor("iv")
etw = machine_data.get_entry_wheel('etw')
reflector = machine_data.get_reflector("c")
rotor_1.update({'start_position': 'Q', 'position': 1, 'ring_setting': 7})
rotor_2.update({'start_position': 'e', 'position': 2, 'ring_setting': 11})
rotor_3.update({'start_position': 'V', 'position': 3, 'ring_setting': 15})
rotor_4.update({'start_position': 'Z', 'position': 4, 'ring_setting': 19})
settings = Settings()
settings.add_entry_wheel(etw)
settings.add_rotors([rotor_1, rotor_2, rotor_3, rotor_4])
settings.add_reflector(reflector)
enigma = Enigma(settings=settings)
print(enigma.parse("Z"))
def example_1():
rotor_1 = machine_data.get_rotor("i")
rotor_2 = machine_data.get_rotor("ii")
rotor_3 = machine_data.get_rotor("iii")
etw = machine_data.get_entry_wheel('etw')
reflector = machine_data.get_reflector("b")
rotor_1.update({'start_position': 'A', 'position': 1})
rotor_2.update({'start_position': 'A', 'position': 2})
rotor_3.update({'start_position': 'Z', 'position': 3})
settings = Settings()
settings.add_entry_wheel(etw)
settings.add_rotors([rotor_1, rotor_2, rotor_3])
settings.add_reflector(reflector)
settings.set_switchboard_pairs(
['HL', 'MO', 'AJ', 'CX', 'BZ', 'SR', 'NI', 'YW', 'DG', 'PK'])
enigma = Enigma(settings=settings)
print(enigma.parse("HELLOWORLD"))
def __init__(self):
setproctitle('GWinWrap')
GLib.unix_signal_add(GLib.PRIORITY_DEFAULT, signal.SIGINT,
gtk.main_quit)
faulthandler.enable() # For better debug info
settings = Settings()
builder = settings.returnBuilder()
# Gets the methods from the classes and sets to handler.
# Then, builder connects to any signals it needs.
classes = [CrossClassSignals(settings)]
handlers = {}
for c in classes:
methods = inspect.getmembers(c, predicate=inspect.ismethod)
handlers.update(methods)
builder.connect_signals(handlers)
window = settings.createWindow()
window.show()
def __init__(self, screen: Any, data: dict, **kwargs):
self.screen = screen
self.data = data
self.score_1, self.score_2 = data.values()
self.name_1, self.name_2 = data.keys()
self.st = Settings()
self.size = self.st.size
self.width = self.st.width
self.resources = Path.resources()
self.styles = Path.styles()
self.sounds = Path.sounds()
self.soundtrack = Path.soundtracks()
self.font = Path.fonts()
self.image = Path.images()
self._createUI(kwargs)
self.sb = ScoreboardData(data)
self.sb.updateTable()
self.sb.winnerUpdate()