Exemple #1
0
 def setUp(self):
     self.valid = Validator()
     self.bookRepo = RepoData()
     self.undoService = UndoService()
     self.rentalRepo = RepoData()
     self.book_service = BookService(self.valid, self.bookRepo,
                                     self.undoService, self.rentalRepo)
 def __get_pep8_formatted_data(path, get_data):
     raw_data = get_data(path)
     if Validator.contains_multiple_class(raw_data) is not False:
         return raw_data
     else:
         print(f'Data Extraction has stopped as more than 1 class '
               f'definition was found in \n{abspath(path)}')
         return ''
Exemple #3
0
 def setUp(self):
     self.clientRepo = RepoData()
     self.valid = Validator()
     self.UndoService = UndoService()
     self.rentalRepo = RepoData()
     self.bookRepo = RepoData()
     self.serviceClient = ClientService(self.valid, self.clientRepo,
                                        self.UndoService, self.rentalRepo,
                                        self.bookRepo)
Exemple #4
0
 def __init__(self):
     self.args = self.get_arguments()
     self.size = None
     self.puzzle = []
     if self.args.file:
         self.file = Validator.read_file(self.args.file.name)
         self.read_puzzle_from_file()
     elif self.args.random_number:
         self.size = self.args.random_number
     else:
         Validator.print_error_message("No puzzle - no program, sorry")
     self.puzzle_len = self.size**2
     self.target = [0 for _ in range(self.puzzle_len)]
     self.create_target()
     self.moves = self.get_moves()
     if len(self.puzzle) == 0:
         self.puzzle = self.target[:]
         self.create_random_puzzle()
     elif not self.solvable():
         Validator.print_error_message("Puzzle not solvable")
Exemple #5
0
 def read_from_folder(path):
     data = []
     for root, dirs, files in os.walk(path):
         for file in files:
             if file.endswith('.py'):
                 file_path = os.path.abspath(os.path.join(root, file))
                 valid = Validator.validate(file_path)
                 if valid == 'ok':
                     raw_data = FileReader.read(file_path)
                     if Validator.contains_multiple_class(
                             raw_data) is not False:
                         data.append(raw_data)
                     else:
                         print(
                             'Data Extraction has stopped as more than 1 class definition was found in \n'
                             + file_path)
                         data = []
                         break
                 elif valid == 'f':
                     raw_data = Pep8Formatter.format_pep8(file_path)
                     if Validator.contains_multiple_class(
                             raw_data) is not False:
                         data.append(raw_data)
                     else:
                         print(
                             'Data Extraction has stopped as more than 1 class definition was found in \n'
                             + file_path)
                         data = []
                         break
                 else:
                     print(
                         'Not a valid Python code in ', file_path,
                         ' Extraction process has been stopped! Fix the file and try again'
                     )
                     data = []
                     break
     return data
Exemple #6
0
 def read_from_file(path):
     result = ""
     if path.endswith('.py'):
         valid = Validator.validate(path)
         if valid == 'ok':
             raw_data = FileReader.read(path)
             if Validator.contains_multiple_class(raw_data) is not False:
                 result = raw_data
             else:
                 print(
                     'Data Extraction has stopped as more than 1 class definition was found in \n'
                     + path)
         elif valid == 'f':
             raw_data = Pep8Formatter.format_pep8(path)
             if Validator.contains_multiple_class(raw_data) is not False:
                 result = raw_data
             else:
                 print(
                     'Data Extraction has stopped as more than 1 class definition was found in \n'
                     + path)
         else:
             print('Not a valid Python code in ', path,
                   ' Fix the file and try again')
     return result
 def setUp(self):
     self.bookRepo = RepoData()
     self.clientRepo = RepoData()
     self.rentalRepo = RepoData()
     self.valid = Validator()
     self.undoService = UndoService()
     self.serviceBook = BookService(self.valid, self.bookRepo,
                                    self.undoService, self.rentalRepo)
     self.serviceClient = ClientService(self.valid, self.clientRepo,
                                        self.undoService, self.rentalRepo,
                                        self.bookRepo)
     self.serviceRental = RentalService(self.valid, self.rentalRepo,
                                        self.serviceBook,
                                        self.serviceClient,
                                        self.undoService)
    def __try_read_data(path):
        valid_functions = {
            'ok': FileReader.read,
            'f': Pep8Formatter.format_pep8
        }

        valid = Validator.validate(path)
        if valid not in valid_functions.keys():
            print(f'Not a valid Python code in {abspath(path)} '
                  f'Extraction process has been stopped! '
                  f'Fix the file and try again')
            return ''

        return FileReader.__get_pep8_formatted_data(path,
                                                    valid_functions[valid])
Exemple #9
0
    def __readAllFromFileTxt(self):
        try:
            with open(self.__file_name_settings, "r") as file:
                lines = file.readlines()
                dict_of_lines = {}
                for line in lines:
                    lst = line.split("=")
                    dict_of_lines[lst[0].strip()] = lst[1].strip().strip('"')
        except FileNotFoundError:
            print("Inexistent file : " + self.__file_name_settings)

        if dict_of_lines['repository'] == 'inmemory':
            pass
        elif dict_of_lines['repository'] == 'text files':
            bookRepo = FileBookRepository(dict_of_lines['books'])
            clientRepo = FileClientRepository(dict_of_lines['clients'])
            rentalRepo = FileRentalRepository(dict_of_lines['rentals'])
        elif dict_of_lines['repository'] == 'binary files':
            bookRepo = FileBookRepositoryBinary(dict_of_lines['books'])
            clientRepo = FileClientRepositoryBinary(dict_of_lines['clients'])
            rentalRepo = FileRentalRepositoryBinary(dict_of_lines['rentals'])

        valid = Validator()
        undoService = UndoService()

        serviceBook = BookService(valid, bookRepo, undoService, rentalRepo)
        serviceClient = ClientService(valid, clientRepo, undoService,
                                      rentalRepo, bookRepo)
        serviceRental = RentalService(valid, rentalRepo, serviceBook,
                                      serviceClient, undoService)

        if dict_of_lines['ui'] == 'gui':
            ui = Console(serviceBook, serviceClient, serviceRental,
                         undoService)
        else:
            ui = Console(serviceBook, serviceClient, serviceRental,
                         undoService)
        ui.runUI()
Exemple #10
0
 def read_puzzle_from_file(self):
     for row in self.file:
         row = row.strip()
         if row.startswith("#"):
             continue
         arr = row.split()
         if self.size is None:
             if len(arr) == 1:
                 self.size = Validator.parse_int(arr[0])
                 continue
             else:
                 if arr[1].startswith("#"):
                     self.size = Validator.parse_int(arr[0])
                     continue
                 else:
                     Validator.print_error_message(
                         "Cannot parse matrix size")
         if self.size < 3:
             Validator.print_error_message(
                 "Matrix size should be more or equal to 3")
         if self.size != 0:
             if len(arr) < self.size:
                 Validator.print_error_message("Not valid puzzle")
             if len(arr) > self.size and not arr[self.size].startswith("#"):
                 Validator.print_error_message("Not valid puzzle")
             for index, value in enumerate(arr[0:self.size]):
                 num = Validator.validate_element(
                     Validator.parse_int(value), self.size)
                 if num in self.puzzle:
                     Validator.print_error_message("Not valid puzzle")
                 self.puzzle.append(
                     Validator.validate_element(num, self.size))
Exemple #11
0
#!/Users/pkolomiy/.brew/bin/python3
import sys
from Validation.NPuzzle import NPuzzle
from Validation.Parser import Parser
from Validation.Validator import Validator
from AStar import AStar

if __name__ == '__main__':
    if len(sys.argv) < 2:
        Validator.print_error_message(Parser.usage())
    n_puzzle = NPuzzle()
    AStar(n_puzzle).algorithm()