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()