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
