Unnecessary Complex Snake Game

Principal.py

import pygame
from pygame.locals import *

#Colors

white = (255, 255, 255)
black = (0, 0, 0)
red = (255, 0, 0)


class Pointer:

    def __init__(self, screen, poss):
        self.screen = screen
        self.pos_x = poss[0]
        self.pox_y = poss[1]

    def show(self, wanted_color):
        pygame.draw.rect(self.screen, wanted_color, [self.pos_x, self.pox_y, 9, 9])

    def get_x(self):
        return self.pos_x

    def get_y(self):
        return self.pox_y

    def valid(self):
        condition_1 = 0 < self.pos_x < 600
        condition_2 = 0 < self.pox_y < 600
        return condition_1 and condition_2

    def get_pos(self):
        pos = (self.pos_x, self.pox_y)
        return pos


class Snake:

    def __init__(self, screen, lenght, start_pos):
        self.screen = screen
        self.lenght = lenght
        self.lead_x = start_pos[0]
        self.lead_y = start_pos[1]
        self.points = []

    def reset(self):
        self.screen.fill(white)
        self.__init__(self.screen, self.lenght, (self.lead_x, self.lead_y))
        self.generate_points()
        self.show()
        pygame.display.update()

    def generate_points(self):
        x = self.lead_x
        y = self.lead_y

        for _ in range(self.lenght):
            point = Pointer(self.screen, (x, y))
            self.points.append(point)
            x -= 10

    def show(self):
        self.points[0].show(black)
        for i in range(1, len(self.points)):
            self.points[i].show(red)

    def overlap(self):
        head_pos = self.points[0].get_pos()
        for i in range(1, len(self.points)):
            point = self.points[i]
            if point.get_pos() == head_pos:
                return True
        return False

    def valid(self):
        return self.valid_points() and not self.overlap()

    def verify(self):
        if not self.valid():
            self.reset()

    def valid_points(self):
        for point in self.points:
            if not point.valid():
                return False
        return True

    def mover(self, pointer):
        new_points = [pointer]

        for i in range(len(self.points) - 1):
            new_points.append(self.points[i])

        self.points = new_points
        self.screen.fill(white)
        self.show()
        pygame.display.update()

    def move(self, pair):
        head = self.points[0]
        pointer = Pointer(self.screen, (head.get_x() + pair[0], head.get_y() + pair[1]))
        self.mover(pointer)
        self.verify()
        
    def move_right(self):
        self.move((+10, 0))

    def move_left(self):
        self.move((-10, 0))

    def move_down(self):
        self.move((0, +10))

    def move_up(self):
        self.move((0, -10))



class Game:

    def __init__(self):
        pygame.init()

        self.loop = True
        self.game_display = pygame.display.set_mode((600, 600))
        pygame.display.set_caption("Sllieder")

        self.snake = Snake(self.game_display, 5, (300, 300))

        self.run()

        pygame.quit()
        quit()

    def run(self):
        self.game_display.fill(white)
        self.snake.generate_points()
        self.snake.show()
        pygame.display.update()

        while self.loop:

            self.event_handler()

    def event_handler(self):
        for event in pygame.event.get():

            if event.type == pygame.QUIT:
                self.loop = False

            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_LEFT:
                    self.snake.move_left()
                if event.key == pygame.K_UP:
                    self.snake.move_up()
                if event.key == pygame.K_RIGHT:
                    self.snake.move_right()
                if event.key == pygame.K_DOWN:
                    self.snake.move_down()


def execute():
    game = Game()


if __name__ == "__main__":
    execute()