cool_shit.py
                        
                             · 1.8 KiB · Python
                        
                    
                    
                      
                        Orginalformat
                      
                      
                        
                          
                        
                    
                    
                
                
            from database import read
from reddit_scraper.utils import limit_iter
from typing import Iterable, Generic, TypeVar, List, Iterator
T = TypeVar('T')
class CustomIter(Generic[T]):
    def __init__(self, i: Iterable[T]) -> None:
        self.i = i
        self.l: List[T] = []
        self.is_generated = False
        # if i doesn't have __next__ pre generate it as it is not lazy
        if not isinstance(self.i, Iterator):
            self.generate()
    def generate(self):
        if not self.is_generated:
            self.l.extend(self.i)
            self.is_generated = True
    def __len__(self):
        self.generate()
        return len(self.l)
    def __iter__(self):
        yield from self.l
        if not self.is_generated:
            for j in self.i:
                self.l.append(j)
                yield j
            self.is_generated = True
            
    @property
    def empty(self) -> bool:
        if len(self.l):
            return False
        
        if not self.is_generated:
            for j in self.i:
                self.l.append(j)
                return False
        
        return True
    
    @property
    def first(self) -> T:
        if self.empty:
            raise KeyError("can't get first element from empty list")
        return self.l[0]
    @property
    def last(self) -> T:
        self.generate()
        if not len(self.l):
            raise KeyError("can't get last element from empty list")
        
        return self.l[-1]
def test_iter():
    print("yield foo")
    yield "foo"
    print("yield bar")
    yield "bar"
    print("yield baz")
    yield "baz"
if __name__ == "__main__":
    ci: Iterable = CustomIter(test_iter())
    for c in ci:
        print(c)
        break
    
    print("#" * 10)
    for c in ci:
        print(c)
    print("#" * 10)
    for c in ci:
        print(c)
                | 1 | from database import read | 
| 2 | |
| 3 | from reddit_scraper.utils import limit_iter | 
| 4 | from typing import Iterable, Generic, TypeVar, List, Iterator | 
| 5 | |
| 6 | |
| 7 | T = TypeVar('T') | 
| 8 | |
| 9 | |
| 10 | class CustomIter(Generic[T]): | 
| 11 | def __init__(self, i: Iterable[T]) -> None: | 
| 12 | self.i = i | 
| 13 | self.l: List[T] = [] | 
| 14 | self.is_generated = False | 
| 15 | |
| 16 | # if i doesn't have __next__ pre generate it as it is not lazy | 
| 17 | if not isinstance(self.i, Iterator): | 
| 18 | self.generate() | 
| 19 | |
| 20 | def generate(self): | 
| 21 | if not self.is_generated: | 
| 22 | self.l.extend(self.i) | 
| 23 | self.is_generated = True | 
| 24 | |
| 25 | def __len__(self): | 
| 26 | self.generate() | 
| 27 | return len(self.l) | 
| 28 | |
| 29 | def __iter__(self): | 
| 30 | yield from self.l | 
| 31 | |
| 32 | if not self.is_generated: | 
| 33 | for j in self.i: | 
| 34 | self.l.append(j) | 
| 35 | yield j | 
| 36 | self.is_generated = True | 
| 37 | |
| 38 | |
| 39 | @property | 
| 40 | def empty(self) -> bool: | 
| 41 | if len(self.l): | 
| 42 | return False | 
| 43 | |
| 44 | if not self.is_generated: | 
| 45 | for j in self.i: | 
| 46 | self.l.append(j) | 
| 47 | return False | 
| 48 | |
| 49 | return True | 
| 50 | |
| 51 | @property | 
| 52 | def first(self) -> T: | 
| 53 | if self.empty: | 
| 54 | raise KeyError("can't get first element from empty list") | 
| 55 | return self.l[0] | 
| 56 | |
| 57 | @property | 
| 58 | def last(self) -> T: | 
| 59 | self.generate() | 
| 60 | |
| 61 | if not len(self.l): | 
| 62 | raise KeyError("can't get last element from empty list") | 
| 63 | |
| 64 | return self.l[-1] | 
| 65 | |
| 66 | |
| 67 | def test_iter(): | 
| 68 | print("yield foo") | 
| 69 | yield "foo" | 
| 70 | print("yield bar") | 
| 71 | yield "bar" | 
| 72 | print("yield baz") | 
| 73 | yield "baz" | 
| 74 | |
| 75 | |
| 76 | if __name__ == "__main__": | 
| 77 | ci: Iterable = CustomIter(test_iter()) | 
| 78 | |
| 79 | for c in ci: | 
| 80 | print(c) | 
| 81 | break | 
| 82 | |
| 83 | print("#" * 10) | 
| 84 | for c in ci: | 
| 85 | print(c) | 
| 86 | |
| 87 | print("#" * 10) | 
| 88 | for c in ci: | 
| 89 | print(c) |