def test_init(self): ft = FakeTransmitter(3) real_transmission = libhoney.transmission.Transmission libhoney.transmission.Transmission = mock.MagicMock(return_value=ft) libhoney.init(writekey="wk", dataset="ds", sample_rate=3, api_host="uuu", max_concurrent_batches=5, block_on_response=True) self.assertEqual(libhoney.g_writekey, "wk") self.assertEqual(libhoney.g_dataset, "ds") self.assertEqual(libhoney.g_api_host, "uuu") self.assertEqual(libhoney.g_sample_rate, 3) self.assertEqual(libhoney._xmit, ft) self.assertEqual(libhoney.g_responses, None) libhoney.transmission.Transmission.assert_called_with(5, False, True) libhoney.transmission.Transmission = real_transmission
def submit(): global city, start_date, end_date, preference, weather_date global routes, route_distance, weather_output city = city_tkvar.get() start_date = start_date_entry.get() num_days = end_date_entry.get() preference = pref_tkver.get() if validator(city, start_date, num_days, preference): end_date = (dt.datetime.strptime(start_date, "%Y-%m-%d").date() + dt.timedelta(int(num_days))).strftime('%Y-%m-%d') weather_date = dt.datetime.strptime( start_date, "%Y-%m-%d").date().strftime('%b %-d').upper() routes, route_distance, weather_output = init.init( city, start_date, end_date, preference) table_builder()
threadLock.release() time.sleep(ticks*5) # 100 seconds if __name__ == "__main__": device = formDeviceName() init(device) # params for wampserver ip = sys.argv[1] port = sys.argv[2] realm = unicode(sys.argv[3]) path = sys.argv[4] __init__.init(path) print(ip, port, realm, path) global client check = client.connect(ip, port, realm) #wait till the connection is established time.sleep(5) #create an instance periodicTransmit_I = periodicTransmit(device) # Launch thread handle_heartbeat = periodicTransmit_I.heartbeat() handle_containerStatus = periodicTransmit_I.containerStatus()
# Copyright (C) 2010 David Barnett <*****@*****.**> # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. if __name__ == '__main__': from __init__ import init; init() import unittest from ranger.gui import ansi class TestDisplayable(unittest.TestCase): def test_char_len(self): ansi_string = "[0;30;40mX[0m" self.assertEqual(ansi.char_len(ansi_string), 1) def test_char_len2(self): ansi_string = "[0;30;40mXY[0m" self.assertEqual(ansi.char_len(ansi_string), 2) def test_char_len3(self): ansi_string = "[0;30;40mX[0;31;41mY"
level = logging.DEBUG, \ format = '%(asctime)s | %(levelname)s | %(message)s', \ datefmt = '%Y-%m-%d %H:%M:%S' ) # In[4]: def start(): logging.info('Start of program'.center(30, '-')) # In[5]: def shutdown(): logging.info('End of program'.center(30, '-')) logging.shutdown() # In[6]: if __name__ == '__main__': __init__.init() __config__ = __init__.config.__config__ init(logpath=__config__.LOG_PATH) start() logging.debug('Try logging..') shutdown()
import __init__ if __name__ == "__main__": __init__.welcome() __init__.init() __init__.run()
parser = argparse.ArgumentParser() parser.add_argument('--task', required=True) parser.add_argument('--action', choices=["split","check","remove"], required=True) parser.add_argument('--debug', action='store_true') parser.add_argument('--monkey_patch', action='store_true') args = parser.parse_args() logging.basicConfig(level=(logging.DEBUG if args.debug else logging.INFO), format='%(asctime)-15s: %(message)s [%(filename)s:%(lineno)s]') task_file = open(args.task+'.json') task = json.loads(task_file.read()) task_file.close() sys.path.append("../pymysql_split_tool") import __init__ if args.monkey_patch: import re import db def new_get_table_structure(database, table): '''Change the table creation sql''' db.old_get_table_structure(database, table) db.db_ori_table_create_sql = re.sub('AUTO_INCREMENT\=\d+', '', db.db_ori_table_create_sql) db.db_ori_table_create_sql = db.db_ori_table_create_sql.replace('AUTO_INCREMENT','') db.db_ori_table_create_sql = db.db_ori_table_create_sql.replace('PRIMARY KEY (`id`)','PRIMARY KEY (`data_int`)') logging.debug(db.db_ori_table_create_sql) db.old_get_table_structure = db.get_table_structure db.get_table_structure = new_get_table_structure __init__.init(args.action, task) __init__.do_work()
#!/usr/bin/env python3 # -*- coding: utf-8 -*- import __init__ as _fonts from collections import OrderedDict import json import unicodedata FS = dict() _fonts.init(100) for char in range(0x0, 0xFFFF): ucd = unicodedata.name("{}".format(chr(char)), "UNKNOWN") if ucd == "UNKNOWN": chard = "{} | {} | {}".format(0, ucd, char) else: chard = "{} | {} | {}".format(chr(char), ucd, hex(char)) FS[chard] = _fonts.textlength("★" + chr(char) + "★") - 2 FSk = OrderedDict(sorted(FS.items(), key=lambda t: t[0])) FSs = OrderedDict(sorted(FSk.items(), key=lambda t: t[1])) print(json.dumps(FSs, ensure_ascii=False, indent="\t", sort_keys=False))
import argparse import __init__ as app app.init() etl = __import__(app.etl) # Extraction raw_data = etl.extract() # Transform processed_data = etl.transform(raw_data) # Load etl.load(processed_data)
print(type(array), array.dtype, array.shape, array[50]) array = coda.cursor_read_complex_double_split_array(cursor) print(type(array), len(array), len(array[0]), type(array[0]), array[0].dtype, array[0][50], array[1][50]) coda.cursor_goto_array_element_by_index(cursor, 50) scalar = coda.cursor_read_complex(cursor) print(type(scalar), scalar) scalar = coda.cursor_read_complex_double_pair(cursor) print(type(scalar), scalar.dtype, scalar) scalar = coda.cursor_read_complex_double_split(cursor) print(type(scalar), scalar) coda.close(product) coda.init() coda.set_option_bypass_special_types(0) print(coda.get_option_bypass_special_types()) coda.set_option_perform_boundary_checks(1) print(coda.get_option_perform_boundary_checks()) coda.set_option_perform_conversions(1) print(coda.get_option_perform_conversions()) coda.set_option_use_fast_size_expressions(1) print(coda.get_option_use_fast_size_expressions()) coda.set_option_use_mmap(1) print(coda.get_option_use_mmap()) for i in range(REPEAT): test() coda.done()
from __init__ import init from flask_restful import Api from routes.Product import add_product, get_all_products, get_product, update_product, delete_product app = init() api = Api(app) api.add_resource(add_product, '/product') api.add_resource(get_all_products, '/products') api.add_resource(get_product, '/product/<id>') api.add_resource(update_product, '/product/<id>') api.add_resource(delete_product, '/product/<id>') if __name__ == '__main__': app.run(debug=True)
#!/usr/bin/env python3 # coding=utf8 import __init__ as _fonts import json import unicodedata from collections import OrderedDict FS = dict() _fonts.init() for char in range(0x0, 0xFFFF): chard = unicodedata.name("{}".format(chr(char)), "UNKNOWN") if chard == "UNKNOWN": chard = "{}".format(hex(char)) FS[chard] = _fonts.textlength(chr(char)) FSk = OrderedDict(sorted(FS.items(), key=lambda t: t[0])) FSs = OrderedDict(sorted(FSk.items(), key=lambda t: t[1])) print(json.dumps(FSs, ensure_ascii=False, indent="\t", sort_keys=False))
#!/usr/bin/env python3 # -*- coding: utf-8 -*- import __init__ as _fonts from collections import OrderedDict import json import unicodedata FS = dict() _fonts.init(100) for char in range(0x0, 0xFFFF): ucd = unicodedata.name("{}".format(chr(char)), "UNKNOWN") if ucd == "UNKNOWN": chard = "{} | {} | {}".format(0, ucd, char) else: chard = "{} | {} | {}".format(chr(char), ucd, hex(char)) FS[chard] = _fonts.textlength("★" + chr(char) + "★")-2 FSk = OrderedDict(sorted(FS.items(), key=lambda t: t[0])) FSs = OrderedDict(sorted(FSk.items(), key=lambda t: t[1])) print(json.dumps(FSs, ensure_ascii=False, indent="\t", sort_keys=False))
file_holder.close() if not isJson: player = AudioPlayer(tmp_file_path) player.start() finally: client_sock.close() server_sock.close() class AudioPlayer(threading.Thread): def __init__(self,path): super().__init__() self.path = path def run(self): tools.playAudio(self.path) class ConnectionServer(threading.Thread): def __init__(self): super().__init__() def run(self): import __init__ as initializer initializer.init() startBT() if __name__ == "__main__": import __init__ as initializer initializer.init() startBT()
import datetime import logging import time from __init__ import init from component import mymysql, my_async, request_dingding_webhook from config import app_conf init() target_db_pool = mymysql.init(app_conf["mysql"]["target"]) self_db_pool = mymysql.init(app_conf["mysql"]["self"]) logger = logging.getLogger('sync_polardb_slow_log') logger.setLevel(logging.DEBUG) local_cache_sql_template_id_2_text = {} grafana_base_url = app_conf["grafana"]["base_url"] def post_alarm(msg_content, at_mobiles): dingding_webhook_access_token = app_conf["dingding_webhook_access_token"][ 0] dingding_resp = request_dingding_webhook.request_dingding_webhook( dingding_webhook_access_token, "慢SQL", msg_content, at_mobiles) logger.debug(dingding_resp) def select_sql_template_id_by_text(db_name, sql_template_text): # 在本地查询 global local_cache_sql_template_id_2_text if local_cache_sql_template_id_2_text.__contains__(db_name): local_cache_sql_template_id_2_text_db_level = local_cache_sql_template_id_2_text[
def run(self): import __init__ as initializer initializer.init() startBT()
#!/usr/bin/env python # -*- coding: utf-8 -*- from __future__ import absolute_import from __init__ import init init() from tinyrpc.server import RPCServer import concurrent.futures class RPCServerThreaded(RPCServer): def __init__(self, *args, **kw): self.executor = concurrent.futures.ThreadPoolExecutor(5) return RPCServer.__init__(self, *args, **kw) def _spawn(self, func, *args, **kwargs): self.executor.submit(func, *args, **kwargs)
from mapgen import CellularAutomata from objects import Floor, Wall import ui from gridview import HexGridView from perception import PGrid import globals from __init__ import init is_debug=True logger.setLevel(logging.DEBUG) if seeds[0]!=seeds[1]: usage() exit(1) init('asp_spa.conf') generator=CellularAutomata(Random(int(seeds[0])),Floor,Wall) level=generator.generateLevel(geometry[0],geometry[1]) tiles=[level[geometry[0]/2,geometry[1]/2]] done_tiles=[] while tiles[0].blocksLOS(): tile=tiles.pop(0) tiles.extend([t for t in level.getNeighbors(tile.loc) if t not in tiles and t not in done_tiles]) done_tiles.append(tile) tile=tiles[0] world=[(i,j,level[i,j].blocksLOS()) for i in xrange(level.width) for j in xrange(level.height)] me=(tile.loc[0],tile.loc[1],False) perception=PGrid(level, None) for t in perception.getTiles(): t.was_seen=True worldview=HexGridView(level, perception)
def appGenerator(): init() return app