def copyFile(sourceFile, targetFile): Common.assertExit(os.path.isfile(sourceFile), "源文件不存在" + sourceFile) # 创建目标文件夹 targetDir = FileUtils.getFileDirectory(targetFile) FileUtils.createDirectory(targetDir) shutil.copy(sourceFile, targetFile)
def __init__(self, parent=None): super(MyWindow, self).__init__(parent) self.init_Ui() self.com = Common() self.title = [ u"COUNT", u"CPU(%)", u"MEM(M)", u"FPS", u"Wifi下行(KB/S)", u"Wifi上行(KB/S)", u"下载流量(MB)", u"上传流量(MB)", u"Wifi总流量(MB)", u"移动网络下行(KB/S)", u"移动网络上行(KB/S)", u"下载流量(MB)", u"上传流量(MB)", u"移动网络总流量(MB)", u"温度", "Drawcall", u"电量" ] self.excel_path = "D:\PerfReport" # self.create_excel() self.getData = 0 BufferSize = 1 #同时并发的线程数 FpsS = QSemaphore(BufferSize) # cpu并发锁 CpuS = QSemaphore(0) DrawcallS = QSemaphore(0) NetS = QSemaphore(0) MemS = QSemaphore(0) TempS = QSemaphore(0) BatteryS = QSemaphore(0) TimeS = QSemaphore(0) self.lock = {} #并发锁词典 self.lock['cpu'] = CpuS self.lock['fps'] = FpsS self.lock['drawcall'] = DrawcallS self.lock['net'] = NetS self.lock['mem'] = MemS self.lock['temp'] = TempS self.lock['battery'] = BatteryS self.lock['time'] = TimeS self.dw = Draw() self.isCollect = 0
def save_word2vec_format(self, dest, source): with tf.variable_scope('model', reuse=None): if source is VocabType.Token: vocab_size = self.word_vocab_size embedding_size = self.config.EMBEDDINGS_SIZE index = self.index_to_word var_name = 'WORDS_VOCAB' elif source is VocabType.Target: vocab_size = self.target_word_vocab_size embedding_size = self.config.EMBEDDINGS_SIZE * 3 index = self.index_to_target_word var_name = 'TARGET_WORDS_VOCAB' else: raise ValueError( 'vocab type should be VocabType.Token or VocabType.Target.' ) embeddings = tf.get_variable(var_name, shape=(vocab_size + 1, embedding_size), dtype=tf.float32, trainable=False) self.saver = tf.train.Saver() self.load_model(self.sess) np_embeddings = self.sess.run(embeddings) with open(dest, 'w') as words_file: Common.save_word2vec_file(words_file, vocab_size, embedding_size, index, np_embeddings)
def handle_menu(user): ''' Allows to choose an action to perform. ''' options = ['View grades', "Submit an assignment", 'View attandence'] while True: Ui.print_message(('\n...:::Logged in as {}:::...\n').format(user)) Ui.print_menu("What do you want to do?", options, 'Exit') inputs = Ui.get_inputs(["Please enter a number: "], "") option = inputs[0] if option == '1': StudentMenu.show_grades(user) elif option == '2': os.system('clear') user.submit_assignment() elif option == '3': StudentMenu.show_attendance(user) elif option == '0': Common.write_submission_to_db('database.db', Submission.submission_list) sys.exit() else: Ui.print_message('There is no such option.')
def __init__(self): self.api_key = 'AIzaSyC7SQ-1m0M6dN9L4E2aUhTM1ihAfTXIA0k ' self.date_val = [] self.date = [] self.regex_val = '' self.result = {} self.keys = [] self.values = [] self.description = [] self.name = Queue() self.actual_date = [] self.date_val1 = [] self.zip_code = [] self.licence_id = '' self.regex_value = [] self.code = '' self.first_name_original,self.last_name_original,self.middle_name_original,self.first_name_processed,self.last_name_processed,self.middle_name_processed={},{},{},{},{},{} self.regex_value,self.street,self.address,self.full_address=[],[],[],[] self.street_address_original,self.state_original,self.city_original,self.zip_code_original,self.street_address_processed,self.state_processed,self.city_processed,self.zip_code_processed={},{},{},{},{},{},{},{} self.failure_regex = '' self.c = Common() with open('../config/city.json', 'r') as data_file: self.cities = json.load(data_file) with open('../config/filtering.json', 'r') as data: self.state_value = json.load(data)
def wait_system_activation_page(cls, sn): try: co.reboot_device(sn) time.sleep(random.randint(30, 40)) logger.log_info("wait adb alive", \ sys._getframe().f_code.co_filename, sys._getframe().f_code.co_name, sys._getframe().f_lineno) adb_object.check_adb_device_isalive() os.system('adb root') time.sleep(random.randint(3, 6)) while True: Result = subprocess.check_output( 'adb -s %s shell "%s|%s wc -l"' % (sn, system_activation_pid, busybox), shell=True) print("antony@@debug") Result = co.removal(Result) print("antony@@@debug %s" % (Result)) if int(Result) == 1: logger.log_info("system activation has showed", \ sys._getframe().f_code.co_filename, sys._getframe().f_code.co_name, sys._getframe().f_lineno) return 0 time.sleep(random.randint(5, 10)) except Exception as e: logger.log_error("%s" %(e), \ sys._getframe().f_code.co_filename, sys._getframe().f_code.co_name, sys._getframe().f_lineno)
def login(): if not session.get('logged_in'): form = forms.LoginForm(request.form) if request.method == 'POST': username = request.form['username'].lower() password = request.form['password'] if form.validate(): #if helpers.credentials_valid(username, password): session['logged_in'] = True session['username'] = username return json.dumps({'status': 'Login successful'}) #return json.dumps({'status': 'Invalid user/pass'}) return json.dumps({'status': 'Both fields required'}) return render_template('login.html', form=form) user = helpers.get_user() sskey = "" if 'keyword' in session: sskey = session["keyword"] simages = "" if 'imagePath' in session: if session['imagePath'] != "": imagePath = session['imagePath'] print(imagePath) if (sskey == ""): return render_template("home.html", user=user) commonF = Common() simages = commonF.sprkSQLReadDFtoList(imagePath, sskey) sskey = "You are searching " + sskey return render_template('home.html', user=user, searchkey=sskey, hists=simages)
def predict(self, predict_data_lines): if self.predict_queue is None: self.predict_queue = PathContextReader.PathContextReader(word_to_index=self.word_to_index, path_to_index=self.path_to_index, target_word_to_index=self.target_word_to_index, config=self.config, is_evaluating=True) self.predict_placeholder = self.predict_queue.get_input_placeholder() self.predict_top_words_op, self.predict_top_values_op, self.predict_original_names_op, \ self.attention_weights_op, self.predict_source_string, self.predict_path_string, self.predict_path_target_string = \ self.build_test_graph(self.predict_queue.get_filtered_batches(), normalize_scores=True) self.initialize_session_variables(self.sess) self.saver = tf.train.Saver() self.load_model(self.sess) results = [] for batch in Common.split_to_batches(predict_data_lines, 1): top_words, top_scores, original_names, attention_weights, source_strings, path_strings, target_strings = self.sess.run( [self.predict_top_words_op, self.predict_top_values_op, self.predict_original_names_op, self.attention_weights_op, self.predict_source_string, self.predict_path_string, self.predict_path_target_string], feed_dict={self.predict_placeholder: batch}) top_words, original_names = Common.binary_to_string_matrix(top_words), Common.binary_to_string_matrix( original_names) # Flatten original names from [[]] to [] attention_per_path = self.get_attention_per_path(source_strings, path_strings, target_strings, attention_weights) original_names = [w for l in original_names for w in l] results.append((original_names[0], top_words[0], top_scores[0], attention_per_path)) return results
def getPsuadeInstalledModules(): libs = ['MARS','TPROS','SVM','METIS'] foundLibs = dict() for lib in libs: foundLibs[lib] = False #psuadePath = LocalExecutionModule.getPsuadePath(False) psuadePath = LocalExecutionModule.getPsuadePath() if psuadePath is None: # return foundLibs raise Exception('PSUADE path not set!') p = subprocess.Popen(psuadePath + ' --info', stdin=None, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True) # process error out, error = p.communicate() if error: Common.showError(error, out) return foundLibs # parse results lines = out.splitlines() installedString = 'installed... true'; if len(lines) >= 2: for line in lines: # skip first line with version info for lib in libs: if (lib in line) and (installedString in line): foundLibs[lib] = True break return foundLibs
def getFactionAverageGameInterestStats(self, sFactionName): gameEndDatas = self.getGameEndDatasWithFaction(sFactionName) iNumEntries = len(gameEndDatas) if not gameEndDatas: return 0, 0, 0, 0 fInterest = 0 fTimesPlayed = 0 fAverageScore = 0 fFactionPlusMinus = 0 for gameEndData in gameEndDatas: fInterest += gameEndData.m_fGameInterest fTimesPlayed += gameEndData.m_fTimesPlayed fAverageScore += gameEndData.m_fAverageScore for factionGameEndData in gameEndData.m_lFactionGameEndDatas: if factionGameEndData.m_Faction.m_sFactionName == sFactionName: fFactionPlusMinus += factionGameEndData.m_fScore * 6 - gameEndData.m_fAverageScore break return Common.floatround(fInterest / iNumEntries, 4), Common.floatround( fFactionPlusMinus / (iNumEntries * 6), 1), iNumEntries, round( fTimesPlayed / iNumEntries, 2)
class BatteryThread(QThread, Common): trigger = pyqtSignal(int, bool) def __init__(self, excel, sheet, workbook, interval, durtime, package, lock): super(QThread, self).__init__() self.excel = excel self.interval = interval self.durtime = durtime self.package = package self.sheet = sheet self.workbook = workbook self.btn_enable = False self.lock = lock self.com = Common() def run(self): try: row = 0 durtime = self.durtime.replace("min", "") interval = self.interval.replace("s", "") durtime = int(durtime) * 60 interval = int(interval) n = int(durtime / interval) for i in range(n): sleep_interval = 0.001 start_time = time.time() if self.check_adb(self.package) == 1: cmd = self.com.adb + " shell dumpsys battery" res = self.execshell(cmd) while res.poll() is None: line = res.stdout.readline().decode('utf-8', 'ignore') if line != "": if 'level' in line: line = re.findall('level\:\s(\d+)', line).pop() line = int(line) self.lock['battery'].acquire() self.trigger.emit(line, self.btn_enable) row += 1 self.sheet.write(row, 16, line) self.lock['mem'].release() # print("mem release %d" % (self.lock['mem'].available())) while (time.time() - start_time) * 1000000 <= interval * 1000000: sleep_interval += 0.0000001 sleep(sleep_interval) end_time = time.time() # avg = (end_time-start_time)*1000 # print("Battery为%f" % avg) self.btn_enable = True self.trigger.emit(0, self.btn_enable) # self.workbook.save(self.excel) except Exception: self.com.writeLog().info(traceback.format_exc())
def get_attention_per_path(self, source_strings, path_strings, target_strings, attention_weights): attention_weights = np.squeeze(attention_weights) # (max_contexts, ) attention_per_context = {} for source, path, target, weight in zip(source_strings, path_strings, target_strings, attention_weights): string_triplet = ( Common.binary_to_string(source), Common.binary_to_string(path), Common.binary_to_string(target)) attention_per_context[string_triplet] = weight return attention_per_context
def setForKey(plistPath, key, value): Common.assertExit(os.path.isfile(plistPath), plistPath + "文件不存在") if Plist.isKeyExist(plistPath, key): cmd = '/usr/libexec/PlistBuddy -c "Set :%s %s" %s' % (key, value, plistPath) return Common.runCmd(cmd) Plist.addStringForKey(plistPath, key, value)
def setUp(self): print("--setUp") # Get the current file name which will be output to the log gloVar.caseName = os.path.basename(__file__)[:-3] # Initial automation script self.common = Common() gloVar.common = self.common self.common.timeOut(30)
def __init__(self, inputStream, outputStream, options): Common.__init__(self, inputStream, outputStream, options) self.rcBuffer = 0 self.rcRange = 0x7fffffff self.xFFRunLength = 0 self.lastOutputByte = 0 self.delay = False self.carry = False
def __init__(self): self.common = Common() self.timetemp = time.strftime("%Y-%m-%d-%H-%M-%S", time.localtime()) # 存储Excel表格文件名编号 self.db = "case" self.dboperate = DbOperate() self.windows = None self.report_path = ReadConfig().save_report() self.catlog = 1
def Run(cls): templateApi = groupdocs_parser_cloud.TemplateApi.from_config(Common.GetConfig()) options = groupdocs_parser_cloud.CreateTemplateOptions() options.template = Common.GetTemplate() options.template_path = "templates/template-for-companies.json" request = groupdocs_parser_cloud.CreateTemplateRequest(options) response = templateApi.create_template(request) print("Path to saved template in storage: " + response.template_path + ". Link to download template: " + response.url);
def up_photo(): img = request.files.get('photo') #username = request.form.get("name") if (not img): return redirect('/') if not (img and allowed_file(img.filename)): return jsonify({ "error": 1001, "msg": "Only support .png .PNG .jpg .JPG .bmp .gif" }) path = basedir + "/static/photo/" imgfilename = img.filename.encode("utf-8").decode("latin1") file_path = path + imgfilename img.save(file_path) ''' encoded_string="" with open(file_path, "rb") as image_file: encoded_string = base64.b64encode(image_file.read()) #print (encoded_string) ''' imgType = imghdr.what(file_path) imagebase64 = base64.b64encode(open(file_path, 'rb').read()) commonF = Common() #if (not commonF.sparkSQLIsRepeat('04122019203919021146.txt',str(imagebase64, 'utf-8'))): # return redirect('/') x = commonF.readImageText(file_path, "all") x = re.sub('\s', '', x) x = x.replace('\n', '').replace(' ', '').replace('|', '') x = ("NoTag") if x == "" else (x.lower()) sstring = img.filename + "|" + x + "|data:image/" + imgType + ";base64," + str( imagebase64, 'utf-8') nowstring = sstring.encode("utf-8").decode("latin1") print("here here here here") conf = SparkConf( ) #.setAppName("Upload One Image to HDFS").setMaster("yarn") #sc = SparkContext(conf=conf) sc = SparkContext.getOrCreate(conf=conf) sqlContext = SQLContext(sc) uploadedDF = sc.parallelize([ (img.filename, x, "data:image/" + imgType + ";base64," + str(imagebase64, 'utf-8')) ]).toDF(["path", "features", "binary"]) uploadedDF.write.mode('append').parquet( dataFrameUrl) #("hdfs://gpu3:9000/dataFrames/final9") print(nowstring) #file = '04122019203919021146.txt' #with open(file, 'a+') as f: # f.write(nowstring) # f.write('\n') # f.close() # with hdfs.open('hdfs://gpu3:9000/wuxi/04122019203919021146.txt', 'a') as f: # f.write(nowstring) #return render_template('home.html') return redirect('/')
def talker(): calc = 'calculated' pub = rospy.Publisher('calc_done', String, queue_size=10) rospy.init_node('mapcalc', anonymous=True) common = Common() common.Init() common.Frame() if not rospy.is_shutdown(): rospy.loginfo(calc) pub.publish(calc)
def replaceContent(sourceContent, targetContent, filePath): Common.assertExit(os.path.isfile(filePath), "文件不存在") with open(filePath, "r") as f: lines = f.readlines() with open(filePath, "w") as f_w: for line in lines: strinfo = re.compile(sourceContent) b = strinfo.sub(targetContent, line) f_w.write(b)
def getDirectorysFromDirectory(dirPath): Common.assertExit(os.path.isdir(dirPath), "文件夹不存在:" + dirPath) dirPaths = [] dirNames = [] for fileName in os.listdir(dirPath): path = os.path.join(dirPath, fileName) if os.path.isdir(path): Array.insert(dirPaths, path) Array.insert(dirNames, fileName) return dirPaths, dirNames
def __init__(self): try: self.__usrInpt = -1 self.common = Common("KEY.txt", "ENC.txt") self.keyGeneration = KeyGeneration(self.common) self.encryption = Encryption(self.common) self.decryption = Decryption(self.common) self.breakEncryption = BreakEncryption(self.common) except Exception as ex: print("An error occurred while initializing class Main. Error: ", ex)
def __init__(self, image_level=None): """ Builds the object Parameters ---------- image_level : bool Whether using image-level dataset, set to False if using bounding boxes, by default is True """ self.image_level = True if image_level is None else image_level self.common = Common(self.image_level)
def maskdata(v, vmin, vmax): vm = np.ma.array(v) vm = np.ma.masked_where(vm < vmin, vm) # mask data below min value vm = np.ma.masked_where(vm > vmax, vm) # mask data above max value if vm.mask.all(): # if all values are masked (i.e., no valid data) error = 'Visualizer: Data lies within [%f, %f] (outside of specified range [%f, %f]).' % (min(v), max(v), vmin, vmax) Common.showError(error) vm = None return vm
def calculateInterest(fCubeScore, inputFaction): fInterest = 1.4 bConverged = False while not bConverged: fDummyFinalScore = calculateFinalScore(fInterest, inputFaction) if Common.floatround(fDummyFinalScore, 2) == fCubeScore: bConverged = True fInterest = fInterest + 0.3 * ( (fCubeScore - fDummyFinalScore) / fCubeScore) return Common.floatround(fInterest, 4)
def Run(cls): # For example purposes create template if not exists. Common.CreateIfNotExist("templates/companies.json") templateApi = groupdocs_parser_cloud.TemplateApi.from_config( Common.GetConfig()) options = groupdocs_parser_cloud.TemplateOptions() options.template_path = "templates/template-for-companies.json" request = groupdocs_parser_cloud.DeleteTemplateRequest(options) response = templateApi.delete_template(request) print("Done.")
class TimeThread(QThread, Common): trigger = pyqtSignal(str) def __init__(self, excel, sheet, workbook, interval, durtime, package, lock): super(QThread, self).__init__() self.excel = excel self.interval = interval self.durtime = durtime self.package = package self.sheet = sheet self.workbook = workbook self.btn_enable = False self.lock = lock self.com = Common() def run(self): try: durtime = self.durtime.replace("min", "") interval = self.interval.replace("s", "") durtime = int(durtime) * 60 interval = int(interval) n = int(durtime / interval) name = self.get_package(self.package) for i in range(n): start_time = time.time() sleep_interval = 0.001 durtime -= interval min = int(durtime / 60) sec = (durtime % 60) timeCount = str(min) + ":" + str(sec) self.lock['time'].acquire() self.trigger.emit(timeCount) self.lock['fps'].release() # print("fps release %d" % (self.lock['fps'].available())) while (time.time() - start_time) * 1000000 <= interval * 1000000: sleep_interval += 0.0000001 time.sleep(sleep_interval) end_time = time.time() # avg = (end_time - start_time) * 1000 # print("内存为%f" % avg) # print("time over") self.trigger.emit("0") # self.workbook.save(self.excel) except Exception: self.com.writeLog().info(traceback.format_exc())
def __init__(self, excel, sheet, workbook, interval, durtime, package, lock): super(QThread, self).__init__() self.excel = excel self.interval = interval self.durtime = durtime self.package = package self.sheet = sheet self.workbook = workbook self.btn_enable = False self.lock = lock self.com = Common()
def analyze(self): data = self.ensemble.getValidSamples() Common.initFolder(RawDataAnalyzer.dname) fname = Common.getLocalFileName(RawDataAnalyzer.dname, data.getModelName().split()[0], '.dat') data.writeToPsuade(fname) #perform UA mfile = RawDataAnalyzer.performCA(fname, self.outputs[0]) #archive file if mfile is not None: self.archiveFile(mfile) return mfile
def getStickerwithPrice(sticker): found = False with open("Sticker.csv", 'r', encoding="utf-8") as readFile: reader = csv.reader(readFile) for row in reader: sticker_name = row[0] if sticker_name == sticker: found = True return convertPrice(row[1], 'USD') # print("Name: {0}. Price {1}".format(sticker_name,sticker_price)) if found is False: print("Sticker not found: " + sticker_name) Common.sendLog("info", sticker_name + "Not found")
class ResultController: def __init__(self): self.common_tools = Common() self.search_type = self.common_tools.enum(SubDirectory=1, FileName=2, FileContent=3) @staticmethod def convert_item_to_result_object(item, current_root_directory, current_search_type, item_content=None): result_dictionary = {} result_dictionary["size"] = getsize(join(current_root_directory, item)) result_dictionary["is_directory"] = os.path.isdir(os.path.join(os.path.expanduser(current_root_directory), item)) result_dictionary["root_directory"] = str(current_root_directory) result_dictionary["name"] = str(item) result_dictionary["search_type"] = current_search_type if not item_content is None: result_dictionary["item_content"] = item_content return result_dictionary def convert_list_to_result_object_dictionary(self, current_list, last_dict_enumerator, current_root_directory, current_search_type): dictionary_enumerator = last_dict_enumerator new_dictionary = {} for item in current_list: assert isinstance(item, str) dictionary_enumerator += 1 new_dictionary[dictionary_enumerator] = self.convert_item_to_result_object(item, current_root_directory, current_search_type) return new_dictionary
def generateKey(self, mediaid, size = 32): # Below: Do some black magic eq1 = int(int(math.floor(math.sqrt(6.9) * math.pow(2, 25))) ^ mediaid) eq2 = int(math.floor(math.sqrt(6.9) * math.pow(2, 25))) eq3 = (mediaid ^ eq2) ^ (mediaid ^ eq2) >> 3 ^ eq1 * 32 # Below: Creates a 160-bit SHA1 hash shaHash = sha.new(self.createString([20, 97, 1, 2]) + str(eq3)) finalHash = shaHash.digest() hashArray = Common().createByteArray(finalHash) # Below: Pads the 160-bit hash to 256-bit using zeroes, incase a 256-bit key is requested padding = [0]*4*3 hashArray.extend(padding) keyArray = [0]*size # Below: Create a string of the requested key size for i, item in enumerate(hashArray[:size]): keyArray[i] = item return Common().ByteArrayToString(keyArray)
def __init__(self): self.common_tools = Common() self.notification_category = self.common_tools.enum(Normal=Style.NORMAL + Fore.CYAN, Large_Header=Style.BRIGHT + Back.RED + Fore.WHITE, Header=Style.BRIGHT + Back.WHITE + Fore.BLACK, Small_Header=Style.NORMAL + Fore.MAGENTA, Small_Print=Style.NORMAL + Fore.GREEN, Warning=Style.BRIGHT + Fore.YELLOW, Error=Style.BRIGHT + Fore.RED, Style=Style.NORMAL + Fore.BLUE)
def test_search_verify_picture(self): common_obj = Common(self.driver) elem = common_obj.wait_for_element_visibility(5, "name", 'q') common_obj.fill_out_field('name', 'q', 'leatherback') elem.send_keys(Keys.RETURN) common_obj.wait_for_element_visibility(5, 'xpath', "//div[@class='wsite-search-product-image-container']" ) time.sleep(3)
class OutputInteraction: def __init__(self): self.common_tools = Common() def request_result_item(self, search_directory, result_dictionary, input_message): message_tool = NotificationController() user_input = raw_input(input_message) # If escape key is pressed then escape method if user_input == '': return # If the input provided is not a number indicate to user and continue to loop through method until correct input # provided. if not user_input.isdigit(): message_tool.print_with_style("No such option exists", message_tool.notification_category.Warning) return self.request_result_item(search_directory, result_dictionary, input_message) # If the input provided is not a number indicate to user and request another option if not user_input.isdigit(): user_input = raw_input("") current_operating_system = self.common_tools.get_operating_system() # Make sure that the requested key exists otherwise return a message. if int(user_input) in result_dictionary: if result_dictionary[int(user_input)]["is_directory"]: message_tool.print_with_style(os.path.join( os.path.expanduser(result_dictionary[int(user_input)]["root_directory"]), result_dictionary[int(user_input)]["name"]), message_tool.notification_category.Header) print "" if current_operating_system == "Windows": subprocess.check_call(["dir", os.path.join( os.path.expanduser(result_dictionary[int(user_input)]["root_directory"]), result_dictionary[int(user_input)]["name"])]) else: subprocess.check_call(["ls", "-l", os.path.join(os.path.expanduser( result_dictionary[int(user_input)]["root_directory"]), result_dictionary[int(user_input)]["name"])]) else: # os.system('vi %s' % search_results[int(user_input)]) subprocess.call(["nano", os.path.join(os.path.expanduser( result_dictionary[int(user_input)]["root_directory"]), result_dictionary[int(user_input)]["name"])]) else: message_tool.print_with_style("No such option exists.", message_tool.notification_category.Warning) return self.request_result_item(search_directory, result_dictionary, input_message)
def callme(self): print "++++++++++++++++++++++ Regression Week 3: Polynomial Regression ++++++++++++++++++++++" cmnHandle = Common() df_train = cmnHandle.readcsv("../data/kc_house_train_data.csv") df_test = cmnHandle.readcsv("../data/kc_house_test_data.csv") tmp = np.array(range(3)) print cmnHandle.polynomial_sframe(tmp, 3) poly1_data = cmnHandle.polynomial_sframe(df_train["sqft_living"], 1) print "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"
class NotificationController: def __init__(self): self.common_tools = Common() self.notification_category = self.common_tools.enum(Normal=Style.NORMAL + Fore.CYAN, Large_Header=Style.BRIGHT + Back.RED + Fore.WHITE, Header=Style.BRIGHT + Back.WHITE + Fore.BLACK, Small_Header=Style.NORMAL + Fore.MAGENTA, Small_Print=Style.NORMAL + Fore.GREEN, Warning=Style.BRIGHT + Fore.YELLOW, Error=Style.BRIGHT + Fore.RED, Style=Style.NORMAL + Fore.BLUE) def print_with_style(self, output, notification_category): # Initialize colorama object init() if not notification_category: notification_category = self.notification_category.Normal print notification_category + output + Style.RESET_ALL
def __init__(self, inputStream, outputStream, options): Common.__init__(self, inputStream, outputStream, options) self.started = False self.nextHighBit = 0 self.rcBuffer = 0 self.rcRange = 0
def __init__(self): self.common_tools = Common()
def __init__(self): self.common_tools = Common() self.search_type = self.common_tools.enum(SubDirectory=1, FileName=2, FileContent=3)