class NewSession:
"""Create a session for connecting to repl.it. The session is good because
then one connection to repl.it is needed for all scrapes and not a new
connection per scrape."""
def __init__(self, proxies={}):
# Create new session
self.request_session = requests.Session()
self.proxies = proxies
# Use header that makes it seem less like a bot
self.headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/55.0.2883.87 Safari/537.36",
"Accept-Language": "en-US,en;q=0.8",
"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8"}
# repl base is A-Z0-9a-z
repl_it_string = string.ascii_uppercase + string.digits + string.ascii_lowercase
self.repl_it_base = BaseConverter(repl_it_string)
def decode(self, number):
"Decode repl.it code id to a base 10 number"
return int(self.repl_it_base.decode(number))
def encode(self, number):
"Encode base 10 number to repl.it code id"
return self.repl_it_base.encode(number)
def get_repl_save(self, code_id):
"Save repl.it by code id"
repl_html = self.get_repl_it_html(code_id)
return self.get_data_from_html(repl_html, code_id)
def get_repl_it_html(self, code_id):
"Get html for code id"
url = 'https://repl.it/{}'.format(code_id)
return self.request_session.get(url, proxies=self.proxies, headers=self.headers).text
def get_data_from_html(self, repl_html, code_id):
"Get all data from the html"
# All the data we need is in the HTML
soup = BeautifulSoup(repl_html, 'html.parser')
try:
editor_data = [x.text for x in soup.findAll('script') if 'REPLIT_DATA' in x.text][0]
except IndexError:
data = {}
data['session_id'] = code_id
for x in ['language', 'time_created',
'time_updated', 'owner', 'title', 'editor_text']:
data[x] = '404'
return data
editor_data_json = re.findall('{.*}', editor_data)[0]
data = json.loads(editor_data_json)
del data['console_dump'] # Not needed
# String is HTML escaped so we need to unescape it
data['editor_text'] = html.unescape(data['editor_text'])
return data
class IdConverter(object):
"""
Generates an id based on an integer.
Essentially it's a small hashing algorithm that allows us to
give unique ids that aren't too long.
"""
def __init__(
self,
state: int = 0,
prefix: str = "",
length: int = 4,
alphabet: str = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ',
) -> None:
"""
"""
self.state = state
self.prefix = prefix
self.length = length
self.alphabet = alphabet
from baseconv import BaseConverter
self.converter = BaseConverter(alphabet)
return
def encode(self, number: int) -> str:
"""
"""
template = "{pre}{{p:{first}>{length}}}".format(
pre=self.prefix,
first=self.converter.digits[0],
length=self.length,
)
return template.format(p=self.converter.encode(number))
def decode(self, pattern: str) -> int:
"""
"""
pattern = pattern[len(self.prefix):]
return int(self.converter.decode(pattern))
def __next__(self):
string = self.encode(self.state)
self.state += 1
return string
def __iter__(self):
return self
def is_jam_coin(f, base, primes, res):
conv = BaseConverter(('').join(map(str, [ tmp for tmp in range(0, base) ])))
f = int(conv.decode(f))
if base == 10:
factor = find_prime_fact(f, primes)
if factor:
res.append(factor)
return True
else:
return False
factor = find_prime_fact(f, primes)
if factor:
res.append(factor)
return is_jam_coin(conv.encode(f), base+1, primes, res)
else:
return False
def find_prime(f, base, res):
conv = BaseConverter(('').join(map(str, [tmp for tmp in range(0, base)])))
f = int(conv.decode(f))
if base == 10:
factor = get_prime_factor(f)
if factor:
res.append(factor)
return True
else:
return False
factor = get_prime_factor(f)
if factor:
res.append(factor)
return find_prime(conv.encode(f), base + 1, res)
else:
return False
def is_jam_coin(f, base, primes, res):
conv = BaseConverter(('').join(map(str, [tmp for tmp in range(0, base)])))
f = int(conv.decode(f))
if base == 10:
factor = find_prime_fact(f, primes)
if factor:
res.append(factor)
return True
else:
return False
factor = find_prime_fact(f, primes)
if factor:
res.append(factor)
return is_jam_coin(conv.encode(f), base + 1, primes, res)
else:
return False
from baseconv import BaseConverter
import random
primary_numbers = []
secondary_numbers = []
outputs = []
for i in xrange(25):
ternary_string1 = ""
for j in xrange(random.randint(50, 100)):
ternary_string1 += str(random.randint(0,2))
ternary_string2 = ""
for j in xrange(random.randint(50, 100)):
ternary_string2 += str(random.randint(0,2))
base3 = BaseConverter("012")
decimal_string1 = base3.decode(ternary_string1)
decimal_string2 = base3.decode(ternary_string2)
decimal_output = int(decimal_string1) - int(decimal_string2)
ternary_output = base3.encode(str(decimal_output))
input = ternary_string1 + "#" + ternary_string2
expected_output = ternary_output
print "Input:"
print input
print "Expected Output:"
print expected_output
print
from baseconv import BaseConverter
string =['2d', '33', '2g', '1i', '2c', '31', '4f', '20', '1p', '3e', '1o',
'3n', '3e', '1l', '3e', '3i', '1p', '46', '1p', '40', '3n', '1l', '3e', '1p',
'45', '49', '1m', '3e', '1o', '3n', '3e', '3h', '3g', '47', '3k', '3e', '1n',
'21', '4h'];
full = '0123456789abcdefghijklmnopqrstuvxwyz'
size = len(full)
zero = 0
for i in string:
if ord(i[1]) > zero:
zero = ord(i[1])
for i in range((full.find(chr(zero)) + 1), size):
base = BaseConverter(full[0:i])
result = []
for j in string:
result.append(int(base.decode(j)))
text = ''.join(chr(c) for c in result)
print text
pt_i = pattern[:1][0]
pt_t = pattern[-1:][0]
pt = pt_i + pt_t
# print(pt)
if pt == 'UU' or pt == 'SU':
return 2
elif pt == 'DD' or pt == 'SD':
return 0
else:
return 1
def encode_column_to_range_index(x, i=0, alpha=0.001):
# print(x,i)
for f in filter_ranges:
if f['range'][0] <= x + (alpha * i) <= f['range'][1]:
return f['label']
# print("None",x)
return "U"
def decode_column_to_int(x):
return int(encoder_base.decode(x)) / float(
encoder_base.decode("".rjust(len(x), 'D')))
encode_column_to_range_index(-0.02)
decode_column_to_int("UUUDSDSSS")
encoder_base.decode("DDDDDDDDD")
from baseconv import BaseConverter
import random
primary_numbers = []
secondary_numbers = []
outputs = []
for i in xrange(25):
ternary_string1 = ""
for j in xrange(random.randint(50, 100)):
ternary_string1 += str(random.randint(0, 2))
ternary_string2 = ""
for j in xrange(random.randint(50, 100)):
ternary_string2 += str(random.randint(0, 2))
base3 = BaseConverter("012")
decimal_string1 = base3.decode(ternary_string1)
decimal_string2 = base3.decode(ternary_string2)
decimal_output = int(decimal_string1) - int(decimal_string2)
ternary_output = base3.encode(str(decimal_output))
input = ternary_string1 + "#" + ternary_string2
expected_output = ternary_output
print "Input:"
print input
print "Expected Output:"
print expected_output
print
