from $\_\_$future$\_\_$ import annotations

import python$\_$ta

from python$\_$ta$.$contracts import check$\_$contracts

###############################################################################

# TODO Task $1$:

# Add at least two doctest examples to each helper below, then

# implement each helper function according to its docstring.

###############################################################################

@check$\_$contracts

def within$\_$grid$($coord: tuple$[$int$,$ int$],$ n: int$)->$ bool:

$"""$

Return whether is within an n$-$by$-$n grid

Preconditions:

$-$ n $>0$

TODO Task $1$: add at least two doctests here and implement this function

$"""$

# TODO: Implement this function

@check$\_$contracts

def all$\_$within$\_$grid$($coords: list$[$tuple$[$int$,$ int$]],$ n: int$)->$ bool:

$"""$

Return whether every coordinate in is within an n$-$by$-$n grid.

Preconditions:

$-$ n $>0$

TODO Task $1$: add at least two doctests here and implement this function

$"""$

# TODO: Implement this function

@check$\_$contracts

def reflect$\_$vertically$($coord: tuple$[$int$,$ int$],$ n: int$)->$ tuple$[$int$,$ int$]$:

$"""$

Return the coordinate that is $,$ but reflected across the middle

horizontal of an n$-$by$-$n grid. See the handout and supplemental materials

for a diagram showing an example.

Preconditions:

$-$ n $>0$

$-$ within$\_$grid$($coord$,$ n$)$

TODO Task $1$: add at least two doctests here and implement this function

$"""$

# TODO: Implement this function

@check$\_$contracts

def reflect$\_$points$($line: list$[$tuple$[$int$,$ int$]],$

n: int$)->$ list$[$tuple$[$int$,$ int$]]$:

$"""$

Return the given reflected vertically across the middle horizontal

of an n$-$by$-$n grid.

Preconditions:

$-$ n $>0$

$-$ all$\_$within$\_$grid$($line$,$ n$)$

TODO Task $1$: add at least two doctests here and implement this function

$"""$

# TODO: Implement this function

@check$\_$contracts

class Square:

$"""$

A class representing a single square in a Four$-$in$-$a$-$Row game.

Attributes:

$-$ symbol: the symbol indicating which player, if any, has played here. Note,

the strings $\text{'}$X$\text{'}$ and $\text{'}$O$\text{'}$ are used as the symbols of the players.

$-$ coord: the $($row$,$ column$)$ coordinate indicating this square's location in

the grid.

Representation Invariants:

$-$ self.symbol is None or self.symbol in $(\text{'}$X$\text{'},\text{'}$O$\text{'})$

$-$ coord$[0]>=0$ and coord$[1]>=0$

$"""$

symbol: None $|$ str

coord: tuple$[$int$,$ int$]$

def $\_\_$init$\_\_($self$,$ coord: tuple$[$int$,$ int$],$ s: None $|$ str $=$ None$)->$ None:

$"""$

Initialize this Square with symbol and coordinate $.$

Note: parameter has a defualt parameter value of None specified for

this method. This means that if we only provide $,$ then

will automatically have a value of None $($see example below$).$

$>>>$ sq $=$ Square$((0,0))$

$>>>$ sq$.$symbol is None

True

$>>>$ sq $=$ Square$((0,1),\text{'}$X$\text{'})$

$>>>$ sq$.$symbol

$\text{'}$X$\text{'}$

$>>>$ sq$.$coord

$(0,1)$

$"""$

self.symbol $=$ s

self.coord $=$ coord

def $\_\_$str$\_\_($self$)->$ str:

$"""$

Return a suitable string representation of this Square.

This method will determine how our Square class is represented as a

string, when we use either str or print $($see below for an example$).$

$>>>$ print$($Square$((0,0)))$

$-$

$>>>$ print$($Square$((0,1),\text{'}$X$\text{'}))$

X

$"""$

if self.symbol is not None:

return self.symbol

else:

return $\text{'}-\text{'}$

###############################################################################

# TODO Task $2$:

# Line Class and related helpers

# For each of the three public helper functions below,

# write at least two pytests in test$\_$a$0.$py$,$ then implement $\_$is$\_$diagonal.

# Once these tests are passing, see the Line class for the rest of Task $2.$

###############################################################################

@check$\_$contracts

def is$\_$row$($squares: list$[$Square$])->$ bool:

$"""$

Return whether is a valid row or not.

A line is a valid row if all of its row coordinates are the same, and

the column coordinates all increase by exactly $1$ from the previous square.

Preconditions:

$-$ len$($squares$)>3$

$>>>$ l $=[$Square$((0,1)),$ Square$((0,2)),$ Square$((0,3)),$ Square$((0,4))]$

$>>>$ is$\_$row$($l$)$

True

$>>>$ not$\_$l $=[$Square$((0,1)),$ Square$((0,2)),$ Square$((0,4)),$ Square$((0,3))]$

$>>>$ is$\_$row$($not$\_$l$)$

False

$"""$

cur$\_$row, cur$\_$col $=$ squares$[0].$coord

for square in squares$[1$:$]$:

if square.coord$[0]!=$ cur$\_$row or square.coord$[1]-$ cur$\_$col $!=1$:

return False

cur$\_$col $=$ square.coord$[1]$

return True

@check$\_$contracts

def is$\_$column$($squares: list$[$Square$])->$ bool:

$"""$

Return whether is a valid column or not.

A line is a valid column if all of its column coordinates are the same, an