def __init__(self): self.ui = Tk() self.start_ui() self.reader = Driver() self.homework = HomeworkList() self.timer = 0 self.auto = threading.Thread(target=self.auto_load_thread, daemon=True) self.id_input = Label(self.ui, text='아이디', font='Verdana 10 bold', background='white') self.id_value = Entry(self.ui) self.password_input = Label(self.ui, text='비밀번호', font='Verdana 10 bold', background='white') self.password_value = Entry(self.ui, show='*') self.password_value.bind('<Return>', self.enter_key) self.login_btn = Button(self.ui, text='로그인', command=self.click_login, height=2, font='Verdana 10 bold', background='white') self.subject_name = [] self.homework_name = [] self.end_time = [] self.remain = [] self.submit_btn = [] self.submit = [] self.login() self.ui.mainloop()
def main(): with open("testfiles/parsing/Valid.txt", "r") as testfile: blueprint = TestCase.parse_syntax(testfile) if blueprint is not None: tc = TestCase(blueprint) dr = Driver(tc) dr.execute()
def loop(): while True: message = Log.get_current_message() if message == "Start" or message == "Continue": try: driver = Driver() driver.run() except KeyboardInterrupt: Log.send("Keyboard Interrupt. Bot will exit now.") print("Exiting...") break except socket_error as err: raise err except Exception as err: for frame in traceback.extract_tb(sys.exc_info()[2]): fname, lineno, fn, text = frame error = "Error in " + str(fname) + " on line " + str( lineno) + ": " + str(err) print(error) Log.send(error) pass else: if message == "Stop" or message == "Exit": Log.send("XING Bot will exit now.") raise Exception sleep(1)
class Engine: def __init__(self, dBRange, timeOut, ledGpioPins, groveChannel, piezoGpioPIN): self.__dBRange = dBRange self.__driver = Driver(ledGpioPins, groveChannel, piezoGpioPIN) #self.__currentdB = self.__driver.GetCurrentdB() # what is this range ? maybe could be used for rounding values of dB # or maybe even better an array of maxdB/NUMBER_OF_LED ya better # soundRange = 0 ? [255*1/8, 255*2/8, 255*3/8, 255*4/8, 255*5/8, 255*6/8, 255*7/8, 255*8/8] # self.__soundRange = soundRange #self.__timeOut = timeOut def Start(self): print("SoundAnalyzer engine started...") unit = self.__dBRange * (1 / 8) dBInterval = [ unit * 1, unit * 2, unit * 3, unit * 4, unit * 5, unit * 6, unit * 7, unit * 8 ] while True: # say dB is 0-255 currentSoundLevel = self.__driver.GetCurrentdB() #currentSoundLevel = random.randint(1, 70) # if currentSoundLevel < soundRange[i]: if currentSoundLevel < dBInterval[0]: self.__driver.LightUpToNthLed(0) elif currentSoundLevel < dBInterval[1]: self.__driver.LightUpToNthLed(1) elif currentSoundLevel < dBInterval[2]: self.__driver.LightUpToNthLed(2) elif currentSoundLevel < dBInterval[3]: self.__driver.LightUpToNthLed(3) elif currentSoundLevel < dBInterval[4]: self.__driver.LightUpToNthLed(4) elif currentSoundLevel < dBInterval[5]: self.__driver.LightUpToNthLed(5) #self.__driver.TriggerPiezo(duration=4) # timout to quiet # self.__driver.TimeOutPiezo(2) elif currentSoundLevel < dBInterval[6]: self.__driver.LightUpToNthLed(6) # vary duration ? #self.__driver.TriggerPiezo(duration=4) elif currentSoundLevel < dBInterval[7]: self.__driver.LightUpToNthLed(7) #self.__driver.TriggerPiezo(duration=4) self.__driver.CheckForShutdown() time.sleep(.07)
def __init__(self, db_connection): # Function Description: Intialise the Event_Driver. Inherits from Driver. # Function Parameters: db_connection (pymysql.connections.Connection: The connection to the database.) # Function Throws: Nothing # Function Returns: Nothing Driver.__init__(self, db_connection) # Send the parameters up.
def __init__(self, db_connection): # Function Description: Intialise the Game_Driver. The Game_Driver will handle all the function related to a Game: # 1. Insert a new instance of a Game. # Paramters: db_connection (pymysql.connections.Connection: The connection to the database.) # Function Throws: Nothing # Function Returns: Nothing Driver.__init__(self, db_connection)
def __init__(self, db_connection, max_size=1000): # Class Description: The function will manage all the individual batch queues. Note: The key identifying each Batch_Queue # must match each table name. # Class Parameters: db_connection (The existing connection to the database.), # max_size (The point where we insert all the queues into the database.) Driver.__init__(self, db_connection) self.max_size = max_size self.queues = {} self.current_size = 0 # Manage the size of the queue. Empty the queue when it gets to large.
def __init__(self, db_connection): # Class Description: The class will manage and control the data insertions into the baseball database. Note, # the class does not perform any queries. The queries are delegated to the specific drivers. Driver.__init__(self, db_connection) # The path to the pymysql connector to access the database. self.path_to_raw_data = Path("BaseballAnalytics/bin/db/raw_data/") # The path to the raw data that will be inserted into the database. self.path_to_player_list = self.path_to_raw_data / 'rosters' # The folder containing the player data. self.path_to_pickle_player_data = self.path_to_player_list / 'pickle_player_data.pickle' # The path to the pickle file containing the player information. self.log_folder = Path('BaseballAnalytics/logs/insert_file_logs/') # The path to the log file. self.path_to_raw_data = Path('C:/Users/micha/Desktop/') self.log_file = self.__initiate_log_file(self.log_folder)
def main(): c1 = Car(brand="opel", model="astra", maxSpeed=22) c2 = Car() print(int(c1)) print(c2) d1 = Driver() d2 = Driver("Ivan", c1) print(d1) print(d2) r1 = Race()
def __init__(self, id, num, ser): Driver.__init__(self, id) self.ser = ser self.num = num if os.path.isfile("persist/"+str(self.id)): f = open("persist/"+str(self.id), "rb") self.setParameters(pickle.load(f)) f.close() else: self.status = 0 self.setStatus(self.status)
def main(): instabot = Driver(key.username, key.password) instabot.login() instabot.messages() starttime = time.time() while True: print(instabot.getactivity()) time.sleep(60.0 - ((time.time() - starttime) % 60.0)) instabot.refresh()
def main(): # confirm python3 version_info = sys.version_info try: assert version_info.major >= 3 except AssertionError: print("Use python3.") print("Usage: python3 main.py [parameter_file]") return # Initilize from Driver import Driver driver = Driver() try: # Command line arguments args = sys.argv if len(args) < 2: raise InitialArgumentsError # Load parameters driver.load(args[1]) # Control Loop driver.doOperation() except InitialArgumentsError: print("[ERROR] NO ARGUMENTS") print("Usage: python3 main.py [parameter_file]") except KeyboardInterrupt: print("KeyboardInterrupt") finally: # If you finalize this program, # this program set the system to stop driver.finalize() print("finish")
class TestOpenAccount(unittest.TestCase): def setUp(self): self.D = Driver() self.driver = self.D.browser_open("http://10.7.106.235:8000/login") self.oa = OpenAccount(self.driver) def test004_openaccount(self): # self.oa.open_account('18252023049', 'cjs123456', u'陈进松', '320621199301178313', '6214852116479075', # '18051969073') # 该账户已开通了 # self.oa.open_account('18252023050', 'cjs123456', u'陈进松', '320621199301178313', '6214852116479075', # '18051969073') pass def tearDown(self): self.D.browser_close()
def VideoStream(): global command_client global driver global recv_inst print("Started") driver = Driver() recv_inst = True command_client = socket.socket() command_client.connect((host, command_port)) Thread(target=steer).start() sleep(1) cam = cv2.VideoCapture(0) client = NetGear(address=host, port=video_port, protocol='tcp', pattern=0, recieve_mode=False, logging=False) cam.set(3, 320) cam.set(4, 240) #cam.set(cv2.CAP_PROP_FPS, 10) while recv_inst: ret, frame = cam.read() if frame is None: break cv2.imshow("Car Cam", frame) client.send(frame) if cv2.waitKey(1) & 0xFF == ord('q'): break cam.release() client.close() command_client.close() cv2.destroyAllWindows()
def analysis(foldername, outdir, partitionssize, referencenum, maxsize=None): """ Start the analysis Input: 1) Path to the driver directory 2) Path where the submission file should be written 3) Number of drivers to compare against """ seed(42) start = datetime.now() submission_id = datetime.now().strftime("%H_%M_%B_%d_%Y") folders = [ os.path.join(foldername, f) for f in os.listdir(foldername) if os.path.isdir(os.path.join(foldername, f)) ] referencefolders = [ folders[i] for i in sorted(sample(xrange(len(folders)), referencenum)) ] referencedrivers = [] for referencefolder in referencefolders: referencedrivers.append(Driver(referencefolder)) #for testing if maxsize: folders = folders[:maxsize] results = [] for folderlist in chunks(folders, partitionssize): results.append(perform_analysis(folderlist, referencedrivers)) with open( os.path.join(outdir, "pyMultiClass_{0}.csv".format(submission_id)), 'w') as writefile: writefile.write("driver_trip,prob\n") for item in results: writefile.write("%s\n" % item) print 'Done, elapsed time: %s' % str(datetime.now() - start)
def perform_analysis(folder): print("Working on {0}".format(folder)) sys.stdout.flush() temp = Driver(folder) cls = RegressionDriver(temp, REFERENCE_DATA) cls.classify() return cls.toKaggle()
def __init__(self, file_name=None): """Creates a DriversDict composed by Driver objects, from a file with a list of drivers. Requires: If given, file_name is str with the name of a .txt file containing a list of drivers organized as in the examples provided in the general specification (omitted here for the sake of readability). Ensures: if file_name is given: a DriversDict, composed by objects of class Driver that correspond to the drivers listed in file with name file_name. if file_name is none: a empty DriversList.""" UserDict.__init__(self) if file_name is not None: inFile = FileUtil(file_name) for line in inFile.getContent(): driverData = line.rstrip().split(", ") driverName = driverData.pop(DriversDict.INDEXDriverName) driverEntryTime, driverAccumTime = driverData driverEntryTime = Time(driverEntryTime) driverAccumTime = Time(driverAccumTime) newDriver = Driver(driverName, driverEntryTime, driverAccumTime) self[driverName] = newDriver
def __init__(self): # Constructor for Repository class self.__address = {} self.__driver = {} with open("addresses", "r") as file: data = file.read() data = data.split("\n") if len(data) != 1: for address in data: address = address.split(",") self.__address[int(address[0].strip())] = Address( int(address[0].strip()), address[1].strip(), int(address[2].strip()), int(address[3].strip())) with open("drivers", "r") as file: data = file.read() data = data.split("\n") if len(data) != 1: for driver in data: driver = driver.split(",") self.__driver[driver[0].strip()] = Driver( driver[0].strip(), int(driver[1].strip()), int(driver[2].strip()))
def perform_analysis(trainfolder): print "Working on {0}".format(trainfolder) sys.stdout.flush() temp = Driver(trainfolder) cls = RegressionDriver(temp, REFERENCE_DATA) cls.classify() return cls.validate(TEST_DATA)
def analysis(foldername, outdir, referencenum): """ Start the analysis Input: 1) Path to the driver directory 2) Path where the submission file should be written 3) Number of drivers to compare against """ seed(42) start = datetime.now() submission_id = datetime.now().strftime("%H_%M_%B_%d_%Y") driver_No = [int(f) for f in os.listdir(foldername)] driver_No = [str(f) for f in sorted(driver_No)] folders = [os.path.join(foldername, f) for f in driver_No] referencefolders = [ folders[i] for i in sorted(sample(range(len(folders)), referencenum)) ] referencedrivers = [] for referencefolder in referencefolders: referencedrivers.append(Driver(referencefolder)) generatedata(referencedrivers) results = [perform_analysis(folder) for folder in folders] with open(os.path.join(outdir, "pyRegression_{0}.csv".format(submission_id)), 'w', newline='') as writefile: writefile.write("driver_trip,prob\n") for item in results: writefile.write("%s\n" % item) print('Done, elapsed time: %s' % str(datetime.now() - start))
def __init__(self): self._state = {} GPIO.setmode(GPIO.BCM) self._gpio = GPIO self._driver = Driver.Driver(self._gpio) self._sensors = Sensors.Sensors(self._gpio) self._vision = Vision.Vision((640, 480)) self._laser = Laser.Laser(self._gpio, 25)
def analysis(trainfoldername, testfoldername, outdir, referencenum): """ Start the analysis Input: 1) Path to the driver directory 2) Path where the submission file should be written 3) Number of drivers to compare against """ seed(42) start = datetime.now() submission_id = datetime.now().strftime("%H_%M_%B_%d_%Y") trainfolders = [ os.path.join(trainfoldername, f) for f in os.listdir(trainfoldername) if os.path.isdir(os.path.join(trainfoldername, f)) ] referencefolders = [ trainfolders[i] for i in sorted(sample(xrange(len(trainfolders)), referencenum)) ] referencedrivers = [] for referencefolder in referencefolders: referencedrivers.append(Driver(referencefolder)) generatedata(referencedrivers) testdrivers = [] testfolders = [ os.path.join(testfoldername, f) for f in os.listdir(testfoldername) if os.path.isdir(os.path.join(testfoldername, f)) ] for testfolder in testfolders: testdrivers.append(Driver(testfolder)) generatetestdata(testdrivers) results = Parallel(n_jobs=10)(delayed(perform_analysis)(trainfolder) for trainfolder in trainfolders) with open( os.path.join(outdir, "testing_results_{0}.txt".format(submission_id)), 'w') as writefile: for item in results: writefile.write("%.4f\n" % item) mean = sum(results) / len(results) writefile.write("Mean: %.4f\n" % mean) writefile.write("Median: %.4f\n" % median(results)) writefile.write("Min: %.4f\n" % min(results)) print 'Done, elapsed time: %s' % str(datetime.now() - start)
def __init__(self, inputData): self.inputData = inputData nBuses = self.inputData.nBuses nDrivers = self.inputData.nDrivers nServices = self.inputData.nServices start = self.inputData.start duration = self.inputData.duration kms = self.inputData.kms passengers = self.inputData.passengers capacity = self.inputData.capacity cost_km = self.inputData.cost_km cost_min = self.inputData.cost_min maxWorkingTime = self.inputData.maxWorkingTime self.maxBuses = self.inputData.maxBuses self.BM = self.inputData.BM self.CBM = self.inputData.CBM self.CEM = self.inputData.CEM self.drivers = [] self.buses = [] self.services = [] self.overlapping = [[0 for x in range(nServices)] for y in range(nServices)] for sId in xrange( 0, nServices): #hopefully really 0..(nServices-1) --> Check that service = Service(sId, start[sId], duration[sId], kms[sId], passengers[sId]) self.services.append(service) for dId in xrange(0, nDrivers): driver = Driver(dId, maxWorkingTime[dId]) self.drivers.append(driver) for bId in xrange(0, nBuses): bus = Bus(bId, capacity[bId], cost_km[bId], cost_min[bId]) self.buses.append(bus) for s1 in xrange(0, nServices): for s2 in xrange(0, nServices): startS1 = self.services[s1].getStart() endS1 = startS1 + self.services[s1].getDuration() startS2 = self.services[s2].getStart() endS2 = startS2 + self.services[s2].getDuration() if not (endS1 < startS2 or startS1 > endS2): self.overlapping[s1][s2] = 1 self.overlapping[s2][s1] = 1 else: self.overlapping[s1][s2] = 0 self.overlapping[s2][s1] = 0
def __init__(self, jid, password, params_map): super().__init__(jid, password) self.race_name = "" self.desire = False self.params_map = params_map self.track = [] self.track_length = 0 self.driver = Driver(jid) self.environment_jid = ""
def F_writeFeaturesfile4onedriver(folder, exten, nonstandfeatfile): print "Writing features for {0}".format(folder) sys.stdout.flush() STAND = False temp = Driver(folder, exten, STAND) with open(nonstandfeatfile, 'a') as featsfile: csvwriter = csv.writer(featsfile, delimiter=',') for i in xrange(len(temp.generate_data_model)): csvwriter.writerow(temp.generate_data_model[i])
def __init__(self, device): """ :param device: the linux event file of the Wacom device to connect to (eg: /dev/input/event12) """ self.logger = logging.getLogger(__name__) self.logger.setLevel(logging.DEBUG) self.driver = Driver(device) self.driver.start() # Start Async Task self.dataSet = DataSet() self.digitSets = [] # Externally set variables self.activeDrawingWindow = None self.activeDigitSet = None self.currentDigitPhase = 0 self.count = 0
def perform_analysis(folders, referencedrivers): print folders sys.stdout.flush() temp = [] for folder in folders: temp.append(Driver(folder)) cls = MultiClassDriver(temp, referencedrivers) cls.classify() return cls.toKaggle()
def create_query(self): drivers = {} riders = {} for key, driver in self.drivers.items(): drivers[key] = Driver(driver.start, driver.dest, driver.endTime, driver.seats) for key, rider in self.riders.items(): riders[key] = Rider(rider.start, rider.endTime) return Query(riders, drivers)
def __init__(self, id, id1, id2, q): Driver.__init__(self, id) self.id1 = id1 self.id2 = id2 self.q = q.queue q.start() if os.path.isfile("persist/"+str(self.id)): f = open("persist/"+str(self.id), "rb") self.setParameters(pickle.load(f)) f.close() else: self.status = 0 self.brightness = 100 self.mode = 1 # 1=temp, 0=color self.color = 0 self.temp = 100 self.setStatus(self.status) self.apply()
class Simcar: driver = Driver() __init__(self, driver, env = Env()): super() self.driver = driver steerAngle = 0 accelerator = 0 brake = 0 speed = 0
def _loadFile(self): """ :return: reads the drivers from the given text file and adds them in the repo """ f = open(self._fileName, "r") line = f.readline().strip() while len(line) >= 2: tok = line.split(",") driver = Driver(int(tok[0]), tok[1]) Repository.add(self, driver) line = f.readline().strip()
def run(self) -> None: driver = Driver() driver = driver.get_driver() driver.get( 'https://domclick.ru/search?offset=10&limit=10&sort_dir=desc') html = driver.page_source soup = BeautifulSoup(html) max_ads = re.search( '(\d*)', soup.find('div', { 'class': 'listing-title' }).text.replace(' ', '')).group(1) for i in range(0, int(max_ads), 100): soup = BeautifulSoup( requests.get(self._ads_list_url_pattern.format(i)).text) hrefs = list(map(lambda a: a.get('href', ''), soup.find_all('a'))) for href in hrefs: if href.find('card') != -1: self._data.put(href)
class Wrapper(): def __init__(self): self.myDriver = Driver() self.data = '' self.start_time = 0 self.end_time = -1 self.total_time = -1 def run(self): colnames = ['STIME','TIME','UID','PID','D','BLOCK','SIZE','COMM','PATHNAME'] data = pandas.read_csv(self.data,names = colnames) data_dir = data.D.tolist() data_addr = map(lambda x: x*512, data.BLOCK.tolist()) data_size = data.SIZE.tolist() arrs = [] length = len(data_dir) self.start_time = time.time() for i in range(0,length): self.myDriver.drive(data_dir[i],data_addr[i],data_size[i]) self.end_time = time.time() self.total_time = self.end_time - self.start_time self.myDriver.close() def open(self,data,target): self.myDriver.open(target) self.data = data def get_time(self): return self.total_time
def __init__(self): self.myDriver = Driver() self.data = '' self.start_time = 0 self.end_time = -1 self.total_time = -1
from detection.SquareDetection import SquareDetection from detection.CircleDetection import CircleDetection from Stepper import Stepper from Driver import Driver import time # # This script is controlling the main logic for the # autonomous robot decisions. # if __name__ == '__main__': # initialize Driver object for stepper motor controls d = Driver(0.003) # move a bit forwards (first feedback) for i in range(0,10): d.forwards() # this first initialization will also initialize the # raspberry pi camera (will happen only once in this program) circleDetection = CircleDetection(draw=False,width=640 ,height= 480, debug=True) while(circleDetection.isRunning()): # does the detection and frame analysis (circle, frame) = circleDetection.loop() print("circle found: " + str(circle)) # if no circle is shown, turn right (right hand rule)