How to use the chess.pgn.Game function in chess

def NetworkCompetitionBlack(bestNet, testingNet, playouts, round="1"):
    score = 0
    PGN = chess.pgn.Game()
    PGN.headers["Event"] = "Neural Network Comparison Test"
    PGN.headers["Site"] = "Cozy Computer Lounge"
    PGN.headers["Date"] = datetime.datetime.today().strftime('%Y-%m-%d %H:%M')
    PGN.headers["Round"] = round
    PGN.headers["White"] = "Network: " + testingNet.nameOfNetwork
    PGN.headers["Black"] = "Network: " + bestNet.nameOfNetwork
    PGN.headers["Variant"] = "crazyhouse"


    sim = ChessEnvironment()
    while sim.result == 2:
        #print("Win Probability:", ValueEvaluation.positionEval(sim, bestNet.neuralNet))
        noiseVal = 1.0 / (2*(sim.plies//2 + 1))
        if sim.plies % 2 == 1:
            if playouts > 0:
                bestNet.competitivePlayoutsFromPosition(playouts, sim)

def simulateTrainingGame(self, playouts, round="1"):

        PGN = chess.pgn.Game()
        PGN.headers["Event"] = "Simulated Training Game"
        PGN.headers["Site"] = "Cozy Computer Lounge"
        PGN.headers["Date"] = datetime.datetime.today().strftime('%Y-%m-%d %H:%M')
        PGN.headers["Round"] = round
        PGN.headers["White"] = "Network: " + self.nameOfNetwork
        PGN.headers["Black"] = "Network: " + self.nameOfNetwork
        PGN.headers["Variant"] = "crazyhouse"

        sim = ChessEnvironment()
        while sim.result == 2:
            if playouts == 0:
                position = sim.boardToString()
                if position not in self.dictionary:
                    state = torch.from_numpy(sim.boardToState())
                    nullAction = torch.from_numpy(np.zeros(1))  # this will not be used, is only a filler
                    testSet = DoubleHeadDataset(state, nullAction, nullAction)

def pretty_print(env, colors):
    new_pgn = open("test3.pgn", "at")
    game = chess.pgn.Game.from_board(env.board)
    game.headers["Result"] = env.result
    game.headers["White"], game.headers["Black"] = colors
    game.headers["Date"] = datetime.now().strftime("%Y.%m.%d")
    new_pgn.write(str(game) + "\n\n")
    new_pgn.close()
    pyperclip.copy(env.board.fen())

line = sys.stdin.readline()
        line = line.rstrip()
        board.push_uci(line)
    print(board)
    print("thinking...")
    best, node = search.BRUE_search(board, nodes, net=nn)
    print("best: ", best, 'eval', node.Q())
    board.push_uci(best)
    
    best, node = search.UCT_search(board, nodes, net=nn)
    print("best: ", best, 'eval', node.Q())
    board.push_uci(best)
    if board.pc_board.is_game_over() or board.is_draw():
        print("Game over... result is {}".format(board.pc_board.result(claim_draw=True)))
        print(board)
        print(chess.pgn.Game.from_board(board.pc_board))
        break

def accept(self, visitor):
        """
        Traverses the game in PGN order using the given *visitor*. Returns
        the visitor result.
        """
        visitor.begin_game()

        visitor.begin_headers()
        for tagname, tagvalue in self.headers.items():
            visitor.visit_header(tagname, tagvalue)
        visitor.end_headers()

        if self.comment:
            visitor.visit_comment(self.comment)

        super(Game, self).accept(visitor, _board=self.board())

        visitor.visit_result(self.headers.get("Result", "*"))
        visitor.end_game()
        return visitor.result()

async def pgn(self, ctx):
		'''PGN of the current game'''
		match = self.get_match(ctx.channel, ctx.author)
		if not match:
			return await ctx.embed_reply(":no_entry: Chess match not found")
		await ctx.embed_reply(chess.pgn.Game.from_board(match))

def playout(self, round,
                explorationConstant=0.15,  # lower? will test more.
                notFromBeginning=False, arrayBoard=0, pythonBoard=0, plies=0, wCap=0, bCap=0,
                actuallyAPawn=0,
                noise=True,
                printPGN=True):  # Here is the information just for starting at a different position

        if printPGN:
            PGN = chess.pgn.Game()
            PGN.headers["Event"] = "Playout"
            PGN.headers["Site"] = "Cozy Computer Lounge"
            PGN.headers["Date"] = datetime.datetime.today().strftime('%Y-%m-%d')
            PGN.headers["Round"] = round
            PGN.headers["White"] = "Network: " + self.nameOfNetwork
            PGN.headers["Black"] = "Network: " + self.nameOfNetwork
            PGN.headers["Variant"] = "Crazyhouse"

        whiteParentStateDictionary = []
        whiteStateSeen = []
        whiteStateWin = []

        blackParentStateDictionary = []
        blackStateSeen = []
        blackStateWin = []

def generate_pgn(model):
    pgn = chess.pgn.Game()
    node = pgn
    for move in model.env.env.move_stack:
        node = node.add_variation(move)
    return pgn

def init_game(self):
        """ Initialize game with initial pgn tag values """
        self.game = chess.pgn.Game()
        self.game.headers['Event'] = INIT_PGN_TAG['Event']
        self.game.headers['Date'] = self.get_tag_date()
        self.game.headers['White'] = INIT_PGN_TAG['White']
        self.game.headers['Black'] = INIT_PGN_TAG['Black']

def export(self, pgn_headers=None) -> Game:
        """ pgn_headers - PGN headers to include in the exported PGN
        """
        fen = self.puzzle.initial_board.fen()
        board = chess.Board(fen)
        game = Game().from_board(board)
        game_node = game
        game_node.comment = "score: %s -> %s" % (
            _score_to_str(self.puzzle.initial_score),
            _score_to_str(self.puzzle.final_score)
        )
        comment = self._candidate_moves_annotations(self.puzzle.analyzed_moves)
        for position in self.puzzle.positions:
            game_node = game_node.add_variation(
                chess.Move.from_uci(position.initial_move.uci())
            )
            if comment:
                game_node.comment = comment
            comment = self._candidate_moves_annotations(position.candidate_moves)
        if pgn_headers:
            for h in pgn_headers:
                if h == "FEN":