Implementacion Lista Simple

from dataclasses import dataclass
from typing import Any

class lsimple():

    @dataclass
    class _Nodo:
        valor: Any =None
        prox: "_Nodo" =None

    class _NodoFantasma:
        prox: "_Nodo" =None

    __slots__=["_contador","_back"]

    def __init__(self,valor=None):
        self._contador=0
        self._back=lsimple._NodoFantasma()
        self._back.prox=self._back
        if valor is not None:
            for x in valor:
                self.append_front(valor)

    def __eq__(self,other):
        c1=self.begin()
        c2=other.begin()
        c1.advance()
        c2.advance()
        while c1 != self.end() and c2 != other.end():
            if c1.valor != c2.valor:
                return False
            c1.advance()
            c2.advance()
        return c1 == self.end() and c2 == other.end()

    def __len__(self):
        return self._contador

    def __iter__(self):
        return lsimple.Iterador(self._back.prox,self._back)

    def __repr__(self):
        return "ListaSimple(["+", ".join(repr(x) for x in self)+"]"+")"

    def empty(self):
        return self._contador==0

    @property
    def primero(self):
        x=self.begin()
        x.advance()
        return x.valor

    @property
    def ultimo(self):
        return self.end().valor

    def begin(self):
        return lsimple.Coordenada(self._back)

    def end(self):
        aux=lsimple.Coordenada(self._back)
        aux.advance()
        while aux._nodo.prox is not self._back:
            aux.advance()
        return aux

    def insert(self,coordenada,valor):
        nodo_actual=coordenada._nodo
        nuevo=lsimple._Nodo(valor)
        nuevo.prox=nodo_actual.prox
        nodo_actual.prox=nuevo

    def popvalue(self,valor):
        coor_busqueda=self.begin()
        coor_busqueda.advance()
        coor2=self.begin()
        while coor_busqueda._nodo != self._back:
            if coor_busqueda._nodo.valor == valor:
                coor2._nodo.prox=coor_busqueda._nodo.prox
                return(valor)
            coor2.advance()
            coor_busqueda.advance()
        assert not self.existe(),"No existe al valor a borrar"

    def append_back(self,valor):
        self._contador+=1
        self.insert(self.end(),valor)

    def append_front(self,valor):
        self._contador+=1
        self.insert(self.begin(),valor)

    def clear(self):
        self._back.prox=self._back

    #def copy(self):

    #def reverse(self):

    def existe(self,valor):
        coor_busqueda=self.begin()
        coor_busqueda.advance()
        while coor_busqueda._nodo != self._back:
            if coor_busqueda._nodo.valor == valor:
                return True
            coor_busqueda.advance()
        return False

    class Coordenada():
        __slots__=["_nodo"]

        def __init__(self,coord_nodo):
            if isinstance(coord_nodo,lsimple.Coordenada):
                self._nodo=coord_nodo._nodo
            else:
                self._nodo=coord_nodo

        def __eq__(self,other):
            return self._nodo is other._nodo

        def valor(self):
            return self._nodo.valor

        def advance(self):
            self._nodo=self._nodo.prox

        def next(self):
            return lsimple.Coordenada(self_nodo).advance()

    class Iterador():

        __slots__=["_ini","_fin"]

        def __init__(self,inicio,final):
            self._ini=inicio
            self._fin=final

        def __iter__(self):
            return self

        def __next__(self):
            if self._ini is self._fin:
                raise StopIteration
            value=self._ini.valor
            self._ini=self._ini.prox
            return value