def send_email():
if not has_args(request.json, ['email']):
raise InvalidUsage('Missing email.')
if not has_args(request.json, ['password']):
raise InvalidUsage('Missing password.')
if not has_args(request.json, ['name']):
raise InvalidUsage('Missing name.')
if not has_args(request.json, ['state']):
raise InvalidUsage('Missing state.')
if not has_args(request.json, ['county']):
raise InvalidUsage('Missing county.')
sender = Sender()
state = request.json['state']
county = request.json['county']
email = unquote(request.json['email'])
password = unquote(request.json['password'])
print(email)
recv = sender.get_recipients(state, county)
num_sent = sender.send_email(recv, request.json['name'], email, password)
return jsonify({'number of emails sent': num_sent})
def main():
args = parse_args()
ENC_PATH = os.environ.get('ENC_PATH')
if args.mode == 'init':
keyPair = RSA.generate(3072)
with open('.myPrivKey', 'wb') as f:
f.write(keyPair.export_key('DER'))
with open('myPubKey', 'wb') as f:
f.write(keyPair.publickey().exportKey('DER'))
#print(keyPair.exportKey().decode('ascii'))
print('new key pair generated and saved.')
print('showing public key on screen:')
print(keyPair.publickey().exportKey().decode('ascii'))
return
f = open('.myPrivKey', 'rb')
privKey = RSA.import_key(f.read())
f = open('myPubKey', 'rb')
pubKey = RSA.import_key(f.read())
if args.mode == 'send':
assert args.text is not None, 'text not provided. What am I encrypting?'
assert args.to_whom is not None, "recipient's alias not provided. Whom am I sending to?"
### ECRYPT TEXT
encryptor = PKCS1_OAEP.new(pubKey)
encrypted = encryptor.encrypt(args.text.encode('utf8'))
with open(ENC_PATH, 'wb') as f:
f.write(encrypted)
### SEND ENCRYPTED TEXT OVER EMAIL
sender = Sender(text="see attached",
attached=ENC_PATH,
to_addr=recipients[args.to_whom])
sender.send()
os.remove(ENC_PATH)
elif args.mode == 'recv':
assert args.from_whom is not None, "sender's alias not provided. From whom is the inbound message?"
### FETCH EMAIL, EXTRACT PAYLOAD
receiver = Receiver(args.from_whom)
ps = receiver.receive()
### DECRYPT PAYLOAD
if len(ps) == 0:
print("No ptalk message found.")
exit(1)
print(f"{len(ps)} new ptalk message(s) found. Decrypted:")
privKey = PKCS1_OAEP.new(privKey)
for p in ps:
with open(p, 'rb') as f:
enc_msg = f.read()
dec_msg = privKey.decrypt(enc_msg).decode("utf-8")
print(f"> {dec_msg}")
os.remove(p)
def divide_and_receive_work(ChildConnect, port_num, binding_ip, connecting_ip,
book_to_count, name_of_dict_file):
#instantiate sender and receiver
sender = Sender()
receiver = Receiver()
#begin sending file
sender.send_txt(port_num, binding_ip, book_to_count)
#begin receiving dictionary for other server, being sure to use a different port than the sender
receiver.receive_txt(port_num + 1, binding_ip, connecting_ip,
name_of_dict_file)
#open file pointer to read from received pickled dictionary file
unpickled_dict = open(name_of_dict_file, "rb")
#unpickle dictionary file and save it to an actual dictionary object
word_dict = pickle.load(unpickled_dict)
#send dictionary objject through Pipe object to Parent process
ChildConnect.send(word_dict)
def callback(ch, method, properties, body):
project_id, tweet_id = body.decode().split()
if (tweet_id != '/t'):
client = pymongo.MongoClient(
"mongodb+srv://admin:" + urllib.parse.quote("sug@r123") +
"@cluster0-jsbm1.gcp.mongodb.net/test?retryWrites=true")
print('Database connection established.')
mydb = client["test"]
proj = mydb["projects"]
query = {"_id": ObjectId(project_id)}
project = proj.find_one(query)
tweets = project['data']
tweet = [tweet for tweet in tweets if tweet['tweetID'] == tweet_id][0]
t = tweet['tweetObject']['text']
i = tweets.index(tweet)
print(t)
print(f'-> Sending text to NN:\n\t{t}')
sentiment = evaluate(t)
print(f'-> Result:\t{sentiment}')
print(f'-> Updating database entry')
update_result = proj.update_one(
{'_id': ObjectId(project_id)},
{"$set": {
"data." + str(i) + ".tweetSentiment": sentiment
}},
upsert=False)
print(f'-> Matched {update_result.matched_count} doc, '
f'modified {update_result.modified_count} doc.')
client.close()
s = Sender()
s.open_conn()
s.send_message(f'{project_id} {tweet_id}')
s.close_conn()
import config
import strings
from send import Sender
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "settings")
from django.core.wsgi import get_wsgi_application
application = get_wsgi_application()
from db.models import TelegramUser, Settings
from django.db.models import ObjectDoesNotExist
bot = AsyncTeleBot(config.BOT_TOKEN, num_threads=4)
sender = Sender(bot)
def update_user(msg: ttypes.Message):
try:
user = TelegramUser.objects.get(user_id=msg.from_user.id)
user.first_name = msg.from_user.first_name
user.last_name = msg.from_user.last_name
user.username = msg.from_user.username
except ObjectDoesNotExist:
user = TelegramUser.objects.create(user_id=msg.from_user.id,
first_name=msg.from_user.first_name,
last_name=msg.from_user.last_name,
username=msg.from_user.username)
user.save()
pointer_to_log = open('worker_log_14.txt', 'a')
new_receiver = Receiver()
new_receiver.receive_txt(5000, '10.100.0.14', '10.100.0.13', 'book_from_13')
fp_to_book = open("book_from_13", "r")
wordcount = defaultdict(int)
for word in fp_to_book.read().split():
wordcount[word] += 1
pickle_out = open("dict_pickle", "wb")
pickle.dump(wordcount, pickle_out)
pickle_out.close()
new_sender = Sender()
new_sender.send_txt(5001, '10.100.0.14', 'dict_pickle')
end_time = int(time.time() * 1000000)
pointer_to_temp_log = open('temp.txt', 'r')
start_time = int(pointer_to_temp_log.readline())
total_compute_time_ms = str(end_time - start_time)
pointer_to_log.write("Total Worker Computation Time (In Microseconds): " +
total_compute_time_ms + '\n')
pointer_to_log.close()
pointer_to_temp_log.close()
from aiogram import Bot, Dispatcher, types, filters, exceptions
from aiogram.utils.executor import start_webhook
import analytics
import strings
from filters import CallbackDataRegExFilter, InlineQueryRegExFilter, IsTextMessageFilter
from config import Config
from flibusta_server import BookAPI
from send import Sender
from db import TelegramUserDB, SettingsDB, prepare_db
from utils import ignore, make_settings_keyboard, make_settings_lang_keyboard, download_by_series_keyboard, beta_testing_keyboard
bot = Bot(token=Config.BOT_TOKEN)
dp = Dispatcher(bot)
Sender.configure(bot)
@dp.message_handler(commands=["start"])
@ignore((exceptions.BotBlocked, exceptions.BadRequest))
async def start_handler(msg: types.Message):
await TelegramUserDB.create_or_update(msg)
try:
await analytics.analyze(msg.text, "get_shared_book", msg.from_user.id)
file_type, book_id = (msg["text"].split(' ')[1].split("_"))
await Sender.send_book(msg, int(book_id), file_type)
except (ValueError, IndexError):
await analytics.analyze(msg.text, "start", msg.from_user.id)
await msg.reply(
strings.start_message.format(name=msg.from_user.first_name))
def __init__(self, config):
self._sender = Sender(config)
self._mgr = MemberMgr(config)
self._store = Store(config)
self._cfg = config
self._manifest = json.load(open('manifest.json'))
#!/usr/bin/python3
# murmur - manual control functions
# 6/18/18
# updated: 6/18/18
import time
from send import NodeMessage, Sender
sender = Sender('debug')
host_arm_map = {
'murmur01': ['A', 'B', 'C'],
'murmur02': ['D', 'E', 'F'],
'murmur03': ['G', 'H', 'J'],
'murmur04': ['K', 'L', 'M']
}
def get_host_by_arm(arm):
for host in host_arm_map:
if arm in host_arm_map[host]:
return host
def _listify(arms):
return [arms] if type(arms) is not list else arms
def _move_mids(arms, direction=None):
if not direction or direction not in ['raise', 'drop']:
print('please specify a valid direction')
return