def __init__(self, packet, table_map, table_subscribed):
super(RowsEvent, self).__init__(packet)
self._payload = packet[23:]
self._table_map = table_map
self._table_subscribed = table_subscribed
head = self._payload
# header
head, self.table_id = utils.read_int(head, 6)
head, self.flags = utils.read_int(head, 2)
# with MySQL 5.6.x there will be other data following.
# body
head, self.number_of_columns = utils.read_lc_int(head)
columns_present_bitmap_len = (self.number_of_columns + 7) / 8
head, columns_present_bitmap1 = utils.read_int(head,
columns_present_bitmap_len)
if self.header.event_type == EventType.UPDATE_ROWS_EVENT:
head, columns_present_bitmap2 = utils.read_int(head,
columns_present_bitmap_len)
# read rows.
null_bitmap_len = (self.number_of_columns + 7) / 8;
head, null_bitmap = utils.read_int(head, null_bitmap_len)
row = {}
for i in range(self.number_of_columns):
is_null = True if ((null_bitmap[i/8] >> (i%8)) & 0x01) else False
def _pkt_parse_eof(self, buf):
"""Parse a MySQL EOF-packet"""
res = {}
buf = buf[1:] # disregard the first checking byte
(buf, res['warning_count']) = utils.read_int(buf, 2)
(buf, res['status_flag']) = utils.read_int(buf, 2)
return res
def _pkt_parse_field(self, buf):
"""Parse a MySQL Field-packet"""
field = {}
(buf,field['catalog']) = utils.read_lc_string(buf)
(buf,field['db']) = utils.read_lc_string(buf)
(buf,field['table']) = utils.read_lc_string(buf)
(buf,field['org_table']) = utils.read_lc_string(buf)
(buf,field['name']) = utils.read_lc_string(buf)
(buf,field['org_name']) = utils.read_lc_string(buf)
buf = buf[1:] # filler 1 * \x00
(buf,field['charset']) = utils.read_int(buf, 2)
(buf,field['length']) = utils.read_int(buf, 4)
(buf,field['type']) = utils.read_int(buf, 1)
(buf,field['flags']) = utils.read_int(buf, 2)
(buf,field['decimal']) = utils.read_int(buf, 1)
buf = buf[2:] # filler 2 * \x00
res = (
field['name'],
field['type'],
None, # display_size
None, # internal_size
None, # precision
None, # scale
~field['flags'] & FieldFlag.NOT_NULL, # null_ok
field['flags'], # MySQL specific
)
return res
def _parse(self):
version = ''
options = 0
srvstatus = 0
buf = self.data
(buf,self.protocol) = utils.read_int(buf,1)
(buf,version) = utils.read_string(buf,end='\x00')
(buf,thrdid) = utils.read_int(buf,4)
(buf,scramble) = utils.read_bytes(buf, 8)
buf = buf[1:] # Filler 1 * \x00
(buf,srvcap) = utils.read_int(buf,2)
(buf,charset) = utils.read_int(buf,1)
(buf,serverstatus) = utils.read_int(buf,2)
buf = buf[13:] # Filler 13 * \x00
(buf,scramble_next) = utils.read_bytes(buf,12)
scramble += scramble_next
self.info = {
'version' : version,
'thrdid' : thrdid,
'seed' : scramble,
'capabilities' : srvcap,
'charset' : charset,
'serverstatus' : serverstatus,
}
def parse_column(self, packet):
"""Parse a MySQL column-packet"""
column = {}
(packet, column['catalog']) = utils.read_lc_string(packet[4:])
(packet, column['db']) = utils.read_lc_string(packet)
(packet, column['table']) = utils.read_lc_string(packet)
(packet, column['org_table']) = utils.read_lc_string(packet)
(packet, column['name']) = utils.read_lc_string(packet)
(packet, column['org_name']) = utils.read_lc_string(packet)
packet = packet[1:] # filler 1 * \x00
(packet, column['charset']) = utils.read_int(packet, 2)
(packet, column['length']) = utils.read_int(packet, 4)
(packet, column['type']) = utils.read_int(packet, 1)
(packet, column['flags']) = utils.read_int(packet, 2)
(packet, column['decimal']) = utils.read_int(packet, 1)
packet = packet[2:] # filler 2 * \x00
return (
column['name'],
column['type'],
None, # display_size
None, # internal_size
None, # precision
None, # scale
~column['flags'] & FieldFlag.NOT_NULL, # null_ok
column['flags'], # MySQL specific
)
def parse_column(self, packet):
"""Parse a MySQL column-packet"""
column = {}
(packet, column['catalog']) = utils.read_lc_string(packet[4:])
(packet, column['db']) = utils.read_lc_string(packet)
(packet, column['table']) = utils.read_lc_string(packet)
(packet, column['org_table']) = utils.read_lc_string(packet)
(packet, column['name']) = utils.read_lc_string(packet)
(packet, column['org_name']) = utils.read_lc_string(packet)
packet = packet[1:] # filler 1 * \x00
(packet, column['charset']) = utils.read_int(packet, 2)
(packet, column['length']) = utils.read_int(packet, 4)
(packet, column['type']) = utils.read_int(packet, 1)
(packet, column['flags']) = utils.read_int(packet, 2)
(packet, column['decimal']) = utils.read_int(packet, 1)
packet = packet[2:] # filler 2 * \x00
return (
column['name'],
column['type'],
None, # display_size
None, # internal_size
None, # precision
None, # scale
~column['flags'] & FieldFlag.NOT_NULL, # null_ok
column['flags'], # MySQL specific
)
def _pkt_parse_field(self, buf):
"""Parse a MySQL Field-packet"""
field = {}
(buf,field['catalog']) = utils.read_lc_string(buf)
(buf,field['db']) = utils.read_lc_string(buf)
(buf,field['table']) = utils.read_lc_string(buf)
(buf,field['org_table']) = utils.read_lc_string(buf)
(buf,field['name']) = utils.read_lc_string(buf)
(buf,field['org_name']) = utils.read_lc_string(buf)
buf = buf[1:] # filler 1 * \x00
(buf,field['charset']) = utils.read_int(buf, 2)
(buf,field['length']) = utils.read_int(buf, 4)
(buf,field['type']) = utils.read_int(buf, 1)
(buf,field['flags']) = utils.read_int(buf, 2)
(buf,field['decimal']) = utils.read_int(buf, 1)
buf = buf[2:] # filler 2 * \x00
res = (
field['name'],
field['type'],
None, # display_size
None, # internal_size
None, # precision
None, # scale
~field['flags'] & FieldFlag.NOT_NULL, # null_ok
field['flags'], # MySQL specific
)
return res
def _pkt_parse_eof(self, buf):
"""Parse a MySQL EOF-packet"""
res = {}
buf = buf[1:] # disregard the first checking byte
(buf, res['warning_count']) = utils.read_int(buf, 2)
(buf, res['status_flag']) = utils.read_int(buf, 2)
return res
def __init__(self, packet, table_map, table_subscribed, ctl_conn):
super(TableMapEvent, self).__init__(packet)
self._payload = packet[24:]
self._ctl_conn = ctl_conn
head = self._payload
head, self.table_id = utils.read_int(head, 6)
# add or modify table map.
if self.table_id not in table_map:
table_map[self.table_id] = {"schema":None, "table":None, "column_schemas":[]}
if self.schema in table_subscribed and self.table in table_subscribed[self.schema]:
table_map[self.table_id]["column_schemas"] = \
self.__get_table_informations(self.schema, self.table)
head, self.flags = utils.read_int(head, 2)
head, schema_name_len = utils.read_int(head, 1)
head, self.schema = utils.read_bytes(head, schema_name_len)
self.schema = str(self.schema)
table_map[self.table_id]["schema"] = self.schema
head, _ = utils.read_bytes(head, 1) #filler
head, table_name_len = utils.read_int(head, 1)
head, self.table = utils.read_bytes(head, table_name_len)
self.table = str(self.table)
table_map[self.table_id]["table"] = self.table
head, _ = utils.read_bytes(head, 1) #filler
head, self.columns_cnt = utils.read_lc_int(head)
head, column_types = utils.read_bytes(head, self.columns_cnt)
for i in range(0, self.columns_cnt):
schema = table_map[self.table_id]["column_schemas"][i]
t = ord(column_types[i])
schema["TYPE_ID"] = t
head, _ = self.__read_metadata(t, schema, head)
def _parse(self):
buf = self.data
(buf,self.field_count) = utils.read_int(buf,1)
(buf,self.affected_rows) = utils.read_lc_int(buf)
(buf,self.insert_id) = utils.read_lc_int(buf)
(buf,self.server_status) = utils.read_int(buf,2)
(buf,self.warning_count) = utils.read_int(buf,2)
if buf:
(buf,self.info_msg) = utils.read_lc_string(buf)
def extract_gma(in_path, out_path):
if path_exists(out_path):
rmtree(out_path)
if not path_exists(out_path):
path_make_directories(out_path)
"""
Takes an input path, and output path,
and creates a directory from the gma input.
"""
data, file = get_header(
in_path) # Call the function. Might as well, keep it dry.
file_num = 0
files = []
while utils.read_int(file) != 0:
file_data = {}
file_num += 1
file_data['name'] = utils.read_null_string(file)
file_data['size'] = utils.read_int(file, 8)
file_data['crc'] = utils.read_int(file)
files.append(file_data)
for key in range(file_num):
content = file.read(files[key]["size"])
if crc32(content) != files[key]['crc']:
raise IOError("CRC of data from " + files[key]['name'] +
" failed to pass CRC.")
tmp_out_path = path_join(out_path, files[key]['name'])
if not path_exists(path_get_directory(tmp_out_path)):
path_make_directories(path_get_directory(tmp_out_path))
with open(tmp_out_path, 'wb') as new_file:
new_file.write(content)
_, ext = path_ext(tmp_out_path)
if ext == ".lua":
with open(tmp_out_path, 'rb') as new_file:
cnt = new_file.read()
cset = chardet.detect(cnt)['encoding']
if cset is None:
cset = "ascii"
# print(tmp_out_path, cset)
cnt = cnt.decode(cset, errors="ignore")
cnt = cnt.replace("//", "--")
cnt = cnt.replace("/*", "--[[")
cnt = cnt.replace("*/", "--]]")
with open(tmp_out_path, 'w', encoding="utf8") as new_file:
new_file.write(cnt)
with open(path_join(out_path, "addon.json"), 'w',
encoding="utf8") as new_file:
new_file.write(data['info'])
file.close()
return data
def parse_eof(self, packet):
"""Parse a MySQL EOF-packet"""
if not (packet[4] == '\xfe' and len(packet) <= 9):
raise errors.InterfaceError("Failed parsing EOF packet.")
res = {}
packet = packet[5:] # disregard the first checking byte
(packet, res['warning_count']) = utils.read_int(packet, 2)
(packet, res['status_flag']) = utils.read_int(packet, 2)
return res
def parse_eof(self, packet):
"""Parse a MySQL EOF-packet"""
if not (packet[4] == '\xfe' and len(packet) <= 9):
raise errors.InterfaceError("Failed parsing EOF packet.")
res = {}
packet = packet[5:] # disregard the first checking byte
(packet, res['warning_count']) = utils.read_int(packet, 2)
(packet, res['status_flag']) = utils.read_int(packet, 2)
return res
def _pkt_parse_ok(self, buf):
"""Parse a MySQL OK-packet"""
ok = {}
(buf,ok['field_count']) = utils.read_int(buf,1)
(buf,ok['affected_rows']) = utils.read_lc_int(buf)
(buf,ok['insert_id']) = utils.read_lc_int(buf)
(buf,ok['server_status']) = utils.read_int(buf,2)
(buf,ok['warning_count']) = utils.read_int(buf,2)
if buf:
(buf,ok['info_msg']) = utils.read_lc_string(buf)
return ok
def _pkt_parse_ok(self, buf):
"""Parse a MySQL OK-packet"""
ok = {}
(buf,ok['field_count']) = utils.read_int(buf,1)
(buf,ok['affected_rows']) = utils.read_lc_int(buf)
(buf,ok['insert_id']) = utils.read_lc_int(buf)
(buf,ok['server_status']) = utils.read_int(buf,2)
(buf,ok['warning_count']) = utils.read_int(buf,2)
if buf:
(buf,ok['info_msg']) = utils.read_lc_string(buf)
return ok
def main():
ans = True
while ans:
lo = utils.read_int('min?')
hi = utils.read_int('max?')
primes = p.prime_range(lo, hi)
result = average(*primes)
print('total primes in range ({}-{}) is {}'.format(
lo, hi, len(primes)))
print('average of {} is {}'.format(primes, result))
ans = utils.read_bool('continue?')
def rsa():
"""
Test RSA
"""
# Decrypt
res_image_stream = open('decrypt_rsa.jpg', 'wb')
with open('tests/encrypted.txt', 'rb') as encrypted:
d = read_int(encrypted)
n = read_int(encrypted)
if d != 6126098115646990325497939754751346680273131840506753785808675623744493660811:
raise Exception('Not equal d')
if n != 11714199531846391552190233593088023207845451372578311171850728357335472002497:
raise Exception('Not equal n')
e = 8486391357485896322440256533131770617523773615720428244581337759609685018543
rsa = Rsa(n, e, d)
rsa.decrypt(encrypted, res_image_stream)
res_image_stream.close()
# Encrypt
res_encrypted = open('encrypted_rsa.txt', 'wb')
with open('tests/decrypted.jpg', 'rb') as image_stream:
rsa.encrypt(image_stream, res_encrypted)
res_encrypted.close()
# Test encrypt
test_encrypt = open('test_encrypt.jpg', 'wb')
with open('encrypted_rsa.txt', 'rb') as res_encrypted:
d = read_int(res_encrypted)
n = read_int(res_encrypted)
if d != 6126098115646990325497939754751346680273131840506753785808675623744493660811:
raise Exception('Not equal d')
if n != 11714199531846391552190233593088023207845451372578311171850728357335472002497:
raise Exception('Not equal n')
e = 8486391357485896322440256533131770617523773615720428244581337759609685018543
rsa = Rsa(n, e, d)
rsa.decrypt(res_encrypted, test_encrypt)
test_encrypt.close()
print(rsa.keygen())
def decrypt(self, reader, writer):
length = os.fstat(reader.fileno()).st_size
pos = reader.tell()
while pos < length - 32:
c = pow(read_int(reader), self.d, self.n)
bytes_arr = c.to_bytes(8, byteorder='big')
writer.write(bytes_arr)
pos += 32
c = pow(read_int(reader), self.d, self.n)
bytes_arr = c.to_bytes(8, byteorder='big')
if bytes_arr[7] != 0x08:
writer.write(bytes_arr[:8 - bytes_arr[7]])
def _pkt_parse_handshake(self, buf):
"""Parse a MySQL Handshake-packet"""
res = {}
(buf,res['protocol']) = utils.read_int(buf,1)
(buf,res['server_version_original']) = utils.read_string(buf,end='\x00')
(buf,res['server_threadid']) = utils.read_int(buf,4)
(buf,res['scramble']) = utils.read_bytes(buf, 8)
buf = buf[1:] # Filler 1 * \x00
(buf,res['capabilities']) = utils.read_int(buf,2)
(buf,res['charset']) = utils.read_int(buf,1)
(buf,res['server_status']) = utils.read_int(buf,2)
buf = buf[13:] # Filler 13 * \x00
(buf,scramble_next) = utils.read_bytes(buf,12)
res['scramble'] += scramble_next
return res
def _pkt_parse_handshake(self, buf):
"""Parse a MySQL Handshake-packet"""
res = {}
(buf,res['protocol']) = utils.read_int(buf,1)
(buf,res['server_version_original']) = utils.read_string(buf,end='\x00')
(buf,res['server_threadid']) = utils.read_int(buf,4)
(buf,res['scramble']) = utils.read_bytes(buf, 8)
buf = buf[1:] # Filler 1 * \x00
(buf,res['capabilities']) = utils.read_int(buf,2)
(buf,res['charset']) = utils.read_int(buf,1)
(buf,res['server_status']) = utils.read_int(buf,2)
buf = buf[13:] # Filler 13 * \x00
(buf,scramble_next) = utils.read_bytes(buf,12)
res['scramble'] += scramble_next
return res
def read_multi():
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(('121.41.58.181', 22536))
conn_str = 'm=TJ;u=qq1277;p=abc898;EX_SIZE=1;'
send_bytes = struct.pack('%ss' % len(conn_str), conn_str)
print send_bytes
sock.send(conn_str)
kline = models.KLineData(datetime.datetime.fromtimestamp(0))
while True:
# print 'try to recv package head'
total_length = utils.read_int(sock)
# print 'package length is %s' % total_length
if total_length == 16:
#print utils.read_raw_data(sock, 16)
break
read_size = 0
while read_size < total_length:
zip_length = utils.read_int(sock)
read_size += 4
if zip_length > 16777216:
# print 'Recv a text package, length is %s' % zip_length
# data = utils.read_raw_data(sock, zip_length)
# read_size += zip_length
# print data
break
if zip_length <= 0:
# print "invalid package length"
continue
ori_length = utils.read_int(sock)
# print 'to recv zip pacakge, length is %s, ori length is %s' % (zip_length, ori_length)
data = utils.read_raw_data(sock, zip_length - 4)
parsed_data = parse_zlib(data)
if parsed_data.label.startswith('TJCU'):
if (is_same_min(kline.time, parsed_data.time)):
update(kline, parsed_data)
else:
kline = models.KLineData(parsed_data.time, open = parsed_data.new_price, close = parsed_data.new_price)
save(kline)
#print 'parsed data is %s, name is %s' % (parsed_data, parsed_data.name)
read_size += zip_length
def _parse(self):
buf = self.data
(buf,self.catalog) = utils.read_lc_string(buf)
(buf,self.db) = utils.read_lc_string(buf)
(buf,self.table) = utils.read_lc_string(buf)
(buf,self.org_table) = utils.read_lc_string(buf)
(buf,self.name) = utils.read_lc_string(buf)
(buf,self.org_name) = utils.read_lc_string(buf)
buf = buf[1:] # filler 1 * \x00
(buf,self.charset) = utils.read_int(buf, 2)
(buf,self.length) = utils.read_int(buf, 4)
(buf,self.type) = utils.read_int(buf, 1)
(buf,self.flags) = utils.read_int(buf, 2)
(buf,self.decimal) = utils.read_int(buf, 1)
buf = buf[2:] # filler 2 * \x00
def is_error(self):
header = utils.read_int(self._body, 1)[1]
if 0xff == header:
log.debug("received err packet.")
return True
else:
return False
def get_exception(packet):
"""Returns an exception object based on the MySQL error
Returns an exception object based on the MySQL error in the given
packet.
Returns an Error-Object.
"""
errno = errmsg = None
if packet[4] != '\xff':
raise ValueError("Packet is not an error packet")
sqlstate = None
try:
packet = packet[5:]
(packet, errno) = utils.read_int(packet, 2)
if packet[0] != '\x23':
# Error without SQLState
errmsg = packet
else:
(packet, sqlstate) = utils.read_bytes(packet[1:], 5)
errmsg = packet
except Exception as err:
return InterfaceError("Failed getting Error information (%r)" % err)
else:
return get_mysql_exception(errno, errmsg, sqlstate)
def get_exception(packet):
"""Returns an exception object based on the MySQL error
Returns an exception object based on the MySQL error in the given
packet.
Returns an Error-Object.
"""
errno = errmsg = None
if packet[4] != '\xff':
raise ValueError("Packet is not an error packet")
sqlstate = None
try:
packet = packet[5:]
(packet, errno) = utils.read_int(packet, 2)
if packet[0] != '\x23':
# Error without SQLState
errmsg = packet
else:
(packet, sqlstate) = utils.read_bytes(packet[1:], 5)
errmsg = packet
except Exception, err:
return InterfaceError("Failed getting Error information (%r)" % err)
def parse_handshake(self, packet):
"""Parse a MySQL Handshake-packet"""
res = {}
(packet, res['protocol']) = utils.read_int(packet[4:], 1)
(packet, res['server_version_original']) = utils.read_string(
packet, end='\x00')
(packet, res['server_threadid']) = utils.read_int(packet, 4)
(packet, res['scramble']) = utils.read_bytes(packet, 8)
packet = packet[1:] # Filler 1 * \x00
(packet, res['capabilities']) = utils.read_int(packet, 2)
(packet, res['charset']) = utils.read_int(packet, 1)
(packet, res['server_status']) = utils.read_int(packet, 2)
packet = packet[13:] # Filler 13 * \x00
(packet, scramble_next) = utils.read_bytes(packet, 12)
res['scramble'] += scramble_next
return res
def sell_ticket(cinema):
cinema.show_rooms()
n = utils.read_int("Introduce el número de sala: ")
if n is not None:
room = cinema.get_room(n)
if room is not None:
room.show_free()
seat = utils.read_int("Introduce el número de butaca: ")
if seat is not None:
if room.select_seat(seat):
print("Se ha reservado la butaca")
#room.show_all()
else:
print("La butaca es incorrecta")
else:
print("El número de sala es incorrecto")
def choose_function():
print("Выберите нелинейное уравнение")
counter = 0
for pair in functions:
print(str(counter) + ": " + pair[0])
counter += 1
num = utils.read_int(0, len(functions) - 1, "Выберите номер уравнения")
return num
def parse_ok(self, packet):
"""Parse a MySQL OK-packet"""
if not packet[4] == '\x00':
raise errors.InterfaceError("Failed parsing OK packet.")
ok = {}
try:
(packet, ok['field_count']) = utils.read_int(packet[4:], 1)
(packet, ok['affected_rows']) = utils.read_lc_int(packet)
(packet, ok['insert_id']) = utils.read_lc_int(packet)
(packet, ok['server_status']) = utils.read_int(packet, 2)
(packet, ok['warning_count']) = utils.read_int(packet, 2)
if packet:
(packet, ok['info_msg']) = utils.read_lc_string(packet)
except ValueError:
raise errors.InterfaceError("Failed parsing OK packet.")
return ok
def new_room(cinema):
n = utils.read_int("Introduce el número de butacas: ")
if n is not None:
if n > 0:
cinema.new_room(n)
print("La sala ha sido dada de alta correctamente.")
else:
print("La sala debe tener al menos una butaca.")
def get_option(prompt: str, options: List[str]) -> int:
numbered_options = [
'{}. {}'.format(number + 1, option)
for number, option in enumerate(options)
]
full_prompt = '\n'.join([prompt] + numbered_options +
['Wybór (1-{}): '.format(len(options))])
return read_int(full_prompt, (1, len(options)))
def parse_ok(self, packet):
"""Parse a MySQL OK-packet"""
if not packet[4] == '\x00':
raise errors.InterfaceError("Failed parsing OK packet.")
ok = {}
try:
(packet, ok['field_count']) = utils.read_int(packet[4:], 1)
(packet, ok['affected_rows']) = utils.read_lc_int(packet)
(packet, ok['insert_id']) = utils.read_lc_int(packet)
(packet, ok['server_status']) = utils.read_int(packet, 2)
(packet, ok['warning_count']) = utils.read_int(packet, 2)
if packet:
(packet, ok['info_msg']) = utils.read_lc_string(packet)
except ValueError:
raise errors.InterfaceError("Failed parsing OK packet.")
return ok
def parse_handshake(self, packet):
"""Parse a MySQL Handshake-packet"""
res = {}
(packet, res['protocol']) = utils.read_int(packet[4:], 1)
(packet,
res['server_version_original']) = utils.read_string(packet,
end='\x00')
(packet, res['server_threadid']) = utils.read_int(packet, 4)
(packet, res['scramble']) = utils.read_bytes(packet, 8)
packet = packet[1:] # Filler 1 * \x00
(packet, res['capabilities']) = utils.read_int(packet, 2)
(packet, res['charset']) = utils.read_int(packet, 1)
(packet, res['server_status']) = utils.read_int(packet, 2)
packet = packet[13:] # Filler 13 * \x00
(packet, scramble_next) = utils.read_bytes(packet, 12)
res['scramble'] += scramble_next
return res
def reset_room(cinema):
cinema.show_rooms()
n = utils.read_int("Introduce el número de sala: ")
if n is not None:
if cinema.reset_room(n):
print("Sala libre")
else:
print("El número de sala es incorrecto")
def show_room(cinema):
cinema.show_rooms()
n = utils.read_int("Introduce el número de sala: ")
if n is not None:
room = cinema.get_room(n)
if room is not None:
print(room)
room.show_all()
def new_film(cinema):
cinema.show_rooms()
n = utils.read_int("Introduce el número de sala: ")
if n is not None:
film = input("Introduce el título de la película: ")
if cinema.new_film(n, film):
print("La película ha sido dada de alta satisfactoriamente.")
else:
print("Las sala indicada no existe")
def is_eof(self, buf):
"""
Check if the given buffer is a MySQL EOF Packet. It should
start with \xfe and be smaller 9 bytes.
Returns boolean.
"""
l = utils.read_int(buf, 3)[1]
if buf and buf[4] == '\xfe' and l < 9:
return True
return False
def from_bytes(cls, buffer):
# we need to re-read the type byte
buffer.seek(-1, 1)
type_byte = buffer.read1(1)[0]
fin = type_byte & 0x20 > 0
data_len_present = type_byte & 0x10 > 0
offset_len = type_byte & 0x0C >> 2
stream_id_len = (type_byte & 0x03)
stream_id = read_int(stream_id_len, buffer)
offset = read_int(offset_len, buffer)
if not data_len_present:
data_length = len(bytedata)
else:
data_length = read_int(2, buffer)
return cls(stream_id, offset, fin, buffer.read1(data_length))
def from_bytes(cls, buffer):
# we need to re-read the type byte
buffer.seek(-1, 1)
type_byte = buffer.read1(1)[0]
ll = type_byte & 0x0c
if type_byte & 0x10:
num_blocks = buffer.read1(1)[0]
else:
num_blocks = 1
num_ts = buffer.read1(1)[0]
largest_acknowledged_len = (1, 2, 4, 6)[ll >> 2]
largest_acknowledged = read_int(largest_acknowledged_len, buffer)
ack_delay = read_int(2, buffer)
ack_blocks = []
ack_blocks.append(read_int(largest_acknowledged_len, buffer))
for i in range(1, num_blocks):
ack_blocks.append(
(read_int(1, buffer), read_int(largest_acknowledged_len,
buffer)))
timestapms = []
if num_ts:
timestapms.append((buffer.read1(1)[0], read_int(4, buffer)))
for i in range(1, num_ts):
timestapms.append((buffer.read1(1)[0], read_ufloat16(buffer)))
return cls(largest_acknowledged, ack_delay, ack_blocks, timestapms)
def __init__(self, buf):
self.timestamp = utils.read_int(buf, 4)[1]
self.event_type = utils.read_int(buf[4:], 1)[1]
self.server_id = utils.read_int(buf[5:], 4)[1]
self.event_size = utils.read_int(buf[9:], 4)[1]
self.log_pos = utils.read_int(buf[13:], 4)[1]
self.flags = utils.read_int(buf[17:], 2)[1]
def __init__(self, buf):
self.timestamp = utils.read_int(buf, 4)[1]
self.event_type = utils.read_int(buf[4:], 1)[1]
self.server_id = utils.read_int(buf[5:], 4)[1]
self.event_size = utils.read_int(buf[9:], 4)[1]
self.log_pos = utils.read_int(buf[13:], 4)[1]
self.flags = utils.read_int(buf[17:], 2)[1]
def get_header(in_path):
"""Extracts the gma header from the input file."""
if not path_exists(in_path):
raise IOError("in_path " + in_path + " does not exist.")
file = open(in_path, 'rb')
data = {}
data['identifier'] = utils.read_length_string(file, 4)
if data['identifier'] != "GMAD":
raise IOError("in_path `" + in_path + "` does not contain .gma file.")
data['gmadversion'] = utils.read_int(file, 1)
data['steamid'] = utils.read_int(file, 8)
data['timestamp'] = utils.read_int(file, 8)
data['required'] = utils.read_int(file, 1)
data['title'] = utils.read_null_string(file)
data['info'] = utils.read_null_string(file)
data['author'] = utils.read_null_string(file)
data['version'] = utils.read_int(file)
return data, file
def main():
# create_date_set(lambda x: np.sin(x), np.linspace(0, 10, 10, endpoint=True), "sin.txt")
# x, y = read_data("sin.txt")
# a, b, c, d = spline.get_coefficients(x, y)
# show(x, y, b, c, d, lambda t: np.sin(t))
func_num = utils.choose_from_map(functions)
section = utils.read_section("Введите интервал, используя разделитель ;",
";")
n = utils.read_int(
0, 100, "Укажите количество узлов для вычисления уравнения сплайнов")
x = np.linspace(section[0], section[1], n, endpoint=True)
y = functions[func_num][1](x)
a, b, c, d = spline.get_coefficients(x, y)
show(x, y, b, c, d, functions[func_num][1])
def raise_error(cls, buf):
"""Raise an errors.Error when buffer has a MySQL error"""
errno = errmsg = None
try:
buf = buf[5:]
(buf, errno) = utils.read_int(buf, 2)
if buf[0] != '\x23':
# Error without SQLState
errmsg = buf
else:
(buf, sqlstate) = utils.read_bytes(buf[1:], 5)
errmsg = buf
except Exception, e:
raise errors.InterfaceError("Failed getting Error information (%r)"\
% e)
def raise_error(buf):
"""Raise an errors.Error when buffer has a MySQL error"""
errno = errmsg = None
try:
buf = buf[5:]
(buf,errno) = utils.read_int(buf, 2)
if buf[0] != '\x23':
# Error without SQLState
errmsg = buf
else:
(buf,sqlstate) = utils.read_bytes(buf[1:],5)
errmsg = buf
except Exception, e:
raise InterfaceError("Failed getting Error information (%r)"\
% e)
def _parse(self):
buf = self.data
if buf[0] != '\xff':
raise errors.InterfaceError('Expected an Error Packet.')
buf = buf[1:]
(buf,self.errno) = utils.read_int(buf, 2)
if buf[0] != '\x23':
# Error without SQLState
self.errmsg = buf
else:
(buf,self.sqlstate) = utils.read_bytes(buf[1:],5)
self.errmsg = buf
def main():
options = [new_room, new_film, sell_ticket, reset_room, show_room]
cinema = Cinema()
while True:
print("************")
menu()
n = utils.read_int("Selecciona una opción: ")
if n is not None:
if n == 0:
break
elif n > 0 and n < 6:
options[n - 1](cinema)
else:
print("Opción incorrecta")
print("Hasta pronto!")
def get_alphabet() -> str:
default_alphabet = ''.join(
get_characters_between('0', '9') + get_characters_between('a', 'z') +
get_characters_between('A', 'Z'))
select_number_of_letters = 'Liczba dostępnych liter (od 1 do {})'.format(
len(default_alphabet))
select_alphabet = 'Wprowadzenie wszystkich dostępnych liter'
mode = get_option('Proszę wybrać metodę wprowadzenia alfabetu: ',
[select_number_of_letters, select_alphabet])
if mode == 1:
alphabet = default_alphabet[:read_int(select_number_of_letters +
': ', (1,
len(default_alphabet)))]
else:
alphabet = ''.join(sorted(list(set(input(select_alphabet + ': ')))))
print('Wyznaczony alfabet: {}'.format(alphabet))
return alphabet
def _parse(self):
buf = self.data
buf = buf[1:] # disregard the first checking byte
(buf, self.warning_count) = utils.read_int(buf, 2)
(buf, self.status_flag) = utils.read_int(buf, 2)
def get_max_game_length() -> int:
return read_int('Proszę wybrać maksymalną liczbę ruchów: ', (1, None))
