def redraw(self): wlogger.log_info("Redraw Lights") glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) glPushMatrix() # Translate to face location. glTranslatef(0.0, 0.0, -0.5) glColor(0.0, 0.3, 0.1) glBegin(GL_QUADS) # start drawing a rectangle glVertex2f(-3, -3) # bottom left point glVertex2f(3, -3) # bottom right point glVertex2f(3, 3) # top right point glVertex2f(-3, 3) # top left point glEnd() glPopMatrix() glPushMatrix() glTranslatef(-2.8, 2.8, -0.47) for strip in self.LightStripArray: glPushMatrix() self.drawStrip(strip) glPopMatrix() glTranslate(0.0, -self.led_row_spacing, 0.0) glPopMatrix() # Refresh display pygame.display.flip()
def all_off(strip, blockList): """ This function turns all LEDs in the blocks given off.""" if not blockList: return if print_debug: print("----------------------------") print("All Off") print(config.current_brightness) # The index of the LED within the current blocks. local_led_index = 0 for block in blockList: if block.get_direction(): ledList = np.arange(block.get_end_index() - 1, block.get_start_index() - 1, -1) else: ledList = np.arange(block.get_start_index(), block.get_end_index()) for led in ledList: # Paint LED black. strip.set_pixel(led, 0.0, 0.0, 0.0) local_led_index += 1 info_string = "Pattern: All Off." wlogger.log_info(info_string)
def __init__(self, num_led, global_brightness=MAX_BRIGHTNESS, order='rgb', mosi=10, sclk=11, max_speed_hz=8000000): """Initializes the library. """ wlogger.log_info("Set up Strip") self.num_led = num_led # The number of LEDs in the Strip order = order.lower() self.rgb = RGB_MAP.get(order, RGB_MAP['rgb']) self.strip_id = APA102.NEXT_STRIP_ID APA102.NEXT_STRIP_ID += 1 wlight.lightController.LightStripArray.append(self) # Limit the brightness to the maximum if it's set higher if global_brightness > self.MAX_BRIGHTNESS: self.global_brightness = self.MAX_BRIGHTNESS else: self.global_brightness = global_brightness self.leds = [self.LED_START, 0, 0, 0] * self.num_led # Pixel buffer
def re_centre(self, stepSize): """ This function calculates which eye is further from the centre and then calls the StepTowardsCentre function to move that eye closer to the centre""" wlogger.log_info("Performing Recentre") tol = 0.01 while ((-tol > abs(self.RightEye.eye_vert_angle) or abs(self.RightEye.eye_vert_angle) > tol) or (-tol > abs(self.RightEye.eye_horiz_angle) or abs(self.RightEye.eye_horiz_angle) > tol) or (-tol > abs(self.LeftEye.eye_vert_angle) or abs(self.LeftEye.eye_vert_angle) > tol) or (-tol > abs(self.LeftEye.eye_horiz_angle) or abs(self.LeftEye.eye_horiz_angle) > tol)): right_eye_distance_sq = self.RightEye.eye_vert_angle**2 + self.RightEye.eye_horiz_angle**2 left_eye_distance_sq = self.LeftEye.eye_vert_angle**2 + self.LeftEye.eye_horiz_angle**2 # If the step size is bigger than the distance remaining there is a chance of overstepping # - only step the smaller distance. if right_eye_distance_sq > left_eye_distance_sq: if stepSize**2 > right_eye_distance_sq: self.StepTowardsCentre(self.RightEye, math.sqrt(right_eye_distance_sq)) else: self.StepTowardsCentre(self.RightEye, stepSize) else: if stepSize**2 > left_eye_distance_sq: self.StepTowardsCentre(self.LeftEye, math.sqrt(left_eye_distance_sq)) else: self.StepTowardsCentre(self.LeftEye, stepSize)
def show(self): """Sends the content of the pixel buffer to the strip. Todo: More than 1024 LEDs requires more than one xfer operation. Done by mikey- needs testing """ start_frame = self.clock_start_frame() end_frame = self.clock_end_frame() led_buffer = np.concatenate((start_frame, self.leds, end_frame)) packetnum = len(list(led_buffer)) transfersize = 4096 transfernum = int(packetnum / transfersize) for x in range(0, transfernum): out_array = led_buffer[x * transfersize:(x + 1) * transfersize] outArrayAsList = out_array.tolist() if log_buffer: wlogger.log_info(outArrayAsList) self.spi.write(outArrayAsList) out_array = led_buffer[(transfernum * transfersize):packetnum] outArrayAsList = out_array.tolist() if log_buffer: wlogger.log_info(outArrayAsList) self.spi.write(outArrayAsList)
def unsafe_move_to_mapped_position(self, horiz_angle, vert_angle): # Map the new angle against a correction matrix, which accounts for the mechanism of the eye. servo_angle_horiz, servo_angle_vert = self.map_eye_to_servo( horiz_angle, vert_angle) # Convert the corrected angle into a PWM tick count and therefore duty cycle servo_pwm_period_vert = self.conv_servo_angle_ms(int(servo_angle_vert)) servo_pwm_period_horiz = self.conv_servo_angle_ms( int(servo_angle_horiz)) #print("Servo PWM period Vert: " + str(servo_pwm_period_vert)) #print("Servo PWM period Horiz: " + str(servo_pwm_period_horiz)) # Apply this new duty cycle to the servomotor successful_move = False num_tries = 0 while not successful_move and num_tries < 1000: try: self.eye.set_pwm(self.vert_ch, 0, int(servo_pwm_period_vert)) self.eye.set_pwm(self.horiz_ch, 0, int(servo_pwm_period_horiz)) successful_move = True except IOError as e: if print_debug: print("ExceptionCaught") wlogger.log_info("Exception Caught") wlogger.log_info(e) successful_move = False num_tries += 1 pass #Update the positions self.eye_horiz_angle = horiz_angle self.eye_vert_angle = vert_angle
def end_test(strip, blockList): """ This function turns the LEDs in the given blocks on.""" if not blockList: return current_colour = blockList[0].get_colour() if print_debug: print("----------------------------") print("End Test") for block in blockList: # Paint single LEDS with given colour strip.set_pixel( block.get_start_index(), math.floor(enums.colourDi[enums.WColour.Blue][0] * 255), math.floor(enums.colourDi[enums.WColour.Blue][1] * 255), math.floor(enums.colourDi[enums.WColour.Blue][2] * 255), config.current_brightness) strip.set_pixel(block.get_start_index() + 1, math.floor(enums.colourDi[enums.WColour.Red][0] * 255), math.floor(enums.colourDi[enums.WColour.Red][1] * 255), math.floor(enums.colourDi[enums.WColour.Red][2] * 255), config.current_brightness) strip.set_pixel(block.get_start_index() + 2, math.floor(enums.colourDi[enums.WColour.Red][0] * 255), math.floor(enums.colourDi[enums.WColour.Red][1] * 255), math.floor(enums.colourDi[enums.WColour.Red][2] * 255), config.current_brightness) strip.set_pixel( block.get_end_index() - 1, math.floor(enums.colourDi[enums.WColour.Blue][0] * 255), math.floor(enums.colourDi[enums.WColour.Blue][1] * 255), math.floor(enums.colourDi[enums.WColour.Blue][2] * 255), config.current_brightness) strip.set_pixel(block.get_end_index() - 2, math.floor(enums.colourDi[enums.WColour.Red][0] * 255), math.floor(enums.colourDi[enums.WColour.Red][1] * 255), math.floor(enums.colourDi[enums.WColour.Red][2] * 255), config.current_brightness) strip.set_pixel(block.get_end_index() - 3, math.floor(enums.colourDi[enums.WColour.Red][0] * 255), math.floor(enums.colourDi[enums.WColour.Red][1] * 255), math.floor(enums.colourDi[enums.WColour.Red][2] * 255), config.current_brightness) info_string = "Pattern: End Test. Colour: " + str(current_colour) \ + ". Brightness: " + str(config.current_brightness) wlogger.log_info(info_string)
def singles(strip, num_steps_per_cycle, current_step, current_cycle, blockList): """ This function moves single LEDs along the LED strip indices given""" if not blockList: return single_gap = 9 current_colour = blockList[0].get_colour() current_speed = blockList[0].get_speed() if print_debug: print("----------------------------") print("Singles") print(current_speed) print(current_colour) print(config.current_brightness) # Pattern specific behaviour pattern_speed_factor = 1 num_steps_per_pattern_step = enums.speedDi[ current_speed] * pattern_speed_factor # The index of the LED within the current blocks. local_led_index = 0 for block in blockList: if block.get_direction(): ledList = np.arange(block.get_end_index() - 1, block.get_start_index() - 1, -1) else: ledList = np.arange(block.get_start_index(), block.get_end_index()) for led in ledList: if (local_led_index + blockList[0].get_pattern_index()) % (single_gap + 1) == 0: # Paint single LEDS with given colour strip.set_pixel( led, math.floor(enums.colourDi[current_colour][0] * 255), math.floor(enums.colourDi[current_colour][1] * 255), math.floor(enums.colourDi[current_colour][2] * 255), config.current_brightness) else: # Paint gap LED black. strip.set_pixel(led, 0.0, 0.0, 0.0) local_led_index += 1 if (current_step % num_steps_per_pattern_step == 0): blockList[0].increment_pattern_index(1) info_string = "Pattern: Singles. Colour: " + str(current_colour) + ". Speed: " \ + str(current_speed) + ". Brightness: " + str(config.current_brightness) wlogger.log_info(info_string)
def extreme_left(self, stepSize): """ This function moves the eyes to the extreme left position. It only affects the Y Axis (left to right)""" wlogger.log_info("Performing Extreme Left") while (self.LeftEye.eye_horiz_angle - stepSize) > -self.LeftEye.eye_movement_max_radius and ( self.RightEye.eye_horiz_angle - stepSize) > -self.LeftEye.eye_movement_max_radius: self.LeftEye.step_horiz_angle(-stepSize) self.RightEye.step_horiz_angle(-stepSize) self.redraw()
def Straight_Eye_Roll(self, stepSize): """ This function represents one of Gromits animated eye rolls.""" wlogger.log_info("Performing Straight Eye Roll") restPosition = [20, 0, -20, 0] startPosition = [0, -25, 0, -25] self.straight_to_point(stepSize, startPosition) #Section for individual movements self.straight_to_point(stepSize, restPosition)
def kbhit(self): ''' Returns True if keyboard character was hit, False otherwise. ''' wlogger.log_info("Keyboard Polled") if os.name == 'nt': return msvcrt.kbhit() else: dr, dw, de = select([sys.stdin], [], [], 0) return dr != []
def extreme_down(self, stepSize): """ This function moves the eyes to the extreme down position. It only affects the X Axis (up and down) This assumes that the eye is starting at the centre and is a test routine""" wlogger.log_info("Performing Extreme Down") while (self.LeftEye.eye_vert_angle - stepSize) > -self.LeftEye.eye_movement_max_radius and ( self.RightEye.eye_vert_angle - stepSize) > -self.RightEye.eye_movement_max_radius: self.LeftEye.step_vert_angle(-stepSize) self.RightEye.step_vert_angle(-stepSize) self.redraw()
def extreme_right(self, stepSize): """ This function moves the eyes to the extreme right position. It only affects the Y Axis (left to right) This assumes that the eye is starting at the centre and is a test routine""" wlogger.log_info("Performing Extreme Right") while (self.LeftEye.eye_horiz_angle + stepSize) < self.LeftEye.eye_movement_max_radius and ( self.RightEye.eye_horiz_angle + stepSize) < self.RightEye.eye_movement_max_radius: self.LeftEye.step_horiz_angle(stepSize) self.RightEye.step_horiz_angle(stepSize) self.redraw()
def __init__(self): """ Create Controller """ wlogger.log_info("Initialising Light Controller") self.LightStripArray = [] self.led_size = 0.1 self.led_spacing = 0.11 self.led_row_length = 50 self.led_row_spacing = 1
def acquire(self, blocking=True): """Acquire the lock. If the lock is not already acquired, return None. If the lock is acquired and blocking is True, block until the lock is released. If the lock is acquired and blocking is False, raise an IOError. """ ops = fcntl.LOCK_EX if not blocking: ops |= fcntl.LOCK_NB fcntl.flock(self.lock_file, ops) wlogger.log_info("Lock Aquired")
def cross_eyes_checker(self): """ This function checks the current positions of the eyes in relation to each other and returns an integer symbolising how to proceed with crossing the eyes""" wlogger.log_info("Performing Eye Position Check") if self.LeftEye.eye_horiz_angle < self.LeftEye.eye_movement_max_radius and self.RightEye.eye_horiz_angle > -self.RightEye.eye_movement_max_radius: return 1 elif self.LeftEye.eye_horiz_angle < self.LeftEye.eye_movement_max_radius and self.RightEye.eye_horiz_angle == -self.RightEye.eye_movement_max_radius: return 2 elif self.LeftEye.eye_horiz_angle == self.LeftEye.eye_movement_max_radius and self.RightEye.eye_horiz_angle > -self.RightEye.eye_movement_max_radius: return 3 else: return 0
def set_tail_on(self): if print_debug: print("Tail On") GPIO.output(config.touchOutputPin, GPIO.HIGH) successful_move = False num_tries = 0 while not successful_move and num_tries < 1000: try: self.motor.set_pwm(self.forward_ch, 0, 2250) # Calibrated self.motor.set_pwm(self.backwards_ch, 0, 0) successful_move = True except IOError as e: if print_debug: print("ExceptionCaught") wlogger.log_info("Exception Caught") wlogger.log_info(e) successful_move = False num_tries += 1 pass if num_tries >= 1000: wlogger.log_info("Num Tries Reached") wlogger.log_info("Set Tail On")
def Eye_Roll(self, start_angle, end_angle, num_steps): """Performs a full circle of the eyes.""" # Convert cartesian step size to an angle step. interval = (end_angle - start_angle) / num_steps rad_interval = interval * math.pi / 180 angle_rad = start_angle * math.pi / 180 end_angle_rad = end_angle * math.pi / 180 # If the distance is 0 just stay in one place if interval == 0: for i in range(0, num_steps): horiz_angle = self.LeftEye.eye_movement_max_radius * math.cos( start_angle) vert_angle = self.LeftEye.eye_movement_max_radius * math.sin( start_angle) #print(vert_angle) #print(horiz_angle) self.move_to(horiz_angle, vert_angle) time.sleep(0.01) wlogger.log_info("Performing Eye Roll") while angle_rad < end_angle_rad: horiz_angle = self.LeftEye.eye_movement_max_radius * math.cos( angle_rad) vert_angle = self.LeftEye.eye_movement_max_radius * math.sin( angle_rad) angle_rad += rad_interval #print(horiz_angle) #print(vert_angle) self.move_to(horiz_angle, vert_angle) time.sleep(0.01) horiz_angle = self.LeftEye.eye_movement_max_radius * math.cos( end_angle_rad) vert_angle = self.LeftEye.eye_movement_max_radius * math.sin( end_angle_rad) angle_rad += rad_interval #print(horiz_angle) #print(vert_angle) self.move_to(horiz_angle, vert_angle) time.sleep(0.01)
def test_file_rotation(self, mock_get_now): mock_get_now = mock.Mock.return_value = datetime.datetime(1960, 1, 1, 8, 10, 10) wlogger.setup_loggers(os.path.join(self.test_data_dir, 'Temp'), debug_on=True, test_mode_on=True, name='test_file_rotation', maxBytes=1000) for i in range(0, 1000): wlogger.log_info('Info Message ' + str(i), name='test_file_rotation') wlogger.log_debug('Debug Message ' + str(i), name='test_file_rotation') wlogger.log_error('Error Message ' + str(i), name='test_file_rotation') wlogger.tear_down_loggers(name='test_file_rotation') self.log_test_compare()
def fixed_morse(strip, num_steps_per_cycle, current_step, current_cycle, morse, colour_b, blockList): """ This function moves Renishaw in morse code along the LED strip indices given""" if not blockList: return current_colour = blockList[0].get_colour() current_b = colour_b if print_debug: print("----------------------------") print("Fixed Morse") print(current_colour) print(config.current_brightness) # The index of the LED within the current blocks. local_led_index = 0 for block in blockList: if block.get_direction(): ledList = np.arange(block.get_end_index() - 1, block.get_start_index() - 1, -1) else: ledList = np.arange(block.get_start_index(), block.get_end_index()) for led in ledList: if local_led_index < len(morse) and morse[local_led_index]: # Paint snake LEDS with given colour strip.set_pixel(led, math.floor(enums.colourDi[colour_b][0] * 255), math.floor(enums.colourDi[colour_b][1] * 255), math.floor(enums.colourDi[colour_b][2] * 255), config.current_brightness) else: # Paint gap LED black. strip.set_pixel( led, math.floor(enums.colourDi[colour_b][0] * 255), math.floor(enums.colourDi[current_colour][1] * 255), math.floor(enums.colourDi[current_colour][2] * 255), config.current_brightness) local_led_index += 1 info_string = "Pattern: Fixed Morse. Colour: " + str(current_colour) \ + ". Brightness: " + str(config.current_brightness) wlogger.log_info(info_string)
def Low_Cross_Eyes(self, stepSize): """This function represents Gromit's eyes focussing on his nose""" wlogger.log_info("Performing Low Cross Eyes") while ((self.LeftEye.eye_vert_angle - stepSize) > -self.LeftEye.eye_movement_corner_angle and (self.LeftEye.eye_horiz_angle + stepSize) < self.LeftEye.eye_movement_corner_angle and (self.RightEye.eye_vert_angle - stepSize) > -self.RightEye.eye_movement_corner_angle and (self.RightEye.eye_horiz_angle - stepSize) > -self.RightEye.eye_movement_corner_angle): self.LeftEye.step_vert_angle(-stepSize) self.RightEye.step_vert_angle(-stepSize) self.LeftEye.step_horiz_angle(stepSize) self.RightEye.step_horiz_angle(-stepSize)
def test_message_levels_debug_off(self, mock_get_now): mock_get_now = mock.Mock.return_value = datetime.datetime(1960, 1, 1, 8, 10, 10) wlogger.setup_loggers(os.path.join(self.test_data_dir, 'Temp'), debug_on=False, test_mode_on=True, name='test_message_levels_debug_off') wlogger.log_info('Info Message', name='test_message_levels_debug_off') wlogger.log_debug('Debug Message', name='test_message_levels_debug_off') wlogger.log_error('Error Message', name='test_message_levels_debug_off') wlogger.log_info('Info Message', name='test_message_levels_debug_off') wlogger.log_debug('Debug Message', name='test_message_levels_debug_off') wlogger.log_warning('Warning Message', name='test_message_levels_debug_off') wlogger.tear_down_loggers(name='test_message_levels_debug_off') self.log_test_compare()
def control_big_leds(): # Set up pins. set_up_pins() # Set LEDs on to start. change_leds() is_LEDs_on = True continue_control = True button_already_pressed = False button_press_count = 0 count = 0 while continue_control: count += 1 # Gather button input inputButton = GPIO.input(config.touchInputPin) # Change BigLED if button is pressed. if inputButton and not button_already_pressed: GPIO.output(config.touchOutputPin, GPIO.HIGH) button_press_count += 1 button_already_pressed = True change_leds() wlogger.log_info("Button press -> LEDs Changed") if print_debug: print("Button press -> LEDs Changed", flush=True) elif not inputButton: GPIO.output(config.touchOutputPin, GPIO.LOW) button_already_pressed = False try: if count % config.num_cycles_between_button_recording == 0: record_button_presses(button_press_count) button_press_count = 0 except Exception as e: print("Recording Error") wlogger.log_info(e) pass # Small time delay between each run through. time.sleep(0.1)
def __init__(self): """ Create Controller """ wlogger.log_info("Initialising Controller") self.LeftEye = weye.Eye(1, (1, 0, 0), 4, 5) self.RightEye = weye.Eye(1, (-1, 0, 0), 6, 7) # Set up initial position - this would make more sense to do internally # but calling PCA9685(0x40) resets the signals to zero. self.LeftEye.move_to(0, 0) self.RightEye.move_to(0, 0) self.redraw() # Calibrate #Speeds self.sloth_step_size = 0.5 self.tortoise_step_size = 1 self.hare_step_size = 3 self.ostrich_step_size = 6 self.cheetah_step_size = 10 self.speeds = [ self.sloth_step_size, self.tortoise_step_size, self.hare_step_size, self.ostrich_step_size, self.cheetah_step_size ] #Positions self.resting = [20, 0, -20, 0] self.extremeLeft = [-60, 0] self.extremeRight = [60, 0] self.extremeUp = [0, 60] self.extremeDown = [0, -60] self.crossEyes = [60, 0, -60, 0] self.upLeft = [-48, 48] self.upRight = [48, 48] self.downLeft = [-48, -48] self.downRight = [48, -48] self.positions = [ self.resting, self.extremeLeft, self.extremeRight, self.extremeUp, self.extremeDown, self.crossEyes, self.upLeft, self.upRight, self.downLeft, self.downRight ]
def StepTowardsCentre(self, eye, stepSize): """ This function moves the given eye a step closer to the centre in either axis depending on which is further away""" wlogger.log_info("Performing Step Towards Centre") if abs(eye.eye_vert_angle) > abs(eye.eye_horiz_angle): #print("Vertical Step") if eye.eye_vert_angle > 0: eye.step_vert_angle(-stepSize) else: eye.step_vert_angle(stepSize) else: #print("Horizontal Step") if eye.eye_horiz_angle > 0: eye.step_horiz_angle(-stepSize) else: eye.step_horiz_angle(stepSize) self.redraw()
def cross_eyes(self, stepSize): """ This function makes Gromit go cross-eyed and the returns to centre""" wlogger.log_info("Performing Cross-Eyes") while self.cross_eyes_checker() == 1: self.LeftEye.step_horiz_angle(stepSize) self.RightEye.step_horiz_angle(-stepSize) self.redraw() while self.cross_eyes_checker() == 2: self.LeftEye.step_horiz_angle(stepSize) self.redraw() while self.cross_eyes_checker() == 3: self.RightEye.step_horiz_angle(-stepSize) self.redraw() while self.LeftEye.eye_horiz_angle > 0 > self.RightEye.eye_horiz_angle: self.LeftEye.step_horiz_angle(-stepSize) self.RightEye.step_horiz_angle(stepSize) self.redraw()
def test_basic_log(self, mock_get_now): mock_get_now = mock.Mock.return_value = datetime.datetime(1960, 1, 1, 8, 10, 10) wlogger.setup_loggers(os.path.join(self.test_data_dir, 'Temp'), test_mode_on=True, name='test_basic_log') wlogger.log_info('First Info Message', name='test_basic_log') wlogger.log_info('Second Info Message', name='test_basic_log') wlogger.log_info('Third Info Message', name='test_basic_log') wlogger.tear_down_loggers(name='test_basic_log') self.log_test_compare()
def all_on(strip, blockList): """ This function turns the LEDs in the given blocks on.""" if not blockList: return current_colour = blockList[0].get_colour() if print_debug: print("----------------------------") print("All On") print(current_colour) print(config.current_brightness) # The index of the LED within the current blocks. local_led_index = 0 for block in blockList: if block.get_direction(): ledList = np.arange(block.get_end_index() - 1, block.get_start_index() - 1, -1) else: ledList = np.arange(block.get_start_index(), block.get_end_index()) for led in ledList: # Paint single LEDS with given colour strip.set_pixel( led, math.floor(enums.colourDi[current_colour][0] * 255), math.floor(enums.colourDi[current_colour][1] * 255), math.floor(enums.colourDi[current_colour][2] * 255), config.current_brightness) local_led_index += 1 info_string = "Pattern: All On. Colour: " + str(current_colour) \ + ". Brightness: " + str(config.current_brightness) wlogger.log_info(info_string)
def __init__(self): '''Creates a KBHit object that you can call to do various keyboard things. ''' wlogger.log_info("Keyboard Listener Initialised") if os.name == 'nt': pass else: # Save the terminal settings self.fd = sys.stdin.fileno() self.new_term = termios.tcgetattr(self.fd) self.old_term = termios.tcgetattr(self.fd) # New terminal setting unbuffered self.new_term[3] = (self.new_term[3] & ~termios.ICANON & ~termios.ECHO) termios.tcsetattr(self.fd, termios.TCSAFLUSH, self.new_term) # Support normal-terminal reset at exit atexit.register(self.set_normal_term)
def test_dir_does_not_exist(self, mock_get_now): mock_get_now = mock.Mock.return_value = datetime.datetime(1960, 1, 1, 8, 10, 10) # Extend filepath required to check that sub directories are created. file_path = os.path.join(self.test_data_dir, 'Temp', 'SubDirectory', 'SubSubDirectory') wlogger.setup_loggers(file_path, test_mode_on=True, name='test_dir_does_not_exist') wlogger.log_info('First Info Message', name='test_dir_does_not_exist') wlogger.log_info('Second Info Message', name='test_dir_does_not_exist') wlogger.log_info('Third Info Message', name='test_dir_does_not_exist') wlogger.tear_down_loggers(name='test_dir_does_not_exist') self.log_test_compare()