def Webhook( self: Any, comment: praw.reddit.Comment, flair: str, configuration: dict ) -> None: """Send the specified comment to Discord via Webhook.""" embed: dict = { "username": configuration["name"], "avatar_url": configuration["avatarUrl"], "embeds": [ { "color": int("FF5700", base=16), "author": { "name": f"/u/{comment.author.name} ({flair})", "url": f"https://reddit.com/user/{comment.author.name}", "icon_url": comment.author.icon_img, }, "title": f"Comment in /r/{comment.subreddit.display_name}", "url": f"https://reddit.com{comment.permalink}?context=1000", "description": Utility.Truncate( self, Utility.Quote(self, comment.body), 2045 ), "footer": { "icon_url": "https://i.imgur.com/zbrkjFR.png", "text": "Snoopy", }, "timestamp": Utility.NowISO(self), } ], } res: httpx.Response = httpx.post(configuration["url"], json=embed) # HTTP 204 (Success: No Content) if (code := res.status_code) != 204: log.error(f"Failed to POST to Discord Webhook (HTTP {code}), {res.text}")
def main(self): print("Athena - Fortnite Item Shop Generator") print("https://github.com/Liimiitz/Athena-FNAPI.io\n") initialized = Athena.LoadConfiguration(self) if initialized is True: if self.delay > 0: log.info(f"Delaying process start for {self.delay}s...") sleep(self.delay) itemShop = Utility.GET( self, "https://fortniteapi.io/v1/shop", {"Authorization": self.apiKey}, {"lang": self.language}, ) if itemShop is not None: itemShop = json.loads(itemShop) # Strip time from the timestamp, we only need the date date = Utility.ISOtoHuman(self, today, self.language) log.info(f"Retrieved Item Shop for {date}") shopImage = Athena.GenerateImage(self, date, itemShop) if shopImage is True: if self.twitterEnabled is True: Athena.Tweet(self, date)
def main(self): Log.Intro(self, "Athena - Fortnite Item Shop Generator") initialized = Athena.LoadConfiguration(self) if initialized is True: if self.delay > 0: Log.Info(self, f"Delaying process start for {self.delay}s...") sleep(self.delay) itemShop = Utility.GET(self, "https://fortnite-api.com/shop/br", parameters={'language': self.language}) if itemShop is not None: itemShop = json.loads(itemShop)['data'] # Strip time from the timestamp, we only need the date date = Utility.ISOtoHuman(self, itemShop["date"].split("T")[0]) Log.Success( self, f"Retrieved Item Shop for {date} in {self.language}") shopImage = Athena.GenerateImage(self, date, itemShop) if shopImage is True: if self.twitterEnabled is True: Athena.Tweet(self, date)
def main(self): print("Athena - Fortnite Item Shop Generator") print("https://github.com/EthanC/Athena\n") initialized = Athena.LoadConfiguration(self) if initialized is True: if self.delay > 0: log.info(f"Delaying process start for {self.delay}s...") sleep(self.delay) itemShop = Utility.GET( self, "https://fortnite-api.com/v2/shop/br", {"x-api-key": self.apiKey}, {"language": self.language}, ) if itemShop is not None: itemShop = json.loads(itemShop)["data"] # Strip time from the timestamp, we only need the date date = Utility.ISOtoHuman(self, itemShop["date"].split("T")[0], self.language) log.info(f"Retrieved Item Shop for {date}") shopImage = Athena.GenerateImage(self, date, itemShop) if shopImage is True: if self.twitterEnabled is True: Athena.Tweet(self, date)
def two_d_anagram(self, rng): """ :param rng: Take one input parameter as range Print the prime anagram between 2 to range """ prime_number = Utility.get_prime_number(rng) b_value = True cnt = 0 for i in range(len(prime_number)): for j in range(len(prime_number)): if i == j: continue b_value = True if Utility.is_anagram(str(prime_number[i]), str(prime_number[j])): self.arr[0][cnt] = prime_number[i] # cnt += 1 # self.arr[0][cnt] = prime_number[j] cnt += 1 b_value = False break if b_value: self.arr[1][i] = prime_number[i] for x in range(2): for y in range(395): if self.arr[x][y] == 0: continue print(int(self.arr[x][y]), end=" ") print()
class CannonEngine: def __init__(self): self.cannons = {} self.tactics = {} self.ips = [] self.scaninfo = {} self.util = Utility() self.shells = {} def registerCannonPlug(self, plug: CannonPlug): tactics = plug.getSupportedAttackTactics() for tactic in tactics: if not (tactic in self.tactics): self.tactics[tactic] = [] for mod in plug.getModulesForTactics(tactic): self.tactics[tactic].append([type(plug).__name__, mod]) self.cannons[type(plug).__name__] = globals()[type(plug).__name__] def getAllRegisteredTechniques(self): return list(self.tactics.keys()) def registerIP(self, ipaddr: str): u = Utility() if not u.isValidIP(ipaddr): raise ValueError("Invalid IP Address") if not (ipaddr in self.ips): self.ips.append(ipaddr) def gatherInformation(self, ipaddr: str): if not (ipaddr in self.ips): raise ValueError("IP Address must already be registered.") self.scaninfo[ipaddr] = SystemScan(ipaddr) self.scaninfo[ipaddr].startScan() def getSession(self, ipaddr: str): # TA0001 : Initial Access if not ("TA0001" in self.getAllRegisteredTechniques()): self.util.print_message( FAIL, "No Initial Access Modules are registered. Cannot Continue.") return False if not (self.scaninfo[ipaddr]): self.util.print_message( FAIL, "No Scan info for host: " + ipaddr + "! Cannot Continue.") return False tactics = self.tactics['TA0001'] for t in tactics: cannon = self.cannons[t[0]]() targets = self.scaninfo[ipaddr].cpes print(targets) for target in targets: print(target) shell = cannon.fireModule(t[1], target['host'], int(target['port'])) if (shell is not None): self.shells[ipaddr] = shell return True return False
def main(self): print("Generador de Tienda de Objetos") print("Creado por: https://github.com/EthanC/Athena\n") print( "Modificado y Traducido por: https://github.com/PokeSantiTW/Spanish-Twitter-Item-Shop-Bot\n" ) initialized = Athena.LoadConfiguration(self) if initialized is True: if self.delay > 0: log.info(f"Retrasando ejecución por {self.delay}s...") sleep(self.delay) itemShop = Utility.GET( self, "https://fortnite-api.com/v2/shop/br/combined", {"x-api-key": self.apiKey}, {"language": self.language}, ) if itemShop is not None: itemShop = json.loads(itemShop)["data"] # Strip time from the timestamp, we only need the date date = Utility.ISOtoHuman(self, itemShop["date"].split("T")[0], self.language) log.info(f"Encontrado Tienda de Objetos del {date}") shopImage = Athena.GenerateImage(self, date, itemShop) if shopImage is True: if self.twitterEnabled is True: Athena.Tweet(self, date)
def __init__(self): self.cannons = {} self.tactics = {} self.ips = [] self.scaninfo = {} self.util = Utility() self.shells = {}
def encrypt(self, s_box, random_numbers, im, result_queue, image_id): for i in range(len(im)): for j in range(len(im[0])): b, g, r = im[i][j] hex_r = Util.convert_dec_to_hex(r) hex_g = Util.convert_dec_to_hex(g) hex_b = Util.convert_dec_to_hex(b) row_r = int(hex_r[0], 16) column_r = int(hex_r[1], 16) row_g = int(hex_g[0], 16) column_g = int(hex_g[1], 16) row_b = int(hex_b[0], 16) column_b = int(hex_b[1], 16) new_r = int( s_box[random_numbers[i][j][0], random_numbers[i][j][1]], 16) ^ int(s_box[row_r, column_r], 16) new_g = int( s_box[random_numbers[i][j][2], random_numbers[i][j][3]], 16) ^ int(s_box[row_g, column_g], 16) new_b = int( s_box[random_numbers[i][j][4], random_numbers[i][j][5]], 16) ^ int(s_box[row_b, column_b], 16) im[i, j] = new_b, new_g, new_r result_queue.put((im, image_id))
def test_util(fname): lines = Utility.file_len(fname) assert lines == 64 lines, split_list = Utility.split_files(fname, lines, 4) assert len(split_list) == 4 assert lines == 16 return lines, split_list
def getTangentStiffness(self, elemdat): n = self.dofCount() sData = getElemShapeData(elemdat.coords) elemdat.outlabel.append("stresses") elemdat.outdata = zeros(shape=(len(elemdat.nodes), 3)) for iData in sData: kin = self.getKinematics(iData.dhdx, elemdat.state) firstPiola, K4tang = self.mat.getStress(kin) K4 = ut.transform_4thTensor_to_2ndTensor_inlargestrain(K4tang) firstPiola_vector = ut.transform_matrix_to_vector(firstPiola) Bnl = self.getBNLmatrix(iData.dhdx) elemdat.stiff += dot(Bnl.transpose(), dot(K4, Bnl)) * iData.weight elemdat.fint += dot(Bnl.transpose(), firstPiola_vector) * iData.weight secondPiola = dot(np.linalg.inv(kin.F), firstPiola) secondPiola_vector = np.array( [secondPiola[0, 0], secondPiola[1, 1], secondPiola[0, 1]]) elemdat.outdata += outer(ones(len(elemdat.nodes)), secondPiola_vector) # elemdat.stiff += dot(B.transpose(), dot(tang, B)) * iData.weight # nonlinear material: dF : (F . DS) -> (dF.F) : C DE -> (dF.F) : C : (DF.F) # T = self.stress2matrix(sigma) # Bnl = self.getBNLmatrix(iData.dhdx) # elemdat.stiff += dot(Bnl.transpose(), dot(T, Bnl)) * iData.weight # nonlinear geometry: dF : (DF . S) # elemdat.fint += dot(B.transpose(), sigma) * iData.weight # power conjugate: chuyen tu F:P sang E:S -> 1/2(FT.F + F.FT):S -> FT.F : S (vi S symmetry) # elemdat.outdata += outer(ones(len(elemdat.nodes)), sigma) elemdat.outdata *= 1.0 / len(sData)
def start(self) -> None: """Start generating and tweet the itemshop""" if self.delay > 0: log.info(f"Delaying process start for {self.delay}s...") sleep(self.delay) item_shop = Utility().get_url( "https://fortnite-api.com/v2/shop/br/combined", {"language": self.language}, ) if item_shop is not None: item_shop = item_shop["data"] # Strip time from the timestamp, we only need the date + translate # in every language from googletrans date = Translator().translate(Utility().iso_to_human( item_shop["date"].split("T")[0]), str='en', dest=self.date_language).text log.info(f"Retrieved Item Shop for {date}") shop_image = self.generate_image(date, item_shop) if shop_image is True: if self.twitter_enabled is True: self.tweet(date)
def Diff(self: Any, mode: str, newData: List[dict]): """ Determine changes between local and remote news feeds, generate a Tweet for any new items. """ if os.path.isfile(f"{mode}.json") is False: Utility.WriteFile(self, mode, "json", newData) log.info(f"Created {mode}.json") return oldData: Optional[dict] = Utility.ReadFile(self, mode, "json") oldMotds: List[Optional[str]] = [] changed: bool = False motd: dict for motd in oldData: if motd.get("id") is not None: oldMotds.append(motd.get("id")) for motd in newData: if motd.get("id") in oldMotds: continue elif motd.get("id") is None: continue elif (_title := motd.get("title")) in self.ignoredTitles: log.info( f'Ignoring news feed item "{_title}" due to ignored title configuration' ) continue else: for _body in self.ignoredBodies: if _body.lower() in motd["body"].lower(): log.info( f'Ignoring news feed item "{_title}" due to ignored body configuration' ) continue body = f"{motd['title']}\n{motd['body']}" for hashtag in self.hashtags: # This allows for multi-word strings to be hashtagged hashtagged = hashtag.replace(" ", "") body = body.replace(hashtag, f"#{hashtagged}", 1) # Trim Tweet body to <280 characters (275 plus ellipses), as per # Twitter's requirements. body = body[:275] + (body[275:] and "...") log.info(body.replace("\n", " | ")) if self.twitterEnabled is True: Sleuth.Tweet(self, body, motd["image"]) changed = True
def login(self): inp = Utility.getInput("Machine or agent").lower() if (inp not in ["machine", "agent"]): Utility.error("Not a valid login type.") else: self.loginType = inp self.transactions.clear() print("Logged in as " + str(self.loginType))
def deposit(self, number, amount): number = int(number) amount = int(amount) acct = self.getAccountByNumber(number) if acct is None: Utility.log('Aborting deposit, account does not exist: ' + str(number)) return acct.balance += amount
def test1(self): utility = Utility() testNeighbors = [(1, 0), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2), (3, 0), (4, 0), (5, 0), (6, 0), (7, 0), (8, 0)] output = utility.getNeighboringCoordinates((0, 0)) for neighbor in testNeighbors: self.assertIn(neighbor, output) self.assertEquals(len(output), len(testNeighbors))
def WDR(self, account1, account2, amount, name): Utility.checkAccountNumber(account1) Utility.checkAmount(amount) if account2 != self.Unused['account']: self.fatalAccountNumber('WDR', account2) elif name != self.Unused['name']: self.fatalAccountName('WDR', name) else: self.accounts.withdraw(account1, amount)
def DEL(self, account1, account2, amount, name): Utility.checkAccountNumber(account1) Utility.checkAccountName(name) if account2 != self.Unused['account']: self.fatalAccountNumber('DEL', account2) elif amount != self.Unused['amount']: self.fatalAmount('DEL', amount) else: self.accounts.deleteAccount(account1, name)
def DEP(self, account1, account2, amount, name): Utility.checkAccountNumber(account1) Utility.checkAmount(amount) if account2 != self.Unused['account']: self.fatalAccountNumber('DEP', account2) elif name != self.Unused['name']: self.fatalAccountName('DEP', name) else: self.accounts.deposit(account1, amount)
def transfer(self): fromAccount = Utility.getAccountNumber("From account #") if fromAccount is None: return if not fromAccount in self.accounts: Utility.error("Account does not exist") return toAccount = Utility.getAccountNumber("To account #") if toAccount is None: return if not toAccount in self.accounts: Utility.error("Account does not exist") return if (fromAccount == toAccount): Utility.error("Cannot transfer from and to the same account.") return amount = Utility.getAmount(self.loginType, "Amount to transfer in cents") if amount is None: return self.transactions.transfer(fromAccount, toAccount, amount)
def data_process(self): """ This method is to process the data. It will calculate the line count in file and split file based on line count. Now files are split to the number based on number of cores in machine. returns :Nothing """ logging.info('Processing the data and split files') lines = Utility.file_len(self.fname) self.lines_to_be, self.split_files = Utility.split_files(self.fname, lines, cpu_count().real)
def prime_with_stack(self, rng): """ :param rng : Take one input from user as range Print prime number between 2 to range """ prime_number = Utility.get_prime_number(rng) anagram = Utility.get_anagram(prime_number) for i in anagram: self.stack.push(i) for i in range(self.stack.size()): print(self.stack.pop(), end=" ")
def prime_anagram_with_queue(self, rng): """ :param rng: take one parameter range for calculating prime anagram from 1 to range print prime anagram number on console """ prime_number = Utility.get_prime_number(rng) anagram_number = Utility.get_anagram(prime_number) for i in anagram_number: self.queue.enqueue(i) for i in range(self.queue.size()): print(self.queue.dequeue(), end=" ")
def test1(self): ptext = utl.toBitSet(0x2345, 16) sub1 = self.getSBoxGroup(ptext) print('substitution:', utl.toInteger(sub1, 16), '-', int(sub1)) print('permutation: ', int(self.permuteBits(ptext))) sub1 = self.getSBoxGroup(utl.toBitSet(0x1234, 16)) sub2 = self.getSBoxGroup(utl.toBitSet(0x5678, 16)) subinv3 = self.getSBoxInvGroup(utl.toBitSet(0x9abc, 16)) print('permutation: ', int(sub1), " - ", int(sub2)) print('subinv: ', int(subinv3))
def withdraw(self, number, amount): acct = self.getAccountByNumber(number) if acct is None: Utility.log('Aborting withdrawal, account does not exist: ' + number) return if acct.balance < amount: Utility.log( 'Aborting withdrawal, the account does not have enough funds: ' + number) else: acct.balance -= amount
def getDiffPair16(self, seed16, dp): X = utl.toBitSet(0xF000, 16) Y = utl.toBitSet(seed16, 16) Z = utl.toBitSet(0, 16) for i in range(4): sb = int(X & Y) >> (4 - 1 - i) * 4 sb = int(dp[sb]) sb = sb << (4 - 1 - i) * 4 Xpm = utl.toBitSet(sb, 16) Z = Xpm | Z X = X >> 4 return Z
def deposit(self): account = Utility.getAccountNumber("Account #") if account is None: return if account not in self.accounts: Utility.error("Account does not exist") return amount = Utility.getAmount(self.loginType, "Amount in cents") if amount is None: return self.transactions.deposit(account, amount)
def transfer(self, fromNumber, toNumber, amount): fromNumber = int(fromNumber) toNumber = int(toNumber) amount = int(amount) fromAcct = self.getAccountByNumber(fromNumber) toAcct = self.getAccountByNumber(toNumber) if fromAcct is None: Utility.log('Aborting transfer, account does not exist: ' + str(fromNumber)) elif toAcct is None: Utility.log('Aborting transfer, account does not exist: ' + str(toNumber)) elif fromNumber == toNumber: Utility.log( 'Aborting transfer, cannot transfer between the same accounts: ' + str(fromNumber) + '/' + str(toNumber)) elif fromAcct.balance < amount: Utility.log( 'Aborting transfer, not enough funds in the source account: ' + str(fromNumber)) else: fromAcct.balance -= amount toAcct.balance += amount return
def EOS(self, account1, account2, amount, name): if account1 != self.Unused['account'] or account2 != self.Unused[ 'account']: Utility.fatal('Invalid account number(s) in EOS command' + account1 + ' / ' + account2) elif amount != self.Unused['amount']: self.fatalAmount('EOS', amount) elif name != self.Unused['name']: self.fatalAccountName('EOS', name) else: # If this is the second EOS in a row, exit if self.lastCommand is 'EOS': self.accounts.finish() sys.exit()
def main(self): initialized = ShopBot.LoadConfig(ShopBot) if initialized: log.info("Fortnite-ShopBot") log.info("製作者: gomashio") log.info("参考: Athena") log.info("Getting ItemShop data...") data = json.loads( ShopBot.GET_ItemShop(self, api_key=self.api_key, language=self.language)) date = Utility.ISOtoHuman(self, date=Utility.Now_ISO(self), dateformat=self.text_override['date'], hour=self.text_override['hour'], language=self.language) specialoffer = None if self.text_override['auto-specialoffer-convert']['enabled']: with requests.Session() as session: specialoffer = AuthUtil.get_special_offer( self, session=session, email=self.text_override['auto-specialoffer-convert'] ['email'], password=self. text_override['auto-specialoffer-convert']['password'], user_agent=self.user_agent, language=self.language) if specialoffer is None: specialoffer = self.text_override['auto-specialoffer-convert'][ 'default'] if data is not None and date is not None: log.info("Generating shop image...") Image = ShopBot.GenerateImage(self, data=data, date=date, text_override=self.text_override, specialoffer=specialoffer, namefont=self.namefont, categoryfont=self.categoryfont) else: log.error("Failed to get shop data") if Image: log.info("Success") if self.monitor_change_enabled: ShopBot.MonitorChange(self) else: exit()
def LoadConfiguration(self): """ Set the configuration values specified in configuration.json Return True if configuration sucessfully loaded. """ configuration = json.loads( Utility.ReadFile(self, "configuration", "json")) try: self.delay = configuration["delayStart"] self.apiKey = configuration["fortniteAPI"]["apiKey"] self.language = configuration["language"] self.supportACreator = configuration["supportACreator"] self.twitterEnabled = configuration["twitter"]["enabled"] self.twitterAPIKey = configuration["twitter"]["apiKey"] self.twitterAPISecret = configuration["twitter"]["apiSecret"] self.twitterAccessToken = configuration["twitter"]["accessToken"] self.twitterAccessSecret = configuration["twitter"]["accessSecret"] log.info("Loaded configuration") return True except Exception as e: log.critical(f"Failed to load configuration, {e}")
def LoadConfiguration(self: Any) -> Optional[bool]: """ Set the configuration values specified in configuration.json Return True if configuration sucessfully loaded. """ configuration: Optional[Union[dict, str]] = Utility.ReadFile( self, "configuration", "json") try: # self.saveTheWorld: bool = configuration["saveTheWorld"] self.battleRoyale: bool = configuration["battleRoyale"] self.creative: bool = configuration["creative"] self.language: str = configuration["language"] self.apiKey: str = configuration["fortniteAPI"]["apiKey"] self.twitterEnabled: bool = configuration["twitter"]["enabled"] self.twitterAPIKey: str = configuration["twitter"]["apiKey"] self.twitterAPISecret: str = configuration["twitter"]["apiSecret"] self.twitterAccessToken: str = configuration["twitter"][ "accessToken"] self.twitterAccessSecret: str = configuration["twitter"][ "accessSecret"] self.hashtags: List[str] = configuration["hashtags"] self.ignoredTitles: List[str] = configuration["ignoredTitles"] self.ignoredBodies: List[str] = configuration["ignoredBodies"] log.info("Loaded configuration") return True except Exception as e: log.critical(f"Failed to load configuration, {e}")
opts, args = getopt.getopt(argv, "hi:o:", ["ifile=", "ofile="]) input_file = None output_file = None for opt, arg in opts: if opt == '-h': print 'worker.py -i <inputfile> -o <outputfile>' sys.exit() elif opt in ("-i", "--ifile"): input_file = arg elif opt in ("-o", "--ofile"): output_file = arg except getopt.GetoptError, e: logging.info('worker.py -i <inputfile> -o <outputfile>') raise e if not input_file or not output_file: logging.info('worker.py -i <inputfile> -o <outputfile>') raise NoArgumentException("One of Argument is not passed") if Utility.is_file_exists(input_file): try: ws = Worker(input_file, output_file) ws.data_process() ws.run() except Exception, e: raise e else: raise FileNotFound(" The specified file does not present") if __name__ == "__main__": main(sys.argv[1:])