def top_menu_caller(self, widget, branch_id, name):
if name == "trial":
cash = accounting.TrialBalance(branch_id, self.notebook.accounts, self.window)
cash.show_all()
if name == "calc":
calculator.Calc("Calculator", self.window)
if name == "settings":
Settings(branch_id,
self.definitions.get_date(), "Settings", self.window, Gtk.DialogFlags.MODAL,
(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
Gtk.STOCK_OK, Gtk.ResponseType.OK))
if name == "purchase":
Purchases(branch_id, self.notebook.sales.get_date())
if name == "add_item":
Item(branch_id, "Add item", self.window, Gtk.DialogFlags.MODAL,
(Gtk.STOCK_OK, Gtk.ResponseType.OK,
Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL))
self.notebook.sales.update_inventory()
self.notebook.sales.dip.update_tanks()
self.notebook.sales.lub.update_inventory()
if name == "print":
response = self.printwindow.run()
if response == Gtk.ResponseType.OK:
print("printing")
elif response == Gtk.ResponseType.CANCEL:
pass
self.printwindow.hide()
def run_game():
# 初始化游戏并创建一个屏幕对象
pygame.init()
pygame.display.set_caption('Alien Invasion')
ai_settings = Settings()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
ship = Ship(ai_settings, screen)
play_button = Button(ai_settings, screen, 'Play')
bullets = Group()
aliens = Group()
gf.create_fleet(ai_settings, screen, aliens, ship)
stats = GameStats(ai_settings)
sb = Scoreboard(ai_settings, screen, stats)
# 开始游戏的主循环
while True:
gf.check_events(ai_settings, screen, ship, bullets, stats, play_button,
aliens, sb)
if not stats.game_over:
ship.update()
gf.update_bullets(ai_settings, screen, bullets, aliens, ship,
stats, sb)
gf.update_aliens(ai_settings, screen, aliens, bullets, ship, stats,
sb)
gf.update_screen(ai_settings, screen, ship, bullets, aliens, stats,
play_button, sb)
def __init__(self, d):
self.d = d
self.setting = Settings(self.d)
self.path = image_comparison.get_path()
self.log_data = []
self.ts_wifi_report_data = []
def run_game():
# 初始化游戏并创建一个屏幕对象
pygame.init()
ai_settings = Settings()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
pygame.display.set_caption("Alien Invasion")
# 创建一艘飞船
ship = Ship(ai_settings, screen)
# 创建一个用于存储子弹的编组
bullets = Group()
aliens = Group()
# 创建外星人群
gf.create_fleet(ai_settings, screen, ship, aliens)
# 开始游戏的主循环
while True:
# 监视键盘和鼠标事件
gf.check_events(ai_settings, screen, ship, bullets)
ship.update()
gf.update_bullets(ai_settings, screen, ship, aliens, bullets)
gf.update_aliens(ai_settings, ship, aliens)
gf.update_screen(ai_settings, screen, ship, aliens, bullets)
time.sleep(0.01)
def initiate_unknown_package_ingestion(self):
"""Ingestion of Unknown dependencies."""
if Settings().disable_unknown_package_flow:
logger.warning('Skipping unknown flow %s',
self.get_all_unknown_packages())
return
logger.error('Ingestion is Not active for Golang.')
def __init__(self, application):
super().__init__()
self._loading = True
self.application = application
self.settings = Settings(self)
self.workflows = Workflows(self)
self.undo_stack = QUndoStack(self)
self.refresh_timer = QTimer()
self._init_widgets()
self.main_window_actions = MainWindowActions(self)
self._init_window()
self._init_toolbars()
self.settings.restore()
if self.settings.signature_key is None:
self.settings.signature_key = genkey()
self.show()
self._update_action_toggles()
# Update the GUI so that everything matches the model
cell_attributes = self.grid.model.code_array.cell_attributes
attributes = cell_attributes[self.grid.current]
self.on_gui_update(attributes)
self._loading = False
self._previous_window_state = self.windowState()
def __init__(self):
# Declare settings
self.cfg = Settings()
# Declare library
self.sf = Salesforce(self.cfg.get_salesforce_credentials())
def __init__(self, d):
self.d = d
self.gmail = Gmail(self.d)
self.path = image_comparison.get_path()
self.log_data = []
self.settings = Settings(d)
self.gmail_report_details = []
async def games_list(request: Request, db: Session = Depends(get_db)):
settings = Settings()
games = db.query(Game)
return settings.templates.TemplateResponse('games/list.jinja', {
'request': request,
'games': games
})
def __init__(self):
super(JiraToMd, self).__init__()
sprint_id = int(input("Enter Sprint ID: "))
epic_id = str(input("Enter EPIC ID: "))
self.sprint_id = sprint_id
self.epic_id = epic_id
self.jira_service = JiraServices()
self.settings = Settings()
self.datetime_service = DateTimeService()
self.make_md_file()
def start_test():
# read config file
settings = Settings("../config/test_config.json")
# tell scraper about the settings
scraper.settings_ref = settings
# scrape
ret = scraper.craw_all()
for obj in ret:
print(obj)
def run():
with open(location_file, "r") as file:
location = file.readline()
file.close()
ers = Errors()
settings = Settings(location, ers)
if write_errors(ers):
return
classroom = Classroom(settings.created_students, settings)
print_testing_report(settings)
write_results(classroom)
subprocess.call(['open', '-a', 'TextEdit', results_file])
def __init__(self, d):
self.d = d
self.nictalk = NicTalk(self.d)
self.camtalk = CamTalk(self.d)
self.qq = Tx_QQ(self.d)
self.clock = Clock(self.d)
self.camera = Camera(self.d)
self.settings = Settings(self.d)
self.message = Message1(self.d)
self.path = os.path.abspath(os.path.join(
os.getcwd(), "../..")) + "\\enter_resource\\"
self.language = self.settings.change_language()
self.settings.display_setting()
def run_game():
pygame.init()
ai_settings = Settings()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
pygame.display.set_caption("Alien Invasion")
ship = Ship(ai_settings, screen)
bullets = Group()
alien = Alien(ai_settings, screen)
while True:
gf.check_events(ai_settings, screen, ship, bullets)
ship.update()
gf.update_bullet(bullets)
gf.update_screen(ai_settings, screen, ship, alien, bullets)
def run_game():
pygame.init()
game_settings = Settings()
screen = Screen(game_settings)
pygame.display.set_caption("BOMBERMAN")
character = Character(game_settings, screen.screen, (0, 0))
character2 = Character(game_settings, screen.screen, (1, 1))
bombs_handler = BombsHandler(Group(), Group())
obstacles = Group()
hard_obstacles = Group()
explosions = Group()
treasures = Group()
obstacle_placer = ObstaclePlacer()
obstacle_placer.create_obstacles(game_settings, screen.screen, obstacles)
obstacle_placer.create_hard_obstacles(game_settings, screen.screen,
hard_obstacles)
joystick = Joystick()
smile_of_fate = SmileOfFate(game_settings)
latest_choices = (0, 0)
controller = Controller()
while True:
pygame.event.pump()
controller.check_events(game_settings, screen.screen, character,
bombs_handler.bombs[0], character2,
bombs_handler.bombs[1])
character.update(obstacles, hard_obstacles)
if joystick.is_joystick():
latest_choices = controller.check_joystick_events(
character2, joystick.is_joystick(), latest_choices)
character2.update(obstacles, hard_obstacles)
bombs_handler.update_bombs(bombs_handler.bombs[0], game_settings,
screen.screen, explosions, obstacles,
treasures, smile_of_fate)
bombs_handler.update_bombs(bombs_handler.bombs[1], game_settings,
screen.screen, explosions, obstacles,
treasures, smile_of_fate)
bombs_handler.kill_your_heroes(explosions, character, character2)
if len(obstacles.sprites()) < 5:
treasures.empty()
character.reset_character_status()
character2.reset_character_status()
obstacle_placer.create_obstacles(game_settings, screen.screen,
obstacles)
smile_of_fate.player_collected_treasure(character, treasures)
smile_of_fate.player_collected_treasure(character2, treasures)
screen.update_screen(game_settings, character, obstacles,
bombs_handler.bombs[0], character2,
bombs_handler.bombs[1], hard_obstacles,
explosions, treasures)
def load_settings(task_file, arg_duration, arg_seed):
settings = task_file['settings']
if arg_seed is None and 'seed' not in settings:
seed = None
else:
seed = int(arg_seed) if arg_seed is not None else settings['seed']
if arg_duration is None and 'duration' not in settings:
print('No duration specified, using the default of 30 seconds')
duration = 30
else:
duration = int(arg_duration) if arg_duration is not None else settings['duration']
breath_pause_length = settings['breath_pause_length']
return Settings(seed, duration, breath_pause_length)
def init_app():
app = Sanic(__name__, strict_slashes=False)
env = Env()
env.read_env()
app.config.update_config(Settings())
setup_routes(app)
setup_middlewares(app)
app.request_class = AppRequest
app.run(
host=app.config.HOST,
port=app.config.PORT,
debug=app.config.DEBUG,
auto_reload=app.config.DEBUG,
)
return app
def __init__(self, d):
self.d = d
self.settings = Settings(d)
self.ncacootv = NCA_Cootv(d)
self.khmcootv = KHM_Cootv(d)
self.cooclean = Coo_Clean(d)
self.ncacoobill = NCA_CooBill(d)
self.khmcoobill = KHM_CooBill(d)
self.mi_cootel = Mi_CooTel(d)
self.camtalk = CamTalk(d)
self.nictalk = NicTalk(d)
self.path = os.path.abspath(os.path.join(
os.getcwd(), "../..")) + "\\enter_resource\\"
self.NCA_test_report = []
self.KHM_test_report = []
self.test_report = []
def __init__(self):
pygame.init()
pygame.display.set_caption("Battle Tank")
self.settings = Settings()
self.screen = pygame.display.set_mode(
(self.settings.screen_width, self.settings.screen_height))
self.clock = pygame.time.Clock()
self.fps = self.settings.fps
self.blocks = pygame.sprite.Group()
self.all_objects = pygame.sprite.Group()
self.all_tanks = pygame.sprite.Group()
self.enemies = pygame.sprite.Group()
self.bg = None
self.player = None
def __init__(self):
pygame.init()
self.settings = Settings()
self.screen = pygame.display.set_mode((0, 0), pygame.FULLSCREEN)
self.settings.screen_height = self.screen.get_rect().height
self.settings.screen_width = self.screen.get_rect().width
self.bg = pygame.image.load('../images/bg.png').convert()
pygame.display.set_caption("Battle Tank")
self.bullets = pygame.sprite.Group()
self.player = Player(self)
enemy = Enemy(self)
self.enemies = pygame.sprite.Group()
self.enemies.add(enemy)
self.all_tanks = pygame.sprite.Group()
self.all_tanks.add(self.player)
self.all_tanks.add(enemy)
def run_game():
"""Main entry point for Py-Climber"""
# Startup pygame object
pygame.init()
random.seed()
# Load our settings object and image resources, disk I/O that can be done in advance
settings = Settings()
image_res = ImageResources(settings)
# Add to the cache so it's accessible where needed
settings.image_res = image_res
# Create the main screen to render to based on settings
screen = pygame.display.set_mode(
(settings.screen_width, settings.screen_height))
pygame.display.set_caption(settings.caption)
# Create a 2D tilemap - this takes a list of indices and an image list to produce a tiled surface
tile_map = Tilemap(settings, screen, settings.map_indicies,
image_res.tile_images, image_res.block_image,
image_res.blob_exit_images,
image_res.player_sprite_images,
image_res.enemy_blob_images)
# Overwrite default indices with generated map
tile_map.generate_basic_map(settings.map_number_floors,
settings.map_number_subfloors)
# Reset the game
gf.reset_game(tile_map)
# Use pygame's simple loop management for a fixed 30 FPS
clock = pygame.time.Clock()
while True:
# Should make sure each frame spends at least 1/30 seconds in this loop
# downside is wasted sleep on fast hardware and slow hardware will lag
# but slow hardware will always lag and implementing a time-delta based
# loop for this simple game is IMHO overkill.
clock.tick(30)
# Process system events (key-presses, joystick, etc)
gf.check_events(settings, screen, tile_map)
# Update the game (this will update all sub-object and render them to the screen)
gf.update_screen(settings, screen, tile_map)
def main():
settings = Settings()
point_list = func.fractal_list[settings.current_fractal](settings)
# palette = func.linear_colorize(settings)
palette = func.colorize(settings)
init() #pygame
screen = display.set_mode((settings.SCREEN_WIDTH, settings.SCREEN_HEIGHT))
display.set_caption(f"Fractals")
func.display_fractal(palette, screen, point_list)
func.update_screen()
while True:
pf.check_events(screen, settings, palette)
def __init__(self, application, args, unit_test=False):
super().__init__()
self._loading = True
self.application = application
self.unit_test = unit_test
self.settings = Settings(self)
self.workflows = Workflows(self)
self.undo_stack = QUndoStack(self)
self.refresh_timer = QTimer()
self._init_widgets()
self.main_window_actions = MainWindowActions(self)
self._init_window()
self._init_toolbars()
self.settings.restore()
if self.settings.signature_key is None:
self.settings.signature_key = genkey()
# Update recent files in the file menu
self.menuBar().file_menu.history_submenu.update()
if not self.unit_test:
self.show()
self._update_action_toggles()
# Update the GUI so that everything matches the model
cell_attributes = self.grid.model.code_array.cell_attributes
attributes = cell_attributes[self.grid.current]
self.on_gui_update(attributes)
self._loading = False
self._previous_window_state = self.windowState()
# Open initial file if provided by the command line
if args.file is not None:
if self.workflows.filepath_open(args.file):
self.workflows.update_main_window_title()
else:
msg = "File '{}' could not be opened.".format(args.file)
self.statusBar().showMessage(msg)
def get_result(self) -> StackAggregatorResult:
"""Aggregate stack data."""
# denormalize package details according to request.dependencies relations
package_details = self._get_denormalized_package_details()
unknown_dependencies = self._get_direct_unknown_packages()
started_at = time.time()
license_analysis = get_license_analysis_for_stack(package_details)
logger.info('%s took %0.2f secs for get_license_analysis_for_stack()',
self._request.external_request_id,
time.time() - started_at)
return StackAggregatorResult(
**self._request.dict(exclude={'packages'}),
analyzed_dependencies=package_details,
unknown_dependencies=unknown_dependencies,
license_analysis=license_analysis,
registration_link=Settings().snyk_signin_url)
def __init__(self, settingsFile, manifestFile, resume=0):
manifest = Settings(manifestFile)
Analysis.__init__(self, settingsFile, manifest['expName'])
self.resume = resume
self.name = manifest['expName']
self.dataType = manifest['dataType']
self.readType = manifest['readType']
self.replicates = []
self.json = {}
if self.readType == 'single':
if 'fileRep1' in manifest:
self.replicates.append(1)
self.registerInputFile('tagsRep1.fastq', manifest['fileRep1'])
if 'fileRep2' in manifest:
self.replicates.append(2)
self.registerInputFile('tagsRep2.fastq', manifest['fileRep2'])
elif self.readType == 'paired':
if 'fileRd1Rep1' in manifest:
self.replicates.append(1)
self.registerInputFile('tagsRd1Rep1.fastq',
manifest['fileRd1Rep1'])
self.registerInputFile('tagsRd2Rep1.fastq',
manifest['fileRd2Rep1'])
if 'fileRd1Rep2' in manifest:
self.replicates.append(2)
self.registerInputFile('tagsRd1Rep2.fastq',
manifest['fileRd1Rep2'])
self.registerInputFile('tagsRd2Rep2.fastq',
manifest['fileRd2Rep2'])
self.interimDir = None
self.targetDir = None
self.pipeline = None
if self.dataType == 'DNAse':
self.pipeline = DnasePipeline(self)
else:
pass
def main(config_file_name):
"""
:param config_file_name: str, name of the configuration json file
:return:
"""
global push_notifier, settings
# read config file
settings = Settings(config_file_name)
# tell scraper about the settings
scraper.settings_ref = settings
# create notifier
push_notifier = PushBulletNotifier(settings.token)
# start timer
timer = Timer(settings.hours, unit_callback)
timer.start_counter()
def run_game():
"""The function opens the game and creates a screen"""
# Initialize pygame, settings, and screen object.
pygame.init()
ai_settings = Settings()
screen = pygame.display.set_mode(
(ai_settings.display_width, ai_settings.display_height))
pygame.display.set_caption("Alien Invasion")
# Make a rocket ship
rocket_ship = RocketShip(screen, ai_settings)
# Make a group to store bullets in.
bullets = Group()
# Make a group of Aliens and the fleet.
aliens = Group()
game_functions.create_fleet(ai_settings, screen, rocket_ship, aliens)
# Create an instance to store game statistics.# Create an instance to store game statistics and create a scoreboard
stats = GameStats(ai_settings)
empty_ship = EmptyShip(ai_settings, screen)
sb = Scoreboard(ai_settings, screen, stats)
# Make the Play button.
play_button = Button(ai_settings, screen)
# Start the main loop for the game.
while True:
game_functions.check_events(ai_settings, screen, stats, sb,
play_button, rocket_ship, aliens, bullets)
if stats.game_active:
rocket_ship.update()
game_functions.update_bullets(ai_settings, screen, stats, sb,
rocket_ship, aliens, bullets)
game_functions.update_aliens(ai_settings, stats, sb, screen,
rocket_ship, aliens, bullets)
game_functions.update_screen(ai_settings, screen, stats, sb,
rocket_ship, aliens, bullets, play_button,
empty_ship)
def initiate_unknown_package_ingestion(self):
"""Ingestion of Unknown dependencies."""
if Settings().disable_unknown_package_flow:
logger.warning('Skipping unknown flow %s',
self.get_all_unknown_packages())
return
ecosystem = self._normalized_packages.ecosystem
try:
for dep in self.get_all_unknown_packages():
server_create_analysis(ecosystem,
dep.name,
dep.version,
api_flow=True,
force=False,
force_graph_sync=True)
except Exception as e: # pylint:disable=W0703,C0103
logger.error('Ingestion failed for {%s, %s, %s}', ecosystem,
dep.name, dep.version)
logger.error(e)
def __init__(self):
super().__init__()
self.setWindowTitle("Urban Terror DemoRecorder")
self.setGeometry(0, 0, 500, 200)
self.settings = Settings()
self.path = ""
self.format = ""
# Path
self.layout = QVBoxLayout()
self.initPath()
self.initDemosFormat()
self.initSubmitButton()
widget = QWidget()
widget.setLayout(self.layout)
self.setCentralWidget(widget)
def run_game():
"""Initialize game, settings and create a screen object"""
pygame.init()
sounds = Sounds()
ai_settings = Settings()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
pygame.display.set_caption("Alien Invasion")
# Make the play button.
play_button = Button(ai_settings, screen, 'Play')
# Make a ship, a group of aliens and a group of bullets
ship = Ship(ai_settings, screen)
aliens = Group()
bullets = Group()
# Create a fleet of aliens
gf.create_fleet(ai_settings, screen, ship, aliens)
# Create an instance to store the game statistics and scoreboard
stats = GameStats(ai_settings)
sb = Scoreboard(ai_settings, screen, stats)
# Start the main loop for the game.
while True:
gf.check_events(ai_settings, screen, stats, sb, play_button, ship,
sounds, aliens, bullets)
if stats.game_active:
ship.update()
gf.update_bullets(ai_settings, screen, stats, sb, ship, sounds,
aliens, bullets)
gf.update_aliens(ai_settings, stats, sb, screen, ship, aliens,
bullets)
gf.update_screen(ai_settings, screen, sb, ship, aliens, bullets)
else:
gf.display_menu_screen(ai_settings, screen, play_button)
