def SearchContentFromFiles(self, keys): self.InitKeyArray(keys) if len(self.keyWords) > 0 and len(self.excelDict) > 0: for key in self.excelDict.keys(): value = self.excelDict[key] # print(value.columns) for col in self.keyWords: listofPos = self.GetIndexes(value, col) finalValue = "" if len(listofPos) > 0: rowIndex = listofPos[0][0] colIndex = listofPos[0][1] finalValue = value.iloc[rowIndex, colIndex + 1] else: if not self.IsForcedCol(col): logger.warning("在文件%s 没找到的列名%d", key, col) if self.colValuesDict.get(col) == None: # print("列名为空,要初始化,列名是:", key, col) colValues = list() if self.IsForcedCol(col): finalValue = key colValues.append(finalValue) self.colValuesDict[col] = colValues else: if self.IsForcedCol(col): finalValue = key self.colValuesDict[col].append(finalValue)
def reload(self, fileName): try: config = Config.loadConfigFile(fileName) self.__dict__ = config if config is not None else dict() self.reloaded.emit() except: logger.warning("Can't reload from file `{0}'.".format(fileName))
def __init__(self): super().__init__() try: config = Config.loadConfigFile('config.yaml') except: logger.warning("Can't load `config.yaml', using `defaultConfig.yaml' instead.") config = Config.loadConfigFile('defaultConfig.yaml') finally: self.__dict__ = config if config is not None else dict()
def setStatus(self, status): # check if new status is a valid state. if status not in list(map(int, Status)): logger.warning("Status: " + str(status) + " is invalid, setting STOP status.") self.status = Status.STOP return # backup last status self.prevStatus = self.status # set new status self.status = status
def update(self): self.updateExternalController() collisionImminent = False isUTurning = self.pathRunner.isUTurning() isParking = self.parking.isParking() isParked = self.parking.isParked() isSearchingPark = self.parking.isSearchingPark() isManualActive = self.manualDrive.isEnabled() isGoalReached = self.pathRunner.isGoalReach() collisionImminent = self.collisionAvoidance.isCollisionDetected() obstacleDetected = self.collisionAvoidance.isObstacleDetected() logger.debug("collissionImminent: " + str(collisionImminent) + " obstacleDetected: " + str(obstacleDetected) + " isUTurning: " + str(isUTurning)) if self.status == PATH_FOLLOWING: logger.debug("MOTION: PathFollowing") self.updatePathRunner() # During path find a object that can be avoid if collisionImminent and not isUTurning: self.setStatus(COLLISION_AVOIDANCE) if isGoalReached: self.parking.enable() self.setStatus(PARKING) elif self.status == PARKING: logger.debug("MOTION: Parking") self.updateParking() if isParked: self.setStatus(STOP) # During parking find a object that can be avoid if collisionImminent and isSearchingPark: self.setStatus(COLLISION_AVOIDANCE) elif self.status == COLLISION_AVOIDANCE: logger.debug("MOTION: Collision Avoidance") self.updateCollisionAvoidance() if not collisionImminent: self.setPrevStatus() # During path find a object that can't be avoid if obstacleDetected and not isUTurning and self.prevStatus == PATH_FOLLOWING: logger.debug("Reset Path") self.pathRunner.updatePath() collisionImminent = False self.collisionAvoidance.resetObstacleDetection() self.setStatus(PATH_FOLLOWING) elif self.status == STOP: logger.debug("MOTION: Stop") self.setSpeed(0) self.setAngle(0) self.parking.disable() elif self.status == MANUAL: logger.debug("MOTION: Manual") self.manualDrive.enable() self.updateManualDrive() else: logger.warning("MOTION STATUS: " + str(self.status)) self.setStatus(STOP)
def parse(xml_text, configuration, is_deprovision=False): """ Parse xml tree, retrieving user and ssh key information. Return self. """ ofv_env = OvfEnv() logger.log_if_verbose(re.sub("<UserPassword>.*?<", "<UserPassword>*<", xml_text)) dom = xml.dom.minidom.parseString(xml_text) if len(dom.getElementsByTagNameNS(ofv_env.OvfNs, "Environment")) != 1: logger.error("Unable to parse OVF XML.") section = None newer = False for p in dom.getElementsByTagNameNS(ofv_env.WaNs, "ProvisioningSection"): for n in p.childNodes: if n.localName == "Version": verparts = get_node_text_data(n).split('.') major = int(verparts[0]) minor = int(verparts[1]) if major > ofv_env.MajorVersion: newer = True if major != ofv_env.MajorVersion: break if minor > ofv_env.MinorVersion: newer = True section = p if newer: logger.warning( "Newer provisioning configuration detected. Please consider updating waagent.") if section is None: logger.error( "Could not find ProvisioningSection with major version=" + str(ofv_env.MajorVersion)) return None ofv_env.ComputerName = get_node_text_data(section.getElementsByTagNameNS(ofv_env.WaNs, "HostName")[0]) ofv_env.UserName = get_node_text_data(section.getElementsByTagNameNS(ofv_env.WaNs, "UserName")[0]) if is_deprovision: return ofv_env try: ofv_env.UserPassword = get_node_text_data(section.getElementsByTagNameNS(ofv_env.WaNs, "UserPassword")[0]) except (KeyError, ValueError, AttributeError, IndexError): pass try: cd_section = section.getElementsByTagNameNS(ofv_env.WaNs, "CustomData") if len(cd_section) > 0: ofv_env.CustomData = get_node_text_data(cd_section[0]) if len(ofv_env.CustomData) > 0: ext_utils.set_file_contents(constants.LibDir + '/CustomData', bytearray( translate_custom_data(ofv_env.CustomData, configuration))) logger.log('Wrote ' + constants.LibDir + '/CustomData') else: logger.error('<CustomData> contains no data!') except Exception as e: logger.error(str(e) + ' occured creating ' + constants.LibDir + '/CustomData') disable_ssh_passwd = section.getElementsByTagNameNS(ofv_env.WaNs, "DisableSshPasswordAuthentication") if len(disable_ssh_passwd) != 0: ofv_env.DisableSshPasswordAuthentication = (get_node_text_data(disable_ssh_passwd[0]).lower() == "true") for pkey in section.getElementsByTagNameNS(ofv_env.WaNs, "PublicKey"): logger.log_if_verbose(repr(pkey)) fp = None path = None for c in pkey.childNodes: if c.localName == "Fingerprint": fp = get_node_text_data(c).upper() logger.log_if_verbose(fp) if c.localName == "Path": path = get_node_text_data(c) logger.log_if_verbose(path) ofv_env.SshPublicKeys += [[fp, path]] for keyp in section.getElementsByTagNameNS(ofv_env.WaNs, "KeyPair"): fp = None path = None logger.log_if_verbose(repr(keyp)) for c in keyp.childNodes: if c.localName == "Fingerprint": fp = get_node_text_data(c).upper() logger.log_if_verbose(fp) if c.localName == "Path": path = get_node_text_data(c) logger.log_if_verbose(path) ofv_env.SshKeyPairs += [[fp, path]] return ofv_env
def _unified_diff(self): functions = {} re_control = re.compile(r"^@@ -(.*) \+(.*) @@") lh_index, lh_content = self._get_indexer(self._file1) rh_index, rh_content = self._get_indexer(self._file2) lines = list(difflib.unified_diff(lh_content, rh_content, n=0)) cursor = 0 while cursor < len(lines): line = lines[cursor].strip() cursor += 1 if line.startswith(('+++', '---')): continue ''' Consume range-info together with corresponding chunk range-info format is: @@ -l,s +l,s @@ optional section heading - => range-info is for left-hand file + => range-info is for right-hand file l => is the starting line number s => is the number of _total_lines the change hunk applies ,s => is optional, and if omitted number-of-_total_lines defaults to 1. ''' match = re_control.match(line) if match is not None: lh = match.group(1).split(',') rh = match.group(2).split(',') lh_start = int(lh[0]) if len(lh) <= 1: lh_range = 1 else: lh_range = int(lh[1]) rh_start = int(rh[0]) if len(rh) <= 1: rh_range = 1 else: rh_range = int(rh[1]) cursor, diffchunk = self._consume_chunk(lines, cursor) diffcursor = 0 # if len(diffchunk) <= 0, we can assume that entire diffchunk have been filtered out due # to ignore_attributes, so therefore we skip this chunk if len(diffchunk) <= 0: continue if lh_range == rh_range: ''' If ranges are equal, assume that entire diffchunk are line-by-line changes ''' for index in range(0, rh_range): linenr = rh_start + index # Use rh func names, due to that if there was a rename, diff should be reported on the new name func, total_ = rh_index.get_function_by_linenr(linenr) try: (added, changed, deleted, total) = functions[func] except KeyError: added, changed, deleted, total = 0, 0, 0, 0 changed += 1 functions[func] = (added, changed, deleted, total_) else: while diffcursor < len(diffchunk): op, line = diffchunk[diffcursor] diffcursor += 1 added_, changed_, deleted_ = 0, 0, 0 if lh_range != 0: # Only left-hand changes linenr = lh_start + diffcursor - 1 func, _ = lh_index.get_function_by_linenr(linenr) if op == '-': deleted_ += 1 elif op == '+': added_ += 1 elif rh_range != 0: # Only right-hand changes linenr = rh_start + diffcursor - 1 func, _ = rh_index.get_function_by_linenr(linenr) if op == '-': deleted_ += 1 elif op == '+': added_ += 1 else: logger.warning("strange range combo:%s at line:%s", match.group(0), diffcursor) exit(-1) try: (added, changed, deleted, total) = functions[func] except KeyError: added, changed, deleted, total = 0, 0, 0, 0 added += added_ changed += changed_ deleted += deleted_ # Use rh to calculate function total length, since that is the "new" total. rh_func, total = rh_index.get_function_by_linenr(linenr) # if we could not find func in rh side, that means that function got deleted, and thus should # have size=0, otherwise we report size of random function (or likely global scope) if rh_func != func: total = 0 functions[func] = (added, changed, deleted, total) return functions
def computeParkingAngleAndSpeed(self): logger.debug("PARKING STATE: " + str(self.status)) # get distance sensors ds = self.distanceSensors # set reference distanceTraveled = self.positioning.getActualDistance() side = 0 front = 0 rear = 0 bside = 0 fside = 0 if self.status > SEARCH and self.sideOfParkingLot != UNKNOWN: # get rear and side sensors values rear = self.distanceSensors.backCenter.getValue() front = self.distanceSensors.frontCenter.getValue() if self.sideOfParkingLot == RIGHT: side = self.distanceSensors.sideRight.getValue() bside = self.distanceSensors.backRight.getValue() fside = self.distanceSensors.frontRight.getValue() elif self.sideOfParkingLot == LEFT: side = self.distanceSensors.sideLeft.getValue() bside = self.distanceSensors.backLeft.getValue() fside = self.distanceSensors.frontLeft.getValue() # SEARCH status 2 if self.status == SEARCH: # set slow speed self.speed = 0.2 # set straight wheels self.angle = self.lineFollower.getNewSteeringAngle() if self.lineFollower.isLineLost(): self.resetParkingPosition() self.angle = self.lineFollower.getSteeringAngleLineSearching() logger.debug("PARKING angle from Line Follower: " + str(self.angle)) if abs(self.angle) > 0.25: self.resetParkingPosition() # side threshold, if side sensor is greather than threshold the parking lot if occupied sideThreshold = 650 # get side left sensors values leftSensorValue = ds.sideLeft.getValue() rightSensorValue = ds.sideRight.getValue() # checking parking lot on the LEFT side if leftSensorValue < sideThreshold and not self.leftIsEmpty: self.leftIsEmpty = True self.leftStartingPosition = distanceTraveled elif leftSensorValue > sideThreshold and self.leftIsEmpty: self.leftIsEmpty = False elif self.leftIsEmpty and distanceTraveled - self.leftStartingPosition > CAR_LENGTH + ( CAR_LENGTH * 2 / 3): self.leftStartingPosition = distanceTraveled self.sideOfParkingLot = LEFT self.status = FORWARD # checking parking lot on the RIGHT side if rightSensorValue < sideThreshold and not self.rightIsEmpty: self.rightIsEmpty = True self.rightStartingPosition = distanceTraveled elif rightSensorValue > sideThreshold and self.rightIsEmpty: self.rightIsEmpty = False elif self.rightIsEmpty and distanceTraveled - self.rightStartingPosition > CAR_LENGTH + ( CAR_LENGTH * 2 / 3): self.rightStartingPosition = distanceTraveled self.sideOfParkingLot = RIGHT self.status = FORWARD # FORWARD status 3 # this ensure that the parking manoeuvre starts after going forward and not as soon as the parking lot is detected elif self.status == FORWARD: # distance to travel before starting the maneuver distance = 0.13 # check if distance traveled is greater than distance to travel if self.sideOfParkingLot == LEFT: if distanceTraveled - self.leftStartingPosition >= distance: self.status = PARKING elif self.sideOfParkingLot == RIGHT: if distanceTraveled - self.rightStartingPosition >= distance: self.status = PARKING else: # if parking is found but is not set the side logger.warning( "Parking lot found! But I don't know if right or left. Looking for anther one." ) self.status = SEARCH # starting the parking manoeuvre 4 elif self.status == PARKING: # check is the side of the parking lot is known if self.sideOfParkingLot != LEFT and self.sideOfParkingLot != RIGHT: logger.error("Side of parking lot is unknown.") # stop the vehicle, turn the wheels and go back slowly self.angle = self.sideOfParkingLot self.speed = -0.1 # back thresholds that tells when contursteer backCenterThreshold = 610 backSideThreshold = 410 if self.sideOfParkingLot == LEFT: backCenterThreshold = 625 backSideThreshold = 425 # debug log logger.debug("Rear: " + str(rear) + " Back Park Side: " + str(bside)) # if true countersteer if bside > backSideThreshold or rear > backCenterThreshold: self.status = PARKING2 # PARKING2 status 5 elif self.status == PARKING2: # set countersteering angle if self.angle != 0: self.angle = -1 * self.sideOfParkingLot self.speed = -0.05 # set side and back threshold rearThreshold = 985 sideThreshold = 945 backSideThreshold = 915 # debug log logger.debug("sideOfParkingLot: " + str(self.sideOfParkingLot) + " side: " + str(side)) # check if the park is completed if (bside <= fside and side >= 865): self.status = CENTER # check if need some orient adjust if self.distanceSensors.backDistance( sideThreshold): #and bside > fside: self.status = ADJUST_POSITION # ADJUST_POSITION status 6 elif self.status == ADJUST_POSITION: # debug log logger.debug("Need to adjust position") # set angle self.angle = self.sideOfParkingLot self.speed = 0.05 # check if the park is completed if (bside < fside and side > 865): self.status = CENTER if front > 925 or fside > 925 or not self.distanceSensors.backDistance( 825): self.angle = -1 * self.sideOfParkingLot self.status = PARKING2 # CENTER status 7 elif self.status == CENTER: if rear > 950 or (rear < 100 and front < 700): self.speed = 0.05 elif front > 950 or (front < 100 and rear < 700): self.speed = -0.05 # set angle streight if abs(bside - fside) < 50 and abs(rear - front) < 80: self.angle = 0.0 self.status = STOP logger.debug( "TRYING TO STAY CENTER: same distance sides and rear and front!" ) elif abs(bside - fside) < 50 and rear < 100 and front > 700: self.angle = 0.0 self.status = STOP logger.debug( "TRYING TO STAY CENTER: there's nothing behind, stay ahead!" ) elif abs(bside - fside) < 50 and rear < 100 and front > 700: self.angle = 0.0 self.status = STOP logger.debug( "TRYING TO STAY CENTER: there's nothing behind, stay ahead!" ) elif abs(bside - fside) < 50 and front < 100 and rear > 700: self.angle = 0.0 self.status = STOP logger.debug( "TRYING TO STAY CENTER: there's nothing ahead, stay behind!" ) elif abs(bside - fside) < 20: self.angle = 0.0 logger.debug("TRYING TO STAY CENTER: same distance sides!") else: if self.speed > 0: nextAngle = 0.2 else: nextAngle = -0.2 if fside < bside: nextAngle *= self.sideOfParkingLot else: nextAngle *= -self.sideOfParkingLot self.angle = nextAngle logger.debug("TRYING TO STAY CENTER: NEED TO GO " + ("right" if self.angle > 0 else "left")) # STOP status 8 elif self.status == STOP: self.speed = 0.0 self.angle = 0.0 # invalid status else: logger.debug("Invalid parcking status")
def run(self): logger.info("Running..") leftIsEmpty = False # flag used to detect left parking lot rightIsEmpty = False # flag used to detect right parking lot leftStartingPosition = 0.0 # length of the left parking lot rightStartingPosition = 0.0 # length of the right parking lot sideOfParkingLot = 0 # indicates the side of the parking lot found: -1 left, 1 right, 0 not found yet actualTurn = 0 while self.driver.step() != -1: ## here goes code that should be executed each step ## # get actual compass value #compassValues = self.compass.getValues() #logger.debug("COMPASS: "******"INIT status") # set wheel angle self.setAngle(0.0) # set starting speed self.setSpeed(0.5) # set new status self.setStatus(Status.TURN) # skip to next cycle to ensure everything is working fine continue # FOLLOW LINE STATUS if self.status == Status.FOLLOW_LINE: # set cruise speed self.setSpeed(0.5) # compute new angle newAngle = self.lineFollower.getNewSteeringAngle() # logger.debug("new steering angle: " + str(newAngle)) # set new steering angle if newAngle != UNKNOWN: self.setAngle(newAngle) else: self.setStatus(Status.TURN) # TURN STATUS if self.status == Status.TURN: if actualTurn < len(self.turns): turn = self.turns[actualTurn] self.setAngle(0.5 * turn * MAX_ANGLE) else: self.setStatus(Status.STOP) # compute new angle newAngle = self.lineFollower.getNewSteeringAngle() # if line is found if newAngle != UNKNOWN: self.setStatus(Status.FOLLOW_LINE) actualTurn += 1 continue # FORWARD STATUS if self.status == Status.FORWARD: # logger.debug("FORWARD status") # set cruise speed self.setSpeed(0.2) # avoing obstacles ds = self.distanceSensors # get distance sensors values frontLeftSensor = ds.frontLeft.getValue() frontRightSensor = ds.frontRight.getValue() sideLeftSensor = ds.sideLeft.getValue() sideRightSensor = ds.sideRight.getValue() # set values of thresholds tolerance = 10 sideThreshold = 950 # check if front left obstacle, turn right if frontLeftSensor > frontRightSensor + tolerance: self.setAngle(RIGHT * frontLeftSensor / 500.0 * MAX_ANGLE) # logger.debug("Steering angle: " + str(RIGHT * frontLeftSensor / 1000.0 * MAX_ANGLE)) logger.debug("Steering angle: " + str(self.angle)) # check if front right obstacle, turn left elif frontRightSensor > frontLeftSensor + tolerance: self.setAngle(LEFT * frontRightSensor / 500.0 * MAX_ANGLE) # logger.debug("Steering angle: " + str(LEFT * frontRightSensor / 1000.0 * MAX_ANGLE)) logger.debug("Steering angle: " + str(self.angle)) # check if side left obstacle, turn slight right elif sideLeftSensor > sideThreshold: self.setAngle(RIGHT * sideLeftSensor / 4000.0 * MAX_ANGLE) # check if side right obstacle, turn slight left elif sideRightSensor > sideThreshold: self.setAngle(LEFT * sideRightSensor / 4000.0 * MAX_ANGLE) # if no obstacle go straight else: self.setAngle(self.angle / 1.5) # SEARCHING_PARK STATUS if self.status == Status.SEARCHING_PARK: # set slow speed self.setSpeed(0.2) # set straight wheels self.setAngle(0.0) # get distance and position sensors ds = self.distanceSensors ps = self.positionSensors #log info for debug logger.debug("Left Distance Sensor: " + str(ds.sideLeft.getValue())) logger.debug("Left Position Sensor: " + str(ps.frontLeft.getValue()) + " rad") logger.debug("Left Wheel Length: " + str(self.leftWheelDistance) + " m") logger.debug("Starting position: " + str(leftStartingPosition) + " m") logger.debug("Parking Lot Length: " + str(self.leftWheelDistance - leftStartingPosition) + " m") sideThreshold = 650 leftSensorValue = ds.sideLeft.getValue() rightSensorValue = ds.sideRight.getValue() # checking parking lot on the LEFT side if leftSensorValue < sideThreshold and not leftIsEmpty: leftIsEmpty = True leftStartingPosition = self.leftWheelDistance # 100 elif leftSensorValue > sideThreshold and leftIsEmpty: leftIsEmpty = False elif leftIsEmpty and self.leftWheelDistance - leftStartingPosition > LENGTH + LENGTH / 3: leftStartingPosition = self.leftWheelDistance # 200 - 100 sideOfParkingLot = LEFT self.setStatus(Status.FORWARD2) # checking parking lot on the RIGHT side if rightSensorValue < sideThreshold and not rightIsEmpty: rightIsEmpty = True rightStartingPosition = self.rightWheelDistance elif rightSensorValue > sideThreshold and rightIsEmpty: rightIsEmpty = False elif rightIsEmpty and self.rightWheelDistance - rightStartingPosition > LENGTH + LENGTH / 3: rightStartingPosition = self.rightWheelDistance sideOfParkingLot = RIGHT self.setStatus(Status.FORWARD2) # this ensure that the parking manoeuvre starts after going forward and not as soon as the parking lot is detected if self.status == Status.FORWARD2: distance = 0.19 if sideOfParkingLot == LEFT: if self.leftWheelDistance - leftStartingPosition > distance: self.status = Status.PARKING elif sideOfParkingLot == RIGHT: if self.rightWheelDistance - rightStartingPosition > distance: self.status = Status.PARKING else: logger.warning( "Parking lot not found! I don't know if right or left." ) self.setStatus(Status.SEARCHING_PARK) # starting the parking manoeuvre if self.status == Status.PARKING: if sideOfParkingLot != LEFT and sideOfParkingLot != RIGHT: logger.error("side of parking lot unknown.") exit(1) # stop the vehicle, turn the wheels and go back self.setSpeed(0.0) self.setAngle(sideOfParkingLot * MAX_ANGLE) self.setSpeed(-0.1) # when should it turn the other way backThreshold = 400 ds = self.distanceSensors rear = ds.back.getValue() logger.debug("Back sensor: " + str(rear)) if rear > backThreshold: self.status = Status.PARKING2 if self.status == Status.PARKING2: self.setAngle(-1 * sideOfParkingLot * MAX_ANGLE) threshold = 945 rear = self.distanceSensors.back.getValue() if rear > threshold: self.setStatus(Status.CENTER) if self.status == Status.CENTER: self.setAngle(0.0) self.setSpeed(0.2) rear = self.distanceSensors.back.getValue() front = self.distanceSensors.frontCenter.getValue() if rear - front < 20: self.setStatus(Status.STOP) if self.status == Status.STOP: self.setSpeed(0.0) self.setAngle(0.0) # if obstacle is cleared go forward if not self.avoidObstacle( ) and self.prevStatus == Status.PARKING2: self.setStatus(Status.FORWARD) if self.status == Status.MANUAL: # get current state speed = self.speed angle = self.angle # logger.debug("Current Key: " + str(currentKey)) # keyboard controlls # accelerate if currentKey == self.keyboard.UP: if speed < 0: speed += 0.02 else: speed += 0.008 # break elif currentKey == self.keyboard.DOWN: if speed > 0: speed -= 0.02 else: speed -= 0.008 # turn left elif currentKey == self.keyboard.LEFT: angle -= 0.01 # turn right elif currentKey == self.keyboard.RIGHT: angle += 0.01 # handbreak elif currentKey == ord(' '): speed /= 4 # update state self.setSpeed(speed) self.setAngle(angle)