def encrypt_file_with_pgpy(data: bytes, public_key: str) -> PGPMessage: key = pgpy.PGPKey() key.parse(public_key) msg = pgpy.PGPMessage.new(data, encoding="utf-8") r = key.encrypt(msg) return r
def test_submit_form(self): keypair = generate_test_keypair() first_key = EncryptionKey.objects.create( public_key=keypair["publickey"], user=self.user, active=True) with self.assertRaises(FormServiceException): FormService.submit(form_id=self.form.id, content="helo") create_signature_key.Command().handle() result = FormService.submit(form_id=self.form.id, content="helo") pub = pgpy.PGPKey() pub.parse( SignatureKey.objects.get( active=True, key_type=SignatureKey.SignatureKeyType.SECONDARY).public_key) self.assertEqual( bool(pub.verify(result["content"], result["signature"])), True) signed_content = json.loads(result["content"]) self.assertEqual(signed_content["form_data"], "helo") self.assertEqual(len(signed_content["public_keys_recipients"]), 1) self.assertEqual( signed_content["public_key_server"], SignatureKey.objects.get( active=True, key_type=SignatureKey.SignatureKeyType.SECONDARY).public_key) self.assertIn("BEGIN PGP PUBLIC KEY BLOCK", signed_content["public_key_server"]) self.assertNotIn("BEGIN PGP PRIVATE KEY BLOCK", signed_content["public_key_server"])
def setUp(self): self.quedex_private_key = pgpy.PGPKey() self.quedex_private_key.parse(open('keys/quedex-private-key.asc', 'r').read()) self.trader_public_key = pgpy.PGPKey() self.trader_public_key.parse(open('keys/trader-public-key.asc', 'r').read()) trader = Trader('123456789', open('keys/trader-private-key.asc', 'r').read()) trader.decrypt_private_key('aaa') exchange = Exchange(open('keys/quedex-public-key.asc', 'r').read(), 'wss://url') self.listener = TestListener() self.user_stream = UserStream(exchange, trader) self.user_stream.add_listener(self.listener) self.sent_message = None def set_sent_message(message): self.sent_message = message self.user_stream.send_message = set_sent_message
def load_private_key_from_file(self, key_type: PillarKeyType): try: self.logger.info(f"Loading key type: {key_type.value}") path = os.path.join(self.config.get_value('config_directory'), key_type.value) key, d = pgpy.PGPKey().from_file(path) return key except FileNotFoundError: raise KeyTypeNotPresent
def sign(sec_key, message, passphrase, salt): temp_pgpy = pgpy.PGPKey() temp_pgpy.parse(sec_key) try: with temp_pgpy.unlock(passphrase + salt): message = pgpy.PGPMessage.new(message) signature = temp_pgpy.sign(message) return signature except: print("Wrong passphrase") return False
def _parse_key(self, armored): pgpkey = pgpy.PGPKey() try: parse_result = pgpkey.parse(armored) log.debug('Parse key result {}'.format(parse_result)) result_keys = [] for keyid, parsedkey in parse_result.items(): result_keys.append(PGPPublicKey(keyid[0], parsedkey)) return result_keys except Exception as exc: log.error('Parse key failed {}'.format(exc)) return []
def merge(public_key, delete_signature): with open(f'{public_key}', 'r') as f: string = f.read() pub_key = pgpy.PGPKey() pub_key.parse(string) del_sig = pgpy.PGPMessage.from_file(delete_signature) try: if pub_key.verify(del_sig): del_sig_keyid = del_sig.message except pgpy.errors.PGPError as e: click.echo(e) sys.exit(1) # Delete Signature from Public Key pub_fingerprint = pub_key.fingerprint.replace(" ", "") gpg = pexpect.spawn(f"gpg --edit-key {pub_fingerprint}") gpg.expect("gpg>") # all UID gpg.sendline("uid *") gpg.expect("gpg>") # delsig gpg.sendline("delsig") while True: gpg.expect(r"(y/N/q)|gpg>") # all signatures are checked if gpg.after == b"gpg>": break if gpg.after == b"y/N/q": if del_sig_keyid in gpg.before.decode('UTF-8'): gpg.sendline("y") else: gpg.sendline("N") # Save gpg.sendline("save") # Export with open(f'deleted_{public_key}', 'w') as f: # cmd = f"gpg --armor --export {pub_fingerprint}" # subprocess.run(cmd, stdout=f) subprocess.run(["gpg", "--armor", "--export", f"{pub_fingerprint}"], stdout=f) subprocess.run(["cat", f"deleted_{public_key}"])
def submit(cls, form_id: int, content: str) -> dict: """receives encrypted form data and signs it :param form_id: id of the form the content is for :param content: pgp encrypted form content :returns: object with signed content and the signature """ form = FormService.retrieve_form(form_id) # load the signature key try: # we currently load the primary key b/c of a bug in pgpy signature_key = SignatureKey.objects.filter( active=True, key_type=SignatureKey.SignatureKeyType.SECONDARY).get() pkey = pgpy.PGPKey() pkey.parse(signature_key.private_key) except SignatureKey.DoesNotExist: raise FormServiceException( _("Couldn't sign form because there are no signing keys available." )) created_at = datetime.now() signed_content = json.dumps({ "form_data": content, "timestamp": created_at.isoformat(), "public_key_server": str(pkey.pubkey), "public_keys_recipients": [ pubkey.public_key for pubkey in FormService.retrieve_public_keys_for_form(form.pk) ], "form_id": form.pk, "form_name": form.name, }) # build the object that should be signed with pkey.subkeys[signature_key.subkey_id].unlock(settings.SECRET_KEY): signature = pkey.subkeys[signature_key.subkey_id].sign( signed_content) FormSubmission.objects.create(signature=signature, data=content, submitted_at=created_at, form=form) return {"content": signed_content, "signature": signature}
def compose_msg(body_file, to_addr, subject, passphrase, attachment): shatar = hashlib.sha256(subject).hexdigest() f = open(body_file, 'r') f2 = open('./tx/dec/' + shatar + '/msg.txt', 'w+') f2.write("SUBJECT: " + subject + "\nFROM: " + USRNM + "@" + HOST + "\nTO: " + to_addr + "\n\n\n" + f.read()) f2.close() f.close() # tarfile.open('./tx/dec/'+shatar+'.tar', 'x') os.mkdir('./tx/dec/' + shatar) tf = tarfile.open('./tx/dec/' + shatar + '.tar', 'w') if len(attachment) > 0: os.mkdir('./tx/dec/' + shatar + '/attach') for i in range(len(attachment)): fname = attachment[i].split("/").split("\\") att_file = open(attachment[i], 'r') att_dest_file = open('./tx/dec/' + shatar + '/attach/' + fname, 'w+') att_dest_file.write(att_file.read()) att_dest_file.close() att_file.close() tf.addfile('./tx/dec/' + shatar + '/attach') s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock = ssl.wrap_socket(s, ssl_version=ssl.PROTOCOL_TLSv1_2, ciphers="ALL") sock.connect((HOST, 2930)) msg = "GETKEY " + to_addr msghead = len(msg) sock.send(bytes(f"{msghead:<{HEADSIZE}}{msg}")) recvhead = int(sock.recv(HEADSIZE).decode("UTF-8")) if sock.recv(recvhead).decode("UTF-8") == 'OK': recvhead = int(sock.recv(HEADSIZE).decode("UTF-8")) pubkey_rec = pgpy.PGPKey() pubkey_rec.parse(sock.recv(recvhead)) msg = to_addr msghead = len(msg) sock.send(bytes(f"{msghead:<{HEADSIZE}}{msg}")) recvhead = int(sock.recv(HEADSIZE).decode("UTF-8")) recvmsg = sock.recv(recvhead).decode("UTF-8") recvmsgf = recvmsg.split(' ') if recvmsgf[0] == "OK": arc = pubkey_rec.encrypt( open('./tx/dec/' + shatar + '.tar', 'r').read()) msghead = len(bytes(arc)) sock.send(bytes(f'{len(shatar):<{HEADSIZE}}{shatar}', "UTF-8")) sock.send(bytes(f"{msghead:<{HEADSIZE}}", "UTF-8")) sock.send(bytes(arc, "UTF-8")) else: print("ERROR") print("Done!")
def __init__( self, armored_private_keys: list[str], ) -> None: self._keys: dict[str, pgpy.PGPKey] = {} for armored_private_key in armored_private_keys: private_key: pgpy.PGPKey = pgpy.PGPKey() private_key.parse(armored_private_key) if private_key.is_public: raise Exception(f"Key {private_key.fingerprint} is public") self._keys[private_key.fingerprint] = private_key
def serialize(self, name, comment, email): rsa_priv = RSAPriv() rsa_priv.e = MPI(self.public_numbers._e) rsa_priv.n = MPI(self.public_numbers._n) rsa_priv.d = MPI(self._d) rsa_priv.p = MPI(self._p) rsa_priv.q = MPI(self._q) # https://github.com/SecurityInnovation/PGPy/blob/f08afed730816e71eafa0dd59ce77d8859ce24b5/pgpy/packet/fields.py#L1116 rsa_priv.u = MPI(rsa.rsa_crt_iqmp(self._q, self._p)) rsa_priv._compute_chksum() pub_key_v4 = PrivKeyV4() pub_key_v4.pkalg = PubKeyAlgorithm.RSAEncryptOrSign pub_key_v4.keymaterial = rsa_priv pub_key_v4.update_hlen() pgp_key = pgpy.PGPKey() pgp_key._key = pub_key_v4 uid = pgpy.PGPUID.new(name, comment=comment, email=email) # FIXME: Should I add a "Signature" Packet? # FIXME: Should I add subkeys? pgp_key.add_uid(uid, usage={ KeyFlags.Sign, KeyFlags.EncryptCommunications, KeyFlags.EncryptStorage }, hashes=[ HashAlgorithm.SHA256, HashAlgorithm.SHA384, HashAlgorithm.SHA512, HashAlgorithm.SHA224 ], ciphers=[ SymmetricKeyAlgorithm.AES256, SymmetricKeyAlgorithm.AES192, SymmetricKeyAlgorithm.AES128 ], compression=[ CompressionAlgorithm.ZLIB, CompressionAlgorithm.BZ2, CompressionAlgorithm.ZIP, CompressionAlgorithm.Uncompressed ]) if self.password: pgp_key.protect(self.password, SymmetricKeyAlgorithm.AES256, HashAlgorithm.SHA256) return str(pgp_key)
def rsatogpg(e, N, name, **idargs): """ :param e,N: RSA parameters as Python integers or longints :param name: Identity name :param idargs: PGP Identity parameters, such as comment,email :return: PGPy pubkey object """ rsakey = custPubKeyV4(custRSAPub(N, e)) pgpkey = pgpy.PGPKey() pgpkey._key = rsakey uid = pgpy.PGPUID.new(name, **idargs) uid._parent = pgpkey pgpkey._uids.append(uid) return pgpkey
def verify(self, authors: Manager) -> VerifiedMessage: try: author = authors.get(email=self.sender_address) except ObjectDoesNotExist: raise AuthorUnknown(self.sender_address) if not author.pgp_public_key: raise AuthorNotVerifyable(author) expected_public_key = pgpy.PGPKey() expected_public_key.parse(author.pgp_public_key) # Mandatory: Verify Signature if not self._signature: raise NoSignature(self) attached_signature = pgpy.PGPSignature() attached_signature.parse(self._signature) # Verify signature if not (attached_signature.signer_fingerprint == expected_public_key.fingerprint): raise SignatureMismatch(expected_public_key.fingerprint, attached_signature.signer_fingerprint) # Optional: If a public key was attached, verify it for good measure if self._public_key: attached_pub_key = pgpy.PGPKey() attached_pub_key.parse(self._public_key) # Verify public Key if not expected_public_key.fingerprint == attached_pub_key.fingerprint: raise PublicKeyMismatch(expected_public_key, attached_pub_key) return VerifiedMessage(subject=self._message.get('subject'), body=self._body, author=author)
def encrypt_decrypt_text(text: str): public_key_path = os.path.join(ROOT_DIR, "local_data/public-pgp.asc") public_key = open(public_key_path).read() encrypted: PGPMessage = encrypt_file_with_pgpy(text.encode(), public_key) # decrypt private_key_path = os.path.join(ROOT_DIR, "local_data/private-pgp.asc") private_key = open(private_key_path).read() priv = pgpy.PGPKey() priv.parse(private_key) decrypted = priv.decrypt(encrypted).message if type(decrypted) == str: assert decrypted == text elif type(decrypted) == bytearray: assert decrypted.decode() == text
def send_mail(self): text = ''' {name} {contact} {message} '''.format( name=self.cleaned_data['name'], contact=self.cleaned_data['contact'], message=self.cleaned_data['message'], ) if pgpy is not None: public_key = pgpy.PGPKey() public_key.parse(PUBLIC_KEY) message = pgpy.PGPMessage.new(text) text = public_key.encrypt(message) mail_managers('Behörden-Kontaktformular', str(text))
def decryption(sec_key, enc_message, passphrase, salt): temp_pgpy = pgpy.PGPKey() temp_pgpy.parse(sec_key) try: message = pgpy.PGPMessage() message.parse(enc_message) if message.is_encrypted: try: with temp_pgpy.unlock(passphrase + salt): decrypted_message = temp_pgpy.decrypt(message) return decrypted_message.message except: print("Wrong passphrase") return False else: return None except: return None
def serialize(self, name, comment, email): rsa_pub = RSAPub() rsa_pub.e = MPI(self._e) rsa_pub.n = MPI(self._n) pub_key_v4 = PubKeyV4() pub_key_v4.pkalg = PubKeyAlgorithm.RSAEncryptOrSign pub_key_v4.keymaterial = rsa_pub pub_key_v4.update_hlen() pgp_key = pgpy.PGPKey() pgp_key._key = pub_key_v4 uid = pgpy.PGPUID.new(name, comment=comment, email=email) uid._parent = pgp_key pgp_key._uids.append(uid) return str(pgp_key)
def create(secret_key, signature_keyid): with open(f'{secret_key}', 'r') as f: string = f.read() priv_key = pgpy.PGPKey() priv_key.parse(string) password = getpass('your password: '******'{str(signature_keyid)}') message |= priv_key.sign(message) click.echo(message) except pgpy.errors.PGPDecryptionError as e: click.echo(e) sys.exit(1) with open(f'{signature_keyid}.asc', 'w') as f: f.write(str(message))
def pgp_keys_POST(): user = User.query.get(current_user.id) valid = Validation(request) pgp_key = valid.require("pgp-key") valid.expect( not pgp_key or len(pgp_key) < 32768, Markup("Maximum encoded key length is 32768 bytes. " "Try <br /><code>gpg --armor --export-options export-minimal " "--export <fingerprint></code><br /> to export a " "smaller key."), field="pgp-key") if valid.ok: try: key = pgpy.PGPKey() key.parse(pgp_key.replace('\r', '').encode('utf-8')) except: valid.error("This is not a valid PGP key", field="pgp-key") valid.expect(any(key.userids), "This key has no user IDs", field="pgp-key") try: prepare_email("test", user.email, "test", encrypt_key=pgp_key) except: valid.error( "We were unable to encrypt a test message with this key", field="pgp-key") if valid.ok: valid.expect(PGPKey.query\ .filter(PGPKey.user_id == user.id) \ .filter(PGPKey.key_id == key.fingerprint)\ .count() == 0, "This is a duplicate key", field="pgp-key") if not valid.ok: return render_template("keys.html", current_user=user, pgp_key=pgp_key, valid=valid) pgp = PGPKey(user, pgp_key, key.fingerprint, key.userids[0].email) db.session.add(pgp) audit_log("pgp key added", 'Added PGP key {}'.format(key.fingerprint)) db.session.commit() return redirect("/keys")
def verify_signature( self, *, data: bytes, armored_detached_signature: str, armored_public_key: str, ) -> bool: # Load sig signature: pgpy.PGPSignature = pgpy.PGPSignature() signature.parse(armored_detached_signature) # Load key key: pgpy.PGPKey = pgpy.PGPKey() key.parse(armored_public_key) # Verify verified: pgpy.types.SignatureVerification = key.verify( data, signature) is_verified: bool = bool(verified) return is_verified
def encrypt(self, message, userids): if not isinstance(message, str): raise nova.exceptions.ParameterError( 'The provided message is not a string.') if isinstance(userids, str): userids = [userids] else: if not isinstance(userids, list): raise nova.exceptions.ParameterError( 'The provided userids has to be either a list of strings or a string.' ) keys = [] for userid in userids: keytext = self._connector.get('_keys', '.' + userid) if keytext is None: raise nova.exceptions.EncryptionError( 'Could not find the user associated with a provided userid.' ) k = pgpy.PGPKey() k.parse(keytext) keys.append(k) pgp_msg = pgpy.PGPMessage.new(message) cipher = pgpy.constants.SymmetricKeyAlgorithm.AES256 sessionkey = cipher.gen_key() enc_msg = keys[0].pubkey.encrypt(pgp_msg, cipher=cipher, sessionkey=sessionkey) keys = keys[1:] for key in keys: enc_msg = key.pubkey.encrypt(enc_msg, cipher=cipher, sessionkey=sessionkey) del sessionkey return str(enc_msg)
class PGPy(object): recipients = [] pgpKey = pgpy.PGPKey() def __init__(self, passPhrase): self.passphrase = passPhrase def decrypt_msg(self, msg): emsg = pgpy.PGPMessage.from_blob(msg) with self.pgpKey.unlock(self.passphrase): deCryptedmsg = self.pgpKey.decrypt(emsg) return str(deCryptedmsg.message) def encrypt_msg(self, msg): emsg = pgpy.PGPMessage.new(msg) enCryptedmsg = self.pgpKey.encrypt(emsg) return str(enCryptedmsg) def import_keys(self, key): # download from Blob - to be replaced with KeyVault key, _ = pgpy.PGPKey.from_blob(key) self.pgpKey = key return key
#p = long(p, 16) #q = q.encode("HEX") #q = long(q, 16) e = int('10001', 16) #pub = rsatogpg(e,N,p,q,'Nikola Tesla') #rsakey = custPubKeyV4(custRSAPub(N,e)) #priv_key._key = rsakey return priv_key # we can start by generating a primary key. For this example, we'll use RSA, but it could be DSA or ECDSA as well #with open('test_priv.asc', 'rb') as f: # t = f.read().replace('\r', '') #priv_key, _ = PGPKey.from_blob(t) priv_key = pgpy.PGPKey() # we now have some key material, but our new key doesn't have a user ID yet, and therefore is not yet usable! #with priv_key.unlock("test"): # uid = pgpy.PGPUID.new('Abraham Lincoln', comment='Honest Abe', email='*****@*****.**') # now we must add the new user id to the key. We'll need to specify all of our preferences at this point # because PGPy doesn't have any built-in key preference defaults at this time # this example is similar to GnuPG 2.1.x defaults, with no expiration or preferred keyserver #priv_key.add_uid(uid, usage={KeyFlags.Sign, KeyFlags.EncryptCommunications, KeyFlags.EncryptStorage}, # hashes=[HashAlgorithm.SHA256, HashAlgorithm.SHA384, HashAlgorithm.SHA512, HashAlgorithm.SHA224], # ciphers=[SymmetricKeyAlgorithm.AES256, SymmetricKeyAlgorithm.AES192, SymmetricKeyAlgorithm.AES128], # compression=[CompressionAlgorithm.ZLIB, CompressionAlgorithm.BZ2, CompressionAlgorithm.ZIP, CompressionAlgorithm.Uncompressed]) print() print('Do you want to sign or decrypt a message?') print('s = sign, d = decrypt') print()
def _parse_key(self): self._private_key = pgpy.PGPKey() self._private_key.parse(self._private_key_str)
def __init__(self, exchange): self._exchange = exchange self._quedex_key = pgpy.PGPKey() self._quedex_key.parse(exchange.public_key) self._listeners = []
def sign_data_with_pgpy(data: Union[str, bytes]) -> str: key = pgpy.PGPKey() key.parse(PGP_SENDER_PRIVATE_KEY) signature = str(key.sign(data)) return signature
def get_key_fingerprint(self, *, armored_key: str) -> str: key: pgpy.PGPKey = pgpy.PGPKey() key.parse(armored_key) return key.fingerprint
def KBRImport(): # ---init--------- storage_client = storage.Client() scope = ["https://spreadsheets.google.com/feeds", "https://www.googleapis.com/auth/spreadsheets", "https://www.googleapis.com/auth/drive.file", "https://www.googleapis.com/auth/drive"] credraw = storage_client.get_bucket('hc_tokens_scripts').blob( 'Tokens/hireclix-googlesheets.json').download_as_string() credjson = json.loads(credraw) cred = ServiceAccountCredentials.from_json_keyfile_dict(credjson, scope) gclient = gspread.authorize(cred) sheet = gclient.open_by_key('1nQDxuJVTjfFRSGDIr_eqeT6rJ2yUkZB9kGQWh0GP7d8').worksheet('Automated ATS by BU') # -----dev tool----- pd.set_option('display.max_rows', 500) pd.set_option('display.max_columns', 500) pd.set_option('display.width', 1000) # -----load STFP server----- data = storage_client.get_bucket('hc_tokens_scripts').blob('Tokens/KBRFTP.json').download_as_string() json_data = json.loads(data) transport = paramiko.Transport(json_data["host"], 22) transport.connect(username=json_data["username"], password=json_data["password"]) sftp = paramiko.SFTPClient.from_transport(transport) x = sftp.open("HireClix_Data.csv.pgp", 'rb').read() toread = io.BytesIO() # Removes Empty Null Char from String/prep for decryt toread.write(x) toread.seek(0) # ------pgp decrypt------ if storage_client.get_bucket('hc_tokens_scripts').blob('Tokens/KBR (FD2E83EC) – Secret.asc').exists(): with gcsfs.GCSFileSystem(project="hireclix").open('hc_tokens_scripts/Tokens/KBR (FD2E83EC) – Secret.asc', 'rb') as token: creds = pgpy.PGPKey().from_blob(token.read()) with creds[0].unlock("hireclix10") as ukey: message = pgpy.PGPMessage().from_blob(toread.read()) decryptedmessage = ukey.decrypt(message).message decryptedmessagestr = decryptedmessage.decode() DMIo = io.StringIO(decryptedmessagestr) dataframe = pd.read_csv(DMIo) else: print("PGP Token not Found, please fix") raise FileNotFoundError # ----transform data---- dataframe.rename(columns={'Application Date': 'Application_Date', 'Job Requisition ID': 'Job_Requisition_ID', 'Job Posting Title': 'Job_Posting_Title', 'Job Requisition Primary Location': 'Job_Requisition_Primary_Location', 'Job Requisition Status': 'Job_Requisition_Status', 'Is Evergreen': 'Is_Evergreen', 'First Name': 'First_Name', 'Last Name': 'Last_Name', 'Candidate ID': 'Candidate_ID', 'Candidate Location': 'Candidate_Location', 'Candidate Stage': 'Candidate_Stage', 'Candidate Step': 'Candidate_Step', 'Source': 'Source', 'Referred by': 'Referred_by', 'Job Code': 'Job_Code', 'Security Sub Region': 'Security_Sub_Region'}, inplace=True) dataframe['Application_Date'] = pd.to_datetime(dataframe['Application_Date'], errors='coerce').dt.date # ----pivot table ----- pivot = dataframe.pivot_table(index=['Application_Date', 'Source', 'Security_Sub_Region', 'Job_Posting_Title', 'Job_Requisition_Primary_Location', 'Job_Requisition_ID'], columns=['Candidate_Stage'], values=['Candidate_ID'], aggfunc='count') pivot.reset_index(inplace=True) axes = pivot.axes[1] columnheaders = [] for axis in axes: if axis[1] == "": columnheaders.append(axis[0]) elif axis[0] == "Candidate_ID": columnheaders.append(axis[1]) else: columnheaders.append("unknown") pivotval = pivot.values atslst = [columnheaders + ["Month-Year", "Month", "Year", "Applies", "Quality Applies"]] ind = 1 # -----transform pivot for Google sheets----- for x in pivotval: ind += 1 month = str(x[0].strftime("%B")) year = str(x[0].strftime("%Y")) dates = month[0:3] + "-" + year ap = '=SUM(INDIRECT("G' + str(ind) + ':P' + str(ind) + '"))' # insert Applications formula qap = '=SUM(INDIRECT("I' + str(ind) + ':M' + str(ind) + '"))' # insert Quality Applications formula templst = [] for ex in range(0, len(x)): templst.append(str(x[ex])) # format a temp list in the correct manner templst.extend([dates, month, year, ap, qap]) atslst.append(templst) for i in range(1, len(atslst)): for val in range(5, len(atslst[i])): if atslst[i][val] == 'nan': atslst[i][val] = '' elif re.match('[0-9]+\.[0-9+]', atslst[i][val]): atslst[i][val] = int(re.sub("\.[0-9]", "", atslst[i][val])) sheet.clear() sheet.append_rows(atslst, "USER_ENTERED") today = datetime.today().date() dataframe.to_csv('gs://hc_kbr_ats/File_Completed/' + "kbr_data_ " + str(today.month) + "." + str(today.day) + "." + str(today.year) + ".csv", index=False, header=True) header = ["Application_Date", "Source", "Security_Sub_Region", "Job_Posting_Title", "Job_Requisition_Primary_Location", "Job_Requisition_ID", "Background Check", "Declined by Candidate", "Hire", "Interview", "Offer", "Offer/Employment Agreement", "Pre-Employment Checklist", "Rejected", "Review", "Screen", "Month-Year", "Month", "Year", "Applies", "Quality Applies"] mod = 0 sheetaxis = sheet.get("A1:W1") for x in range(0, len(sheetaxis[0])): # modify header locations post insert for i in range(0, len(header)): if (i - mod) == x: if sheetaxis[0][x] != header[i]: sheet.insert_col([""], i + 1) mod += 1 sheet.insert_row(header) sheet.delete_rows(2, 2)
from threading import Event, Thread from unittest import TestCase import json from autobahn.twisted.websocket import WebSocketServerProtocol, WebSocketServerFactory from autobahn.twisted.resource import WebSocketResource from twisted.internet import reactor from twisted.web.server import Site from twisted.web.static import Data import pgpy exchange_key = pgpy.PGPKey() exchange_key.parse(open('keys/quedex-private-key.asc', 'r').read()) trader_key = pgpy.PGPKey() trader_key.parse(open('keys/trader-public-key.asc', 'r').read()) messages = [] client_messages_received_lock = Event() user_stream_sender = None class TestApiEndToEnd(TestCase): def setUp(self): market_factory = WebSocketServerFactory('ws://localhost:8080/market_stream') user_factory = WebSocketServerFactory('ws://localhost:8080/user_stream') market_factory.protocol = MarketStreamServerProtocol user_factory.protocol = UserStreamServerProtocol market_factory.startFactory() user_factory.startFactory() root = Data('', 'text/plain') root.putChild(b'market_stream', WebSocketResource(market_factory))
def fingerprint(self) -> str: pkey = pgpy.PGPKey() pkey.parse(self.public_key) return pkey.fingerprint