#encoding:utf-8
import urllib2
from bs4 import BeautifulSoup
import re
import threading
from fiction.models import *
import string
from debug import Debug
from models import *
from utils.hashs import create_nid
#for the thread to crawler all the fiction information from qidian.com
from crawler_config import ALL_PATTERN
DG = Debug()
DG.debug = True
def get_book_infor(host, name, url, type_lock=False):
DG.trace('yes now')
"""get book information(avatar, introduction, click times, type, completed words number,
and all the chapter in website:host
Args:
host: fiction website
book_url: book url located in host
content_tag: div area contains the fiction's information that we want
content_class: indetification flags
avatar_tag: the fictions' avatar
avatar_class: indetification
intro_tag, intro_class
Return:
numLabels = len(labels)
wordRect = pygame.Surface((maxWidth, (maxHeight * numLabels) - 4))
i = 0
for l in labels:
h = l.get_height()
w = l.get_width()
offset = (wordRect.get_width() - w) / 2
wordRect.blit(l, (offset, i * h))
i += 1
sx = (self.screen.get_width() - wordRect.get_width()) / 2
sy = (self.screen.get_height() - wordRect.get_height()) / 2
self.screen.blit(wordRect, (sx, sy))
pygame.display.flip()
if __name__ == '__main__':
os.environ['DISPLAY'] = ":0.0"
os.chdir(os.path.dirname(sys.argv[0]))
os.chdir("..") # sigh: get to default app path
Debug(["__main__"])
Specs("%s/%s" % ("speclib", "poem.json"))
pygame.init()
Display().image(sys.argv[1])
time.sleep(5)
Display().text(["foo", "bar"])
time.sleep(5)
Display().text("what a friend we have in bezos. The Bastard")
time.sleep(5)
print("%s at %s" % (pname, datetime.datetime.fromtimestamp(
time.time()).strftime('%Y-%m-%d %H:%M:%S')))
pygame.mixer.pre_init(frequency=44100,
size=-16,
channels=2,
buffer=4096)
pygame.init()
parser = argparse.ArgumentParser()
parser.add_argument('-c',
'--config',
nargs=1,
type=str,
default=[defaultSpecPath],
help='specify different config file')
args = parser.parse_args()
Debug(['specs', "__main__"])
Debug().p("config path %s" % args.config[0])
specs = Specs(args.config[0]).s
Debug().enable(specs['debug'])
while True:
Poem().show()
time.sleep(Specs().s['nextTime'])
except ServiceExit:
print("%s got signal" % pname)
gardenExit = 5
except Exception as e:
print("%s" % e)
traceback.print_exc()
gardenExit = 5
parser.add_argument('value',
metavar='value',
type=float,
help='value in currency1')
parser.add_argument("to",
metavar=("to"),
type=lambda f: str(f).upper(),
help="Currency to which convert to",
choices=provider.symbols)
parser.add_argument(
"-v",
"--verbose",
action='store_const',
const=1,
default=0,
help="if true, print a descriptive message of what is happening")
args = parser.parse_args()
log = Debug(args.verbose)
provider.loadvalues()
log(f"Converting {provider._name(args.fro)} to {provider._name(args.to)}")
result = provider.data[args.fro] / provider.data[args.to] * args.value
log(f"{args.value} {provider._name(args.fro)} equals {result} {provider._name(args.fro)}"
)
print(result)
def register(self, cmds):
Debug().p("%s: registering command %s" % (self.name, cmds))
for k in cmds.keys():
self.commandTable[k] = cmds[k]
file = []
# we append the headers
file.extend(writeheaders(datamodel))
# we write the data model
file.extend(writemodel(datamodel))
# we extract and process relations
relations = process_relations(datamodel)
file.extend(writerelations(relations))
#we end the file
file.extend(closefile(datamodel))
#we write the file
writeplantuml(file)
if __name__ == "__main__":
# Initialize debuger
dbg = Debug(os.path.basename(__file__), level=1)
dbg.msg('Version', 'sys.version', 'sys.version', 1, sys.version)
main()
# Use
# https://plantuml-editor.kkeisuke.com/
# to visualize
# TODO abrir branch nuevo
# TODO make two outputs with and without relations
# TODO black list for relationships
def startRecog(self,cmd):
Debug().p("starting recog")
self.queue.put("__start__")
return Hosts.jsonStatus("ok")
def getUrls(self, qs):
images = []
index = 0
while len(images) < 15:
# Build a service object for interacting with the API. Visit
# the Google APIs Console <http://code.google.com/apis/console>
# to get an API key for your own application.
try:
service = build("customsearch",
"v1",
developerKey=self.creds['key'])
query = qs[0] + " " + qs[1]
startReq = index * 10
Debug().p("query: %s index: %s" % (query, startReq))
res = None
start_time = time.time()
if index == 0:
res = service.cse().list(
q=query,
cx=self.creds['cx'],
searchType='image',
safe='off',
).execute()
else:
res = service.cse().list(
q=query,
cx=self.creds['cx'],
searchType='image',
start=int(startReq),
safe='off',
).execute()
elapsed_time = time.time() - start_time
if 'error' in res:
print "google responded with error message: ", pprint.pformat(
res)
time.sleep(60)
return []
tst = 'items' in res
if tst == False or len(res['items']) < 10:
Debug().p("rejecting too few items")
return []
#Debug().p "res:",res
for l in res['items']:
Debug().p("link %s" % l['link'])
relem = {}
relem['full'] = l['link']
relem['thumb'] = l['image']['thumbnailLink']
images.append(relem)
index += 1
Debug().p(res)
except apiclient.errors.HttpError, e:
print("google cse status:" + str(e.resp.status))
if e.resp.status == 403:
print("Google Quota Exceeded")
return None
except:
def __init__(self):
self.debug = Debug()
self.startLogo()
self.startWarning()
self.debug.letWait()
def __init__(self):
self._db = Debug("country", False)
except apiclient.errors.HttpError, e:
print("google cse status:" + str(e.resp.status))
if e.resp.status == 403:
print("Google Quota Exceeded")
return None
except:
print("google cse:" + str(sys.exc_info()[0]))
return None
return images
if __name__ == '__main__':
from words import Words
os.environ['DISPLAY'] = ":0.0"
os.chdir(os.path.dirname(sys.argv[0]))
os.chdir("..") # sigh: get to default app path
Debug(["__main__", "words"])
Specs("%s/%s" % ("speclib", "commontest.json"))
urls = Search().getUrls(Words().getWords())
if urls == None:
print "Google Error"
exit(1)
if len(urls) == 0:
print "no urls!"
for i in urls:
print "full:", i['full']
print "thumb:", i['thumb']
def main():
"""Main program."""
global dbg, cleanup_objects
sensors = []
itimer_next = {}
# Initialize debugging
dbg = Debug(level=DEBUG_LVL)
cleanup_objects['debug'] = dbg
# Initialize sensors
for sensor in W1ThermSensor.get_available_sensors():
sensors.append({
'obj': sensor,
'id_short': sensor.id[-4:],
'value': None,
'read_success': 0,
'read_crc': 0,
'read_nan': 0,
'e_rate': 0
})
if len(sensors) == 0:
sys.stderr.write('\nERROR: No sensors found\n')
cleanup()
exit(0)
else:
sys.stderr.write('\nINFO: Found {} sensors\n'.format(len(sensors)))
active_sensor_idx = 0
# Initialize LCD
lcd = disp_init()
cleanup_objects['lcd'] = lcd
# Very first run
for sensor in sensors:
read_sensor(sensor)
disp_clock(lcd)
disp_sensor(lcd, sensors[active_sensor_idx])
# Initialize signal file descriptor
# We must set write end of pipe to non blocking mode
# Also we don't want to block while read signal numbers from read end
pipe_r, pipe_w = os.pipe()
cleanup_objects['pipe_r'] = pipe_r
cleanup_objects['pipe_w'] = pipe_w
flags = fcntl.fcntl(pipe_w, fcntl.F_GETFL, 0)
fcntl.fcntl(pipe_w, fcntl.F_SETFL, flags | os.O_NONBLOCK)
signal.set_wakeup_fd(pipe_w)
flags = fcntl.fcntl(pipe_r, fcntl.F_GETFL, 0)
fcntl.fcntl(pipe_r, fcntl.F_SETFL, flags | os.O_NONBLOCK)
# Redefine signal handlers
cleanup_objects['sigalrm'] = signal.signal(signal.SIGALRM, signal_handler)
cleanup_objects['sigint'] = signal.signal(signal.SIGINT, signal_handler)
cleanup_objects['sighup'] = signal.signal(signal.SIGHUP, signal_handler)
cleanup_objects['sigterm'] = signal.signal(signal.SIGTERM, signal_handler)
# Create poller and register file descriptors
poller = select.epoll()
cleanup_objects['poller'] = poller
poller.register(pipe_r, select.EPOLLIN)
# Calculate interval timer value
itimer_value = gcd(gcd(SENSOR_READ_INTERVAL, SENSOR_DISP_INTERVAL),
CLOCK_DISP_INTERVAL)
dbg.dbg(
'Calculated itimer interval value is {} seconds'.format(itimer_value))
# Set interval timer
# Initial value of timer bounded to measurement itimer_value
t = time()
t_rest = itimer_value - t % itimer_value
# if t_rest < 0:
# t_rest += itimer_value
t_start = t_rest + ITIMER_START_SHIFT
signal.setitimer(signal.ITIMER_REAL, t_start, itimer_value)
cleanup_objects['itimer'] = True
dbg.dbg('ITIMER_REAL will fire at {} and each {} seconds'.format(
itimer_conv(t + t_start), itimer_value))
# Set fire times
t_base = t + t_rest
dbg.dbg(' Base time is {}'.format(itimer_conv(t_base)))
f = lambda x, y: x - x % y + y * ceil((x % y) / y)
itimer_next['sensor_read_interval'] = f(t_base, SENSOR_READ_INTERVAL)
dbg.dbg(' Wake up time for SENSOR_READ set to {}'.format(
itimer_conv(itimer_next['sensor_read_interval'])))
itimer_next['sensor_disp_interval'] = f(t_base, SENSOR_DISP_INTERVAL)
dbg.dbg(' Wake up time for SENSOR_DISP set to {}'.format(
itimer_conv(itimer_next['sensor_disp_interval'])))
itimer_next['clock_disp_interval'] = f(t_base, CLOCK_DISP_INTERVAL)
dbg.dbg(' Wake up time for CLOCK_DISP set to {}'.format(
itimer_conv(itimer_next['clock_disp_interval'])))
# Main loop
sys.stderr.write('INFO: Entering main loop\n')
while True:
# Wait for events and process its
try:
events = poller.poll()
except InterruptedError:
continue
for fd, flags in events:
dbg.dbg('Start processing event, fd={}, flags={}'.format(
fd, flags))
# Signal received, extract signal numbers from wakeup fd
if fd == pipe_r and flags & select.EPOLLIN:
dbg.dbg(
'Signal received from wakeup fd, unpacking signal numbers')
data = os.read(pipe_r, SIG_WAKEUP_FD_RLEN)
signums = struct.unpack('{}B'.format(len(data)), data)
dbg.dbg('Signal numbers unpacked: {}'.format(signums))
# Make signal list have unique numbers only
signums = set(signums)
# Process signals
for signum in signums:
if signum == signal.SIGALRM:
t = time()
dbg.dbg('Got SIGALRM, dispatch itimer based tasks')
# Display clock
if itimer_next['clock_disp_interval'] <= time():
dbg.dbg('Start CLOCK_DISP task')
disp_clock(lcd)
while itimer_next['clock_disp_interval'] <= time():
itimer_next[
'clock_disp_interval'] += CLOCK_DISP_INTERVAL
dbg.dbg(
' Wake up time for CLOCK_DISP set to {}'.
format(
itimer_conv(
itimer_next['clock_disp_interval'])))
# Read sensors
if itimer_next['sensor_read_interval'] <= t:
dbg.dbg('Start SENSOR_READ task')
for sensor in sensors:
read_sensor(sensor)
while itimer_next['sensor_read_interval'] <= time(
):
itimer_next[
'sensor_read_interval'] += SENSOR_READ_INTERVAL
dbg.dbg(
' Wake up time for SENSOR_READ set to {}'.
format(
itimer_conv(
itimer_next['sensor_read_interval'])))
# Display sensor
if itimer_next['sensor_disp_interval'] <= t:
active_sensor = sensors[active_sensor_idx]
dbg.dbg(
'Start SENSOR_DISP task, sensor number {} id {}'
.format(active_sensor_idx,
active_sensor['id_short']))
disp_sensor(lcd, active_sensor)
active_sensor_idx += 1
if active_sensor_idx >= len(sensors):
active_sensor_idx = 0
while itimer_next['sensor_disp_interval'] <= time(
):
itimer_next[
'sensor_disp_interval'] += SENSOR_DISP_INTERVAL
dbg.dbg(
' Wake up time for SENSOR_DISP set to {}'.
format(
itimer_conv(
itimer_next['sensor_disp_interval'])))
elif signum == signal.SIGINT:
dbg.dbg('Got SIGINT, terminating')
sys.stderr.write('\nINFO: SIGINT received\n')
cleanup()
sys.exit(0)
elif signum == signal.SIGTERM:
dbg.dbg('Got SIGTERM, terminating')
sys.stderr.write('\nINFO: SIGTERM received\n')
cleanup()
sys.exit(0)
elif signum == signal.SIGHUP:
dbg.dbg('Got SIGHUP, ignoring')
sys.stderr.write('INFO: SIGHUP received\n')
else:
dbg.dbg(
'Got uncaught signal {}, ignoring'.format(signum))
sys.stderr.write(
'WARNING: Unexpected signal received: {}\n'.format(
signum))
# Unexpected event
else:
dbg.dbg('Unexpected event on fd {}, flags {}'.format(
fd, flags))
sys.stderr.write(
'ERROR: Unexpected event on fd {}, flags {}\n'.format(
fd, flags))
def nop(self,msg):
Debug().p("%s: ignoring %s"%(self.name,msg))
print("max volume: %s" % hw['max'])
volRat = float(hw['max']) / 100.0
print("max volume: %s vol: %f volRat: %f" % (hw['max'], vol, volRat))
cmdHdr = ["amixer", "-c", hw['Speaker'], "cget", "numid=3"]
try:
cmd = cmdHdr[:]
output = check_output(cmd)
lines = output.split("\n")
for l in lines:
if l.find(": values=") != -1:
var = l.split("=")
var = var[1].split(",")
vol = int(round(float(var[0]) / volRat))
except CalledProcessError as e:
traceback.print_exc()
print(e.output)
return vol
if __name__ == '__main__':
try:
os.chdir(os.path.dirname(sys.argv[0]))
Debug(['__main__'])
makeRc()
#setVolume(sys.argv[1])
#print getVolume()
except Exception, e:
traceback.print_exc()
from datetime import date
from json import dumps, loads
from requests import get as fetch
from debug import Debug
log = Debug()
'''
class Symbols:
functions:
1. to provide symbols of all possible currencies as : symbol.symbols
2. to provide rate data of all possible currencies : as symbol.data
3. to privide full name of the currency: as symbol.name
4. caching of datewise exchange values
'''
class CurrencyProvider:
data = {}
symbols = []
names = {}
def __init__(self):
try:
with open("currency.json") as file:
self.names = {
key: value['name']
for (key, value) in loads(file.read()).items()
}
except:
self.names = {}
self.symbols = list(self.names.keys())
def initGUI(self):
self.setAutoFillBackground(True)
self.arguments = Arg_Class()
p = self.palette()
p.setColor(self.backgroundRole(), Qt.black)
p.setColor(self.foregroundRole(), Qt.white)
self.setPalette(p)
######################################################
###state machine starts here
## call function that sets the text of each of the startup screens based on what gpio signals are high
## once startup is complete call these to setup dash in race mode
self.rpmGauge = Rpm(self)
self.rpmGauge.move(0, 16.0)
self.rpmGauge.resize(DASH_WIDTH, RPM_HEIGHT)
#self.rpmGauge.hide()
self.socGauge = Soc(self)
self.socGauge.move(500, GAUGE_VPOS - 150.0)
self.socGauge.resize(GAUGE_WIDTH, GAUGE_HEIGHT * 3.0)
self.tempGauge = Temp(self)
self.tempGauge.move(660, GAUGE_VPOS - 180.0)
self.tempGauge.resize(GAUGE_WIDTH, GAUGE_HEIGHT * 2.5)
self.tempGauge.show()
self.debug = Debug(self)
self.debugGps = DebugGPS(self)
self.debug.hide()
self.debugGps.hide()
self.errorGauge = Error(self)
self.errorGauge.move(20, 340)
self.errorGauge.resize(GAUGE_WIDTH * 2.5, GAUGE_HEIGHT)
self.errorGauge.show()
if self.arguments.Args.debug:
self.debug.show()
#### if an error is thrown enter error state machine defined here
######################################################
#### if possible move this so its always visiable, even during startup
#### It would be a good idea to setup a menu option to skip the startup screens
self.mainMenu = self.menuBar()
self.mainMenu.setStyleSheet(
"QMenuBar::item { color: rgb(255,0,0);}") #sets text color
self.mainMenu.setStyleSheet(
"QMenuBar::item { background-color: rgb(255,255,255);}"
) # sets button color
self.fileMenu = self.mainMenu.addMenu('Debug')
self.openDebug = QAction("Open Debug Window", self)
self.fileMenu.addAction(self.openDebug)
self.openDebug.triggered.connect(self.debug.debug_open)
self.openGPS = QAction("Open GPS Window", self)
self.fileMenu.addAction(self.openGPS)
self.openGPS.triggered.connect(self.debugGps.debug_open)
#### Option to display graphs of data, not implemented yet
self.analyzeMenu = self.mainMenu.addMenu('Analyze')
self.graphRpm = QAction("Graph RPM", self)
self.graphSoc = QAction("Graph SOC", self)
self.analyzeMenu.addAction(self.graphRpm)
self.analyzeMenu.addAction(self.graphSoc)
self.tempMenu = self.mainMenu.addMenu('Temp')
self.settingMenu = self.mainMenu.addMenu('Settings')
### Open temp dispaly
self.tempOn = QAction("Open Temp Display:", self)
self.settingMenu.addAction(self.tempOn)
self.tempOn.triggered.connect(self.temp_open)
### Close temp display
self.tempOff = QAction("Close Temp Display:", self)
self.settingMenu.addAction(self.tempOff)
self.tempOff.triggered.connect(self.temp_close)
if self.arguments.Args.debug:
#self.debug.show()
self.debugGps.show()
def add(self, t):
Debug().p("%s adding %s" % (self.name, t.name))
self.feed(t)
# Written by aquova, 2020
# https://github.com/aquova/governor
import discord
import db, commands, events, games, utils, xp
from config import CMD_PREFIX, DISCORD_KEY, GAME_ANNOUNCEMENT_CHANNEL, XP_OFF
from debug import Debug
from slowmode import Thermometer
from tracker import Tracker
client = discord.Client()
db.initialize()
tr = Tracker()
cc = commands.CustomCommands()
dbg = Debug()
game_timer = games.GameTimer()
thermo = Thermometer()
# Dictionary of function pointers
# Maps commands to functions that are called by them
FUNC_DICT = {
"addgame": games.add_game,
"addxp": tr.add_xp,
"cleargames": games.clear_games,
"custom": commands.print_help,
"define": cc.define_cmd,
"edit": commands.edit,
"getgames": games.get_games,
"help": commands.print_help,
"lb": commands.show_lb,
from protocol import Protocol
from utils import singleton
from settings import DEBUG_MODE
from abstract import AGame
@singleton
class Gomoku(AGame):
def __init__(self):
self.is_running = False
self.board = Board()
self.brain = Brain(self.board)
self.protocol = Protocol(self)
self.informations = dict()
def start(self):
self.is_running = True
while self.is_running:
self.protocol.launch_next_command()
def stop(self):
self.is_running = False
if __name__ == '__main__':
if DEBUG_MODE:
from debug import Debug
threading.Thread(target=Gomoku.start).start()
Debug(Gomoku).start()
else:
Gomoku.start()
from default import Default
from database import Database
from waterlevel import Waterlevel
from light import Light
from curtain import Curtain
from pressure import Pressure
from temperature import Temperature
from redox import Redox
from ph import PH
from robot import Robot
from pump import Pump
from panel import Panel
from statistic import Statistic
from debug import Debug
debug = Debug(Debug.DEBUG) # ERROR DEBUG DUMP
class Manager:
AUTO_START_GPIO_PIN = 16
ONCE_BY_HOUR_TICK = 360 # 1h
def __init__(self, refPath, dataPath, dbFilename):
GPIO.cleanup()
GPIO.setmode(GPIO.BCM)
GPIO.setup(self.AUTO_START_GPIO_PIN, GPIO.IN, pull_up_down=GPIO.PUD_UP)
self.__i2c = I2C(2)
self.__analog = Analog(sel.__i2c.getLock(), 0x49)
self.default = Default()
self.database = Database(dataPath, dbFilename)
self.waterlevel = Waterlevel(debug, self.database)
def haltRecog(self,cmd):
Debug().p("halting recog")
self.queue.put("__halt__")
return Hosts.jsonStatus("ok")
def __init__(self, data=None, size=2**10):
self.data = data if data else [' '] * size
self.size = len(self.data)
self.debug = Debug()
def enable(val):
global enabled
playerMutex.acquire()
enabled = val
playerMutex.release()
Debug().p("player enabled:"+str(enabled))
def __init__(self, data=None, size=2**10):
self.data = data if data else [0] * (size >> 2)
self.size = (len(self.data) << 2)
self.debug = Debug()
def __init__(self, settings):
# GLOBAL VARIABLES
self.settings = settings
#application paths
self.apps = {'fop':'fop/fop/fop',
'saxon': 'tools/saxon-he/saxon9he.jar',
'ah':'/usr/AHFormatterV61_64/run.sh',
'xep':'/usr/local/xep/bin/xep/xep'
}
# projects
self.PROJECT_INPUT_FILE_JSON_IS_NOT_VALID = 'project input file json is not valid'
self.PROJECT_INPUT_FILE_TYPE_IS_NOT_SPECIFIED = 'project input file type is not specified'
self.PROJECT_INPUT_FILE_HAS_MORE_THAN_TWO_DOTS = 'project input file has more than two dots'
self.PROJECT_INPUT_FILE_DOES_NOT_EXIST = 'project input_file does not exist'
self.PROJECT_IS_NOT_ACTIVE = 'project is not active'
self.PROJECT_OUTPUT_FILE_IS_NOT_DEFINED = 'project output file is not defined'
self.PROJECT_OUTPUT_FILE_TYPE_IS_NOT_SPECIFIED = 'project output file type is not defined'
self.PROJECT_OUTPUT_FILE_WAS_NOT_CREATED = 'project output file was not created'
self.PROJECT_TYPESETTER_IS_NOT_AVAILABLE = 'project typesetter is not available'
self.PROJECT_TYPESETTER_IS_NOT_SPECIFIED = 'project typesetter is not specified'
self.PROJECT_TYPESETTER_NAME_IS_NOT_SPECIFIED = 'project typesetter name is not specified'
self.PROJECT_TYPESETTER_VAR_IS_NOT_SPECIFIED = 'project typesetter varaible is not specified'
self.PROJECT_TYPESETTERS_ARE_NOT_SPECIFIED = 'project typesetters are not specified'
self.PROJECTS_VAR_IS_NOT_SPECIFIED = 'project variable is not specified'
self.PROJECT_TYPESETTER_PROCESS_METHOD_NOT_SPECIFIED='project typesetter process method not specified'
self.PROJECTS_TYPESETTER_RUNS_WITH_NO_ARGUMENTS = 'projects typesetter runs with no arguments'
# typesetter errors
self.TYPESETTER_ARGUMENTS_NOT_DEFINED = "typesetter arguments not defined"
self.TYPESETTER_EXECUTABLE_VARIABLE_IS_UNDEFINED = 'typesetter executable variable is undefined'
self.TYPESETTER_FILE_OUTPUT_TYPE_IS_UNDEFINED = 'typesetter file output type is undefined'
self.TYPESETTER_METADATA_FILE_WAS_NOT_SPECIFIED = 'Metadata file wasn\'t specified '
self.TYPESETTER_METYPESET_RUNS_WITH_DEFAULT_METADATA_FILE = 'typesetter metypeset runs with default metadata file'
self.TYPESETTER_IS_NOT_SPECIFIED = 'typesetter is not specified '
self.TYPESETTER_PATH_IS_NOT_SPECIFIED = 'typesetter path is not specified '
self.TYPESETTER_BINARY_IS_UNAVAILABLE = 'typesetter binary is unavailable '
self.TYPESETTER_RUNS_WITH_NO_ARGUMENTS = 'typesetter runs with no arguments'
# xml
self.RUNNING_FO_CONVERSION = 'running FO conversion'
self.RUNNING_PDF_CONVERSION = 'running PDF conversion'
self.XML_ELEMENT_NOT_FOUND = 'xml element not found'
self.XML_FILE_NOT_CREATED = 'xml file not created'
self.XML_INPUT_FILE_IS_NOT_FOUND = 'xml input file is not found'
self.XML_INPUT_FILE_IS_NOT_VALID = 'xml input file is not valid'
self.SAXON_IS_NOT_AVAILABLE = 'saxon is not available'
self.FOP_PATH_IS_NOT_AVAILABLE='fop path is not available'
# WORDS
self.OUTPUT = 'Output'
self.debug = Debug()
self.numeral_map = numeral_map
#LOG Object
self.log= []
self.uuid = 'mpt'
self.version = '0.0.1'
nargs=1,
help='specify spec file',
required=True)
parser.add_argument('-o',
'--output',
action='store_true',
help='save session to GardenTakes directory')
args = parser.parse_args()
specFile = args.spec[0]
print("using spec:", specFile)
specs = Specs(specFile)
if args.output:
makeTakesDir()
print("takesDir:", takesDir)
Debug().enable(specs.s['debug'])
pygame.mixer.pre_init(frequency=44100, size=-16, channels=2, buffer=4096)
pygame.init()
SoundFile().setCurrentCollection()
gardenTrack.TrackManager().changeNumGardenThreads(specs.s["numThreads"])
threads = gardenTrack.TrackManager().eventThreads
pulser = Pulser()
pulser.setDaemon(True)
pulser.start()
pt = gardenPlayer.playerThread(threads)
pt.setDaemon(True)
pt.start()
while True:
logger.warn('ID只能输为数字')
elif input_id == '0':
exit()
browser_choice = ''
while not browser_choice.isdigit():
browser_choice = input(
'请选择要运行的浏览器(输入数字，回车)：1、谷歌 2、IE 3、火狐 0-返回上级：')
if not browser_choice.isdigit():
logger.warn('只能输入数字')
elif browser_choice == '0':
break
if browser_choice == '1':
browser_choice = '谷歌'
elif browser_choice == '2':
browser_choice = 'IE'
elif browser_choice == '3':
browser_choice == '火狐'
elif browser_choice == '0':
continue
Debug().run(running_plan_num, input_id, browser_choice)
except Exception as e:
logger.error('%s' % e)
except Exception as e:
logger.error('运行出错：%s' % e)
finally:
test_platform_db.close()
def __init__(self):
# Initialize pygame
pygame.init()
self.screen = pygame.display.set_mode((1280,720))
# Global variables
self.max_tps = 0
self.max_fps = 30
self.lifespan = 10000
self.rockets = 100
self.lifecount = 0
self.environment = Environment(self)
self.population = Population(self)
self.debug = Debug(self)
# Local variables
self.running = True
self.simulating = False
self.tps_counter = 0
self.tps_timer = 0
self.tps_value = 0
self.fps_counter = 0
self.fps_timer = 0
self.fps_value = 0
self.sec_timer = 0
# Main loop
while self.running:
# Get events
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.running = False
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE and not self.simulating:
self.simulating = True
elif event.key == pygame.K_d:
self.environment.obstructions = []
elif event.key == pygame.K_t:
self.environment.target = pygame.mouse.get_pos()
elif event.key == pygame.K_LEFTBRACKET:
if self.max_tps >= 100:
self.max_tps -= 100
elif event.key == pygame.K_RIGHTBRACKET:
self.max_tps += 100
elif event.type == pygame.MOUSEBUTTONDOWN:
if event.button == 1:
self.environment.make_obstruction(event.pos)
if self.simulating:
self.update()
self.draw()
# Performance statistics
if time()-self.sec_timer >= 1.0:
self.sec_timer = time()
self.tps_value = self.tps_counter
self.tps_counter = 0
self.fps_value = self.fps_counter
self.fps_counter = 0
def service_shutdown(signum, frame):
Debug().p('Caught signal %d' % signum)
raise ServiceExit
def getLocalAttr(self,a):
rval = self.getHost(self.getLocalHost())[a]
Debug().p("Get Local Attr %s: %s"%(a,rval))
return rval
