gen_loto_card.py

gen_loto_card.py

import random
from random import shuffle
import os
import uuid
import time


class Card():
    def __init__(self, column_length: int, columns_count: int, total_numbers_count: int):
        self.card = []
        self.column_length = column_length
        self.columns_count = columns_count
        self.total_numbers_count = total_numbers_count

    def _generate_cell(self, from_num: int, to_num: int) -> int:
        return random.randint(from_num, to_num)

    def genarate_column(self, registr) -> list:
        result = []
        # while len(result) < random.randint(1, self.column_length):
        while len(result) < random.randint(1, self.column_length):
            cell = self._generate_cell(1, 9) + registr * 10
            if cell not in result:
                result.append(cell)
        return result
    
    def _shuffle_column(self, lst: list) -> list:
        while len(lst) < self.column_length:
            lst.append(None)
        shuffled_column = sorted(lst, key=lambda x: random.random())
        return shuffled_column

    # считает кол-во заполненых ячеек
    def check_card(self, card: list) -> list:
        cell_count = 0
        for item in card:
            cell_count += len(item)
        return cell_count
    
    def pop_card(self, card: list) -> list:
        for item in card:
            if len(item) > 1:
                old = str(item)
                item.pop(random.randint(0, len(item)-1))
                # print(f"Popped {old} → {item}")
                break
        return card
    
    def expand_card(self, card: list) -> list:
        # for item in card:
        filtered_card = [sublist for sublist in card if len(sublist) < 3]
        random_column = random.choice(filtered_card)
        # if len(item) < 3:
        for number in random_column:
            tail = number % 10
            if tail != 9:
                new_number = number + 1
                if not new_number in random_column:
                    random_column.append(new_number)
                    # print(f"Expanded {new_number} → {random_column}")
                    return card
                else:
                    continue
        

    def genarate_raw_card(self) -> list:

        raw_card = []

        for register in range(self.columns_count):
            column = self.genarate_column(register)
            raw_card.append(column)

        if self.check_card(raw_card) == self.total_numbers_count:
            return raw_card
        
        # print(f"card is not standart - {self.check_card(raw_card)}")

        if self.check_card(raw_card) < self.total_numbers_count:
            while self.check_card(raw_card) < self.total_numbers_count:
                self.expand_card(raw_card)
            return raw_card
        
        if self.check_card(raw_card) > self.total_numbers_count:
            while self.check_card(raw_card) > self.total_numbers_count:
                self.pop_card(raw_card)
            return raw_card
        
        return False

    def __make_hash(self, card: list, pwd: int, salt: int) -> int:
        # print(f"Original summ - {sum(card)}")
        return (sum(card) * pwd) + salt
    
    def generate_card(self, pwd: int, salt: int) -> list:
        result_card = {}
        card = []
        raw_card = self.genarate_raw_card()
        flat_card = [item for sublist in raw_card for item in sublist]
        hash = self.__make_hash(flat_card, pwd, salt)
        # print(f"Hash - {hash}")
        for column in raw_card:
            card.extend(self._shuffle_column(column))
        result_card["ticket_nums"] = flat_card
        result_card["card"] = card
        result_card["hash"] = hash
        return result_card
 

if __name__ == '__main__':
    from card_generator import generate_card
    card = Card(column_length = 3, columns_count = 9, total_numbers_count = 15) # 3 ячейки по вертикали
    # list_card = card.generate_card(columns_count = 9, total_numbers_count = 15) # 9 по горизонтали
    # result = card.generate_card(int(os.getenv("pwd")), int(os.getenv("salt")))
    # print(card.check_card(list_card))
    start_time = time.time()
    game = 0
    for _ in range(100):
        result = card.generate_card(int(os.getenv("pwd")), int(os.getenv("salt")))
        generate_card("src/template.png", f"img/{uuid.uuid4()}.png", result["card"], result["hash"], "000001")
        game += 1
    end_time = time.time()
    elapsed_time = end_time - start_time
    print(f"Elapsed time: {elapsed_time:.6f} seconds")