Переписать код C# под Python

using System;
using System.Collections.Generic;
using System.Drawing;
 
namespace maze
{
    //класс клетки
    class Cell
    {
        //статусы границ: - true - граница есть, false - границы нет
        public bool IsUpBorder { get; set; }
        public bool IsDownBorder { get; set; }
        public bool IsLeftBorder { get; set; }
        public bool IsRightBorder { get; set; }
        //используется при генерации лабиринта
        public bool IsVisit;
        //true - когда клетка часть пути
        public bool IsWay;
        //индекс клетки в лабиринте
        public Point Pos;
        //используется при анимации пути
        public bool IsWayAnim;
    }
    //класс клетки игрока
    class PlayerCell
    {
        //скорость перемещения
        public const float Speed = 0.15f;
        //true - если клетка движется
        public bool IsAnim;
        //индек клеткок для перемещений
        public Point StartPos;
        public Point EndPos;
        //координаты отрисовки на форме
        public PointF DrawPos;
    }
    //класс лабиринта
    class Board
    {
        //список всех клеток
        private List<Cell> _cells;
        //кол-во клеток в лабиринте
        private int _countCells;
        //кол-во клеток по горизонтали
        public int CountColumns { get; private set; }
        //кол-во клеток по вертикали
        public int CountRows { get; private set; }
        //ширина лабиринта в пикелях
        public int Width { get; private set; }
        //высота лабиринта в пикселях
        public int Height { get; private set; }
        //ширина клетки в пикселях
        public int CellWidth { get; private set; }
        //высота клетки в пикселях
        public int CellHeight { get; private set; }
 
        //время до перекличения на следующую клетку при анимации пути
        private const long ShowWayTime = 70;
        //счетчик времени анимации пути
        private long _showWayTimer;
        //счетчик последовательности клеток пути при анимации
        private int _wayCellsSequenceCounter;
        //последовательность клеток пути
        private List<Cell> _wayCellsSequence;
        //true - если показывать путь
        private bool _isShowWay;
        public bool IsShowWay
        {
            get { return _isShowWay; }
            set
            {
                _isShowWay = value;
                if (!_isShowWay)
                {
                    //сброс анимации пути всех клеток
                    foreach (var cell in _cells)
                    {
                        cell.IsWayAnim = false;
                    }
                }
                else
                {
                    //сброс счетсика клеток пути при анимации
                    _wayCellsSequenceCounter = 0;
                }
            }
        }
        //клетка входа лабиринта
        private Cell _startCell;
        //клетка выхода лабиринта
        private Cell _endCell;
        //клетка игрока
        private PlayerCell _playerCell;
 
        //возвращает клетку по индекам в лабиринте
        private Cell GetCell(Point pos)
        {
            if (pos.X >= 0 && pos.X < CountColumns && pos.Y >= 0 && pos.Y < CountRows)
                return _cells[pos.X + pos.Y * CountColumns];
            return null;
        }
        //возвращает клетку по индекам в лабиринте
        private Cell GetCell(int x, int y)
        {
            return GetCell(new Point(x, y));
        }
        //конструктор лабиринта
        //countColumns - кол-во клеток по горизонтали
        //countRows - кол-во клеток по вертикали
        //width - ширина области отрисовки в пикселях
        //height - высота области отрисовки в пикселях
        public Board(int countColumns, int countRows, int width, int height)
        {
            //заполнение св-в класса лабиринта
            CountColumns = countColumns;
            CountRows = countRows;
            Width = width;
            Height = height;
            CellWidth = Width / CountColumns;
            CellHeight = Height / CountRows;
 
            _countCells = CountColumns * CountRows;
            _cells = new List<Cell>(_countCells);
 
            //заполнение клеток лабиринта начальными св-вами
            for (var y = 0; y < CountRows; y++)
            {
                for (var x = 0; x < CountColumns; x++)
                {
                    var cell = new Cell();
                    //считаем, что в начале у клетки есть все границы
                    cell.IsDownBorder = cell.IsUpBorder = cell.IsLeftBorder = cell.IsRightBorder = true;
                    cell.IsVisit = false;
                    cell.Pos = new Point(x, y);
                    _cells.Add(cell);
                }
            }
 
            //вбираем вход в лабиринт
            var rnd = new Random();
            var rndPos = rnd.Next((int)CountColumns);
            _startCell = _cells[(rndPos + (CountRows - 1) * CountColumns)];
            _startCell.IsDownBorder = false;
            //выбираем выход их лабиринта
            rndPos = rnd.Next((int)CountColumns);
            _endCell = _cells[rndPos];
            _endCell.IsUpBorder = false;
 
            //создаем клетку игрока
            _playerCell = new PlayerCell();
            _playerCell.StartPos = _startCell.Pos;
            _playerCell.DrawPos = new PointF(_playerCell.StartPos.X * CellWidth, _playerCell.StartPos.Y * CellHeight);
 
            //далее генерация лабиринта по алгоритму из [url]https://habrahabr.ru/post/262345/[/url]
            var currentCell = _startCell;
            currentCell.IsVisit = true;
            var stackCells = new Stack<Cell>();
            var process = false;
            do
            {
                process = false;
                var nonVisitCells = new List<Cell>();
                var left = GetCell(currentCell.Pos.X - 1, currentCell.Pos.Y);
                var right = GetCell(currentCell.Pos.X + 1, currentCell.Pos.Y);
                var up = GetCell(currentCell.Pos.X, currentCell.Pos.Y - 1);
                var down = GetCell(currentCell.Pos.X, currentCell.Pos.Y + 1);
                if (left != null && !left.IsVisit)
                    nonVisitCells.Add(left);
                if (right != null && !right.IsVisit)
                    nonVisitCells.Add(right);
                if (up != null && !up.IsVisit)
                    nonVisitCells.Add(up);
                if (down != null && !down.IsVisit)
                    nonVisitCells.Add(down);
 
                if (nonVisitCells.Count > 0)
                {
                    stackCells.Push(currentCell);
                    var nextCell = nonVisitCells[rnd.Next(nonVisitCells.Count)];
                    if (nextCell.Pos.X < currentCell.Pos.X)
                    {
                        currentCell.IsLeftBorder = false;
                        nextCell.IsRightBorder = false;
                    }
                    else if (nextCell.Pos.X > currentCell.Pos.X)
                    {
                        currentCell.IsRightBorder = false;
                        nextCell.IsLeftBorder = false;
                    }
                    else if (nextCell.Pos.Y < currentCell.Pos.Y)
                    {
                        currentCell.IsUpBorder = false;
                        nextCell.IsDownBorder = false;
                    }
                    else if (nextCell.Pos.Y > currentCell.Pos.Y)
                    {
                        currentCell.IsDownBorder = false;
                        nextCell.IsUpBorder = false;
                    }
                    currentCell = nextCell;
                    currentCell.IsVisit = true;
                }
                else if (stackCells.Count > 0)
                {
                    currentCell = stackCells.Pop();
                }
                else
                {
                    foreach (var cell in _cells)
                    {
                        if (!cell.IsVisit)
                        {
                            currentCell = cell;
                            currentCell.IsVisit = true;
                            break;
                        }
 
                    }
                }
 
                foreach (var cell in _cells)
                {
                    if (!cell.IsVisit)
                        process = true;
                }
 
            } while (process);
 
            FindWay();
        }
        //поиск пути по алгоритму из [url]https://habrahabr.ru/post/262345/[/url]
        private void FindWay()
        {
            _wayCellsSequence=new List<Cell>();
            foreach (var cell in _cells)
            {
                cell.IsVisit = false;
            }
            var currentCell = _startCell;
            _wayCellsSequence.Add(currentCell);
            currentCell.IsVisit = true;
            currentCell.IsWay = true;
            var stackCells = new Stack<Cell>();
            var rnd = new Random();
            var process = true;
            while (process)
            {
                var nonVisitCells = new List<Cell>();
                if (!currentCell.IsLeftBorder)
                {
                    var left = GetCell(currentCell.Pos.X - 1, currentCell.Pos.Y);
                    if (left != null && !left.IsVisit)
                        nonVisitCells.Add(left);
                }
                if (!currentCell.IsRightBorder)
                {
                    var right = GetCell(currentCell.Pos.X + 1, currentCell.Pos.Y);
                    if (right != null && !right.IsVisit)
                        nonVisitCells.Add(right);
                }
                if (!currentCell.IsUpBorder)
                {
                    var up = GetCell(currentCell.Pos.X, currentCell.Pos.Y - 1);
                    if (up != null && !up.IsVisit)
                        nonVisitCells.Add(up);
                }
                if (!currentCell.IsDownBorder)
                {
                    var down = GetCell(currentCell.Pos.X, currentCell.Pos.Y + 1);
                    if (down != null && !down.IsVisit)
                        nonVisitCells.Add(down);
                }
                if (nonVisitCells.Count > 0)
                {
                    stackCells.Push(currentCell);
                    var nextCell = nonVisitCells[rnd.Next(nonVisitCells.Count)];
                    currentCell = nextCell;
                    currentCell.IsVisit = true;
                    currentCell.IsWay = true;
                    _wayCellsSequence.Add(currentCell);
                    if (currentCell.Pos == _endCell.Pos)
                        process = false;
                }
                else if (stackCells.Count > 0)
                {
                    _wayCellsSequence.Remove(currentCell);
                    currentCell.IsWay = false;
                    currentCell = stackCells.Pop();
                }
                else
                {
                    process = false;
                }
            }
        }
        //возвращает true - если игра окончена
        public bool IsGameOver()
        {
            if (_playerCell != null && _endCell != null)
            {
                return _playerCell.EndPos == _endCell.Pos;
            }
            return false;
        }
        //перемещает клетку игрока влево
        public void MovePlayerLeft()
        {
            if (!_playerCell.IsAnim)
            {
                var cell = GetCell(_playerCell.StartPos);
                if (!cell.IsLeftBorder)
                {
                    var left = GetCell(cell.Pos.X - 1, cell.Pos.Y);
                    if (left != null)
                    {
                        _playerCell.EndPos = left.Pos;
                        _playerCell.IsAnim = true;
                    }
                }
            }
        }
        //перемещает клетку игрока вправо
        public void MovePlayerRight()
        {
            if (!_playerCell.IsAnim)
            {
                var cell = GetCell(_playerCell.StartPos);
                if (!cell.IsRightBorder)
                {
                    var right = GetCell(cell.Pos.X + 1, cell.Pos.Y);
                    if (right != null)
                    {
                        _playerCell.EndPos = right.Pos;
                        _playerCell.IsAnim = true;
                    }
                }
            }
        }
        //перемещает клетку игрока вверх
        public void MovePlayerUp()
        {
            if (!_playerCell.IsAnim)
            {
                var cell = GetCell(_playerCell.StartPos);
                if (!cell.IsUpBorder)
                {
                    var up = GetCell(cell.Pos.X, cell.Pos.Y - 1);
                    if (up != null)
                    {
                        _playerCell.EndPos = up.Pos;
                        _playerCell.IsAnim = true;
                    }
                }
            }
        }
        //перемещает клетку игрока вниз
        public void MovePlayerDown()
        {
            if (!_playerCell.IsAnim)
            {
                var cell = GetCell(_playerCell.StartPos);
                if (!cell.IsDownBorder)
                {
                    var down = GetCell(cell.Pos.X, cell.Pos.Y + 1);
                    if (down != null)
                    {
                        _playerCell.EndPos = down.Pos;
                        _playerCell.IsAnim = true;
                    }
                }
            }
        }

    //класс клетки
    class Cell
    {
        //статусы границ: - true - граница есть, false - границы нет
        public bool IsUpBorder { get; set; }
        public bool IsDownBorder { get; set; }
        public bool IsLeftBorder { get; set; }
        public bool IsRightBorder { get; set; }
        //используется при генерации лабиринта
        public bool IsVisit;
        //true - когда клетка часть пути
        public bool IsWay;
        //индекс клетки в лабиринте
        public Point Pos;
        //используется при анимации пути
        public bool IsWayAnim;
    }

    //класс лабиринта
    class Board
    {
        //кол-во клеток по горизонтали
        public int CountColumns { get; private set; }
 
        /*...*/
    }