def inject_mod(self, filepath):
if filepath != "":
try:
self.modToBeInjected = Mod(self)
self.modToBeInjected.loadMeta(filepath)
if (any(x.modName == self.modToBeInjected.modName
for x in self.modList)) == False:
self.modToBeInjected.install(filepath)
self.modToBeInjected.save()
self.modList.append(self.modToBeInjected)
widget = ModTileWidget(
self.modToBeInjected, self,
self.manageModsScrollFrame.scrollable_frame,
self.modList.index(self.modToBeInjected), 0)
self.modWidgetList.append(widget)
else:
messagebox.showinfo(
"Information",
"Mod with this name is already installed, try remove any mods with the same name!"
)
#Add in option to continue?
#> Nah bro i'm lazy
except Exception as error:
print(error)
messagebox.showerror("Error!",
"The selected mod failed to install.")
def points(self):
i = 0
for x in range(self.mod):
x = Mod(x, self.mod)
for y in range(self.mod):
y = Mod(y, self.mod)
if self.on_curve((x, y), quiet=True):
print(f"{str(i).zfill(2)} - ({x.i}, {y.i})")
i += 1
def __init__(self,
markov_chain_db: str,
head_db: str,
pmi_db: str,
logger=None):
Mod.__init__(self, logger)
self.markov_chain_db = markov_chain_db
self.head_db = head_db
self.gen = MarkovChain(self.markov_chain_db)
self.hs = HeadSelector(self.head_db, pmi_db)
def __init__(
self,
filename: str=None,
logger=None
):
Mod.__init__(self, logger)
self.dict_path = filename or os.path.join(
os.path.abspath(os.path.dirname(__file__)),
"pattern_dict.txt"
)
self.re_text_lst = self.load_dict()
def retrieve_original(secrets, P):
x_s = [s[0] for s in secrets]
acc = Mod(0, P)
for i in range(len(secrets)):
others = list(x_s)
cur = others.pop(i)
factor = Mod(1, P)
for el in others:
factor *= el * (el - cur).inverse()
acc += factor * secrets[i][1]
return acc
def __init__(
self,
markov_chain_db: str,
head_db: str,
pmi_db: str,
logger=None
):
Mod.__init__(self, logger)
self.markov_chain_db = markov_chain_db
self.head_db = head_db
self.gen = MarkovChain(self.markov_chain_db)
self.hs = HeadSelector(self.head_db, pmi_db)
def test_inverse():
number = Mod(7, 17)
assert int(number) == 7
assert number.modulus == 17
other = number.inverse()
assert int(other) == 5
assert other.modulus == 17
product = number * other
assert int(product) == 1
assert product.modulus == 17
def __init__(
self,
filename: str=None,
train: bool=False,
logger=None
):
Mod.__init__(self, logger)
self.dict_path = filename or os.path.join(
os.path.abspath(os.path.dirname(__file__)),
"random_dict.txt"
)
self.is_train = train
self.random_texts = self.load_dict()
def test_copy():
number = Mod(7, 17)
assert int(number) == 7
assert number.modulus == 17
other = number.copy()
assert number == other
assert int(other) == 7
assert other.modulus == 17
other = number.copy(modulus=5)
assert number == other
assert int(other) == 2
assert other.modulus == 5
def double(self, p):
(x1, y1) = p
x1 = Mod(x1, self.mod)
y1 = Mod(y1, self.mod)
print(f"2({x1.i}, {y1.i}) = ")
print(f"(({x1.i} * {y1.i} * 2) / ({x1.i}^2 + {y1.i}^2), "
f"({y1.i}^2 - {x1.i}^2) / (2 - {x1.i}^2 - {y1.i}^2)) = ")
print(
f"({(x1 * y1 * 2).i}/{(((x1 ^ 2) + (y1 ^ 2))).i}, "
f"{((y1 ^ 2) - (x1 ^ 2)).i}/{(Mod(2, self.mod) - (x1 ^ 2) - (y1 ^ 2)).i}) = "
)
x3 = (x1 * y1 * 2) / ((x1 ^ 2) + (y1 ^ 2))
y3 = ((y1 ^ 2) - (x1 ^ 2)) / (Mod(2, self.mod) - (x1 ^ 2) - (y1 ^ 2))
print(f"({x3.i}, {y3.i})")
def test_mod_ipow(mod_127):
with pytest.raises(AttributeError):
mod_127 **= 'hello'
with pytest.raises(ValueError):
mod_127 **= Mod(3, 5)
old_id = id(mod_127)
mod_127 **= 5
assert mod_127.value == 3
assert old_id == id(mod_127)
mod_127 **= Mod(4, 7)
assert mod_127.value == 4
assert old_id == id(mod_127)
def handle_small_numbers(a, b, operation, p):
if operation == '+':
return Mod(a+b, p)
# return int(a + b % p)
elif operation == '-':
return Mod(a-b, p)
# return int(a - b % p)
elif operation == '*':
return Mod(a*b, p)
# return int(a * b % p)
elif operation == '/':
return Mod(a/b, p)
# return int(a / b % p)
else:
return None
def find_pq(b, n, mod=modulus, a=base):
print(b, n, mod, a)
a = Mod(a, mod)
b = Mod(b, mod)
max_p = ceil(mod / n)
max_q = n
n = Mod(n, mod)
vals_p = sorted([(p, a**(n * p)) for p in range(1, max_p + 1)],
key=lambda x: x[1])
for q in range(max_q + 1):
q = Mod(q, mod)
val_q = b * a**q
ip = find_value_sorted(vals_p, val_q, lambda x: x[1])
if ip is not None:
return vals_p[ip][0], q
def test_ordering(mod_127):
assert mod_127 > 3
assert mod_127 >= 5
assert mod_127 < 6
assert mod_127 <= 5
assert mod_127 > Mod(2, 7)
assert mod_127 >= Mod(19, 7)
assert mod_127 < Mod(6, 7)
assert mod_127 <= Mod(6, 7)
with pytest.raises(AttributeError):
mod_127 < 'hello'
with pytest.raises(ValueError):
mod_127 > Mod(5, 3)
def E2M(self, E, p):
"""Import point p=(x,y) from EdwardsCurve E."""
if self.mod != E.mod:
print("Curves have different modulus")
return
(x, y) = p
x = Mod(x, self.mod)
y = Mod(y, self.mod)
one = Mod(1, self.mod)
print(f"u = (1+{y.i})/(1-{y.i}) =")
print(f"{(one + y).i}/{(one - y).i} =")
u = (one + y) / (one - y)
print(f"{u.i}")
v = u / x
print(f"v = {u.i}/{x.i} = {v.i}")
def CRTM(mods):
'''Return the solution to the Chinese Remainder Theorem as an element
of a Mod class, x mod N. The parameter is a nonempty sequence of
Mod class instances, where all the parameter moduli are coprime.
N is the product of the parameter moduli.
For each element a mod m of mods, x satisfies: a mod m equals x mod m.
>>> vals = [Mod(2, 3), Mod(3, 4), Mod(1, 5)]
>>> x = CRTM(vals)
>>> print x
11 mod 60
>>> for val in vals:
... print val, int(val - x.value)
2 mod 3 0
3 mod 4 0
1 mod 5 0
'''
N = 1 # will be product of moduli
for a in mods:
N *= a.modulus()
x = Mod(0, N)
for a in mods:
m = a.modulus()
Nd = N // m
gcd, s, t = xgcd(m, Nd) # t*Nd = 1 mod m
assert gcd == 1, 'moduli not coprime!' # not required, but good idea
x += a.value * t * Nd
return x
def turnbyturn(self):
game = True
self.current = self.PLAYERS[0]
self.turnno = Mod(0, len(self.PLAYERS))
while game:
self.OTHPLYR = [x for x in self.PLAYERS if x != self.current]
actions = input("Are there any actions you wish to perform? ")
actions = actions.lower()
if actions == 'change name':
newname = input('To what do you wish to change your name? ')
self.current.changename(newname)
elif actions == 'Trade':
self.sellaprop(self.current)
elif actions == 'mortgage':
self.mortgagizer(True)
elif actions == 'demortgage':
self.mortgagizer(False)
elif actions == 'help':
site = "https://en.wikibooks.org/wiki/Monopoly/Official_Rules"
webbrowser.open(site)
elif actions == 'houses':
self.addahouse()
dice = self.move(self.current)
if dice[0] != dice[1]:
self.turnno += 1
self.current = self.PLAYERS[self.turnno]
def test_mod_isub(mod_127):
with pytest.raises(AttributeError):
mod_127 -= 'hello'
mod_127 -= 'test'
with pytest.raises(ValueError):
mod_127 -= Mod(3, 5)
old_id = id(mod_127)
mod_127 -= 5
assert mod_127.value == 0
assert old_id == id(mod_127)
mod_127 -= Mod(4, 7)
assert mod_127.value == 3
assert old_id == id(mod_127)
def DecryptPress():
n = int(NInput.get())
d = int(DInput.get())
message = TextInput.get()
pu_key = Mod(d, n)
DecMessage = Decrypt(message, pu_key)
print("Your decrypted message is:", DecMessage)
def find_first_subsequent_timestamp_old(busses):
offsets = []
bus_ids = []
largest_bus_id = 0
largest_i = 0
denominators = []
modulos = []
for i, bus in enumerate(busses):
if bus != "x":
bus_id = int(bus)
denominators.append(bus_id)
if bus_id > largest_bus_id:
largest_bus_id = bus_id
largest_i = i
offsets.append(i)
bus_ids.append(bus_id)
modulos.append(Mod(i, bus_id))
c = count(-largest_i, largest_bus_id)
a = offsets
b = bus_ids
res = filter(
lambda n: all(
list(map(eq, map(mod, map(add, repeat(n), a), b), repeat(0)))), c)
r = next(res)
return r
def EncryptPress():
n = int(NInput.get())
e = int(EInput.get())
message = TextInput.get()
pu_key = Mod(e, n)
EncMessage = Encrypt(message, pu_key)
print("Your encrypted message is:", EncMessage)
def concat_clones_of_num(num, num_len, k):
"""
concat_clones_of_num(num, k) -> number
Creates a number formed of concatenating k appearences of num.
For multiplying num for k times, using the summary of the geometric
progression of:
an = a1 * 2 ** (num_len * k)
Which represents the binary digits that in decimal base can multiply
num fo k times.
:@param num(int) - A number
:@param k(int) - A number presenting the amount of appearnces
:@result tuple(int, int) - A tuple of the result of concatenating num to itself
k times, and the result length.
"""
# Verbose.
print("Concatenating the number for {0} times".format(k))
# Initialize.
res_num = 0
#
result = get_gp_sum(num, Mod(10**num_len, MOD), k)
# Returning num multiplied, and its length for future calculations.
return result, num_len * k
def test_new_object():
number = Mod(7, 17)
assert int(number) == 7
assert number.modulus == 17
with raises(ValueError):
Mod(15, 0)
with raises(ValueError):
Mod(15, 7.5)
with raises(ValueError):
Mod('15', 7)
with raises(TypeError):
Mod(15)
def test_pow_is_multiple_multiplications():
number = Mod(2, 3)
assert number == 2
modified = number**4
assert modified == 1
assert modified.modulus == 3
assert modified == number * number * number * number
def __init__(self, name):
self.NAME = name
self.bank = account(1500)
self.space = Mod(0, 40)
self.houseno = 0
self.keptcards = []
self.owned = []
self.namelist.append(name)
def __new__(self, day, hour, minute):
assert (day >= 0 and day < 7), "Day must be between 0 and 6"
assert (hour >= 0 and hour < 24), "Hour must be between 0 and 23"
assert (minute >= 0 and minute < 60), "Minute must be between 0 and 59"
# Value is in seconds for easy interchange with Unix Epoch format
seconds_per_week = 7*24*60*60
raw_datetime = day*24*60*60 + hour*60*60 + minute*60
return Mod(raw_datetime, seconds_per_week)
def buildA(r, s):
A = np.zeros((r + s, r * s))
for i in range(r):
for j in range(s):
A[i, j + s * i] = 1
for i in range(s):
for j in range(r * s):
if Mod(j - i, s) == 0:
A[i + r, j] = 1
return A
def test_init():
a = Arduino("Test Arduino")
mod = Mod(a, "Test Mod", "Test api", 0xA9, 0xAB, 0xAA)
assert mod.name == "Test Mod"
assert mod.api == "Test api"
assert mod.mod.arduino.name == "Test Arduino"
assert mod.indicator.arduino.name == "Test Arduino"
assert mod.button.arduino.name == "Test Arduino"
def test_floordiv_is_reversed_multiplication():
number = Mod(2, 7)
assert number == 2
assert (number * 3) // 3 == number == 2
assert (number * 8) // 2 == 4 * number == 1
assert number * 7 == 0
with pytest.raises(ZeroDivisionError):
(number * 7) // 7
def getExternalMod(folder, language: str):
mod_lua = open(os.path.join(folder, "mod.lua"), "r", encoding="utf-8")
mod_lua_text = mod_lua.read()
authors = None
name = None
minorVersion = None
try:
mod_json = open(os.path.join(folder, "mod.json"), "r", encoding="utf-8")
except FileNotFoundError:
mod_json = None
if mod_json:
mod_json = json.loads(mod_json.read())
name = mod_json["name"]
authors = mod_json["authors"]
minorVersion = mod_json["minorVersion"]
if not name:
name = getName(folder, mod_lua_text, language)
if not minorVersion:
x = re.search("minorVersion.*=.*,", mod_lua_text)
if x:
x = x.group()[11: len(x.group()) - 1]
minorVersion = int(re.findall("[0-9]", x)[0])
else:
minorVersion = None
x = re.search("tfnetId.*,", mod_lua_text)
if x:
source = "transportfever.net"
else:
source = "other"
try:
image = open(os.path.join(folder, "workshop_preview.jpg"), "r")
image = os.path.join(folder, "workshop_preview.jpg")
except FileNotFoundError:
image = None
x = re.search("options.*=.*{", mod_lua_text)
if x:
options = True
else:
try:
open(os.path.join(folder, "settings.lua"), "r")
options = True
except FileNotFoundError:
options = False
category_image = get_Category(folder)
return Mod(name, minorVersion, source, image, options, folder, authors, category_image)
def test_pow_zero():
number = Mod(2, 2)
assert number == 0
modified = number**2
assert modified == 0
assert modified.modulus == 2
modified = number**0
assert modified == 1
assert modified.modulus == 2
def test_ipow_zero():
number = Mod(2, 2)
assert number == 0
modified = number
modified **= 2
assert modified == 0
assert modified.modulus == 2
modified **= 0
assert modified == 1
assert modified.modulus == 2
def get_mods(filters):
from mod import Mod
all_mod_data = get_data(('data/gun_mods.csv', 'data/melee_mods.csv'), filters)
mods = {}
for mod_data in all_mod_data:
mod = Mod()
mod.s = {}
for stat in mod_data:
if stat == 'name':
mod.name = mod_data[stat]
elif stat == 'type':
pass
elif stat == 'polarity':
mod.polarity = polarity_names[mod_data[stat]]
elif stat == 'drain':
mod.drain = int(mod_data[stat])
elif stat == 'max_rank':
mod.max_rank = int(mod_data[stat])
elif stat == 'primed':
mod.primed = mod_data[stat] == 'True'
elif stat == 'bow2xfr':
mod.bow2xfr = mod_data[stat] == 'True'
elif stat == 'corrupted':
mod.corrupted = mod_data[stat] == 'True'
elif mod_data[stat] != '':
mod.s[stat] = float(mod_data[stat])
if stat == 'damage_faction':
mod.faction = True
mods[mod.name] = mod
return mods
