def test_find_metrics(input, input2, expected):
from server import find_metrics
p = LogIn(username='******')
p.save()
p = UserData(username='******',
image_name=["a.png", "b.png"],
image=["imageA", "imageB"],
processing_time=["0.5s", "0.2s"],
image_size=["400x200", "300x300"],
hist_data=["histA", "histB"],
upload_date=["2019/12/8", "2019/12/9"])
p.save()
p = LogIn(username='******')
p.save()
p = UserData(username='******',
image_name=["a.jpg", "a_hist.jpg"],
image=["imageA", "histA"],
processing_time=["0.3s", "0.4s"],
image_size=["400x100", "200x200"],
hist_data=["histA", "histhistA"],
upload_date=["2019/12/1", "2019/12/2"])
p.save()
result = find_metrics(input, input2)
assert result == expected
UserData.objects.raw({"_id": "1"}).delete()
UserData.objects.raw({"_id": "2"}).delete()
LogIn.objects.raw({"_id": "1"}).delete()
LogIn.objects.raw({"_id": "2"}).delete()
def __init__(self, connection, replayMode=False, enableLog=True):
super().__init__()
self.internalHandlerLookup = {}
self.mavStatus = {MavStsKeys.AP_SYS_ID: 1}
self.isConnected = False
# self.paramList = []
self.paramPanel = None
self.txLock = QMutex() # uplink lock
self.txResponseCond = QWaitCondition()
self.txTimeoutTimer = QTimer()
self.finalWPSent = False
self.wpLoader = MAVWPLoader()
self.onboardWPCount = 0
self.numberOfonboardWP = 0
self.onboardWP = []
self.mavlinkLogFile = None
self.lastMessageReceivedTimestamp = 0.0
self.lastMessages = {} # type = (msg, timestamp)
self.param = UserData.getInstance().getUserDataEntry(
UD_TELEMETRY_KEY, {})
self.messageTimeoutThreshold = UserData.getParameterValue(
self.param, UD_TELEMETRY_TIMEOUT_THRESHOLD_KEY,
MAVLinkConnection.DEFAULT_MESSAGE_TIMEOUT_THRESHOLD)
self.txTimeoutmsec = self.messageTimeoutThreshold * 1000000
# timeout for wait initial heartbeat signal
self.initHeartbeatTimeout = UserData.getParameterValue(
self.param, UD_TELEMETRY_HEARTBEAT_TIMEOUT_KEY,
MAVLinkConnection.DEFAULT_HEARTBEAT_TIMEOUT)
self.txMessageQueue = deque()
self.running = True
self.connection = connection
self.replayMode = replayMode
self.enableLog = enableLog
self.uas = None
if replayMode:
self.enableLog = False
connection.replayCompleteSignal.connect(self.requestExit)
self.internalHandlerLookup[
'PARAM_VALUE'] = self.receiveOnboardParameter
self.internalHandlerLookup[
'MISSION_REQUEST'] = self.receiveMissionRequest
self.internalHandlerLookup[
'MISSION_ACK'] = self.receiveMissionAcknowledge
self.internalHandlerLookup[
'MISSION_COUNT'] = self.receiveMissionItemCount
self.internalHandlerLookup['MISSION_ITEM'] = self.receiveMissionItem
self.internalHandlerLookup['DATA_STREAM'] = self.receiveDataStream
self.internalHandlerLookup['PARAM_SET'] = self.receiveParameterSet
self.txTimeoutTimer.timeout.connect(self._timerTimeout)
self.txTimeoutTimer.setSingleShot(True)
def test_is_image_present(stored_username, stored_img_name, username, img_name,
expected):
from server import is_image_present
user = LogIn(username=stored_username)
user.save()
user_data = UserData(username=user, image_name=[stored_img_name])
user_data.save()
value = is_image_present(username, img_name)
assert expected == value
UserData.objects.raw({"_id": stored_username}).delete()
LogIn.objects.raw({"_id": stored_username}).delete()
def submit_info(self, instance):
# Get all of the values from input
popup = Popup(
title='Submission Successful!',
content=Button(
text='Application successfully stored. Click to close!'),
size_hint=(None, None),
size=(400, 400))
popup.open()
popup.content.bind(on_press=popup.dismiss)
# Retrieve Data
position = self.posInput.text
company = self.companyInput.text
notified = self.NotifiedInput.text
interview = self.InterviewInput.text
accepted = self.AcceptedInput.text
self.userData = UserData(position, company, notified, interview,
accepted)
# Insert to database
db.insertDB(self.userData)
# Clear text inputs
self.posInput.text = ''
self.companyInput.text = ''
self.NotifiedInput.text = ''
self.InterviewInput.text = ''
self.AcceptedInput.text = ''
def test_is_first_upload(stored_username, username, expected):
from server import is_first_upload
user = LogIn(username=stored_username)
user.save()
user_data = UserData(username=user,
image_name=['.'],
image=['.'],
processing_time=['.'],
image_size=['.'],
hist_data=['.'],
upload_date=['.'])
user_data.save()
value = is_first_upload(username)
assert expected == value
UserData.objects.raw({"_id": stored_username}).delete()
LogIn.objects.raw({"_id": stored_username}).delete()
def __init__(self, title, parent = None):
super().__init__(Qt.Horizontal, parent)
self.param = UserData.getInstance().getUserDataEntry(UD_PLOTTER_WINDOW_KEY, {})
self.setWindowTitle(title)
self.plotMessages = {
'RAW_IMU' : None,
'SCALED_IMU' : None,
'GPS_RAW_INT' : None,
'ATTITUDE' : None,
'SCALED_PRESSURE' : None
}
self.chart = PlotterPanel()
self.chartView = QChartView(self.chart)
self.chartView.setRenderHint(QPainter.Antialiasing)
self.plotControl = PlotItemMenu()
self.plotControl.plotDataSignal.connect(self.chart.toggleDataVisibility)
spLeft = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
spLeft.setHorizontalStretch(1)
self.plotControl.setSizePolicy(spLeft)
spRight = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
spRight.setHorizontalStretch(6)
self.chartView.setSizePolicy(spRight)
self.addWidget(self.plotControl)
self.addWidget(self.chartView)
if UD_PLOTTER_WINDOW_HEIGHT_KEY in self.param and UD_PLOTTER_WINDOW_WIDTH_KEY in self.param:
self.resize(self.param[UD_PLOTTER_WINDOW_WIDTH_KEY], self.param[UD_PLOTTER_WINDOW_HEIGHT_KEY])
def start_session(self):
if self.online:
print('Hi, this program will ask you to enter the data you want ' +
'encrypted and then give it to you encrypted.')
username = raw_input('Please enter your username: '******'Please enter your password: '******'Please enter the data that you want encrypted: ')
user_data = UserData(inputted_text, user)
encrypter = Encrypter(user_data)
encrypted_string = encrypter.encrypt()
key = encrypter.get_key()
encrypted_data = EncryptedData(encrypted_string, user, key)
print('Your encrypted data is: ' + encrypted_data.get_data())
print('The key for your encrypted data is: ' +
encrypted_data.get_key())
decrypter = Decrypter(encrypted_data, key)
print('Here is the decrypted data: ')
print(decrypter.decrypt())
def perform_encrypt(self):
self.file_name = self.entry.get()
reader = FileReader(self.file_name)
string_info = reader.read_file()
user_data = UserData(string_info, self.user1)
self.e = Encrypter(user_data)
key = self.e.get_key()
self.encrypted_data = EncryptedData(self.e.encrypt(), self.user1, key)
reader.write_to_file(self.encrypted_data.get_data())
def SelectUserProg(self):#отработка нажатия кнопки пользовательская программа
sender=self.sender()
name = sender.objectName()
point=name[1]
self.point=int(point)
if self.point==1 and self.Line_65 == 0:
self.clear_buttons(self.point)
sender.setStyleSheet(metrocss.prog_active)
self.AskWindow=UserData(self.user_data_signal, self)
self.AskWindow.show()
self.AskWindow.move(313, 195)
if self.point==2 and self.Line_35 == 0:
self.clear_buttons(self.point)
sender.setStyleSheet(metrocss.prog_active)
self.AskWindow=UserData(self.user_data_signal, self)
self.AskWindow.show()
self.AskWindow.move(313, 195)
def __init__(self): self.completedTransactions = dict() self.plannedTransactions = None self.categories = dict() self.sortingAgent = SortingAgent() self.excelManager = ExcelManager() self.csvAgent = CSVAgent() self.transactionFactory = TransactionFactory() self.plottingDataFactory = PlottingDataFactory() self.userData = UserData()
def main():
user = User('alex10gauthier', 'password99')
user_data = UserData('My name is Alex Gauthier', user)
encrypter = Encrypter(user_data)
encrypted_string = encrypter.encrypt()
key = encrypter.get_key()
encrypted_data = EncryptedData(encrypted_string, user, key)
decrypter = Decrypter(encrypted_data)
print(decrypter.decrypt())
def test_inverted_image_upload(username, filepath, expected):
from server import inverted_image_upload
user = LogIn(username=username)
user.save()
user_data = UserData(username=user,
image_name=['.'],
image=['.'],
processing_time=['.'],
image_size=['.'],
hist_data=['.'],
upload_date=['.'])
user_data.save()
inverted_image_upload(username, filepath)
users = UserData.objects.raw({"_id": username})
stored_name = ''
for user in users:
stored_name = user.image_name
assert expected == stored_name[1]
UserData.objects.raw({"_id": username}).delete()
LogIn.objects.raw({"_id": username}).delete()
def get_user_data():
import base64
from flask import request
import pickle
from UserData import UserData
if "data" not in request.cookies:
return UserData()
else:
user = pickle.loads(base64.b64decode(request.cookies["data"]))
return user
def __init__(self, parent):
super().__init__(parent)
self.instrumentOpagueBackground = QBrush(
QColor.fromHsvF(0, 0, 0.3, 1.0))
self.instrumentBackground = QBrush(QColor.fromHsvF(0, 0, 0.3, 0.3))
self.instrumentEdgePen = QPen(QColor.fromHsvF(0, 0, 0.65, 0.5))
self.font = QFont()
self.lineWidth = 2
self.fineLineWidth = 1
self.navigationTargetBearing = PrimaryFlightDisplay.UNKNOWN_ATTITUDE
self.navigationCrosstrackError = 0
self.primaryAltitude = PrimaryFlightDisplay.UNKNOWN_ALTITUDE
self.GPSAltitude = PrimaryFlightDisplay.UNKNOWN_ALTITUDE
self.verticalVelocity = PrimaryFlightDisplay.UNKNOWN_ALTITUDE
self.primarySpeed = PrimaryFlightDisplay.UNKNOWN_SPEED
self.groundspeed = PrimaryFlightDisplay.UNKNOWN_SPEED
self.roll = 0.0
self.pitch = 0.0
self.yaw = 0.0
self.rollspeed = 0.0
self.pitchspeed = 0.0
self.yawspeed = 0.0
self.latitude = 0.0
self.longitude = 0.0
self.additionalParameters = {}
self.param = UserData.getInstance().getUserDataEntry(UD_PFD_KEY, {})
self.isGPSSpeedPrimary = UserData.getParameterValue(
self.param, UD_PFD_PRIMARY_SPEED_SOURCE_KEY) == 'GPS'
self.isGPSAltitudePrimary = UserData.getParameterValue(
self.param, UD_PFD_PRIMARY_ALTITUDE_SOURCE_KEY) == 'GPS'
self.setMinimumSize(480, 320)
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.smallTestSize = self.SMALL_TEXT_SIZE
self.mediumTextSize = self.MEDIUM_TEXT_SIZE
self.largeTextSize = self.LARGE_TEXT_SIZE
self.uiTimer = QTimer(self)
self.uiTimer.setInterval(40)
self.uiTimer.timeout.connect(self.update)
self.uas = None
def __init__(self, parent=None):
super().__init__(parent)
self.mav = None
self.param = UserData.getInstance().getUserDataEntry(
UD_MAIN_WINDOW_KEY, {})
current_path = os.path.abspath(os.path.dirname(__file__))
qmlFile = os.path.join(current_path, './instruments/map.qml')
self.setWindowTitle('Mini GCS')
if UD_MAIN_WINDOW_HEIGHT_KEY in self.param and UD_MAIN_WINDOW_WIDTH_KEY in self.param:
self.resize(self.param[UD_MAIN_WINDOW_WIDTH_KEY],
self.param[UD_MAIN_WINDOW_HEIGHT_KEY])
self.teleWindow = ConnectionEditWindow()
self.teleWindow.MAVLinkConnectedSignal.connect(self.createConnection)
self.window = QSplitter()
self.left = QSplitter(Qt.Vertical, self.window)
self.pfd = PrimaryFlightDisplay(self.window)
self.sts = SystemStatusPanel(self.window)
self.msgSignWindow = MessageSigningSetupWindow()
self.hudWindow = HUDWindow()
self.hud = self.hudWindow.hud
self.sts.connectToMAVLink.connect(self.teleWindow.show)
self.sts.disconnectFromMAVLink.connect(self.disconnect)
spPfd = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
spPfd.setVerticalStretch(3)
self.pfd.setSizePolicy(spPfd)
spSts = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
spSts.setVerticalStretch(2)
self.sts.setSizePolicy(spSts)
self.left.addWidget(self.pfd)
self.left.addWidget(self.sts)
spLeft = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
spLeft.setHorizontalStretch(2)
self.left.setSizePolicy(spLeft)
self.map = MapWidget(qmlFile)
spRight = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
spRight.setHorizontalStretch(5)
self.map.setSizePolicy(spRight)
self.window.addWidget(self.left)
self.window.addWidget(self.map)
self.localGPSWindow = GPSConfigurationWindow()
# TODO configurable behavior
self.localGPSWindow.connection.locationUpdate.connect(
self.map.updateHomeLocationEvent)
self.sts.connectToLocalGPS.connect(self.localGPSWindow.show)
self.sts.disconnectFromLocalGPS.connect(
self.localGPSWindow.connection.disconnect)
self.sts.statusPanel.showHUDButton.clicked.connect(self.hudWindow.show)
self.teleWindow.cancelConnectionSignal.connect(
lambda: self.sts.statusPanel.connectButton.setEnabled(True))
self.__createMenus()
self.setCentralWidget(self.window)
def closeEvent(self, event):
print('[MAIN] closeEvent')
ud = UserData.getInstance()
s = self.size()
self.param[UD_MAIN_WINDOW_HEIGHT_KEY] = s.height()
self.param[UD_MAIN_WINDOW_WIDTH_KEY] = s.width()
ud.setUserDataEntry(UD_MAIN_WINDOW_KEY, self.param)
try:
ud.saveGCSConfiguration()
print('GCS Conf saved.')
except IOError:
pass
super().closeEvent(event)
def initialize_keypaths(base_keypath: str, base_datapath: str):
# check if the keypath and datapaths exist, if not create a new directory to match
if not os.path.exists(base_keypath):
logger.warning(
f"base_keypath {base_keypath} does not exist. Creating directory")
os.makedirs(base_keypath)
if not os.path.exists(base_datapath):
logger.warning(
f"base_datapath {base_datapath} does not exist. Creating directory"
)
os.makedirs(base_datapath)
# initialize output dict
output: Dict[str, UserData] = {}
# keys and databases are filenames of the form username.extension and should match
# i.e for every username.db there is a username.key
keys: List[str] = [
filename for filename in os.listdir(base_keypath)
if filename.split('.')[-1] == "key"
]
databases: List[str] = [
filename for filename in os.listdir(base_datapath)
if filename.split('.')[-1] == "db"
]
# if the above constraint is met then the two lists of paths should be the same length
if len(databases) != len(keys):
raise ValueError("Keys and databases out of sync")
# for each username in the keys list there should be a matching db file, if not then an error is raised
for key in keys:
if '.'.join([key.split('.')[0], "db"]) not in databases:
raise ValueError("Keys and databases out of sync ")
# now that we know keys and databases represent the same users and are in sync
# we can build our output paths using the usernames and known extensions
# each entry of output should look like this
# mycicle: UserData({
# keypath: /home/mycicle/.secrets_manager/keys/mycicle.key
# datapath: /home/mycicle/.secrets_manager/data/mycicle.data
# })
# the path should update to the correct "home" directory for the user's OS
# and the "/" should be properly replaced with a "\" on Windows
for key in keys:
username: str = key.split('.')[0]
output[username] = UserData(
join(base_keypath, key),
join(base_datapath, '.'.join([username, "db"])))
return output
def read(self):
self._file_contents = open(self._file_name, 'rb')
self._user_data = UserData(self._file_contents)
if not self._user_data.read():
return False
print self._user_data
self._archive_header = ArchiveHeader(self._file_contents, self._user_data)
if not self._archive_header.read():
return False
print self._archive_header
self._block_table = BlockTable(self._file_contents, self._archive_header, self)
self._block_table.read()
print self._block_table
def main():
exl = ExcelHandler()
wb = exl.open_workbook("products.xlsx")
exl.assign_sheets(wb)
diet = DietManager()
usrData = UserData()
usrData.set_parameters("Piotrek", "male", 21, 82, 185)
usrData.write_to_file()
print(diet.calculate_bmi(usrData))
print(diet.calculate_limit(usrData))
diet.what_you_ate_today("banan", 300, exl, usrData)
def __init__(self, name, parent=None):
super().__init__(parent)
self.uasName = name
self.autopilotClass = mavlink.MAV_AUTOPILOT_GENERIC
self.param = UserData.getInstance().getUserDataEntry(
UD_UAS_CONF_KEY, {})
self.onboardParameters = []
self.oldOnboardParameters = []
self.onboardParamNotReceived = 0
self.messageHandlers = {}
self.messageHandlers['SYS_STATUS'] = self.uasStatusHandler
self.messageHandlers['GPS_RAW_INT'] = self.uasLocationHandler
self.messageHandlers[
'GLOBAL_POSITION_INT'] = self.uasFilteredLocationHandler
self.messageHandlers['SCALED_PRESSURE'] = self.uasAltitudeHandler
self.messageHandlers['ATTITUDE'] = self.uasAttitudeHandler
self.messageHandlers['GPS_STATUS'] = self.uasGPSStatusHandler
self.messageHandlers['RADIO_STATUS'] = self.uasRadioStatusHandler
self.messageHandlers['RC_CHANNELS'] = self.uasRCChannelsHandler
self.messageHandlers[
'NAV_CONTROLLER_OUTPUT'] = self.uasNavigationControllerOutputHandler
self.messageHandlers[
'LOCAL_POSITION_NED'] = self.uasDefaultMessageHandler
self.messageHandlers['PARAM_VALUE'] = self.uasDefaultMessageHandler
self.messageHandlers['HEARTBEAT'] = self.uasDefaultMessageHandler
self.messageHandlers[
'ATTITUDE_QUATERNION'] = self.uasDefaultMessageHandler
self.messageHandlers['SYSTEM_TIME'] = self.uasDefaultMessageHandler
self.messageHandlers['VFR_HUD'] = self.uasDefaultMessageHandler
self.messageHandlers[
'AUTOPILOT_VERSION'] = self.uasDefaultMessageHandler
self.messageHandlers['BATTERY_STATUS'] = self.uasDefaultMessageHandler
self.messageHandlers['SCALED_IMU'] = self.uasDefaultMessageHandler
self.messageHandlers['RAW_IMU'] = self.uasDefaultMessageHandler
self.altitudeReference = DEFAULT_ALTITUDE_REFERENCE
self.pressureReference = DEFAULT_PRESSURE_REFERENCE
self.signingKey = None
self.initialTimestamp = 0
print(channel_secret, file=sys.stderr)
print(channel_access_token, file=sys.stderr)
line_bot_api = LineBotApi(channel_access_token)
handler = WebhookHandler(channel_secret)
static_tmp_path = os.path.join(os.path.dirname(__file__), 'static', 'tmp')
# ========================= whisper独自のフィールド ========================
from UserData import UserData
from PlantAnimator import PlantAnimator
from beaconWhisperEvent import BeaconWhisperEvent
from datetime import datetime
user_data = UserData()
current_plant = ""
plant_animator = PlantAnimator(user_data)
# =========================================================================
# function for create tmp dir for download content
def make_static_tmp_dir():
try:
os.makedirs(static_tmp_path)
except OSError as exc:
if exc.errno == errno.EEXIST and os.path.isdir(static_tmp_path):
pass
else:
"""
Created by Soumya Ranjan Rout on 6/15/2018
"""
from UserData import UserData as Atm
from collections import namedtuple
data_object = Atm()
input = data_object.get_user_details()
error_message_for_account_validation = "ACCOUNT_ERR"
error_message_for_funds_unavailability = "FUNDS_ERR "
error_message_for_out_of_cash = "ATM_ERR"
total_atm_cash = [int(input.pop(0)[0])]
def process_input(data):
"""
Creating diffrent namedtuples for all user session
:param data: ATM user data file
"""
for atm_data in data:
atm_number, correct_pin, entered_pin = set_atm_number_pin(atm_data[0])
balance, overdraft = set_balance_overdradt(atm_data[1])
Session = namedtuple(
'Session', 'atm_number correct_pin entered_pin balance overdraft')
session = Session(atm_number, correct_pin, entered_pin, balance,
overdraft)
set_transaction(atm_data[2:], session)
def set_atm_number_pin(atm_number_pin):
"""
def original_upload(username, filepath):
"""Performs encoding and uploads to database along with associated data
metrics (upload time, processing time, histogram, size). Checks to see
if username is already associated with a UserData document and uploads
accordingly.
Args:
username (str): username to upload to in database
filepath (str): filepath of image to be processed and encoded
Returns:
None
"""
# Read original image from filepath
image = skimage.io.imread(filepath)
# Process image and encode it.
start_time = time.time()
image_encode = encode_array(image)
processing_time = str(time.time() - start_time)
# Create image name
image_name = img_name_from_filepath(filepath, "_original")
# Calc image size
image_size = get_num_pixels(image)
# Get date and time
upload_date = datetime.now().strftime("%Y-%m-%d %H:%M:%S:%f")
# Calc histogram data. Produces {"red": ndarray, "green....}
# Use each color spectrum for analysis via processing, then
# concatenate back together with img = np.dstack(red, green, blue)
hist_data = pixel_histogram(image)
hist_encode = encode_dict(hist_data)
# Check if previous images exist
if is_first_upload(username):
# If first upload, create document
user = UserData(username=username,
image_name=[image_name],
image=[image_encode],
processing_time=[processing_time],
image_size=[image_size],
hist_data=[hist_encode],
upload_date=[upload_date])
user.save()
else:
# Save image to database
UserData.objects.raw({
"_id": username
}).update({
"$push": {
"image_name": image_name,
"image": image_encode,
"processing_time": processing_time,
"image_size": image_size,
"hist_data": hist_encode,
"upload_date": upload_date
}
})
return
def main():
# Menu
trybun = Trybun()
dictation = Dictation()
trybun.say_something("Witaj w Dajet. Aut. Laud.")
usrData = UserData()
usrData.remove_data_from_file()
dm = DietManager()
sarmata = SarmataVoiceRecognition()
sarmata_numbers = SarmataVoiceRecognitionNumbers()
open_date = datetime.datetime.now().strftime("%Y-%m-%d")
dm.fm.write_date_to_file(open_date, "open_date.txt")
while True:
data, is_something = usrData.read_from_file()
if is_something == True:
usrData.set_params_from_file(data)
trybun.say_something(
"Witaj, %s. wybierz jedną z opcji. liczenie kalorii. liczenie BEEMI. dzienne zapotrzebowanie. ile już zjadłeś. lub wyjście z programu"
% data['name'])
# 1, 2 lub 3
res_semantic_interpretation = sarmata.menu_choice_recognition(
"grammars/menu.abnf")
#res_semantic_interpretation = '5'
if res_semantic_interpretation == '1':
trybun.say_something("Wybrałeś opcję. Liczenie Kalorii.")
while True:
# podawanie produktu
trybun.say_something("podaj nazwę produktu")
produkt = dictation.dictation_recognize()
trybun.say_something("podaj wagę produktu w gramach")
waga = sarmata_numbers.menu_choice_recognition(
"grammars/numbers.abnf")
waga = int(waga)
if waga == -1:
trybun.say_something("Spróbuj jeszcze raz.")
continue
error_result = dm.what_you_ate_today(
produkt, waga, usrData, trybun)
if error_result == -1:
trybun.say_something("Spróbuj jeszcze raz.")
continue
# dodawanie kolejnego produktu albo wracanie, na tak lub nie ----------------------
trybun.say_something(
"Chcesz dodać kolejny produkt, czy wrócić do menu głownego?"
)
res_semantic_interpretation = sarmata.menu_choice_recognition(
"grammars/next_product.abnf")
if res_semantic_interpretation == '1':
continue
# jak ktoś powie głupotę to i tak do menu
elif res_semantic_interpretation == '2':
break
else:
break
elif res_semantic_interpretation == '2':
trybun.say_something("Wybrałeś opcje. Liczenie beemi")
bmi = dm.calculate_bmi(usrData)
trybun.say_something("Twoje beemi wynosi %s" % bmi)
continue
elif res_semantic_interpretation == '3':
trybun.say_something("Wybrałeś opcję. Dzienne zapotrzebowanie")
limit = dm.calculate_limit(usrData)
trybun.say_something("Twój dzienny limit kalorii wynosi %s" %
limit)
continue
elif res_semantic_interpretation == '4':
dm.get_today(trybun, usrData)
continue
elif res_semantic_interpretation == '5':
trybun.say_something("Do widzenia %s" % data['name'])
break
else:
trybun.say_something("Spróbuj jeszcze raz!")
continue
else:
trybun.say_something("Podaj swoje dane.")
while True:
trybun.say_something("Jak masz na imię?.")
reco = dictation.dictation_recognize()
if reco == -1:
continue
trybun.say_something("Spróbuj jeszcze raz")
else:
name = reco
break
while True:
trybun.say_something("Podaj płeć.")
res_semantic_interpretation_gender = sarmata.menu_choice_recognition(
"grammars/gender.abnf")
if res_semantic_interpretation_gender == -1:
trybun.say_something("Spróbuj jeszcze raz")
continue
else:
gender = res_semantic_interpretation_gender
break
while True:
trybun.say_something("Ile masz lat?")
reco = sarmata_numbers.menu_choice_recognition(
"grammars/numbers.abnf")
if reco == -1:
trybun.say_something("Spróbuj jeszcze raz")
continue
else:
age = reco
break
while True:
trybun.say_something("Ile ważysz?")
reco = sarmata_numbers.menu_choice_recognition(
"grammars/numbers.abnf")
if reco == -1:
trybun.say_something("Spróbuj jeszcze raz")
continue
else:
weight = reco
break
while True:
trybun.say_something("Ile masz wzrostu w centymetrach?")
reco = sarmata_numbers.menu_choice_recognition(
"grammars/numbers.abnf")
if reco == -1:
trybun.say_something("Spróbuj jeszcze raz")
continue
else:
height = reco
break
# setData
usrData.set_parameters(name, gender, age, weight, height)
usrData.write_to_file()
'train': transforms.Compose([
transforms.RandomResizedCrop (224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
]),
'val': transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
]),
}
dsets = {x: UserData(img_path=data_dir,
txt_path=(label_txt + x + '.txt'),
data_transforms=data_transforms,
dataset=x) for x in ['test', 'train']}
dset_loaders = {x: torch.utils.data.DataLoader(dsets[x], batch_size=10,
shuffle=True, num_workers=25)#num_workers 用多少个子进程加载数据,这里用了25个子进程
for x in ['test', 'train']}
data_loader_train=dset_loaders['test']
data_loader_test=dset_loaders['train']
def image_visible():
images, labels = next(iter(data_loader_train))#得到一个所有地images和label的列表
print("one batch dim:", images.size())
# for i, (images, labels) in enumerate(data_loader_train):
img = utils.make_grid(images[0:4]) # 绘制四个
# 如果要使用matplotlib显示图片，必须将(channel,height,weight)转换为(height,weight,channel)
img=img.numpy().transpose(1,2,0)
mean=[0.485, 0.456, 0.406]
std=[0.229, 0.224, 0.225]
#!/usr/bin/env python3
import base64
import functools
import os
import pickle
import requests
import flask
from UserData import UserData
cookies = {"data": base64.b64encode(pickle.dumps(UserData())).decode()}
response = requests.get("http://localhost:6001/", cookies=cookies)
response = requests.get("http://localhost:6001/solve")
print(response.text)
def get_jwt(self,user_position_in_list):
if(self.password_match):
user_data = UserData(user_position_in_list)
print('===========>>>>',user_data.getUserData())
jwt = CreateJwt(user_data.getUserData())
return jwt.jwt_created()
self.mav.connection.WIRE_PROTOCOL_VERSION)
self.mav.start()
def disconnect(self):
self.mav.requestExit()
def closeEvent(self, event):
print('[MAIN] closeEvent')
ud = UserData.getInstance()
s = self.size()
self.param[UD_MAIN_WINDOW_HEIGHT_KEY] = s.height()
self.param[UD_MAIN_WINDOW_WIDTH_KEY] = s.width()
ud.setUserDataEntry(UD_MAIN_WINDOW_KEY, self.param)
try:
ud.saveGCSConfiguration()
print('GCS Conf saved.')
except IOError:
pass
super().closeEvent(event)
if __name__ == '__main__':
app = QApplication(sys.argv)
try:
UserData.getInstance().loadGCSConfiguration()
except IOError:
sys.exit(1)
frame = MiniGCS()
frame.show()
sys.exit(app.exec_())
def main():
user = User('alex10gauthier', 'password99')
user_data = UserData('My name is Alex Gauthier', user)
encrypt = Encrypter(user_data)
print(encrypt.encrypt())
async def play_game(message):
print("{} play game".format(message.chat.username))
user_data = UserData(message.chat.id)
print(user_data.get_count_answers())
if user_data.get_count_answers() != 0:
db_worker = SQLither(config.database_name)
db_worker.insert_answer(message.chat.id, user_data.get_question_id(), message.text)
db_worker.update_last_activity(message.chat.id, time.time())
db_worker.close()
if user_data.get_count_answers() >= Questions.get_questions_limit():
markup = types.ReplyKeyboardMarkup(one_time_keyboard=False, resize_keyboard=True)
markup.add(string_worker.get_yes_button())
markup.add(string_worker.get_no_button())
await send_message(message.chat.id, string_worker.get_ask_feedback(), reply_markup=markup)
user_data.delete()
return
next_question_id = Questions.get_next_random_question_id(user_data.get_answers_id())
user_data.set_question_id(next_question_id)
question_text = Questions.get_question(next_question_id)
if Questions.is_time_to_praise(user_data.get_count_answers()):
await send_message(message.chat.id, string_worker.get_praise(user_data.get_count_answers()))
user_data.save()
await send_message(message.chat.id, "<b>{}.</b> {}".format(user_data.get_count_answers(), question_text), parse_mode='HTML')
if Questions.is_gif_time(user_data.get_count_answers()):
await asyncio.sleep(10)
await bot.send_chat_action(message.chat.id, 'upload_video')
await asyncio.sleep(5)
await bot.send_video(message.chat.id, config.pic_begin_game)
class ReplayReader(object):
"""Takes responsibility for reading the entire replay.
Also implements some general use algorithms.
"""
def __init__(self, file_name):
self._file_name = file_name
self._user_data = None
self._archive_header = None
self._block_table = None
self._file_contents = None
self._crypt_table = range(0x500)
self.create_crypt_table()
def read(self):
self._file_contents = open(self._file_name, 'rb')
self._user_data = UserData(self._file_contents)
if not self._user_data.read():
return False
print self._user_data
self._archive_header = ArchiveHeader(self._file_contents, self._user_data)
if not self._archive_header.read():
return False
print self._archive_header
self._block_table = BlockTable(self._file_contents, self._archive_header, self)
self._block_table.read()
print self._block_table
def create_crypt_table(self):
seed = 0x00100001
for index1 in range(0x100):
index2 = index1
for i in range(5):
seed = (seed * 125 + 3) % 0x2AAAAB
temp1 = (seed & 0xFFFF) << 0x10
seed = (seed * 125 + 3) % 0x2AAAAB
temp2 = seed & 0xFFFF
self._crypt_table[index2] = (temp1 | temp2)
index2 += 0x100
def decrypt(self, data_block, length, key):
"""in place, length is in bytes, key is an int"""
seed = 0xEEEEEEEE
# round to int32's
# If the data isn't a multiple of int32s, then the remaining bytes will
# not get decrypted.
length >>= 2
data_block_index = 0
accumulator = StringIO.StringIO()
while(length > 0):
length -= 1
seed += self._crypt_table[0x400 + (key & 0xFF)]
ch = unpack('=I', data_block[data_block_index:data_block_index + 4])[0] ^ ((key + seed) & 0xFFFFFFFF)
key = ((((~key << 0x15) & 0xFFFFFFFF) + 0x11111111) & 0xFFFFFFFF) | (key >> 0x0B)
seed = (ch + seed + (seed << 5) + 3) & 0xFFFFFFFF
accumulator.write(pack("=I", ch))
data_block_index += 4
return accumulator.getvalue()
def hash(self, name, hash_type):
seed1 = 0x7FED7FED
seed2 = 0xEEEEEEEE
for ch in name:
ch = ord(ch.upper())
seed1 = self._crypt_table[(hash_type << 8) + ch] ^ (seed1 + seed2) & 0xFFFFFFFF
seed2 = ch + seed1 + seed2 + (seed2 << 5) + 3 & 0xFFFFFFFF
return seed1
from UserData import UserData
from Ratings import Ratings
from Movies import Movies
import os
if __name__ == '__main__':
root_path = 'C:\Users\p\Documents'
input_files_path = os.path.join(root_path, 'PycharmProjects\SocialCommunicationNetworks\ml-1m')
output_files_path = os.path.join(root_path, 'PycharmProjects\SocialCommunicationNetworks\ml-1m\output')
userdata = UserData(input_files_path, output_files_path)
userdata.prepare_user_data()
movies = Movies(input_files_path, output_files_path)
movies.prepare_user_data()
ratings = Ratings(input_files_path, output_files_path)
ratings.prepare_user_data()
