def addRecord(self, newID, newGender, newAge, newSales, newBMI, newIncome,
autoID, overwrite):
typeCheckStringERR(newID)
preppedID = None
invalidID = False
origRec = None
insertPos = None
overwriteSignal = 0 # will become 1 if overwriting will be used
try:
preppedID = self._prepID(newID)
origRec, insertPos = self._prot_findRecord(preppedID)
except InvalidIDException:
invalidID = True
if origRec is not None and overwrite:
overwriteSignal = 1
elif (origRec is not None or invalidID) and autoID:
preppedID, insertPos = self._autoID()
# doNotUse, insertPos = self._prot_findRecord(preppedID)
elif origRec is not None:
raise DuplicateIDException()
elif invalidID:
raise InvalidIDException()
newRec = Record(preppedID, newGender)
self._allMyRecords[insertPos:insertPos + overwriteSignal] = [newRec]
newRec.setAge(newAge)
newRec.setSales(newSales)
newRec.setBMI(newBMI)
newRec.setIncome(newIncome)
def ReadPacketRecords(self, inp):
'''
Read a file object for all captured frames in the pcap
Args:
inp: A file input/output object
Return:
yields records (this function may be used as an iterator to iterate through very large Pcap files)
Side Effects:
records
Caught Exceptions
struct.error -> Nothing happens
IOError -> Nothing happens
'''
currPtr = inp.tell()
inp.seek(0, 2)
sizeOfInp = inp.tell()
inp.seek(currPtr)
try:
while inp.tell() < sizeOfInp:
record = Record(parent=self)
record.ReadRecord(inp)
if record.is_valid:
yield record
except struct.error:
None
except IOError:
None
def main():
#define record and car variables
car = Car()
car.connect(port="/dev/ttyACM0")
print("Waiting to hear from vehicle...")
while (not car.connected):
time.sleep(0.05)
print('connected')
record = Record()
#have a while loop so multiple runs can be executed
while (True):
print(
"Enter a negative double to go left\nor a positive double to go right\nelse type exit to quit\n"
)
divert = (input('<< '))
try:
divert = float(divert)
except ValueError:
break
print(divert)
executeManeuver(divert, car, record)
record.close()
car.close()
def normalize(paths: List[str]) -> List[Record]:
stats = readRecords(paths)
pairList = sorted(makeThemPair(stats))
results = []
for base, opt in pairList:
rec = Record(base.name, base.traceConfig, opt.ssdConfig, "normalized", 0, [{}])
rec.latency = opt.latency / base.latency
baseLastStat = max(base.statistics, key=lambda x: x["host_time"])
optLastStat = max(opt.statistics, key=lambda x: x["host_time"])
for key in [
"cum_bandwidth",
"ftl.page_mapping.gc.reclaimed_blocks",
"ftl.page_mapping.valid_pages",
]:
baseValue, optValue = map(lambda x: x[key],
[baseLastStat, optLastStat])
try:
normalized = optValue / baseValue
except:
normalized = float("nan")
rec.statistics[0][key] = normalized
rec.statistics[0]["WA"] = WA(optLastStat) / WA(baseLastStat)
results.append(rec)
return results
def insert(self, position, packetData):
'''
Create a record with data==packetData and insert it into the pcap records list at position
'''
rec = Record(self)
rec.CreateRecord(packetData)
self.records.insert(position, rec)
def add_bundles(self):
registry = getUtility(IRegistry)
bundles = registry.collectionOfInterface(IBundleRegistry,
prefix="plone.bundles",
check=False)
# Create new bundles in the registry
if "plonemeeting.portal.core" not in bundles:
bundles["plonemeeting.portal.core"] = Record()
portal_bundle = bundles["plonemeeting.portal.core"]
portal_bundle.resources = ["plonemeeting.portal.core"]
portal_bundle.last_compilation = datetime.now()
portal_bundle.compile = True
portal_bundle.enabled = True
portal_bundle.jscompilation = "++plone++plonemeeting.portal.core/js/core.js"
portal_bundle.csscompilation = (
"++plone++plonemeeting.portal.core/css/main-compiled.css")
if "plonemeeting.portal.core-custom" not in bundles:
bundles["plonemeeting.portal.core-custom"] = Record()
portal_bundle_custom = bundles["plonemeeting.portal.core-custom"]
portal_bundle_custom.resources = ["plonemeeting.portal.core-custom"]
portal_bundle_custom.css = "@@custom_colors.css"
portal_bundle_custom.compile = True
portal_bundle_custom.enabled = True
portal_bundle_custom.last_compilation = datetime.now()
def change_record(self):
print('Введите e-mail изменяемой записи:', end='\n')
email = input()
handbook = open(self.name + '.txt', 'r')
records = handbook.read()
handbook.seek(0)
if '@' not in email:
print('Неверный ввод. Повторите попытку.', end='\n')
return
if email in records:
print('Введите новое значение:', end='\n')
changedRecord = Record(input())
if changedRecord.is_valid():
records = handbook.readlines()
handbook.close()
handbook = open(self.name + '.txt', 'w')
for record in records:
if email in record:
handbook.write(changedRecord.get_record_in_one_row() +
'\n')
else:
handbook.write(record + '\n')
print('Значение изменено.', end='\n')
else:
print('Неверный ввод. Повторите попытку.', end='\n')
return
print('Такой записи не существует.', end='\n')
def findAll(self, fromDate, toDate):
records = []
rows = self.db.selectAllRecords(fromDate, toDate)
for row in rows:
# 0 = id, 1 = ecv, 2 = arrival, 3 = departure, 4 = companyId
# 5 = boxId, 6 = photoFileName, 7 = status
'''
borrowed = False
if row[7] == 'borrowed':
borrowed = True
#ECV, borrowed, companyID, boxId, boxCompanyId
r = Record(row[1], borrowed, row[4], row[5], row[6])
r.recordId = row[0]
cas = row[2].split(" ")
den = cas[0].split("-")
hodziny = cas[1].split(":")
r.arrivalTime = datetime.datetime(int(den[0]),int(den[1]),int(den[2]),int(hodziny[0]),int(hodziny[1]))
cas = row[3].split(" ")
den = cas[0].split("-")
hodziny = cas[1].split(":")
r.departureTime = datetime.datetime(int(den[0]),int(den[1]),int(den[2]),int(hodziny[0]),int(hodziny[1]))
print(datetime.datetime(int(den[0]),int(den[1]),int(den[2]),int(hodziny[0]),int(hodziny[1])))
r.status = row[7]
'''
r = Record(None, None, None, None, None)
r.initFromDatabaseRecord(row)
records.append(r)
return records
def slot_addOneRecord(self):
a = FormAddRecord()
a.exec_()
print(a.success)
if a.success:
print("Log: Data Are Valid")
rc = Record(a.name.text(), a.surname.text(), a.dob.currentText(),
a.address.text(), a.occupation.text())
print(rc.getData())
self.controller.addOneRecord(rc)
def findAllWithStatus(self, fromDate, toDate, status):
records = []
rows = self.db.selectAllRecordsWithStatus(fromDate, toDate, status)
for row in rows:
r = Record(None, None, None, None, None) # Prazdny zaznam
r.initFromDatabaseRecord(row)
records.append(r)
return records
def main():
main_API_logger = APILog()
main_SQL_logger = SQLog(filename='main_gs.db')
global_reporter = Report(
sqlogger=main_SQL_logger,
apilogger=main_API_logger,
)
recorder = Record(reporter=global_reporter)
recorder.start_record()
def add_contact(string):
string = string.split(' ')
name = string[1]
number = string[2]
if name == '' or number == '':
return 'Give me name and number, please!'
obj_name = Name(name)
obj_phone = Phone(number)
obj_record = Record(obj_name)
obj_record.add_phone(obj_phone)
address_book.add_record(obj_record)
return f'Contact with name {name} and number {number} was added'
class Test():
while True:
cho = input('''
请选择功能：
1.停车
2.出车
3.退出系统
''')
if cho == '3':
break
if cho == '1':
print('欢迎光临', Park.park_name, '停车场')
time1 = time.time()
carnumber = input('请输入车牌号')
carowner = input('请输入车主姓名')
carmodel = input('请输入车型')
car = Car(carnumber, carowner, carmodel)
record = Record()
record.time1 = time1
#进车时调用停车厂类的进车方法，把车的相关信息存入列表，由于不需要传订单所以用0代替
park = Park(car, record, 0)
park.goin()
if cho == '2':
carnumber1 = input('请输入车牌号')
b = False
#判断列表是否存在这个车牌
for i in range(0, len(Park.car_list) - 1):
if Park.car_list[i].car.carnum == carnumber1:
carwoner1 = Park.car_list[i].car.carowner
carmodel1 = Park.car_list[i].car.carmodel
#根据列表获得进车时间
cartime1 = Park.car_list[i].record.time1
#出车时间
time4 = time.time()
car2 = Car(carnumber1, carwoner1, carmodel1)
record1 = Record()
record1.time4 = time.time()
record1.time1 = cartime1
order1 = Order()
#调用停车场类的出车方法计算车费，然后打印出来
park1 = Park(car2, record1, order1)
a = park1.getexit(carnumber)
print(a)
#出车后移除信息
Park.car_list.remove(Park.car_list[i])
b = True
if b == False:
print('查无此车')
def main():
main_module_data = ModuleData()
main_gps_data = GPSData()
main_api_logger = APILog()
main_sql_logger = SQLog(filename='test.db')
global_reporter = Report(sql_logger=main_sql_logger,
api_logger=main_api_logger,
gps_data=main_gps_data,
module_data=main_module_data)
main_recorder = Record(reporter=global_reporter)
global_reporter.report_all_unsent_data()
main_recorder.start_record()
global_reporter.start_status_updates()
def _read(self):
#如果有重名，则以后面一个为准，因为实际上bash也是这么做的，后定义的alias会覆盖前面重名的。
#with open(os.path.expanduser(self.__path), 'r') as f:
with open(os.path.expanduser(self.__path), 'a+') as f:
alltext = f.read()
for matched in self._findall(alltext):
r = Record()
if r.parse(matched):
swap_out = self.__records_index_name.get(r.getName(), None)
if swap_out:
self.__records_list.remove(swap_out)
self.__records_index_name[r.getName()] = r;
self.__records_list.append(r)
def _read(self):
#如果有重名，则以后面一个为准，因为实际上bash也是这么做的，后定义的alias会覆盖前面重名的。
#with open(os.path.expanduser(self.__path), 'r') as f:
with open(os.path.expanduser(self.__path), 'a+') as f:
alltext = f.read()
for matched in self._findall(alltext):
r = Record()
if r.parse(matched):
swap_out = self.__records_index_name.get(r.getName(), None)
if swap_out:
self.__records_list.remove(swap_out)
self.__records_index_name[r.getName()] = r
self.__records_list.append(r)
def main():
#takes a filename as one argument
if (len(sys.argv) < 2):
print("No argument received.\n Use HTML file as an argument")
sys.exit(0)
#Check if file exists
if os.path.isfile(sys.argv[1]):
htmlFileName = sys.argv[1]
else:
print("not a valid file")
sys.exit(0)
#read file contents
with open(htmlFileName, "r") as f:
page = f.read()
tree = html.fromstring(page)
#get records form content
dnsForm = tree.xpath(domainXpath)[0]
#get Domain
domainName = dnsForm.attrib['data-domain']
#get records list
subdomains = tree.xpath(subdomainsXpath)
#build filename
fileName = domainName + ".txt"
#create file
f = open(fileName, 'w')
#write header into file
#Domain and TTL
f.write(origin + domainName + "\n")
f.write(ttl + "\n")
#go trough all records found
for sub in subdomains:
#creates a Record Object
myRecord = Record(sub, domainName)
#Print to console status and write to file all entries
print("Writing " + myRecord.recordName + " to file...")
f.write(myRecord.getAWSRecordOutput() + "\n")
#close file
f.close()
def getTop1000(self):
self.getPageTop1000()
soup = BeautifulSoup(self.content, 'lxml')
table_html = soup.find_all('table')[0]
# print(table_html)
# Parse table
nr = 0
for table_row in table_html.findAll("tr"):
# Find Name
name = re.search(
"\>([a-zA-Z0-9\"\.\s]+)\<",
str(table_row.findAll("td", class_="records_name")))
if name:
name = name.group(1)
# Find Time
time = re.search(
"\>([\s]*[0-9]+[\:]+[0-9]+[\.]*[0-9]*[\s]*)\<",
str(table_row.findAll("td", class_="records_time")))
if time:
time = time.group(1)
time = re.sub(r"[\n\t\s]*", "", time)
# Find Year
year = re.search(
"\>([\s]*[0-9]{4}[\s]*)\<",
str(table_row.findAll("td", class_="records_year")))
if year:
year = year.group(1)
year = re.sub(r"[\n\t\s]*", "", year)
# Find Beer
# beer = table_row.findAll("td", nowrap="")
beer = re.search(
"beertype_[a-zA-Z\"\+\s]+\>([a-zA-Z\s]+)\<\/a\>\<\/td\>",
str(table_row.findAll("td", nowrap="")))
if beer:
beer = beer.group(1)
self.records.append(Record(nr, name, time, year, beer))
nr += 1
self.records[0] = Record("Nr.", "Name", "Time", "Year", "Beer")
rec_best = self.records[1]
self.time_best_alco_runner = rec_best.records_time
# print(self.time_best_alco_runner)
self.timeToSec()
rec_best = self.records[1]
self.sec_best_alco_runner = rec_best.records_time
# print(self.sec_best_alco_runner)
self.divideList()
self.startThreads()
def create_cache(records_file_name):
cache = Cache()
records_table = open(records_file_name, "r")
for line in records_table:
cache.add_static_record(Record.from_json(line))
records_table.close()
return cache
def checkDots(self, ray):
encounters = 0
rayPos = ray.getPosAfterStep(10)
rightRayPos = ray.getRight().getPosAfterStep(10)
rayNextPos = ray.getPosAfterStep(1000)
rightRayNextPos = ray.getRight().getPosAfterStep(1000)
for i, dot in enumerate(self.dots):
if dot.getPos().isPointInRect(rayPos, rightRayPos, rayNextPos, rightRayNextPos):
distance = distanceToSegment(ray.getPos(), ray.getRight().getPos(), dot.getPos())
time = ray.getTime(distance, self.obstacles[ray.getMaterial()].getRelativeSpeed())
if time < ray.getNextEncounter():
ray.setNextEncounter(time)
ray.setObstacleNumber(-1)
ray.setVerticeNumber(i)
encounters += 1
for sensor in self.sensors:
if sensor.getPos().isPointInRect(rayPos, rightRayPos, rayNextPos, rightRayNextPos):
distance = distanceToSegment(ray.getPos(), ray.getRight().getPos(), sensor.getPos())
time = ray.getTime(distance, self.obstacles[ray.getMaterial()].getRelativeSpeed())
if time < ray.getNextEncounter():
sensor.addRecord(Record(-time, ray.getIntensity(), 1.0 / ray.getVelocity().getY()))
return encounters
def generate(n, btMIN, btMAX, atMAX, atMIN=0):
"""
:param int n:
:param int btMIN:
:param int btMAX:
:param int atMAX:
:param int atMIN:
:return None:
"""
records = []
# arrivalTimes = []
for i in range(0, n):
at = random.randint(atMIN, atMAX)
# arrivalTimes.append(at)
# while at in arrivalTimes:
# at = random.randint(atMIN, atMAX)
bt = random.randint(btMIN, btMAX)
r = Record(i+1, bt, at)
records.append(r)
return sortByAT(records)
def get_member_record(record_time, member_info_cell, member_records_cell):
user_number = member_info_cell[2].value
user_name = member_info_cell[10].value
count = record_time.end_day - record_time.start_day + 1
records = []
for index in range(0, count):
record_source = member_records_cell[index].value
check_in = ''
check_out = ''
if len(record_source) > 0:
detail = record_source.split('\n')
# print(f'value = {detail}')
if len(detail) == 2:
# 只有一条记录的时候需要判断是签到还是签退
if int(detail[0].split(':')[0]) < 12:
# 早于12点认为是签到
check_in = detail[0]
else:
check_out = detail[0]
else:
check_in = detail[0]
check_out = detail[1]
record_detail = Record(str(record_time.start_month) + '/' + str(index + 1), check_in, check_out)
records.append(record_detail)
# print(
# f'name = {user_name}, number = {user_number}, day = {record_time.start_month}/{index + 1}, check_in = {check_in}, check_out = {check_out}')
return Person(user_name, user_number, records)
def getAllRecords(self):
#open the connection
try:
cnx = mysql.connector.connect(user=self.username,
password=self.password,
host=self.host,
database=self.database)
cursor = cnx.cursor(prepared=True)
#Training set pulled out here, just getting the first x patients' records, when grouper = 5 it means patient does not have MS
#This is a subquery, the inside query makes a list of ruids from the first 200 patients in the DB then the outer query gets every
#record for each of those ruids
show_DB = """select ruid, entry_date, content from notes where ruid in
(Select * from (select distinct ruid from notes where grouper != 5 order by ruid, entry_date Limit 200) as t);"""
cursor.execute(show_DB, multi=True)
results = cursor.fetchall()
#converts each result to a record object
for result in results:
ruid = result[0]
date = result[1]
content = result[2]
record = Record(ruid, date, content)
#appends to records attribute then to be used elsewhere
self.records.append(record)
except mysql.connector.Error as err:
if err.errno == errorcode.ER_ACCESS_DENIED_ERROR:
print("Something is wrong with your user name or password")
elif err.errno == errorcode.ER_BAD_DB_ERROR:
print("Database does not exist")
else:
print(err)
else:
cnx.close()
def __init__(self, parent=None):
super(Interface, self).__init__(parent)
self.recordTab = Record()
self.fromFileTab = FromFile()
self.tab1 = QWidget()
self.tab2 = QWidget()
self.addTab(self.tab1, "Tab 1")
self.addTab(self.tab2, "Tab 2")
self.tab1UI()
self.tab2UI()
self.setWindowTitle("Emokit Visualizer")
self.showMaximized()
class Interface ( QTabWidget ):
def __init__(self, parent=None):
super(Interface, self).__init__(parent)
self.recordTab = Record()
self.fromFileTab = FromFile()
self.tab1 = QWidget()
self.tab2 = QWidget()
self.addTab(self.tab1, "Tab 1")
self.addTab(self.tab2, "Tab 2")
self.tab1UI()
self.tab2UI()
self.setWindowTitle("Emokit Visualizer")
self.showMaximized()
def tab1UI(self):
self.setTabText(0, "Record")
self.tab1.setLayout( self.recordTab.setRecordTab() )
self.timer = pg.QtCore.QTimer()
self.timer.timeout.connect(self.recordTab.update)
self.timer.start(10)
def tab2UI(self):
self.setTabText(1, "From file")
self.tab2.setLayout( self.fromFileTab.setFromFileTab() )
def add_doc(self, doc_id):
terms = self.get_terms(doc_id)
for i in range(len(terms)):
term = terms[i]
if term not in self.index:
self.index[term] = Record(term, [])
self.index[term].add_position(doc_id, i)
def on_delete(self, username):
username = username.get()
if username == "":
showinfo(title='Error', message='Username can not be empty')
else:
Record(username, password='', website='').save()
showinfo(message='Information has been successfully deleted')
def addContents(self, fids):
advertisement = Advertisement()
for fid in fids:
record = Record(fid, '127.0.0.1', RecordStatus.on_the_disk)
self.resourceTable.records.append(record)
advertisement.addRecord(fid)
advertisement.send(None, self.port, self.interface)
class SqlDb(Record("db_conn")):
"""Abstracts the db_conn and cursor behavior a little bit."""
def drop(self, table_name):
db_cursor = self.db_conn.cursor()
try:
db_cursor.execute(sql.drop_table(table_name))
self.db_conn.commit()
except sqlite3.OperationalError:
pass # Already dropped?
def create(self, table_name, field_types):
db_cursor = self.db_conn.cursor()
try:
db_cursor.execute(sql.create_table(table_name, field_types))
self.db_conn.commit()
except sqlite3.OperationalError:
pass # Already exists?
def insert(self, table_name, table_fields, tuples):
db_cursor = self.db_conn.cursor()
insert_statement = sql.insert(table_name, table_fields)
for tup in tuples:
db_cursor.execute(insert_statement, tup)
self.db_conn.commit()
def select(self, table_name, fields, into=None):
db_cursor = self.db_conn.cursor()
for values in db_cursor.execute(sql.select(table_name, fields)):
if into is not None:
values = into(*values)
yield values
def hours():
#######################################################
name = str(request.get_cookie("name"))
start = str(request.get_cookie("start"))
#######################################################
# try to open file with user's name and retrieve data
filePath = hoursDir + "/" + name
# for each record, create a new Record object and add to list to pass to template
# list of records as [obj]
records = Record.parseRecordsFromFile(filePath)
# DEBUG
print("\n***DEBUG***")
for r in records:
print(r)
print("***********\n")
# if file doesn't exist, nullify cookies and proceed
if not records:
name = ""
start = ""
#######################################################
return template('hours', records=records, name=name, start=start)
def getDrugRecords(self):
results = []
try:
cnx = mysql.connector.connect(user=self.username,
password=self.password,
host='localhost',
database='MFD_MS')
cursor = cnx.cursor(prepared=True)
#Training set pulled out here, just getting the first x patients' records
# sqlStatement = "Select ruid, entry_date, content from notes where doc_type != 'PL' and sub_type not like '%PROBLEM%'"
sqlStatement = "select ruid, entry_date, content from notes where ruid in (Select * from (select distinct ruid from notes where grouper != 5 and doc_type != 'PL' and sub_type not like '%PROBLEM%' order by ruid, entry_date Limit 200) as t);"
cursor.execute(sqlStatement, multi=True)
dbResults = cursor.fetchall()
for result in dbResults:
record = Record(result[0], result[1], result[2])
results.append(record)
except mysql.connector.Error as err:
if err.errno == errorcode.ER_ACCESS_DENIED_ERROR:
print("Something is wrong with your user name or password")
elif err.errno == errorcode.ER_BAD_DB_ERROR:
print("Database does not exist")
else:
print(err)
else:
cnx.close()
return results
def __new_init__(self, data):
ndata = []
lang = getToolByName(getSite(), 'portal_languages').getPreferredLanguage()
try:
encoding = getToolByName(self, "portal_properties").site_properties.default_charset
except AttributeError:
encoding = 'ascii'
for v in data:
try:
value = json.loads(v)
value = value['___multilanguage___']
v = value.get(lang, '')
if isinstance(v, basestring):
v = v.encode(encoding)
except:
pass
ndata.append(v)
Record.__init__(self, tuple(ndata))
def getRecords(conn):
cursor = conn.cursor()
cursor.execute("SELECT * FROM records")
recordList = []
row = cursor.fetchone()
while row:
record = Record(row[0],row[1],row[2],row[3],row[4])
temp_player = getPlayer(record.PlayerID, conn)
temp_video = getVideo(record.VideoID, conn)
record.PlayerName = temp_player.FirstName + " " + temp_player.LastName
record.VideoUrl = temp_video.ExtUrl
recordList.append(record)
row = cursor.fetchone()
return recordList
def add(self, target, name, force=False):
#检查
swap_out = self.__records_index_name.get(name, None)
if swap_out:
print "[warn] alias already exists: %s" % swap_out.toString()
if not force:
print "[fail] If you wanna override, please use 'cdthis -f'."
return False;
self.__records_list.remove(swap_out)
r = Record();
r.setName(name)
r.setTarget(target)
t = datetime.datetime.now()
r.setCreatetime(t.strftime("%y-%m-%d %H:%M:%S"))
self.__records_list.insert(0, r)
self.__records_index_name[name] = r
print "[OK] new alias done."
return True
pass
def start(self):
self.success = False
self.gameOver = False
self.setCurses()
Global.shell = MineShell()
Global.timer = Timer()
createField = 'minefield ' + str(self.width) + ' ' + str(self.height) + ' ' + str(self.num)
Global.shell.getInput(createField)
window = Window(self.scr)
layout = window.drawLayout(self.width, self.height)
if layout == None:
curses.endwin()
print("The window is too small to display the Game field")
print("Please increase the window size or decrease the font size")
sys.exit(0);
self.mineWin, log, panel, record = layout
self.record = Record(record)
self.mine = GameField(self.mineWin, Global.shell)
self.mine.drawUndeployedMineField()
Global.panel = panel
clock = ClockUpdater()
clock.daemon = True
clock.start()
return self.mine, log, panel, self.record
def __init__(self, user_id):
Record.__init__(self, user_id)
def __init__(self, record): Record.__init__(self, record.doc)
def readAnnormalDataRecords(self) :
fixedItemsTag = FixedItems(self.path, self.pageOffset)
#carve tag
recordOffset = 0
recordSize = 0
for i in range(self.availablePageTag, (self.pageSize - self.pageHeaderSize)/4) :
tagOffset = self.pageSize - i*4
#get Record Size
recordSize = fixedItemsTag.setItem("recordSize"+str(i), tagOffset-4, 2) & (self.pageSize -1 )
#get Record Offset
recordOffset = fixedItemsTag.setItem("recordOffset"+str(i), tagOffset-2, 2) & (self.pageSize -1 )
#check Record Size
if recordSize <= 0 or recordSize > self.pageSize :
break
#check Record Offset
if recordOffset < 0 or recordOffset > self.pageSize :
break
#check Record Bitmap
if not self.checkBitmap(recordOffset, recordSize) :
continue
#get Page Tag Flag
if self.pageSize >= 16384 :
pageTagFlag = fixedItemsTag.setItem("pageTagFlag"+str(i), self.pageHeaderSize + 1 + recordOffset , 1)
else :
pageTagFlag = (fixedItemsTag.setItem("pageTagFlag"+str(i), tagOffset-1 , 1) )
record = Record(self.path, self.pageSize, self.pageOffset, recordOffset, recordSize, pageTagFlag)
#check Record Header
if not record.isNormalRecord(self.columns) :
break
self.abnormalRecordList.append(record)
self.setBitmap(recordOffset, recordSize)
self.setBitmap(tagOffset-self.pageHeaderSize-4, 4)
fixedItemsTag = None
#carve data
recordInfo = self.carvingData(self.pageHeaderSize)
recordOffset = recordInfo[0]
pageTagFlag = recordInfo[1]
minimumSize = recordInfo[2]
while recordOffset < self.pageSize : #max page Size
if minimumSize == 0 :
break
recordInfo = self.carvingData(recordOffset + minimumSize)
tempRecordOffset = recordInfo[0]
tempPageTagFlag = recordInfo[1]
minimumSize = recordInfo[2]
recordSize = tempRecordOffset - recordOffset
recordOffset -= self.pageHeaderSize
record = Record(self.path, self.pageSize, self.pageOffset, recordOffset, recordSize , pageTagFlag)
self.abnormalRecordList.append(record)
self.setBitmap(recordOffset, recordSize)
recordOffset = tempRecordOffset
pageTagFlag = tempPageTagFlag
#read record
for record in self.abnormalRecordList :
record.setRecordType("Abnormal_Data")
try :
record.readRecord(self.columns)
except :
continue
return self.abnormalRecordList
def __init__(self, data, parent, binit=binit):
Record.__init__(self,data)
binit(self.__of__(parent))
def __init__(self, item_id):
Record.__init__(self, item_id)
class Game:
def __init__(self, stdscr, width, height, num):
self.width = width
self.height = height
self.num = num
self.scr = stdscr
self.fileName = str(width) + 'X' + str(height) + 'with' + str(num) + 'mines'
self.success = None
self.gameOver = None
self.record = None
self.mine = None
#self.timer = None
self.mineWin = None
self.startTime = None
self.clock = None
def start(self):
self.success = False
self.gameOver = False
self.setCurses()
Global.shell = MineShell()
Global.timer = Timer()
createField = 'minefield ' + str(self.width) + ' ' + str(self.height) + ' ' + str(self.num)
Global.shell.getInput(createField)
window = Window(self.scr)
layout = window.drawLayout(self.width, self.height)
if layout == None:
curses.endwin()
print("The window is too small to display the Game field")
print("Please increase the window size or decrease the font size")
sys.exit(0);
self.mineWin, log, panel, record = layout
self.record = Record(record)
self.mine = GameField(self.mineWin, Global.shell)
self.mine.drawUndeployedMineField()
Global.panel = panel
clock = ClockUpdater()
clock.daemon = True
clock.start()
return self.mine, log, panel, self.record
def pause(self):
#self.timer.pause()
Global.timer.pause()
self.mine.drawUndeployedMineField()
self.mine.disablePoke()
return
def resume(self):
#self.timer.resume()
Global.timer.resume()
self.record.eraseRecord()
self.mine.drawUndeployedMineField()
if self.isGameOver():
self.displayGameOver(self.success)
else:
self.mine.drawPokedMineField()
self.mine.enablePoke()
return
def restart(self):
self.success = False
self.gameOver = False
self.record.eraseRecord()
Global.shell = MineShell()
Global.timer = Timer()
createField = 'minefield ' + str(self.width) + ' ' + str(self.height) + ' ' + str(self.num)
Global.shell.getInput(createField)
self.mine = GameField(self.mineWin, Global.shell)
self.mine.drawUndeployedMineField()
return
def poke(self, y, x):
if Global.timer.isTimerStarted() == False:
Global.timer.start()
return self.mine.pokeMineField(y, x)
def flag(self, y, x):
alreadyFlagged = self.mine.flagMineField(y, x)
if alreadyFlagged:
self.mine.unflagMineField(y, x)
def checkWin(self):
return self.mine.shell.getInput('query success')
def checkLose(self):
return self.mine.shell.getInput('query failure')
def status(self):
flags = self.mine.shell.getInput('query flags')
mines = self.mine.shell.getInput('query mines')
return flags, mines
def exit(self):
sys.exit(0)
return
def addNewRecord(self):
self.record.addNewRecord(self.fileName, Global.totalTime)
def displayRecord(self):
if not self.checkWin() and not self.checkLose():
self.pause()
self.record.displayRecords(self.fileName, None)
elif self.checkWin():
self.record.displayRecords(self.fileName, Global.totalTime)
elif self.checkLose():
self.record.displayRecords(self.fileName, None)
return
def displayGameOver(self, success):
self.mine.displayGameOver(success)
self.mine.disablePoke()
def isGameOver(self):
return self.gameOver
def gameWin(self):
if self.isGameOver():
return
self.success = True
self.gameOver = True
Global.timer.end()
self.displayGameOver(True)
self.addNewRecord()
self.displayRecord()
return
def gameLose(self):
if self.isGameOver():
return
Global.timer.end()
self.gameOver = True
self.displayGameOver(False)
return
def setCurses(self):
self.scr.refresh()
curses.start_color()
curses.init_pair(1, curses.COLOR_WHITE, curses.COLOR_BLACK)
curses.init_pair(3, curses.COLOR_GREEN, curses.COLOR_BLACK)
curses.init_pair(6, curses.COLOR_BLUE, curses.COLOR_BLACK)
curses.init_pair(2, curses.COLOR_CYAN, curses.COLOR_BLACK)
curses.init_pair(4, curses.COLOR_YELLOW, curses.COLOR_BLACK)
curses.init_pair(5, curses.COLOR_MAGENTA, curses.COLOR_BLACK)
curses.init_pair(7, curses.COLOR_RED, curses.COLOR_BLACK)
curses.mousemask(-1)
curses.mouseinterval(0)
curses.curs_set(0)
def __init__(self, data, parent, binit=binit):
Record.__init__(self,data)
if parent is not None: self=self.__of__(parent)
binit(self)
