Переписать код 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;
                    }
                }
            }
        }

        //обновляет анимаию показа пути и перемещения игрока
        //dt смещение времени относительно предыдущего вызова
        public void UpdateAnim(long dt)
        {
            if (_playerCell.IsAnim)
            {
                var start = new PointF(_playerCell.StartPos.X, _playerCell.StartPos.Y);
                var end = new PointF(_playerCell.EndPos.X, _playerCell.EndPos.Y);
                var d = new PointF((end.X - start.X) * dt * PlayerCell.Speed, (end.Y - start.Y) * dt * PlayerCell.Speed);
 
                var endDrawPos = new PointF(_playerCell.EndPos.X * CellWidth, _playerCell.EndPos.Y * CellHeight);
                var newDrawPlayerPos = new PointF(_playerCell.DrawPos.X + d.X, _playerCell.DrawPos.Y + d.Y);
                if ((_playerCell.StartPos.X != _playerCell.EndPos.X &&
                     Math.Abs(_playerCell.DrawPos.X - endDrawPos.X) < Math.Abs(newDrawPlayerPos.X - endDrawPos.X)) ||
                    (_playerCell.StartPos.Y != _playerCell.EndPos.Y &&
                     Math.Abs(_playerCell.DrawPos.Y - endDrawPos.Y) < Math.Abs(newDrawPlayerPos.Y - endDrawPos.Y)))
                {
                    _playerCell.DrawPos = endDrawPos;
                    _playerCell.StartPos = _playerCell.EndPos;
                    _playerCell.IsAnim = false;
                }
                else
                {
                    _playerCell.DrawPos = newDrawPlayerPos;
                }
            }
            if (_isShowWay && _wayCellsSequenceCounter < _wayCellsSequence.Count)
            {
                _showWayTimer += dt;
                if (_showWayTimer >= ShowWayTime)
                {
                    _wayCellsSequence[_wayCellsSequenceCounter].IsWayAnim = true;
                    _wayCellsSequenceCounter++;
                    _showWayTimer = 0;
                }
            }
        }
        //рисует лабиритн
        public void Draw(Graphics g)
        {
            var cellBrush = Brushes.LightGray;
            var wayBrush = Brushes.Yellow;
            var cellPen = Pens.Black;
            var borderPen = Pens.Red;
            for (var y = 0; y < CountRows; y++)
            {
                for (var x = 0; x < CountColumns; x++)
                {
                    var px = x * CellWidth;
                    var py = y * CellHeight;
 
                    if (IsShowWay && GetCell(x, y).IsWayAnim)
                    {
                        g.FillRectangle(wayBrush, px, py, CellWidth, CellHeight);
                    }
                    else
                    {
                        g.FillRectangle(cellBrush, px, py, CellWidth, CellHeight);
                    }
                }
            }
 
            var playerBrush = Brushes.Green;
            g.FillRectangle(playerBrush, _playerCell.DrawPos.X, _playerCell.DrawPos.Y, CellWidth, CellHeight);
 
            var cellCounter = 0;
            for (var y = 0; y < CountRows; y++)
            {
                for (var x = 0; x < CountColumns; x++)
                {
                    var px = x * CellWidth;
                    var py = y * CellHeight;
 
                    if (_cells[cellCounter].IsUpBorder)
                    {
                        g.DrawLine(borderPen, px, py, px + CellWidth, py);
                    }
                    if (_cells[cellCounter].IsDownBorder)
                    {
                        g.DrawLine(borderPen, px, py + CellHeight, px + CellWidth, py + CellHeight);
                    }
                    if (_cells[cellCounter].IsLeftBorder)
                    {
                        g.DrawLine(borderPen, px, py, px, py + CellHeight);
                    }
                    if (_cells[cellCounter].IsRightBorder)
                    {
                        g.DrawLine(borderPen, px + CellWidth, py, px + CellWidth, py + CellHeight);
                    }
                    cellCounter++;
                }
            }
        }
    }
 
}