def __init__(self): self.const = Constants() self.f_raw_requests_per_day = 'data/RequestsPerDay.csv' self.f_parsed_requests_per_day = 'data/ParsedRequestsPerDay.csv' self.f_raw_requests_per_month = 'data/RequestsPerMonth.csv' self.f_parsed_requests_per_month = 'data/ParsedRequestsPerMonth.csv' self.f_parsed_requests_per_month = 'data/ParsedRequestsOverTime.csv'
def init(self): constants = Constants() self.gridResolution = constants.getGridSize() self.topLat = constants.corners[0][0] self.bottomLat = constants.corners[2][0] self.leftLon = constants.corners[0][1] self.rightLon = constants.corners[1][1]
def __init__(self): self.constants = Constants() self._querystartlink = None self._queryendlink = None self._imagestartlink = None self._summarystartlink = None
class DbNode(): logger = logging.getLogger('dbnodelogger') logger.setLevel(logging.DEBUG) ch = logging.FileHandler('dbnode.log', 'w') formatter = logging.Formatter( '[%(asctime)s] %(message)s %(funcName)s:%(lineno)d') ch.setFormatter(formatter) logger.addHandler(ch) constants = Constants() zk = KazooClient(hosts='172.25.0.101:2181') flask_port = None def __init__(self): super().__init__() DbNode.zk.add_listener(DbNode.connection_listener) DbNode.zk.start() self.add_myself_to_zookeeper() @staticmethod def print_error(e): print(DbNode.constants.ERROR_PREFIX + e.__str__()) def add_myself_to_zookeeper(self): hostname = socket.gethostname() ip = socket.gethostbyname(hostname) # ToDo: Remove this after testing # ip = '127.0.0.1' try: # print(ip) # print(DbNode.flask_port) node_data = {'ip': ip, 'flask_port': DbNode.flask_port} DbNode.zk.ensure_path("/nodes") DbNode.zk.create("/nodes/node", str.encode(json.dumps(node_data)), ephemeral=True, sequence=True) # print('Added myself to /nodes, children list:') child_node_list = DbNode.zk.get_children('/nodes') if child_node_list: print('subnode list:{}'.format(child_node_list)) except Exception as e: DbNode.print_error(e) pass @staticmethod def connection_listener(state): if state == KazooState.LOST: print('session lost') elif state == KazooState.SUSPENDED: print('session suspended') else: print('running in state {}'.format(state))
def log_control(size = 100000): '''limit the number of lines of logfile to size//2 once size is reached''' path_log = Constants().files().get("logs.log") with open(path_log) as pf: data = pf.readlines() if len(data) > size: size //= -2 with open(path_log, "w+") as pf: pf.writelines(data[size:])
def test_get_model_error(): data1 = [[2, 3, 1], [99, 99, 2], [-1, -4, 3], [99, 99, 4]] data2 = [[3, 4, 1], [-2, -5, 3]] eval.const = Constants() eval.const.set_features(2) result = eval.get_model_error(data1, data2) assert result is not None
def load_stopwords(self): constants = Constants() with open(constants.path_stopwords + constants.file_stopwords) as csvfile: readcsv = csv.reader(csvfile, delimiter=',') for row in readcsv: stopword = row[0] enabled = row[1] stopword = Stopword(stopword, enabled) self.stopwords.append(stopword)
def init(self): constants = Constants() self.gridResolution = constants.getGridSize() self.topLat = constants.corners[0][0] self.bottomLat = constants.corners[2][0] self.centerLat = self.bottomLat + (self.topLat - self.bottomLat) / 2 self.leftLon = constants.corners[0][1] self.rightLon = constants.corners[1][1] self.centerLon = self.leftLon + (self.rightLon - self.leftLon) / 2
def main(): # RUN TRAINING LOOP c = Constants() # run with default params run = Trainer(c) run.test() run.train() run.close()
class TestAttachment(TestCase): c = Constants() def _deleteOrCreateTestRecord(self): client = ServiceNowClient(self.c.server, self.c.credentials) gr = client.GlideRecord('problem') gr.add_query('short_description', 'Unit Test - Attachments') gr.query() if gr.next(): return gr gr.initialize() gr.short_description = "Unit Test - Attachments" gr.description = "Second Field" gr.insert() return gr def _getOrCreateEmptyTestRecord(self): client = ServiceNowClient(self.c.server, self.c.credentials) gr = client.GlideRecord('problem') gr.add_query('short_description', 'Unit Test - Attachments - Empty') gr.query() if gr.next(): return gr gr.initialize() gr.short_description = "Unit Test - Attachments - Empty" gr.description = "Second Field" gr.insert() return gr def test_attachments_for(self): gr = self._getOrCreateEmptyTestRecord() attachments = gr.get_attachments() print(attachments) self.assertNotEquals(attachments, None) self.assertEquals(len(attachments), 0) def test_add_delete(self): client = ServiceNowClient(self.c.server, self.c.credentials) with TempTestRecord(client, 'problem') as gr: attachments = gr.get_attachments() self.assertNotEquals(attachments, None) self.assertEquals(len(attachments), 0) content = "this is a sample attachment" gr.add_attachment('test.txt', content) attachments = gr.get_attachments() self.assertEquals(len(attachments), 1) for a in attachments: self.assertEquals(a.file_name, 'test.txt') f = a.getAsFile() self.assertEquals(f.read(), content.encode('utf-8')) a.delete()
def __init__(self, mapSize): self._map = Map(mapSize) self._C = Constants() self._playerTurn = False self._playerPosition = {"x": mapSize * .5, "y": mapSize * .5} self._attack = False self._playerInCombat = False self._playerMovementDirection = self._C.NoMovement
def __init__(self: object, max_conn: int) -> object: """ This constructor sets up all required address and preliminary configurations. """ self.FAIL_SAFE_ADDRESS = ('', 8006) self.protocols = Constants() self.set_up_logger('failsafe-coordinator') self.max_conn = max_conn self.connected_clients = 0 self.commit = False self.clients = {}
def quit_driver(driver=None): ''' Quits a selenium driver. If driver is running in docker, it stops the docker containers. @param driver: selenium driver to quit ''' logger.info('Quitting {} driver'.format(driver)) const = Constants() if driver is not None: driver.quit() if const.get_docker() is True: selenium_docker_container.stop_docker()
def __init__(self): self.const = Constants() self.input_path = self.const.song_dataset self.feature_path = self.const.feature_path self.output_path = self.const.clustered_music self.api_key = self.const.musixmatch_api_key self.features = None self.details = None self.valence = [] self.arousal = [] self.clusters = []
def __init__(self, handle): activity.Activity.__init__(self, handle) #flags for controlling the writing to the datastore self.I_AM_CLOSING = False self.I_AM_SAVED = False self.props.enable_fullscreen_mode = False self.ui = None Constants(self) #self.modify_bg(gtk.STATE_NORMAL, Constants.color_black.gColor) #wait a moment so that our debug console capture mistakes gobject.idle_add(self._initme, None)
def load_grammar_rules(self): constants = Constants() with open(constants.path_grammar_rules + constants.file_grammar_rules) as csvfile: readcsv = csv.reader(csvfile, delimiter=',') for row in readcsv: ref = row[0] file = row[1] category = row[2] enabled = row[3] grammar = Grammar(ref, file, category, enabled) self.grammar_rules.append(grammar)
def initialize_channel_parameters(self, assumption_flag = "iid"): from constants import Constants import numpy as np const = Constants() self.lambda_id_array = np.ones((self.SOURCE_NUM,), dtype = float) if assumption_flag == "iid": self.lambda_ij_array = const.LAMBDA_interval[0] + \ (const.LAMBDA_interval[1]-const.LAMBDA_interval[0])*np.random.rand(self.SOURCE_NUM) elif assumption_flag == "niid": self.lambda_ij_array = const.LAMBDA_interval[0] + \ (const.LAMBDA_interval[1]-const.LAMBDA_interval[0])*np.random.rand(self.SOURCE_NUM,self.RELAY_NUM) self.lambda_jd_array = const.LAMBDA_interval[0] + \ (const.LAMBDA_interval[1]-const.LAMBDA_interval[0])*np.random.rand(self.RELAY_NUM,self.SOURCE_NUM)
def __init__(self): constants = Constants() self._stats = constants.PlayerDefaults self._equipment = { "body": 0, "legs": 0, "arms": 0, "hands": 0, "feet": 0 } self._activeEnemy = None
def __init__(self: object, max_connections: int, fail_safe_address: str) -> object: """ This constructor sets up all the required address and preliminary configurations. """ self.SERVER_ADDRESS = ('', 8005) self.FAIL_SAFE_ADDRESS = (fail_safe_address, 8006) self.max_connections = max_connections self.clients = {} self.connected_clients = 0 self.commit = 0 self.protocols = Constants() self.set_up_logger('main-coordinator')
def generate_manifest(data_dir, mode): const = Constants(data_dir, mode) # verify the provided path and generate underlying substructure EnvGenerator.generate_directories(data_dir) logging.debug( f"path_datadir == {str(const.get_path_data_dir().resolve())}") logging.debug( f"path_dataset == {str(const.get_path_data_set().resolve())}") logging.debug( f"path_calculators == {str(const.get_path_calculators().resolve())}") # with a validate data directory structure, we can build the manifest.json EnvGenerator.generate_manifest(data_dir, mode)
class TestAuth(TestCase): c = Constants() def test_basic(self): client = ServiceNowClient(self.c.server, self.c.credentials) gr = client.GlideRecord('sys_user') gr.fields = 'sys_id' self.assertTrue(gr.get('6816f79cc0a8016401c5a33be04be441')) def test_basic_fail(self): client = ServiceNowClient(self.c.server, ('admin', 'this is not a real password')) try: gr = client.GlideRecord('sys_user') gr.get('does not matter') assert 'Exception should have been thrown' except exceptions.AuthenticationException as e: self.assertTrue('User Not Authenticated' in str(e)) self.assertTrue('Required to provide Auth information' in str(e)) except Exception: assert 'Should have got an Auth exception' def test_oauth(self): # Manual setup using legacy oauth server = self.c.server creds = self.c.credentials client_id = '3e57bb02663102004d010ee8f561307a' #mobile # get the secret manually secret_url = '%s/api/now/mobileapp/plugin/secret' % server r = requests.get(secret_url, auth=creds) if r.status_code != 200: raise Exception('couldnt get secret') secret = r.json()['result']['secret'] self.assertIsNotNone(secret) oauth = OAuth2Session(client=LegacyApplicationClient(client_id=client_id)) token = oauth.fetch_token(token_url='%s/oauth_token.do' % server, username=creds[0], password=creds[1], client_id=client_id, client_secret=secret) client = ServiceNowClient(self.c.server, oauth) gr = client.GlideRecord('sys_user') gr.fields = 'sys_id' self.assertTrue(gr.get('6816f79cc0a8016401c5a33be04be441')) def test_oauth_builtin(self): client = ServiceNowClient(self.c.server, ServiceNowOAuth2(self.c.credentials)) gr = client.GlideRecord('sys_user') gr.fields = 'sys_id' self.assertTrue(gr.get('6816f79cc0a8016401c5a33be04be441'))
def mapStaticSensors(self, map_obj, plotColor): constants = Constants() staticCoords = constants.staticSensorCoords() plotSensors(map_obj, staticCoords, plotColor) for i in range(staticCoords.shape[0]): folium.CircleMarker( (staticCoords[i][0], staticCoords[i][1]), radius=8, color='#000000', weight=1.0, fill_color='#000000', fill=True, fill_opacity=1, ).add_to(map_obj)
def __init__(self: object, address: str, fail_safe_addr: str = None, timeout: int = 45) -> object: """ This constructor sets up all required address and preliminary configurations. """ self.SERVER_ADDRESS = (address, 8005) self.FAIL_SAFE_ADDRESS = (fail_safe_addr, 8006) self.protocols = Constants() self.timeout = timeout self.database_connector = DatabaseConnection() self.set_up_logger('participant')
def mapExistingSensors(self, map_obj, plotColor): constants = Constants() existingCoords = constants.getExistingSensorCoords() existingNames = constants.getExistingSensorNames() #self.plotSensors(map_obj, existingCoords, plotColor) for i in range(existingCoords.shape[0]): folium.CircleMarker( (existingCoords[i][0], existingCoords[i][1]), radius=8, color=plotColor, weight=1.0, fill_color=plotColor, fill=True, fill_opacity=1, ).add_child(folium.Popup(existingNames[i])).add_to(map_obj)
def test_AlternativeReplacements(self): constantJson = { 'sets': {}, 'specials': {}, 'alternative_names': { 'carda': 'ca', 'card b': ['cb', 'cb b'] } } with TempJson(constantJson) as json: c = Constants(json) self.assertEqual(c.translateAlt("ca"), "carda") self.assertEqual(c.translateAlt("cb"), "cardb") self.assertEqual(c.translateAlt("cc"), "cc")
def test_RefreshCardDB(self): cardDict = { 'Quick Shot': { 'type': 'Spell', 'hpwn': 14459, 'cdn': 'https://media-Hearth.cursecdn.com/14459.png', 'desc': 'Deal 3 damage. Draw a card.', 'hp': 1, 'class': 'Hunter', 'subType': "Mech", 'set': 'Basic', 'rarity': 'Common', 'atk': 3, 'head': 'quick-shot', 'name': 'Quick Shot', 'cost': 2 } } constantDict = { 'sets': { '01': { 'name': 'Basic' } }, 'specials': {}, 'alternative_names': {} } with TempJson(constantDict) as constJson, \ TempJson(cardDict) as cardJson, \ TempJson({}) as emptyJson: c = Constants(constJson) db = CardDB(constants=c, cardJSON=emptyJson, tokenJSON=emptyJson, tempJSON='notexisting.json') self.assertEqual(db.cardNames(), []) self.assertFalse('quickshot' in db) db.tempJSON = cardJson db.refreshTemp() self.assertTrue('quickshot' in db) self.assertTrue('Quick Shot' in db['quickshot'])
def __init__(self): self.c = Constants() self.sm = SceneManager() self.mm = MainMenu() self.sm.push(self.mm) # Pushing here makes sure the object types are consistent. pygame.init() pygame.mixer.pre_init(frequency=44100, size=16, channels=2, buffer=312) self.dt = 0 # Doublebuf makes use of a better memory management, thus it will increase performance. self.screen = pygame.display.set_mode((self.c.screen_width, self.c.screen_height), pygame.DOUBLEBUF) self.screen_rect = self.screen.get_rect() pygame.display.set_caption("Game") self.fps = 60 self.clock = pygame.time.Clock() self.last_time = time.time()
def results(self, age, price, awar, acc, pfmn, size, mtbf): con = Constants() seg = self._SEGMENT[self.segment] pfmn_i = con.pfmn(self.round, self.segment) size_i = con.size(self.round, self.segment) dif_ideal = math.sqrt(pow(pfmn - pfmn_i, 2) + pow(size - size_i, 2)) dif_age = age - con.age(self.segment) dif_mtbf = mtbf - con.mtbf(self.segment) dif_price = price - con.price(self.round, self.segment) return (self._CONSTANT[seg] + self._IDEAL[seg] * dif_ideal + self._AGE[seg] * dif_age + self._MTBF[seg] * dif_mtbf + self._ACC[seg] * (100 * acc) + self._AWAR[seg] * (100 * awar) + self._PRICE[seg] * dif_price)
def main(): log.debug('main() hearthscan-bot starting') # load constant values constants = Constants() # init answered comments sqlite DB answeredDB = commentDB.DB() # load card DB url = 'https://raw.githubusercontent.com/d-schmidt/hearthscan-bot/master/data/tempinfo.json' cardDB = CardDB(constants=constants, tempJSONUrl=url) # init hs helper for hearthstone stuff helper = HSHelper(cardDB, constants) # pm spam filter cache pmUserCache = {} def submissionListener(r, submission): answerSubmission(submission, helper) def commentListener(r, comment): answerComment(r, comment, answeredDB, helper) def mentionListener(r, comment): answerMention(r, comment, answeredDB, helper) def pmListener(r, message): answerPM(r, message, pmUserCache, helper) def postAction(): cleanPMUserCache(pmUserCache) cardDB.refreshTemp() try: RedditBot(subreddits=credentials.subreddits, newLimit=250, connectAttempts=5, userBlacklist=set(credentials.userBlacklist)) \ .withSubmissionListener(submissionListener) \ .withCommentListener(commentListener) \ .withMentionListener(mentionListener) \ .withPMListener(pmListener) \ .run(postAction) except: log.exception('main() RedditBot failed unexpectedly') finally: log.warning('main() leaving hearthscan-bot') answeredDB.close()
def __init__(self, bot): self.bot = bot self.view = View() self.data = Constants() self.dishes = Constants.DISHES_TYPES @self.bot.message_handler(commands=["start"]) def _process_start_message(message): self.process_start_message(message) @self.bot.message_handler(content_types=["text"]) def _process_user_message(message): self.process_user_message(message) @self.bot.callback_query_handler(func=lambda call: True) def _process_callback(call): self.process_callback(call)