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 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.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 __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 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)
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")
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(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 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 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):
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 __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 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 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 _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()
class Simcar:
driver = Driver()
__init__(self, driver, env = Env()):
super()
self.driver = driver
steerAngle = 0
accelerator = 0
brake = 0
speed = 0
class Simulation:
model = Model()
driver = Driver()
scanario = Scenario()
env = Env()
env = None
# Find way to do vector<samples> for line below with correct import
samples = np.array()
results = Results()
results = None
def Simulation(self, model):
self.model = model
driver = Driver(model, "Driver", 25, float(1.0), float(1.0))
scenario = Scenario()
env = Env(driver, scenario)
# samples.add(recordSample(env))
# Find way for syncrhonized to work
def synchronized_update(self):
self.env.update()
# samples.add (recordSample (env))
# analyze() defined below
def getResults(self):
self.results = analyze()
return self.results
def numSamples(self):
return self.samples.size()
def recordSample(self, env):
s = Sample()
s.time = env.time
s.simcarPos = env.simcar.p.myclone()
s.simcarHeading = env.simcar.h.myclone()
s.simcarFracIndex = env.simcar.fracIndex
s.simcarSpeed = env.simcar.speed
s.simcarRoadIndex = env.simcar.roadIndex
if(env.simcar.nearPoint == None):
s.nearPoint = env.simcar.nearPoint.myclone()
s.farPoint = env.simcar.farPoint.myclone()
s.carPoint = env.simcar.carPoint.myclone()
s.steerAngle = env.simcar.steerAngle
s.accelerator = env.simcar.accelerator
s.brake = env.simcar.brake
s.autocarPos = env.autocar.p.myclone()
s.autocarHeading = env.autocar.h.myclone()
s.autocarFracIndex = env.autocar.fracIndex
s.autocarSpeed = env.autocar.speed
s.autocarBraking = env.autocar.braking
def __init__(self, inputData):
self.inputData = inputData
nServices = inputData.numServices
nBuses = inputData.numBuses
nDrivers = inputData.numDrivers
self.maxBuses = inputData.maxBuses
self.buses = {}
for busId in range(0, nBuses):
# Assuming that each element of inputData.buses is a string,
# remove initial and trailing "<...>", then split on ","
busData = inputData.buses[busId].strip('<>').split(',')
# Convert to numeral values
for i in range(0, len(busData)):
try:
busData[i] = int(busData[i].strip())
except ValueError:
busData[i] = float(busData[i].strip())
# Create element
bus = Bus(busId, busData[0], busData[1], busData[2])
self.buses[bus.id] = bus
self.drivers = {}
for driverId in range(0, nDrivers):
# Assuming that each element of inputData.drivers is a string,
# remove initial and trailing "<...>", then split on ","
driverData = inputData.drivers[driverId].strip('<>').split(',')
# Convert to numeral values
for i in range(0, len(driverData)):
try:
driverData[i] = int(driverData[i].strip())
except ValueError:
driverData[i] = float(driverData[i].strip())
# Create element
driver = Driver(driverId, driverData[0], driverData[1],
driverData[2], driverData[3])
self.drivers[driver.id] = driver
self.services = {}
for serviceId in range(0, nServices):
# Assuming that each element of inputData.services is a string,
# remove initial and trailing "<...>", then split on ","
serviceData = inputData.services[serviceId].strip('<>').split(',')
# Convert to numeral values
for i in range(0, len(serviceData)):
serviceData[i] = int(serviceData[i].strip())
service = Service(serviceId, serviceData[0], serviceData[1],
serviceData[2], serviceData[3], self.services)
self.services[service.id] = service
class Levart:
from sys import exit
companyInfo = ['261094735', '261094756', '*****@*****.**']
L = LevartSettings
T = Traveler
Pa = PanicButton("48.067906", "12.860655", "Φωτογραφία")
D = Driver("Aθήνα", "Πάτρα", "12/5/20", "Μεγάλη Βαλίτσα", "Ναι", "4")
P = Passenger("Aθήνα", "Πάτρα", "12/5/20", "Μεγάλη Βαλίτσα", "Ναι", "4")
Pe = PendingReservations("Πάτρα", "Αθήνα", "12/12/2020", "Ναι",
"Μεγάλη Βαλίτσα", "3")
k = True
while k:
print(
"Για να μπείτε στις ρυθμίσεις της εφαρμογής πληκτρολογήστε το 1, \n"
)
print(
"Για να μπείτε στις ρυθμίσεις λογαριασμού πληκτρολογήστε το 2, \n")
print("Για να κάνετε ανάρτηση ταξιδιού πληκτρολογήστε το 3, \n")
print("Για να κάνετε αναζήτηση ταξιδιού πληκτρολογήστε το 4, \n")
print(
"Για να κάνετε επεξεργασία των ταξιδιών που εκκρεμούν πληκτρολογήστε το 5, \n"
)
print("Για να ενεργοποιήσετε το Panic Button πληκτρολογήστε το 6, \n")
print("Για να κάνετε έξοδο από την Levart πληκτρολογήστε το 0.")
e = input("Παρακαλώ επιλέξτε τι θέλετε να κάνετε:\n")
if e == "1":
L.LanguageSettings()
False
elif e == "2":
T.TravelerSettings(T)
False
elif e == "3":
D.FormFill()
False
elif e == "4":
P.FormFill()
False
elif e == "5":
Pe.Form()
False
elif e == "6":
Pa.RequestDangerList()
False
elif e == "0":
exit(0)
else:
print("Παρακαλώ επιλέξτε σύμφωνα με τις οδηγίες\n")
def perform_analysis(folder,
exten,
STAND,
means,
stds,
n_estimators=10,
min_samples_leaf=1,
max_depth=None):
print "Working on {0}".format(folder)
sys.stdout.flush()
temp = Driver(folder, exten, STAND, means=means, stds=stds)
cls = RegressionDriver(temp, REFERENCE_DATA)
cls.classify(n_estimators=n_estimators,
min_samples_leaf=min_samples_leaf,
max_depth=max_depth)
return cls.toKaggle()
class Results:
driver = Driver()
def __init__(self):
self.taskTime = None
self.taskLatDev = None
self.taskLatVel = None
self.headingError = None
self.laneViolations = None
self.taskSpeedDev = None
self.detectionError = None
self.brakeRT = None
def toString(self):
return_string = "(" + str(self.taskTime) + ", " + str(self.taskLatDev) + ", " + str(self.taskLatVel) + ", " + str(self.brakeRT) + ", " + str(self.headingError) + ", " + str(self.taskSpeedDev) + ")"
return return_string
def __init__(self):
self.page = 1
self.pages = []
self.enable = False
self.canLoad = True # sub thread can run?
self.allDone = False
self.store_dir = None
self.init_work_dir()
self.isFirst = False # run only once
self.unload_page_num = 0 # page to be loaded
# 主域名
self.domainName = 'http://www.well1000.cn'
# 模拟浏览器
self.webDriverPage = Driver()
# 第一个窗口
self.windowOpenNum = 0
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
async def run(self):
print(f'{self.__class__.__name__}: running')
msg = await self.receive(timeout=5)
if msg:
parsed_msg = msg.body.lower().split(" ")
if len(parsed_msg) == 1 and parsed_msg[0] == self.agent.race_name:
self.agent.participants.append(Driver(msg.sender))
print(self.agent.participants)
if len(self.agent.participants) < MAX_DRIVERS:
self.set_next_state(CHOOSING_PARTICIPANTS)
else:
self.set_next_state(STARTING_RACE)
else:
self.set_next_state(STARTING_RACE)
