def get_asterisk_conf(): localtest_root = os.getenv("AST_TEST_ROOT") if localtest_root: # The default etc directory for Asterisk default_etc_directory = os.path.join(localtest_root, "etc/asterisk") else: # The default etc directory for Asterisk default_etc_directory = "/etc/asterisk" # Find the system installed asterisk.conf ast_confs = [ os.path.join(default_etc_directory, "asterisk.conf"), "/usr/local/etc/asterisk/asterisk.conf", ] _ast_conf = None for config in ast_confs: if os.path.exists(config): _ast_conf = ConfigFile(config) break if _ast_conf is None: msg = "Unable to locate asterisk.conf in any known location" LOGGER.error(msg) raise Exception(msg) # Get the Asterisk directories from the Asterisk config file _ast_conf.directories = {}; for cat in _ast_conf.categories: if cat.name == "directories": for (var, val) in cat.options: _ast_conf.directories[var] = val return _ast_conf
def __init__(self, account): #Account and password are instagram account and password self.config_file = ConfigFile(account) self.sub_list = self.config_file.get("Reddit", "Subreddits") self.account = account self.ibot = InstagramBot(account) self.rbot = RedditBot(account) self.obot = osManager(int(self.config_file.get("Time", "imagelifetime"))) self.db = dbManager() self.numPosts = int(self.ibot.getNumberOfPosts()) #Make this self and remove all of the member variables and instead call the dicionary when needed times = self.config_file.get("Time") for k,v in times.items(): times[k] = int(v) self.scrape_time = times["scrapetime"] self.upload_time_MAX = times["uploadtimemax"] self.upload_time_MIN = times["uploadtimemin"] self.expire_time = times["expiretime"] self.retry_upload_delay = times["retryuploaddelay"] #Keep this however when deleting for convenience self.slow_hours_start = datetime.time(times["slowhourstart"], 0, 0) self.slow_hours_end = datetime.time(times["slowhourend"], 0, 0) self.slow_hours_delay = times["slowhourdelay"] self.follow_time_MAX = times["followtimemax"] self.follow_time_MIN = times["followtimemin"] self.like_time_MAX = times["liketimemax"] self.like_time_MIN = times["liketimemin"]
def test_pickle(self): config = DayConfig() dayConfig = config.di dayConfig.startTime = time(5,0,0) pumpConfig = dayConfig.pumpPeriod pumpConfig.period = timedelta(minutes = 15) pumpConfig.duration = timedelta(minutes = 5) nigthConfig = config.noct nigthConfig.startTime = time(17,0,0) pumpConfig = nigthConfig.pumpPeriod pumpConfig.period = timedelta(minutes = 60) pumpConfig.duration = timedelta(minutes = 1) saver = ConfigFile('ConfigFileTest_test_pickle.pyc') saver.save(config) # TODO assert file exists loader = ConfigFile('ConfigFileTest_test_pickle.pyc') loadedConfig = loader.load() os.unlink('ConfigFileTest_test_pickle.pyc') loadedDayConfig = loadedConfig.di self.assertEqual(loadedDayConfig.startTime, time(5,0,0)) loadedPumpConfig = loadedDayConfig.pumpPeriod self.assertEqual(loadedPumpConfig.period, timedelta(minutes = 15)) self.assertEqual(loadedPumpConfig.duration, timedelta(minutes = 5))
def test_fileDontExists(self): loader = ConfigFile('ConfigFileTest_test_fileDontExists.pyc') try: loadedConfig = loader.load() self.fail() except IOError: pass
def __init__(self, filename, bridge=None, service=None): self.service = None if service: self.setService(service) ConfigFile.__init__(self, filename) self.bridge = bridge self.name = os.path.basename(self.filename)
def parse_args(): """ Parses command line options and arguments """ config = ConfigFile() ap = ArgumentParser(usage="usage: %prog [opts]") ap.add_argument("-t", "--test", dest="test", default=False, action="store_true", help="executes the test suite") ap.add_argument("-f", "--fullscreen", dest="fullscreen", default=config.get_bool("fullscreen", False), action="store_true", help="starts the application in fullscreen mode") ap.add_argument("-v", "--version", dest="version", default=False, action="store_true", help="displays the current version of the application") return ap.parse_args()
def write_config (self, config, config_name) : """Store a configuration in the archive :Parameters: - `config` (:class:Config) - configuration to store - `config_name` (str) - name to use to retrieve the configuration later """ filename = "%s.xml" % config_name cfg_file = ConfigFile(config)
def _globalConfSettings(self): zenhome = os.environ.get('ZENHOME') if zenhome: with open(os.path.join(zenhome, 'etc/global.conf'), 'r') as fp: globalConf = ConfigFile(fp) settings = {} for line in globalConf.parse(): if line.setting: key, val = line.setting settings[key] = val return settings
def read_config (self, config_name) : """Read a configuration stored in this archive :Parameters: - `config_name` (str) - name of the configuration to read :Returns Type: :class:`Config` """ filename = "%s.xml" % config_name data,descr = self.read_file(filename) cfg_file = ConfigFile()
def __init__(self, iusername): self.config_file = ConfigFile(iusername) self.reddit = praw.Reddit( client_id=self.config_file.get("Reddit", "client_id"), client_secret=self.config_file.get("Reddit", "client_secret"), password=self.config_file.get("Reddit", "password"), user_agent=self.config_file.get("Reddit", "user_agent"), username=self.config_file.get("Reddit", "username")) self.redditURL = 'www.reddit.com/r/' self.db = dbManager() self.osMan = osManager() self.videoDurationMax = int( self.config_file.get("Time", "videodurationmax"))
def network_connect(): sta_if = network.WLAN(network.STA_IF) sta_if.active(True) ssid = ConfigFile.get('wifi', {}).get('ssid') if ssid: sta_if.connect(ssid, ConfigFile.get('wifi', {}).get('pwd')) if not wifi_connected(sta_if): ap = network.WLAN(network.AP_IF) # create access-point interface ap.active(True) # activate the interface ap.config(essid='micropython_ap') # set the ESSID of the access point @MicroWebSrv.route('/aps', 'GET') def scan_ap(http_client, http_response): sta_if.active(True) ap_list = sta_if.scan() http_response.WriteResponseJSONOk([ap[0] for ap in ap_list]) @MicroWebSrv.route('/connect', 'POST') def connect(http_client, http_response): params = json.loads(http_client.ReadRequestContent()) ssid = params.get('ssid') if not ssid: http_response.WriteResponseJSONOk({ 'Success': False, 'Message': 'ssid不能为空!' }) return sta_if = network.WLAN(network.STA_IF) sta_if.active(True) sta_if.connect(ssid, params.get('pwd')) # Connect to an AP if wifi_connected(sta_if): print('connect success!') wifi_config = ConfigFile.get('wifi', {}) wifi_config['ssid'] = ssid wifi_config['pwd'] = params.get('pwd') ConfigFile.set('wifi', wifi_config) machine.reset() http_response.WriteResponseJSONOk({ 'Success': False, 'Message': '连接失败!' }) srv = MicroWebSrv(webPath='/templates/') srv.MaxWebSocketRecvLen = 256 srv.WebSocketThreaded = False srv.Start()
def _getParamsFromGlobalConf(self, defaultDb): zenhome = os.environ.get('ZENHOME') if not zenhome: raise ZenDBError('No $ZENHOME set. In order to use default ' 'configurations, $ZENHOME must point to the ' 'Zenoss install.') else: with open(os.path.join(zenhome, 'etc/global.conf'), 'r') as fp: globalConf = ConfigFile(fp) settings = {} for line in globalConf.parse(): if line.setting: key, val = line.setting if key.startswith(defaultDb + '-'): key = key[len(defaultDb) + 1:] settings[key] = val return settings
def __init__(self, account): self.config_file = ConfigFile(account) self.account = account.strip() self.password = self.config_file.get("Instagram", "password").strip() self.db = dbManager() self.hashtags = self.config_file.get("Hashtags") self.titles = self.config_file.get("Instagram", "Titles") self.follow_amount_min = int( self.config_file.get("Instagram", "followamountmin")) self.follow_amount_max = int( self.config_file.get("Instagram", "followamountmax")) self.unfollow_days = int(self.config_file.get("Time", "unfollowdays")) self.like_ammount_max = int( self.config_file.get("Instagram", "likeamountmax")) self.like_ammount_min = int( self.config_file.get("Instagram", "likeamountmin")) print("Created Instagram Bot!")
def _getParamsFromGlobalConf(self, defaultDb): zenhome = os.environ.get('ZENHOME') if not zenhome: raise ZenDBError('No $ZENHOME set. In order to use default ' 'configurations, $ZENHOME must point to the ' 'Zenoss install.') else: with open(os.path.join(zenhome, 'etc/global.conf'), 'r') as fp: globalConf = ConfigFile(fp) settings = {} for line in globalConf.parse(): if line.setting: key, val = line.setting if key.startswith(defaultDb + '-'): key = key[len(defaultDb)+1:] settings[key] = val return settings
def test_CF_save(self): assert not Path(self.save_path).is_file() try: self.init_config.path = self.save_path self.init_config.save() save_config = ConfigFile(self.save_path) self.assertEqual(save_config, self.init_config) finally: if Path(self.save_path).is_file(): Path(self.save_path).unlink()
def test_CF_schema(self): try: schema_config = ConfigFile(self.init_path, self.schema_path) except jsonschema.ValidationError as e: self.fail() assert not Path(self.save_path).is_file() try: schema_config.path = self.save_path schema_config.overwrite_off() schema_config.save() schema_config[self.new_key] = self.new_data schema_config.save() except jsonschema.ValidationError as e: self.fail() finally: if Path(self.save_path).is_file(): Path(self.save_path).unlink()
def setUp(self): self.root_path = PurePath("test") self.init_path = self._prep_path(PurePath("test.json")) self.init_config = ConfigFile(self.init_path) self.init_config_static = ConfigFile(self.init_path) self.empty_config = ConfigFile() with open(str(self.init_path)) as f: self.init_json = json.load(f) self.save_path = self._prep_path(PurePath("save.json")) self.schema_path = self._prep_path(PurePath("test.schema.json")) self.new_key = "zzz" self.new_data = {"foo": "bar", "baz": ["qux"]} self.new_json = self.init_json.copy() self.new_json[self.new_key] = self.new_data self.list_key = "list_config" self.dict_key = "dict_config" self.list_copy_key = "list_config_copy" self.nested_key = "nested_dict_config"
def connect(http_client, http_response): params = json.loads(http_client.ReadRequestContent()) ssid = params.get('ssid') if not ssid: http_response.WriteResponseJSONOk({ 'Success': False, 'Message': 'ssid不能为空!' }) return sta_if = network.WLAN(network.STA_IF) sta_if.active(True) sta_if.connect(ssid, params.get('pwd')) # Connect to an AP if wifi_connected(sta_if): print('connect success!') wifi_config = ConfigFile.get('wifi', {}) wifi_config['ssid'] = ssid wifi_config['pwd'] = params.get('pwd') ConfigFile.set('wifi', wifi_config) machine.reset() http_response.WriteResponseJSONOk({ 'Success': False, 'Message': '连接失败!' })
def test_CF_overwrite_on(self): assert not Path(self.save_path).is_file() try: self.init_config.path = self.save_path self.init_config.overwrite_on() self.init_config.save() self.init_config[self.new_key] = self.new_data self.init_config.save() save_config = ConfigFile(self.save_path) self.assertNotEqual(save_config, self.init_config_static) self.assertEqual(save_config, self.init_config) finally: if Path(self.save_path).is_file(): Path(self.save_path).unlink()
def check_voicemail_property(self, context, mailbox, msgnum, property_name, property_value, folder=inbox_folder_name): """Check if a voicemail has the property specified Keyword Arguments: context The context of the mailbox mailbox The mailbox msgnum The 1-based index of the voicemail to check for property_name The name of the property to check property_value The value to check for folder The folder to check under; default to the default inbox name Returns: True if the voicemail has the property and value specified False otherwise """ list_formats = [] if not self.check_voicemail_exists(context, mailbox, msgnum, list_formats, folder): return False msg_name = 'msg%(msgnum)04d' % {"msgnum": msgnum} msg_name = msg_name + ".txt" msg_path = (self.__ast.base + "%(vd)s/%(c)s/%(m)s/%(f)s/%(n)s" % { 'vd': self.voicemail_directory, 'c': context, 'm': mailbox, 'f': folder, 'n': msg_name }) config_file = ConfigFile(msg_path) for cat in config_file.categories: if cat.name == 'message': for kvp in cat.options: if kvp[0] == property_name and kvp[1] == property_value: return True return False
def get_sqlite_config(self, ast_instance): """Retrieve necessary SQLite3 config parameters from the config file Keyword Arguments: ast_instance The instance of Asterisk that used the config file Returns: Tuple of (table, columns) """ sqlite_config_file = ( "%s/%s/cdr_sqlite3_custom.conf" % (ast_instance.base, ast_instance.directories['astetcdir'])) sqlite_config = ConfigFile(sqlite_config_file) for option in sqlite_config.categories[0].options: if option[0] == 'table': table = option[1] elif option[0] == 'columns': columns = [col.strip() for col in option[1].split(',')] return (table, columns)
def get_user_object(self, context, mailbox, source_file="voicemail.conf"): """Gets user information from the voicemail configuration file Keyword Arguments: context The context of the mailbox mailbox The mailbox source_file The file containing the user information to pull from. Defaults to voicemail.conf Returns: A VoiceMailMailboxManagement.UserObject object, populated with the user's values, or an empty object """ file_path = (self.__ast.base + self.__ast.directories['astetcdir'] + "/" + source_file) config_file = ConfigFile(file_path) user_object = VoiceMailMailboxManagement.UserObject() for cat in config_file.categories: if cat.name == context: for kvp in cat.options: if kvp[0] == mailbox: tokens = kvp[1].split(',') i = 0 for token in tokens: if i == 0: user_object.password = token elif i == 1: user_object.fullname = token elif i == 2: user_object.emailaddress = token elif i == 3: user_object.pageraddress = token i += 1 return user_object return user_object
class InstagramBot: def __init__(self, account): self.config_file = ConfigFile(account) self.account = account.strip() self.password = self.config_file.get("Instagram", "password").strip() self.db = dbManager() self.hashtags = self.config_file.get("Hashtags") self.titles = self.config_file.get("Instagram", "Titles") self.follow_amount_min = int( self.config_file.get("Instagram", "followamountmin")) self.follow_amount_max = int( self.config_file.get("Instagram", "followamountmax")) self.unfollow_days = int(self.config_file.get("Time", "unfollowdays")) self.like_ammount_max = int( self.config_file.get("Instagram", "likeamountmax")) self.like_ammount_min = int( self.config_file.get("Instagram", "likeamountmin")) print("Created Instagram Bot!") def upload(self, pic_info): try: api = InstagramAPI(self.account, self.password) if (api.login()): startCount = len(api.getTotalSelfUserFeed(self.account)) photo_path = pic_info['Path'] caption = self.genCaption(pic_info["Title"], pic_info["Subreddit"]) if caption is None: caption = self.titles[r.randint( 0, len(self.titles) - 1 )] + "#lol #lmao #funny #rofl #meme #error #404 #human #notabot" if pic_info['FileFormat'] not in ['jpg', 'png']: clip = VideoFileClip(photo_path) clip.save_frame("images/thumbnail.jpg") api.uploadVideo(photo_path, "images/thumbnail.jpg", caption=caption) statusCode = api.LastResponse.status_code if statusCode == 500: print("Retrying to upload video in 10s") time.sleep(10) api.uploadVideo(photo_path, "images/thumbnail.jpg", caption=caption) else: api.uploadPhoto(photo=photo_path, caption=caption) if len(api.getTotalSelfUserFeed( self.account)) - startCount >= 1: iID = self.db.insert("Instagram", [caption, self.account]) self.db.insert("Posted", [pic_info["ID"], iID]) print("Uploaded Post!") return True else: print("Didn't upload post :(") self.db.update("Reddit", {"Path": "null"}, "Reddit.ID == {0}".format(pic_info["ID"])) return False else: print("Can't login!") return False except Exception as e: print("ERROR WHILE UPLOADING: ", e) self.db.update("Reddit", {"Path": "null"}, "Reddit.ID == {0}".format(pic_info["ID"])) return False def genCaption(self, title, subreddit): try: tagList = list(self.hashtags[subreddit]) capList = [] for i in range( 0, min(r.randint(7, 12), len(self.hashtags[subreddit]))): tag = tagList[r.randint(0, len(tagList) - 1)] capList.append(tag) tagList.remove(tag) pronouns = [ "i", "me", "my", "our", "ours", "myself", "ourself", "we", "us", "i'm", "reddit", "sub", "karma", "upvote" ] wordList = title.lower().split() ran = r.randint(0, 9) if any(word in pronouns for word in wordList): return self.titles[r.randint( 0, len(self.titles) - 1)] + " #" + " #".join(capList) if ran in range(0, 9): return title + " #" + " #".join(capList) else: return self.titles[r.randint( 0, len(self.titles) - 1)] + " #" + " #".join(capList) except Exception as e: print("ERROR DURING genCaption: ", e) def getNumberOfPosts(self): try: api = InstagramAPI(self.account, self.password) if (api.login()): return len(api.getTotalSelfUserFeed()) else: return 0 print("ERROR COULDN'T DETERMINE NUMBER OF POSTS") except Exception as e: return 0 print("ERROR DURING getNumberOfPosts: ", e) def getUsernameID(self, username, api): try: api.searchUsername( username) # the InstagramUserID you want to know the followers usernameJson = api.LastJson return re.search( "(?<=pk\'\: )[0-9]*", str(usernameJson)).group() # finds the pk numeral cod except Exception as e: print("ERROR DURING getUsernameID: ", e) def getFollowers(self, api, username=None): try: if username is None: username = self.account pkString = self.getUsernameID(username, api) api.getUserFollowers(int(pkString)) followers = api.LastJson #followersNamesList = re.findall("(?<=username\'\: \').*?(?=\',)", str(followers)) # finds the UserID of the followers and creates a list #followersPksList = re.findall("(?<=pk\'\: )[0-9]*", str(followers)) # finds the UserID of the followers and creates a list return followers['users'] except Exception as e: print("ERROR DURING getFollowers: ", e) def getHashtagFeed(self, hashtag): try: api = InstagramAPI(self.account, self.password) if (api.login()): api.getHashtagFeed(hashtag) tagJson = api.LastJson mediaIdList = re.findall("(?<=\'id\'\: \')[0-9]*_[0-9]*(?=\')", str(tagJson)) return mediaIdList except Exception as e: print("ERROR DURING getHashtagFeed: ", e) def getMediaLikers(self, mediaId, api): try: api.getMediaLikers(mediaId) likerJson = api.LastJson return re.findall("(?<=pk\'\: )[0-9]*", str(likerJson)) except Exception as e: print("ERROR DURING getMediaLikers: ", e) # Will choose a random hashtag for list of hashtags ## Get the feed of that hashtag and pick a picture ## Like the picture, then follow random people who have also ## liked the picture async def followRandom(self): try: api = InstagramAPI(self.account, self.password) if (api.login()): amountToFollow = r.randint(self.follow_amount_min, self.follow_amount_max) hashValues = list(self.hashtags.values()) hashList = r.choice(hashValues) hashtag = r.choice(hashList) mediaList = self.getHashtagFeed(hashtag) amountFollowed = 0 while mediaList and amountFollowed < amountToFollow: mediaId = mediaList.pop(r.randint(0, len(mediaList) - 1)) api.like(mediaId) self.db.insert("Like", [self.account, mediaId]) likersList = self.getMediaLikers(mediaId, api) if not likersList: continue r.shuffle(likersList) for i in range( 0, min(amountToFollow - amountFollowed, len(likersList))): print("trying to follow") try: user_pk = likersList[i] followers = self.db.c.execute( "SELECT PK from FOLLOWING").fetchall() if user_pk not in followers: api.follow(user_pk) self.db.insert("Following", [self.account, user_pk]) except Exception as e: print( "ERRROR DURING followRandom while trying to follow" ) finally: await asyncio.sleep(r.randint(5, 120)) amountFollowed += 1 except Exception as e: print("ERROR DURING followRandom: ", e) async def unfollow(self): try: api = InstagramAPI(self.account, self.password) if api.login(): amountToUnfollow = r.randint(self.follow_amount_min, self.follow_amount_max) expiredSelection = self.db.c.execute( "SELECT PK From Following WHERE DateFollowed IS NOT NULL AND julianday('now') - julianday(DateFollowed) >= " + str(self.unfollow_days)) expiredList = expiredSelection.fetchall() amountUnfollowed = 0 for pk in expiredList: print("trying to unfollow") api.unfollow(pk[0]) self.db.update("Following", {"DateFollowed": "null"}, "PK = {0}".format(pk[0])) await asyncio.sleep(r.randint(5, 120)) amountUnfollowed += 1 if amountUnfollowed >= amountToUnfollow: return except Exception as e: print("ERROR DURING unfollow: ", e) async def likeTimelineRandom(self): try: api = InstagramAPI(self.account, self.password) if api.login(): if not api.getTimeline(): raise Exception("Couldn't get timeline!") amountToLike = r.randint(self.like_ammount_min, self.like_ammount_max) amountLiked = 0 mediaList = re.findall("(?<=\'id\'\: \')[0-9]*_[0-9]*(?=\')", str(api.LastJson)) liked = self.db.c.execute( "SELECT MediaID from Like").fetchall() while mediaList and amountLiked < amountToLike: mediaId = mediaList.pop(r.randint(0, len(mediaList) - 1)) if mediaId not in liked: print("trying to like") #Still need to do check api.like(mediaId) amountLiked += 1 self.db.insert("Like", [self.account, mediaId]) await asyncio.sleep(r.randint( 3, 40)) #You should have a like wait time min/max except Exception as e: print("ERROR DURING likeRandom: ", e) def directMessage(self): try: api = InstagramAPI(self.account, self.password) if api.login(): followersInfo = self.getFollowers(api) followingPks = self.db.c.execute( "SELECT PK FROM Following").fetchall() followingPks = [pk[0] for pk in followingPks] print(type(followingPks[0])) #Get all pks that are in followingPks but not in followersPks ## i.e., Get all people you are following but are not following you nonFollowersPks = [ pk for pk in followingPks if pk not in followersInfo ] # api.direct_message("hey whats up", 'ravioliraviolirobot') except Exception as e: print("ERROR DURING directMessage", e)
def __init__(self, base=None, ast_conf_options=None, host="127.0.0.1", remote_config=None): """Construct an Asterisk instance. Keyword Arguments: base -- This is the root of the files associated with this instance of Asterisk. By default, the base is "/tmp/asterisk-testsuite" directory. Given a base, it will be appended to the default base directory. ast_conf_options -- Configuration overrides for asterisk.conf. host -- The IP address the Asterisk instance runs on remote_config -- Configuration section that defines this as a remote Asterisk instance. If provided, base and ast_conf_options are generally ignored, and the Asterisk instance's configuration is treated as immutable on some remote machine defined by 'host' Example Usage: self.asterisk = Asterisk(base="manager/login") """ self._start_deferred = None self._stop_deferred = None self._stop_cancel_tokens = [] self.directories = {} self.protocol = None self.process = None self.astetcdir = "" self.original_astmoddir = "" self.ast_version = None self.remote_config = remote_config # If the process is remote, don't bother if not self.remote_config: self.ast_version = AsteriskVersion() valgrind_env = os.getenv("VALGRIND_ENABLE") or "" self.valgrind_enabled = True if "true" in valgrind_env else False if base is not None: self.base = base else: self.base = Asterisk.test_suite_root if self.localtest_root: self.ast_binary = self.localtest_root + "/usr/sbin/asterisk" else: ast_binary = test_suite_utils.which("asterisk") self.ast_binary = ast_binary or "/usr/sbin/asterisk" self.host = host self._ast_conf_options = ast_conf_options if self.remote_config: # Pretend as if we made the structure self._directory_structure_made = True self._configs_installed = True self._configs_set_up = True # And assume we've got /etc/asterisk/ where we expect it to be self.astetcdir = "/etc/asterisk" else: self._directory_structure_made = False self._configs_installed = False self._configs_set_up = False # Find the system installed asterisk.conf ast_confs = [ os.path.join(self.default_etc_directory, "asterisk.conf"), "/usr/local/etc/asterisk/asterisk.conf", ] self._ast_conf = None for config in ast_confs: if os.path.exists(config): self._ast_conf = ConfigFile(config) break if self._ast_conf is None: msg = "Unable to locate asterisk.conf in any known location" LOGGER.error(msg) raise Exception(msg) # Set which astxxx this instance will be i = 1 while True: if not os.path.isdir("%s/ast%d" % (self.base, i)): self.base = "%s/ast%d" % (self.base, i) break i += 1 # Get the Asterisk directories from the Asterisk config file for cat in self._ast_conf.categories: if cat.name == "directories": for (var, val) in cat.options: self.directories[var] = val # self.original_astmoddir is for dependency checking only if "astmoddir" in self.directories: if self.localtest_root: self.original_astmoddir = "%s%s" % ( self.localtest_root, self.directories["astmoddir"]) else: self.original_astmoddir = self.directories["astmoddir"]
source_rotated, text=[ f"<b>Vertex:</b> {n}" for n in range(len(source_rotated.vertices)) ], name="Source", **mesh_kwargs, ), row=1, col=1) fig.add_trace(BrowserVisualizer.make_mesh( target_rotated, text=[ f"<b>Vertex:</b> {n}" for n in range(len(target_rotated.vertices)) ], name="Target", **mesh_kwargs, ), row=1, col=2) return fig if __name__ == "__main__": cfg = ConfigFile.load(ConfigFile.Paths.highpoly.horse_camel) source = Mesh.load(cfg.source.reference) target = Mesh.load(cfg.target.reference) markers = cfg.markers plot(source, target).show(renderer="browser")
]) for p in results ]) camera = dict(up=dict(x=0, y=1, z=0)) scene = dict(aspectmode='data', xaxis_title='X', yaxis_title='Z', zaxis_title='Y', camera=camera, dragmode='turntable') fig.update_layout( scene=scene, scene2=scene, yaxis=dict(scaleanchor="x", scaleratio=1), yaxis2=dict(scaleanchor="x", scaleratio=1), margin=dict(l=0, r=0), # scene_camera=camera ) return fig def animate(transf: Transformation, poses: Sequence[meshlib.Mesh]): fig = make_animation(transf, poses) fig.show(renderer="browser") if __name__ == "__main__": # cfg = ConfigFile.load(ConfigFile.Paths.highpoly.horse_camel) cfg = ConfigFile.load("models/lowpoly/markers-cat-voxel.yml") # cfg = ConfigFile.load(ConfigFile.Paths.highpoly.cat_lion) animate_cfg(cfg)
return if '_id' in obj.__dict__: orig_obj = (method)(collection, obj._id) logger.info("Saving %s.\nCurrent:\n%s\nNew:\n%s\n" % (str(obj.__class__), pprint.pformat( orig_obj.__dict__), pprint.pformat(obj.__dict__))) else: logger.info("Saving %s.\nFirst time:\n%s" % (str(obj.__class__), pprint.pformat(obj.__dict__))) print "Saved by:" for n in traceback.format_list(traceback.extract_stack()[12:]): print "%s\n" % n if __name__ == "__main__": l = local_logger('my_app', './log_test.log', logging.DEBUG) # "application" code l.debug("debug message") l.info("info message") l.warn("warn message") l.error("error message") l.critical("critical message") from config import ConfigFile config = ConfigFile() l.setSMTP(config.smtp.server, config.smtp.port, config.smtp.login, config.smtp.password, config.smtp.tls, config.smtp.debug_level, config.smtp.from_addr, config.smtp.to_addrs) l.critical("critical message")
def __init__(self, filename): ConfigFile.__init__(self, filename)
class RedditBot: def __init__(self, iusername): self.config_file = ConfigFile(iusername) self.reddit = praw.Reddit( client_id=self.config_file.get("Reddit", "client_id"), client_secret=self.config_file.get("Reddit", "client_secret"), password=self.config_file.get("Reddit", "password"), user_agent=self.config_file.get("Reddit", "user_agent"), username=self.config_file.get("Reddit", "username")) self.redditURL = 'www.reddit.com/r/' self.db = dbManager() self.osMan = osManager() self.videoDurationMax = int( self.config_file.get("Time", "videodurationmax")) def getImage(self, url, title): try: imgExtensions = [".jpg", ".png"] vidExtensions = [".mp4", ".gif", ".gifv"] doc = requests.get(url, stream=True) filename, file_extension = os.path.splitext(url) #Reddit gifs can be downloaded directly ##So no need for further parsing if re.search("redd[.]?it/.*.gif[v]?", url): return doc, file_extension x = re.compile("(\s?https?:)?(/{2})?") soup = BeautifulSoup(doc.text, 'html.parser') if re.search("v.redd[.]?it/.*", url): print(re.search('fallback_url', soup.prettify())) return doc, file_extension, True #If the image is a Imgur gif if file_extension.__contains__("gif"): #Imgur and reddit structure gifs differently in HTML, so ## The source is for Imgur for video in (soup.find_all('source')): if video.has_attr('src'): src = video['src'] filename, file_extension = os.path.splitext(src) if file_extension not in vidExtensions: return None, None prefix = x.match(src) if not prefix: return requests.get("http://" + src, stream=True), file_extension elif prefix.group(0) == "//": return requests.get("http:" + src, stream=True), file_extension else: return requests.get(src, stream=True), file_extension return None, None #This happens if it wasn't able to find the gif # If this url is already an image if file_extension in imgExtensions: return doc, file_extension # If not, then will need to extract the image from the URL for img in soup.find_all('img'): if img.has_attr('alt') and img[ 'alt'] == title: #There may nor be an alt src = img['src'] filename, file_extension = os.path.splitext(src) prefix = x.match(src) if not prefix: return requests.get("http://" + src, stream=True), file_extension elif prefix.group(0) == "//": return requests.get("http:" + src, stream=True), file_extension else: return requests.get(src, stream=True), file_extension return None, None except Exception as e: print("ERROR WHILE PARSING: ", e) return None, None def download(self, submission, subreddit): pass #make this method call downloadVideo and downloadImage def downloadVideo(self, isGif, filepath, submission, subreddit): try: duration = submission.media['reddit_video']["duration"] if duration > self.videoDurationMax: return doc = requests.get( submission.media['reddit_video']['fallback_url'], stream=True) if not doc: raise Exception("COULDN'T RETRIEVE THE VIDEO") if not isGif: audioLocation = os.path.join(filepath, submission.title + "_audio") videoLocation = os.path.join(filepath, submission.title + "_video") audioPacket = requests.get(submission.url + "/audio", stream=True) if not audioPacket: raise Exception("COULDN'T RETRIEVE THE AUDIO") self.writeFile(audioLocation, audioPacket) self.writeFile(videoLocation, doc) #audio = mp.AudioFileClip(audioLocation) video = mp.VideoFileClip(videoLocation) #video_with_audio = video.set_audio(audio) video_new_loc = videoLocation + ".mp4" video.write_videofile(video_new_loc, audio=audioLocation) self.db.insert("Reddit", [ submission.title, submission.url, video_new_loc, subreddit, "mp4" ]) self.osMan.deleteFile(audioLocation) self.osMan.deleteFile(videoLocation) else: imgLocation = os.path.join(filepath, submission.title) isWritten = self.writeFile(imgLocation, doc) if isWritten: self.db.insert("Reddit", [ submission.title, submission.url, imgLocation, subreddit, "gif" ]) except Exception as e: print("ERROR WHILE downloadVideo: ", e) return def downloadImage(self, submission, subreddit): #Edit so it may only take in image try: url = submission.url #"https://v.redd.it/qahcxxgdvha11" title = submission.title #https://v.redd.it/xglnc6dzlia11/HLSPlaylist.m3u8 videoData = submission.media duplicateAmount = len( self.db.c.execute( "SELECT URL FROM Reddit WHERE URL == '{0}'".format( str(url))).fetchall()) if duplicateAmount >= 1: return False filepath = self.osMan.createDir( subreddit ) # Create the directory in which to store the (change this later so it wont be called in this function if isinstance(videoData, dict) and 'reddit_video' in videoData: self.downloadVideo(videoData['reddit_video']['is_gif'], filepath, submission, subreddit) return else: img, file_extension = self.getImage(url, title) if img == None or file_extension == None: return False imgLocation = os.path.join(filepath, title + file_extension) isWritten = self.writeFile(imgLocation, img) if isWritten: print(title + " URL: " + url) self.db.insert("Reddit", [ title, url, imgLocation, subreddit, file_extension.split('.')[1] ]) except Exception as e: print("ERROR WHILE DOWNLOADING: ", e) return False def writeFile(self, toFile, content): try: with open(toFile, 'wb') as f: for chunk in content.iter_content( chunk_size=1024 ): #iter_content allows you to write the image by chunks if chunk: f.write(chunk) return True except Exception as e: print("ERROR WHILE writeFile: ", e) return False def scrapeImages(self, subreddit_id): try: print("DOWNLOADING IMAGES...") for submission in self.reddit.subreddit(subreddit_id).hot( limit=25): result = self.downloadImage(submission, subreddit_id) except Exception as e: print("ERROR WHILE REQUESTING: ", e)
# # Author: Soufian Salim <*****@*****.**> # # URL: <http://github.com/bolaft/diannotator> """ Grapical User Interface """ from tkinter import Tk, StringVar, Text, Menu, messagebox, BOTH, DISABLED, END, LEFT, BOTTOM, NORMAL, N, X, WORD, SUNKEN, INSERT, SEL, NSEW from tkinter.ttk import Button, Entry, Frame, Label, Scrollbar from ttkthemes import ThemedStyle from config import ConfigFile from strings import Strings config = ConfigFile() # INI configuration file class GraphicalUserInterface(Frame): """ Graphical User Interface class """ # constant tag names STRONG = "STRONG" ITALIC = "ITALIC" HIGHLIGHT = "HIGHLIGHT" window_title = "DiAnnotator" # window title padding = config.get_int("padding", 25) # padding for text area") wrap_length = config.get_int(
def main(): parser = argparse.ArgumentParser( description="manage and report time allocation", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=textwrap.dedent(""" DURATIONs Spans of time can be provided in a concise format, a series of integers or floats each appended with a unit: d, h, m. Whitespace between each component is optional. Fractions less than 1 require a leading 0. Note that a day is 8 hours. Examples: 15m 0.5h 1.5h 1d 4.5h 1d 4h 30m 1d4h30m Note that, while whitespace is optional, if you do specify a duration on the command line and it includes whitespace, you"ll have to quote it. DATEs Dates should be provided in the form YYYY-MM-DD. TIMEs Times should be provided in the form HH:MM. All times used, including "now", have their seconds zeroed out. All times provided on the command line are assumed to occur today. Config File: ~/.worklog/config.json - Can be created to store username and password to avoid being prompted to type in your credentials for Jira authentication. Example File: { "username" : "jsmith" } WARNING: Uploading multiple times in one calendar day will cause inconsistencies with time tracking on the server side. """), ) sub_parser = parser.add_subparsers(dest='command') common_parser = argparse.ArgumentParser(add_help=False) common_parser.add_argument( '--day', '-d', help='manage the worklog for DATE, defaults to today') blurb = 'start a new task, closing the currently open task if any' start_parser = sub_parser.add_parser('start', help=blurb, description=blurb, parents=[common_parser]) start_parser.add_argument( '--ago', metavar='DURATION', help='start the task DURATION time ago, instead of now') start_parser.add_argument('--at', metavar='TIME', help='start the task at TIME, instead of now') start_parser.add_argument('-t', '--ticket', metavar='TICKET', help='the TICKET associated with the task') start_parser.add_argument( 'description', metavar='DESCRIPTION', nargs=argparse.REMAINDER, help="specify the task's description on the command line") blurb = 'like start, but reuse the description from a previous task in this worklog by seleting it from a list' resume_parser = sub_parser.add_parser('resume', help=blurb, description=blurb, parents=[common_parser]) resume_parser.add_argument( '--ago', metavar='DURATION', help='start the task DURATION time ago, instead of now') resume_parser.add_argument('--at', metavar='TIME', help='start the task at TIME, instead of now') blurb = 'close the currently open task' stop_parser = sub_parser.add_parser('stop', help=blurb, description=blurb, parents=[common_parser]) stop_parser.add_argument( '--ago', metavar='DURATION', help='close the open task DURATION time ago, instead of now') stop_parser.add_argument( '--at', metavar='TIME', help='close the open task at TIME, instead of now') blurb = 'report the current state of the worklog' report_parser = sub_parser.add_parser('report', help=blurb, description=blurb, parents=[common_parser]) blurb = 'uploads worklog time to jira' upload_parser = sub_parser.add_parser('upload', help=blurb, description=blurb, parents=[common_parser]) args = parser.parse_args() config_path = os.path.expanduser('~/.worklog/config.json') config = ConfigFile(config_path) color.ENABLED = config.features.colorize try: handler = globals()["on_{}".format(args.command)] except KeyError: parser.print_help() else: if isinstance(handler, Callable): handler(args, config) else: parser.error("unrecognized command: '{}'".format(args.command))
class TestConfigFile(unittest.TestCase): def setUp(self): self.root_path = PurePath("test") self.init_path = self._prep_path(PurePath("test.json")) self.init_config = ConfigFile(self.init_path) self.init_config_static = ConfigFile(self.init_path) self.empty_config = ConfigFile() with open(str(self.init_path)) as f: self.init_json = json.load(f) self.save_path = self._prep_path(PurePath("save.json")) self.schema_path = self._prep_path(PurePath("test.schema.json")) self.new_key = "zzz" self.new_data = {"foo": "bar", "baz": ["qux"]} self.new_json = self.init_json.copy() self.new_json[self.new_key] = self.new_data self.list_key = "list_config" self.dict_key = "dict_config" self.list_copy_key = "list_config_copy" self.nested_key = "nested_dict_config" def _prep_path(self, path): t = type(path) return t(self.root_path) / path def test_CF_clear(self): self.init_config.clear() self.assertEqual(self.init_config, self.empty_config) def test_CF_contains(self): self.assertTrue(self.list_key in self.init_config) def test_CF_delitem(self): del self.init_config[self.list_key] self.assertFalse(self.list_key in self.init_config) def test_CF_eq(self): config_copy = ConfigFile(self.init_path) self.assertEqual(config_copy, self.init_config) def test_CF_iter(self): for i in self.init_config: self.assertTrue(True) def test_CF_get_path(self): path = self.init_config.path self.assertEqual(path, self.init_path) def test_CF_len(self): self.assertEqual(len(self.init_config), len(self.init_json)) def test_CF_ne(self): self.assertNotEqual(self.init_config, self.empty_config) self.assertNotEqual(self.init_config, self.init_config[self.list_key]) self.assertNotEqual(self.init_config, self.init_config[self.dict_key]) self.assertNotEqual(self.init_config, {}) self.assertNotEqual(self.init_config, []) self.assertNotEqual(self.init_config, ()) self.assertNotEqual(self.init_config, "") self.assertNotEqual(self.init_config, 0.0) self.assertNotEqual(self.init_config, 0) self.assertNotEqual(self.init_config, None) def test_CF_overwrite_off(self): assert not Path(self.save_path).is_file() try: self.init_config.path = self.save_path self.init_config.overwrite_off() self.init_config.save() self.init_config[self.new_key] = self.new_data self.init_config.save() save_config = ConfigFile(self.save_path) self.assertEqual(save_config, self.init_config_static) self.assertNotEqual(save_config, self.init_config) finally: if Path(self.save_path).is_file(): Path(self.save_path).unlink() def test_CF_overwrite_on(self): assert not Path(self.save_path).is_file() try: self.init_config.path = self.save_path self.init_config.overwrite_on() self.init_config.save() self.init_config[self.new_key] = self.new_data self.init_config.save() save_config = ConfigFile(self.save_path) self.assertNotEqual(save_config, self.init_config_static) self.assertEqual(save_config, self.init_config) finally: if Path(self.save_path).is_file(): Path(self.save_path).unlink() def test_CF_overwrite_get_set(self): assert not Path(self.save_path).is_file() try: self.assertFalse(self.init_config.overwrite) self.init_config.path = self.save_path self.init_config.overwrite = True self.assertTrue(self.init_config.overwrite) self.init_config.save() self.init_config[self.new_key] = self.new_data self.init_config.save() save_config = ConfigFile(self.save_path) self.assertNotEqual(save_config, self.init_config_static) self.assertEqual(save_config, self.init_config) finally: if Path(self.save_path).is_file(): Path(self.save_path).unlink() def test_CF_repr(self): self.assertEqual(self.init_config.__repr__(), self.init_json.__repr__()) def test_CF_save(self): assert not Path(self.save_path).is_file() try: self.init_config.path = self.save_path self.init_config.save() save_config = ConfigFile(self.save_path) self.assertEqual(save_config, self.init_config) finally: if Path(self.save_path).is_file(): Path(self.save_path).unlink() def test_CF_on_change_callback(self): key = "done" check = {key: False} def callback(x): check[key] = True self.init_config.on_change_callbacks = {"test": callback} self.init_config[self.new_key] = self.new_data self.assertTrue(check[key]) def test_CF_schema(self): try: schema_config = ConfigFile(self.init_path, self.schema_path) except jsonschema.ValidationError as e: self.fail() assert not Path(self.save_path).is_file() try: schema_config.path = self.save_path schema_config.overwrite_off() schema_config.save() schema_config[self.new_key] = self.new_data schema_config.save() except jsonschema.ValidationError as e: self.fail() finally: if Path(self.save_path).is_file(): Path(self.save_path).unlink() def test_CF_setitem(self): self.init_config[self.new_key] = self.new_data self.assertEqual(self.init_config.to_json(), self.new_json) def test_CF_set_path(self): self.init_config.path = self.save_path path = self.init_config.path self.assertEqual(path, self.save_path) def test_CF_to_json(self): config = self.init_config.to_json() self.assertEqual(config, self.init_json) def test_CL_append(self): self.init_config[self.list_key].append(self.new_data) check = self.init_config[self.list_copy_key].to_json() check.append(self.new_data) self.assertEqual(self.init_config[self.list_key], check) def test_CL_clear(self): self.init_config[self.list_key].clear() self.assertEqual(self.init_config[self.list_key].to_json(), []) def test_CF_contains(self): self.assertTrue(self.init_config[self.list_key][0] in self.init_config[ self.list_key]) not_exists = max(self.init_config[self.list_key]) + 1 self.assertFalse(not_exists in self.init_config[self.list_key]) def test_CF_getattr(self): check = self.init_config[self.dict_key] value = getattr(self.init_config, self.dict_key) self.assertEqual(value, check) def test_CF_setattr(self): setattr(self.init_config, self.new_key, self.new_data) value = self.init_config[self.new_key] self.assertEqual(value, self.new_data) def test_CL_count(self): exists = self.init_config[self.list_key][0] self.assertEqual(self.init_config[self.list_key].count(exists), 1) not_exists = max(self.init_config[self.list_key]) + 1 self.assertEqual(self.init_config[self.list_key].count(not_exists), 0) def test_CL_delitem(self): item = self.init_config[self.list_key][0] del self.init_config[self.list_key][0] self.assertFalse(item in self.init_config[self.list_key]) def test_CL_eq(self): self.assertEqual(self.init_config[self.list_key], self.init_config[self.list_copy_key]) self.assertEqual(self.init_config[self.list_key], self.init_json[self.list_key]) def test_CL_extend(self): self.init_config[self.list_key].extend(self.new_data) check = self.init_config[self.list_copy_key].to_json() check.extend(self.new_data) self.assertEqual(self.init_config[self.list_key], check) def test_CL_index(self): first = self.init_config[self.list_key][0] self.assertEqual(self.init_config[self.list_key].index(first), 0) self.assertEqual(self.init_config[self.list_key].index(first, 0, -1), 0) with self.assertRaises(ValueError): self.init_config[self.list_key].index(first, 1, -1) not_exists = max(self.init_config[self.list_key]) + 1 with self.assertRaises(ValueError): self.init_config[self.list_key].index(not_exists) def test_CL_insert(self): self.init_config[self.list_key].insert(0, self.new_data) check = self.init_config[self.list_copy_key].to_json() check.insert(0, self.new_data) self.assertEqual(self.init_config[self.list_key], check) def test_CL_len(self): self.assertEqual(len(self.init_config), len(self.init_json)) def test_CL_ne(self): self.assertNotEqual( self.init_config[self.list_key], self.init_config[self.nested_key][self.list_key], ) self.assertNotEqual( self.init_config[self.list_key], self.init_json[self.nested_key][self.list_key], ) self.assertNotEqual(self.init_config[self.list_key], self.init_config) self.assertNotEqual(self.init_config[self.list_key], {}) self.assertNotEqual(self.init_config[self.list_key], []) self.assertNotEqual(self.init_config[self.list_key], ()) self.assertNotEqual(self.init_config[self.list_key], "") self.assertNotEqual(self.init_config[self.list_key], 0.0) self.assertNotEqual(self.init_config[self.list_key], 0) self.assertNotEqual(self.init_config[self.list_key], None) def test_CL_pop(self): original = self.init_config[self.list_key].to_json() popped = self.init_config[self.list_key].pop() self.assertEqual(popped, original[-1]) original = self.init_config[self.list_copy_key].to_json() popped = self.init_config[self.list_copy_key].pop(0) self.assertEqual(popped, original[0]) def test_CL_remove(self): first = self.init_config[self.list_key][0] self.init_config[self.list_key].remove(first) check = self.init_config[self.list_copy_key].to_json() check.remove(first) self.assertEqual(self.init_config[self.list_key], check) def test_CL_reverse(self): self.init_config[self.list_key].reverse() check = self.init_config[self.list_copy_key].to_json() check.reverse() self.assertEqual(self.init_config[self.list_key], check) def test_CL_setitem(self): self.init_config[self.list_key][0], self.init_config[ self.list_key][1] = ( self.init_config[self.list_key][1], self.init_config[self.list_key][0], ) self.init_config[self.list_key].sort() self.assertEqual(self.init_config[self.list_key], self.init_config[self.list_copy_key]) def test_CL_sort(self): self.init_config[self.list_key].sort(key=lambda x: x, reverse=True) check = self.init_config[self.list_copy_key].to_json() check.sort(key=lambda x: x, reverse=True) self.assertEqual(self.init_config[self.list_key], check) def test_CD_clear(self): self.init_config[self.dict_key].clear() self.assertEqual(self.init_config[self.dict_key].to_json(), {}) def test_CD_contains(self): exists = list(self.init_config[self.dict_key].keys())[0] self.assertTrue(exists in self.init_config[self.dict_key]) not_exists = "" self.assertFalse(not_exists in self.init_config[self.dict_key]) def test_CD_delitem(self): key = list(self.init_config[self.dict_key].keys())[0] del self.init_config[self.dict_key][key] self.assertFalse(key in self.init_config[self.list_key]) def test_CD_eq(self): copy = self.init_config[self.dict_key].to_json() self.assertEqual(copy, self.init_config[self.dict_key]) def test_CD_fromkeys(self): value = self.init_config[self.dict_key].fromkeys([1]) self.assertEqual(value, {1: None}) value = self.init_config[self.dict_key].fromkeys([1], 0) self.assertEqual(value, {1: 0}) def test_CD_get(self): key = list(self.init_config[self.dict_key].keys())[0] value = self.init_config[self.dict_key].get(key) self.assertEqual(value, self.init_config[self.dict_key].to_json()[key]) not_exists = "" value = self.init_config[self.dict_key].get(not_exists) self.assertIsNone(value) value = self.init_config[self.dict_key].get(not_exists, 0) self.assertEqual(value, 0) def test_CD_items(self): items = self.init_config[self.dict_key].items() check = self.init_config[self.dict_key].to_json().items() self.assertEqual(list(items), list(check)) def test_CD_keys(self): keys = self.init_config[self.dict_key].keys() check = self.init_config[self.dict_key].to_json().keys() self.assertEqual(list(keys), list(check)) def test_CD_list(self): value = list(self.init_config[self.dict_key]) check = list(self.init_config[self.dict_key].to_json().keys()) self.assertEqual(value, check) def test_CD_ne(self): self.assertNotEqual( self.init_config[self.dict_key], self.init_config[self.nested_key][self.dict_key], ) self.assertNotEqual( self.init_config[self.dict_key], self.init_json[self.nested_key][self.dict_key], ) self.assertNotEqual(self.init_config[self.dict_key], self.init_config) self.assertNotEqual(self.init_config[self.dict_key], {}) self.assertNotEqual(self.init_config[self.dict_key], []) self.assertNotEqual(self.init_config[self.dict_key], ()) self.assertNotEqual(self.init_config[self.dict_key], "") self.assertNotEqual(self.init_config[self.dict_key], 0.0) self.assertNotEqual(self.init_config[self.dict_key], 0) self.assertNotEqual(self.init_config[self.dict_key], None) def test_CD_pop(self): key = list(self.init_config[self.dict_key].keys())[0] popped = self.init_config[self.dict_key].pop(key) self.assertEqual(popped, self.init_json[self.dict_key][key]) not_exists = "" popped = self.init_config[self.dict_key].get(not_exists) self.assertIsNone(popped) popped = self.init_config[self.dict_key].get(not_exists, 0) self.assertEqual(popped, 0) def test_CD_popitem(self): item = list(self.init_config[self.dict_key].items())[-1] popped = self.init_config[self.dict_key].popitem() self.assertEqual(popped, list(self.init_json[self.dict_key].items())[-1]) def test_CD_reversed(self): check = list(self.init_config[self.dict_key].keys()) check.reverse() self.assertEqual(list(reversed(self.init_config[self.dict_key])), check) def test_CD_setdefault(self): self.init_config[self.dict_key].setdefault(self.new_key, self.new_data) self.assertEqual(self.init_config[self.dict_key][self.new_key], self.new_data) not_exists = "" self.init_config[self.dict_key].setdefault(not_exists) self.assertIsNone(self.init_config[self.dict_key][not_exists]) self.init_config[self.dict_key].pop(not_exists) self.init_config[self.dict_key].setdefault(not_exists, 0) self.assertEqual(self.init_config[self.dict_key][not_exists], 0) def test_CD_setitem(self): self.init_config[self.dict_key][self.new_key] = self.new_data self.assertEqual(self.init_config[self.dict_key][self.new_key], self.new_data) def test_CD_update(self): check = self.init_config[self.dict_key].to_json() check.update({self.new_key: self.new_data}) self.init_config[self.dict_key].update({self.new_key: self.new_data}) self.assertEqual(self.init_config[self.dict_key], check) def test_CD_values(self): values = self.init_config[self.dict_key].values() check = self.init_config[self.dict_key].to_json().values() self.assertEqual(list(values), list(check)) def test_CD_getattr(self): key = list(self.init_config[self.dict_key].keys())[0] check = self.init_config[self.dict_key][key] value = getattr(self.init_config[self.dict_key], key) self.assertEqual(value, check) def test_CD_setattr(self): setattr(self.init_config[self.dict_key], self.new_key, self.new_data) value = self.init_config[self.dict_key][self.new_key] self.assertEqual(value, self.new_data)
def test_CF_eq(self): config_copy = ConfigFile(self.init_path) self.assertEqual(config_copy, self.init_config)
assert A.shape[0] == b.shape[0] assert b.shape[1] == 3 LU = sparse.linalg.splu((A.T @ A).tocsc()) x = LU.solve(A.T @ b) vertices = x result = meshlib.Mesh(vertices=vertices[:len(self.target.vertices)], faces=self.target.faces) return result if __name__ == "__main__": import render.plot_result as plt_res import render.plot as plt # cfg = ConfigFile.load(ConfigFile.Paths.highpoly.horse_camel) cfg = ConfigFile.load(ConfigFile.Paths.lowpoly.catdog) # cfg = ConfigFile.load(ConfigFile.Paths.highpoly.cat_lion) corr_markers = cfg.markers # List of vertex-tuples (source, target) identity = False if identity: corr_markers = np.ascontiguousarray(np.array((corr_markers[:, 0], corr_markers[:, 0]), dtype=np.int).T) ######################################################### # Load meshes original_source = meshlib.Mesh.load(cfg.source.reference) original_pose = meshlib.Mesh.load(cfg.source.poses[0]) original_target = meshlib.Mesh.load(cfg.target.reference) if identity: original_target = meshlib.Mesh.load(cfg.source.reference)
def __init__(self, base=None, ast_conf_options=None, host="127.0.0.1"): """Construct an Asterisk instance. Keyword Arguments: base -- This is the root of the files associated with this instance of Asterisk. By default, the base is "/tmp/asterisk-testsuite" directory. Given a base, it will be appended to the default base directory. Example Usage: self.asterisk = Asterisk(base="manager/login") """ self._start_deferred = None self._stop_deferred = None self._stop_cancel_tokens = [] self.directories = {} self.ast_version = AsteriskVersion() self.process_protocol = None self.process = None self.astetcdir = "" self.original_astmoddir = "" if base is not None: self.base = base else: self.base = Asterisk.test_suite_root if self.localtest_root: self.ast_binary = self.localtest_root + "/usr/sbin/asterisk" else: ast_binary = test_suite_utils.which("asterisk") self.ast_binary = ast_binary or "/usr/sbin/asterisk" self.host = host self._ast_conf_options = ast_conf_options self._directory_structure_made = False self._configs_installed = False self._configs_set_up = False # Find the system installed asterisk.conf ast_confs = [ os.path.join(self.default_etc_directory, "asterisk.conf"), "/usr/local/etc/asterisk/asterisk.conf", ] self._ast_conf = None for config in ast_confs: if os.path.exists(config): self._ast_conf = ConfigFile(config) break if self._ast_conf is None: msg = "Unable to locate asterisk.conf in any known location" LOGGER.error(msg) raise Exception(msg) # Set which astxxx this instance will be i = 1 while True: if not os.path.isdir("%s/ast%d" % (self.base, i)): self.base = "%s/ast%d" % (self.base, i) break i += 1 # Get the Asterisk directories from the Asterisk config file for cat in self._ast_conf.categories: if cat.name == "directories": for (var, val) in cat.options: self.directories[var] = val # self.original_astmoddir is for dependency checking only if "astmoddir" in self.directories: if self.localtest_root: self.original_astmoddir = "%s%s" % ( self.localtest_root, self.directories["astmoddir"]) else: self.original_astmoddir = self.directories["astmoddir"]
except: continue if stat.S_ISDIR(st[stat.ST_MODE]): dirs.append(fn) else: dbfile[fn] = read_data(pp) nfiles = nfiles + 1 dbfile.sync() dbfile.close() print('%s files, %s subdirs' % (nfiles, len(dirs))) for dn in dirs: cvtDirRec(old_root, new_root, lpath + '/' + dn) if __name__ == '__main__': cfg = ConfigFile(os.environ['DFARM_CONFIG']) old_dbroot = cfg.getValue('vfssrv', '*', 'db_root') if not old_dbroot: print( 'VFS Database root directory is not defined in the configuration') sys.exit(1) one_up = '/'.join(old_dbroot.split('/')[:-1]) new_dbroot = one_up + '/new_dbroot' save_dbroot = one_up + '/db_saved' cvtDirRec(old_dbroot, new_dbroot, '/') os.mkdir(new_dbroot + '/.cellinx') os.rename(old_dbroot, save_dbroot) os.rename(new_dbroot, old_dbroot) print('VFS Database conversion is complete.') print('Old database is renamed into %s' % save_dbroot)
class Bot: def __init__(self, account): #Account and password are instagram account and password self.config_file = ConfigFile(account) self.sub_list = self.config_file.get("Reddit", "Subreddits") self.account = account self.ibot = InstagramBot(account) self.rbot = RedditBot(account) self.obot = osManager(int(self.config_file.get("Time", "imagelifetime"))) self.db = dbManager() self.numPosts = int(self.ibot.getNumberOfPosts()) #Make this self and remove all of the member variables and instead call the dicionary when needed times = self.config_file.get("Time") for k,v in times.items(): times[k] = int(v) self.scrape_time = times["scrapetime"] self.upload_time_MAX = times["uploadtimemax"] self.upload_time_MIN = times["uploadtimemin"] self.expire_time = times["expiretime"] self.retry_upload_delay = times["retryuploaddelay"] #Keep this however when deleting for convenience self.slow_hours_start = datetime.time(times["slowhourstart"], 0, 0) self.slow_hours_end = datetime.time(times["slowhourend"], 0, 0) self.slow_hours_delay = times["slowhourdelay"] self.follow_time_MAX = times["followtimemax"] self.follow_time_MIN = times["followtimemin"] self.like_time_MAX = times["liketimemax"] self.like_time_MIN = times["liketimemin"] def start(self): self.db.createDatabase() loop = asyncio.get_event_loop() loop.create_task(self.scrape()) loop.create_task(self.upload()) loop.create_task(self.expire()) loop.create_task(self.follow()) loop.create_task(self.like()) loop.run_forever() loop.close() def getPost(self): try: temp_sub_list = list(self.sub_list) while temp_sub_list: try: sub = temp_sub_list[random.randint(0, len(temp_sub_list) - 1)] pic = self.db.c.execute("SELECT DISTINCT Reddit.ID, Reddit.Title, Reddit.Path, Reddit.Subreddit, Reddit.FileFormat FROM Reddit WHERE Reddit.Subreddit == (?) AND Reddit.Path is NOT NULL AND REDDIT.ID NOT IN (SELECT redditID FROM POSTED) GROUP BY Reddit.Path HAVING COUNT(Reddit.Path) = 1",(sub,)).fetchall() temp_sub_list.remove(sub) #removing here if pic: picList = pic[random.randint(0, len(pic) - 1)] pic_info = { "ID" : picList[0], "Title" : picList[1], "Path" : picList[2], "Subreddit" : picList[3], "FileFormat" : picList[4] } #If the FileFormat value is null (will not need this in the future!) if not pic_info['FileFormat']: filename, file_extension = os.path.splitext(pic_info['Path']) pic_info['FileFormat'] = file_extension.split('.')[1] return pic_info except Exception as e: print("ERROR DURING getPost while trying to get path to image: ", e) return None except Exception as e: print("ERROR DURING getPost: ", e) def getNumPosts(self): try: return self.ibot.getNumberOfPosts() except Exception as e: print("ERROR DURING getnumPosts: ", e) async def scrape(self): while True: try: for sub in self.sub_list: self.rbot.scrapeImages(sub) except Exception as e: print("ERROR DURING scape in bot: ", e) finally: await asyncio.sleep(self.scrape_time) async def upload(self): while True: waitTime = random.randint(self.upload_time_MIN, self.upload_time_MAX) if self.isSlowHours(): waitTime += self.slow_hours_delay try: succeed = self.ibot.upload(self.getPost()) if not succeed: waitTime = self.retry_upload_delay #If it did not succeed only wait 5 more min to post again except Exception as e: print("ERROR DURING upload in bot: ", e) waitTime = self.retry_upload_delay finally: await asyncio.sleep(waitTime) async def expire(self): while True: try: self.obot.checkExpired() except Exception as e: print("ERROR DURING expire in bot: ", e) finally: await asyncio.sleep(self.expire_time) async def follow(self): while True: try: waitTime = random.randint(self.follow_time_MIN, self.follow_time_MAX) if self.isSlowHours(): waitTime += self.slow_hours_delay await self.ibot.followRandom() await self.ibot.unfollow() except Exception as e: print("ERROR DURING expire in bot: ", e) finally: await asyncio.sleep(waitTime) async def like(self): while True: try: waitTime = random.randint(self.follow_time_MIN, self.follow_time_MAX) if self.isSlowHours(): waitTime += self.slow_hours_delay await self.ibot.likeTimelineRandom() except Exception as e: print("ERROR DURING expire in bot: ", e) finally: await asyncio.sleep(waitTime) def isSlowHours(self): currentTime = datetime.datetime.now().time() if self.slow_hours_start <= self.slow_hours_end: return self.slow_hours_start <= currentTime <= self.slow_hours_end else: return self.slow_hours_start <= currentTime or currentTime <= self.slow_hours_end