text: import random
  import os
  from itertools import combinations
  
  
  class Game:
    # creaeting a positions list with list comperhansion
    positions = [x for x in range(1, 10)]
    # prepare the list of the combinations numbers
    wins_combination = [1,2,3,4,5,6,7,8,9]
    
    player_positions = ()
    computer_positions = ()
  
    def __init__(self):
      self.player_hits = 0
      self.computer_hits = 0
  
      self._player_sign = ''
      self._computer_sign = ''
  
      self._player_position = 0
      self._computer_position = 0
  
    """These are the helper methods used iside the class. you can see them starting with
  		single underscore like this: _function_name"""
  
    # private method: says that should be used only inside the class. 
    #  It helps other methods to insert the current position
    def _insertPosition(self, position, sign):
      Game.positions[position-1] = sign
  
    # private method: helps other methods to 
    #  determine id the signs of the players are equel
    def _are_signs_equel(self):
      return (self._computer_sign == self._player_sign)
  
    # cleans the console screen
    def clean_screen(self):
      return os.system("cls")
  
    # first, assign the class variable (Game.positions) to positions.
    #  Then it returns a string of the positions in the variable
    def display_board(self):
      positions = Game.positions
      return f"""
  				{positions[0]} | {positions[1]} | {positions[2]}
  				{positions[3]} | {positions[4]} | {positions[5]}
  				{positions[6]} | {positions[7]} | {positions[8]}"""
      
    # generate new signs for players from a given sign list,
    #  Only if the list is greater or equel to 2, and the signs are equel.
    def generate_new_signs(self, signlist):
      while True:
        if not self._are_signs_equel():
          break
        elif len(signlist) >= 2 and self._are_signs_equel():
          self._player_sign, self._computer_sign = random.choices(signlist, k=2)
        else:
          raise ValueError('signlist length must be graeter than 1')
  
  
    @property
    def computer_sign(self):
      return self._computer_sign
    
    @computer_sign.setter
    def computer_sign(self, signlist):
      return random.choice(signlist)
  
    @property
    def prv_computer_position(self):
      self.computer_hits += 1
      x = random.randint(1, 9)
  
      if x != self._player_position and self._computer_position != x:
        # assign to the radical random 'x'
        self._computer_position = x
        # insert the current position
        self._insertPosition(self._computer_position, self._computer_sign)
        return self._computer_position
      self.prv_computer_position
  
  
    @property
    def player_position(self):
      return self._player_position
  
    @player_position.setter
    def player_position(self, value):
      self.player_hits += 1
      self._player_position = value
      self._insertPosition(value, self._player_sign)
      self.prv_computer_position  
  
    # FIX: add the real functionality
    def get_winner_synce(self):
      for combination in combinations(Game.wins_combination, 3):
        yield combination
  
    def __repr__(self):
      return """
                --------------
                PLAYER: '{0}'   
                COMPUTER: '{1}' 
                --------------""".format(self._player_sign, self._computer_sign)
  
  
  