new setup.py file, added some try except methods, validation for para…

…meters

chase/__main__.py

@@ -1,20 +1,19 @@
 import os
 import sys
-from colorama import Fore, Style
-import logger
-from data import config_file
-from chase_simulation import ChaseSimulation
-from config import args_parser
+from colorama import Style
+from . import logger, parameters
+from .chase_simulation import ChaseSimulation
+from .terminal_parser import args_parser
 
 def main():
-    log = f"Game config:  rounds: {config_file.rounds_no}, sheeps_no: {config_file.sheeps_no}, " \
-          f"init_pos_limit: {config_file.init_pos_limit}, sheep_move_dist: {config_file.sheep_move_dist}, " \
-          f"wolf_move_dist {config_file.wolf_move_dist}"
+    log = f"Game config:  rounds: {parameters.rounds_no}, sheeps_no: {parameters.sheeps_no}, " \
+          f"init_pos_limit: {parameters.init_pos_limit}, sheep_move_dist: {parameters.sheep_move_dist}, " \
+          f"wolf_move_dist {parameters.wolf_move_dist}"
     logger.get_logger().info(log)
 
-    chase_simulation = ChaseSimulation(config_file.rounds_no, config_file.sheeps_no, config_file.init_pos_limit,
-                                     config_file.sheep_move_dist, config_file.wolf_move_dist, config_file.wait,
-                                     config_file.directory)
+    chase_simulation = ChaseSimulation(parameters.rounds_no, parameters.sheeps_no, parameters.init_pos_limit,
+                                       parameters.sheep_move_dist, parameters.wolf_move_dist, parameters.wait,
+                                       parameters.directory)
 
     chase_simulation.simulate()
 

chase/animal.py

@@ -0,0 +1,23 @@
+class Animal:
+
+    def __init__(self, move_dist):
+        self.move_dist = move_dist
+        self.__position = [0.0, 0.0]
+
+    def set_position(self, position):
+        self.__position = position
+
+    def get_position(self):
+        return self.__position
+
+    def get_x(self):
+        return self.__position[0]
+
+    def get_y(self):
+        return self.__position[1]
+
+    def set_x(self, value):
+        self.__position[0] = value
+
+    def set_y(self, value):
+        self.__position[1] = value

chase/chase_simulation.py

@@ -1,53 +1,75 @@
 import json
 import csv
-import logger
-from models.Sheep import *
-from models.Wolf import *
+from . import logger
+from .sheep import *
+from .wolf import *
 from colorama import Fore, Style
-
+from scipy.spatial import distance
 
 class ChaseSimulation:
 
     def __init__(self, rounds_no, sheeps_no, init_pos_limit, sheep_move_dist, wolf_move_dist, wait, directory):
-        # init config parameters
-        self.rounds_no = rounds_no
-        self.sheeps_no = sheeps_no
-        self.init_pos_limit = init_pos_limit
-        self.sheep_move_dist = sheep_move_dist
-        self.wolf_move_dist = wolf_move_dist
-        self.wait = wait
-        self.directory = directory
-
-        # init animals
-        self.wolf = Wolf(self.wolf_move_dist)
-        self.sheeps = []
-
-        for i in range(self.sheeps_no):
-            sheep = Sheep(self.sheep_move_dist, self.init_pos_limit, i + 1)
-            self.sheeps.append(sheep)
-
-        log = f"Animals:  wolf: {self.wolf}, sheeps: {self.sheeps}"
+        # init config parameters validation
+        try:
+            self._rounds_no = int(rounds_no)
+            self._sheeps_no = int(sheeps_no)
+            self._init_pos_limit = float(init_pos_limit)
+            self._sheep_move_dist = float(sheep_move_dist)
+            self._wolf_move_dist = float(wolf_move_dist)
+            self._wait = bool(wait)
+            self._directory = directory
+
+            if rounds_no < 1:
+                logger.get_logger().error("Wrong rounds_no value")
+                raise ValueError("Wrong rounds_no value")
+            if sheeps_no < 1:
+                logger.get_logger().error("Wroung sheeps_no value")
+                raise ValueError("Wroung sheeps_no value")
+            if sheep_move_dist <= 0:
+                logger.get_logger().error("Wrong sheep_move_dist value")
+                raise ValueError("Wrong sheep_move_dist value")
+            if wolf_move_dist <= 0:
+                logger.get_logger().error("Wrong wolf_move_dist value")
+                raise ValueError("Wrong wolf_move_dist value")
+
+                # init animals
+            self.init_animals()
+
+        except:
+            logger.get_logger().error("Wrong values types")
+            raise ValueError("Wrong values types")
+
+
+
+    def init_animals(self):
+        self._wolf = Wolf(self._wolf_move_dist)
+        self._sheeps = []
+
+        for i in range(self._sheeps_no):
+            sheep = Sheep(self._sheep_move_dist, self._init_pos_limit, i + 1)
+            self._sheeps.append(sheep)
+
+        log = f"Animals:  wolf: {self._wolf}, sheeps: {self._sheeps}"
         logger.get_logger().debug(log)
 
-
     def simulate(self):
-        for i in range(self.rounds_no):
-            if self.get_dies_count() == self.sheeps_no:
+        for i in range(self._rounds_no):
+            if self.get_dies_count() == self._sheeps_no:
                 break
             round_log = f"round_no: {i + 1}"
             print(Fore.CYAN + round_log + Style.RESET_ALL)
             # json export
-            json_data = self.create_json(i)
+            json_data = self.create_json(i + 1)
             self.write_json(i, json_data)
-            for sheep in self.sheeps:
+            for sheep in self._sheeps:
                 sheep.move()
             min_distance, nearest_sheep = self.find_nearest_sheep()
-            start_wolf_position = [round(pos, 3) for pos in self.wolf.position]
-            killed_sheep_index = self.wolf.try_catch_sheep(nearest_sheep, min_distance)
+            start_wolf_position = [round(pos, 3) for pos in self._wolf.get_position()]
+            killed_sheep_index = self._wolf.try_catch_sheep(nearest_sheep, min_distance)
             # csv export
             self.write_csv(i + 1, self.get_alive_count())
 
-            end_wolf_position = [round(pos, 3) for pos in self.wolf.position]
+            end_wolf_position = [round(pos, 3) for pos in self._wolf.get_position()]
             other_info_log = f"wolf start position: {start_wolf_position}\nalive: {self.get_alive_count()}\ndied: {self.get_dies_count()}\nwolf end position{end_wolf_position}\n"
             # terminal info
             if killed_sheep_index is not None:
@@ -58,16 +80,16 @@ def simulate(self):
             print(other_info_log.replace("sheep died", Fore.RED + "sheep died"))
 
             logger.get_logger().info(round_log + ", " + other_info_log[:-1].replace("\n", ", "))
-            if self.wait:
+            if self._wait:
                 input(Fore.GREEN + "Press enter to continue symulation")
             print(Style.RESET_ALL)
 
     def find_nearest_sheep(self):
-        min_distance = self.init_pos_limit + 1000
-        nearest_sheep = self.sheeps[0]
-        for sheep in self.sheeps:
+        min_distance = self._init_pos_limit + 1000
+        nearest_sheep = self._sheeps[0]
+        for sheep in self._sheeps:
             if sheep.alive:
-                dist = distance.euclidean(self.wolf.position, sheep.position)
+                dist = distance.euclidean(self._wolf.get_position(), sheep.get_position())
                 if dist < min_distance:
                     min_distance = dist
                     nearest_sheep = sheep
@@ -78,7 +100,7 @@ def find_nearest_sheep(self):
 
     def get_dies_count(self):
         count = 0
-        for sheep in self.sheeps:
+        for sheep in self._sheeps:
             if not sheep.alive:
                 count += 1
 
@@ -89,7 +111,7 @@ def get_dies_count(self):
 
     def get_alive_count(self):
         count = 0
-        for sheep in self.sheeps:
+        for sheep in self._sheeps:
             if sheep.alive:
                 count += 1
 
@@ -101,11 +123,11 @@ def get_alive_count(self):
     def create_json(self, round_no):
         x = {
             "round_no": round_no,
-            "wolf_pos": {"x": self.wolf.get_x(),
-                         "y": self.wolf.get_y()}
+            "wolf_pos": {"x": self._wolf.get_x(),
+                         "y": self._wolf.get_y()}
         }
         sheeps_pos = []
-        for sheep in self.sheeps:
+        for sheep in self._sheeps:
             if sheep.alive:
                 sheeps_pos.append({
                     "sheep_id": sheep.id_number,
@@ -124,7 +146,7 @@ def create_json(self, round_no):
         return x
 
     def write_json(self, round_no, data, filename='pos.json'):
-        path = self.directory + "/" + filename
+        path = self._directory + "/" + filename
 
         if round_no == 0:
             with open(path, 'w') as f:
@@ -140,7 +162,7 @@ def write_json(self, round_no, data, filename='pos.json'):
             logger.get_logger().debug(log)
 
     def write_csv(self, round_no, alive_count, filename='alive.csv'):
-        path = self.directory + "/" + filename
+        path = self._directory + "/" + filename
         if round_no == 1:
             with open(path, mode='w') as csv_file:
                 fieldnames = ['round_no', 'alive']

chase/logger.py

@@ -1,10 +1,10 @@
 import logging
 
-from data import config_file
+from . import parameters
 
 
 def init_logger(level):
-    path = config_file.directory + "/" + "chase.log"
+    path = parameters.directory + "/" + "chase.log"
     logging.basicConfig(level=level, filename=path, filemode='w',
                         format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', datefmt='%d-%b-%y %H:%M:%S')
     logging.info('Init logger')

chase/models/Sheep.py → chase/sheep.py

@@ -1,12 +1,12 @@
 import random
-from colorama import Fore, Style
 
-from .Animal import Animal
+from .animal import Animal
 
 
 class Sheep(Animal):
     def __init__(self, move_dist, init_pos_limit, id_number):
         super().__init__(move_dist)
+
         x = random.uniform(-init_pos_limit, init_pos_limit)
         y = random.uniform(-init_pos_limit, init_pos_limit)
         self.position = [x, y]