Даниил Рыжов

from django.db import models
from django.contrib.auth.models import User

class APIKey(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    key = models.CharField(max_length=64, unique=True)

from django.http import JsonResponse
from your_app.models import APIKey

def api_key_required(view_func):
    @wraps(view_func)
    def _wrapped_view(request, *args, **kwargs):
        api_key = request.headers.get("X-API-Key")
        if not api_key or not APIKey.objects.filter(key=api_key).exists():
            return JsonResponse({"error": "Unauthorized"}, status=403)
        return view_func(request, *args, **kwargs)
    
    return _wrapped_view

from django.http import JsonResponse
from django.views.decorators.csrf import csrf_exempt

@csrf_exempt
@api_key_required
def my_api_view(request):
    return JsonResponse({"message": "Success"})

import logging


async def on_startup(dispatcher):
    logging.basicConfig(
        level=logging.DEBUG,
        format=u'%(filename)s:%(lineno)d #%(levelname)-8s [%(asctime)s] - %(name)s - %(message)s',
    )
    logger.info("Starting bot")

    # Импортируем функции регистрации хендлеров
    from update_photo import register_new_photo
    # Регистрируем хендлеры
    register_new_photo(dispatcher)


async def on_shutdown(dispatcher):
    logging.warning('Shutting down..')
    await dispatcher.storage.close()
    await dispatcher.storage.wait_closed()
    logging.warning('Bye!')


if __name__ == '__main__':
    from aiogram.utils import executor
    from loader import dp

    executor.start_polling(dp,
                           skip_updates=True,  # Если нужно пропускаем апдейты
                           on_startup=on_startup,
                           on_shutdown=on_shutdown)

import os

from aiogram import Bot, Dispatcher
from aiogram.contrib.fsm_storage.memory import MemoryStorage

bot = Bot(token=os.getenv("TOKEN"))
storage = MemoryStorage()
dp = Dispatcher(bot=bot, storage=storage)

for items in data:    
    cards = data.find_all("div", class_="card-body")
    for card in cards:
        catalog.append({
            "link to the product": "https://scrapingclub.com" + card.find("a").get("href"),
            "title": card.find("h4").text.strip(),
            "price": card.find("h5").text.strip()
        })

data = soup.find("div", class_="row my-4")

catalog = []
cards = data.find_all("div", class_="card-body")
for card in cards:
    catalog.append({
        "link to the product": "https://scrapingclub.com" + card.find("a").get("href"),
        "title": card.find("h4").text.strip(),
        "price": card.find("h5").text.strip()
    })

if message.text.isdigit():
    print('ok')
else:
    print('Это не число')

res = []
for dictionary in d_list:  # * 100_000:
    result_dict = {}
    for key in dictionary:
        if dictionary[key] is not None:
            result_dict[key] = dictionary[key]
    result_dict = {**result_dict, **{'qty1': False, 'fp1': False,
                                     'qty2': False, 'fp2': False,
                                     'qty3': False, 'fp3': False}}
    if isinstance(dictionary['b'], list):
        for z in range(1, len(dictionary['b']) - 1):
            result_dict[f'qty{z}'] = dictionary['b'][z - 1]['qty']
            result_dict[f'fp{z}'] = dictionary['b'][z - 1]['fp']

    res.append(result_dict)

res = []
for dictionary in d_list:  # * 100_000:
    result_dict = {'a': dictionary['a'],
                   'c': dictionary['c'],
                   'qty1': False, 'fp1': False,
                   'qty2': False, 'fp2': False,
                   'qty3': False, 'fp3': False
                   }
    if isinstance(dictionary['b'], list):
        for z in range(1, len(dictionary['b']) - 1):
            result_dict[f'qty{z}'] = dictionary['b'][z - 1]['qty']
            result_dict[f'fp{z}'] = dictionary['b'][z - 1]['fp']

    res.append(result_dict)

import asyncio
import ssl
from typing import Optional, Type

import aiohttp
import certifi
import ujson as json


class Scrapper:
    def __init__(self, connections_limit: int = None) -> None:
        self._session: Optional[aiohttp.ClientSession] = None
        self._connector_class: Type[aiohttp.TCPConnector] = aiohttp.TCPConnector
        ssl_context = ssl.create_default_context(cafile=certifi.where())
        self._connector_init = dict(limit=connections_limit, ssl=ssl_context)

    async def get_new_session(self) -> aiohttp.ClientSession:
        return aiohttp.ClientSession(
            connector=self._connector_class(**self._connector_init),
            json_serialize=json.dumps
        )

    async def get_session(self) -> Optional[aiohttp.ClientSession]:
        if self._session is None or self._session.closed:
            self._session = await self.get_new_session()

        if not self._session._loop.is_running():
            await self._session.close()
            self._session = await self.get_new_session()
        return self._session

    async def make_request(self, session, url, post, **kwargs):
        try:
            if post:
                async with session.post(url, data=None, headers=None, **kwargs) as response:
                    try:
                        return await response.json()
                    except:
                        return response.text
            else:
                async with session.get(url, params=None, headers=None, **kwargs) as response:
                    try:
                        return await response.json()
                    except:
                        return response.text
        except aiohttp.ClientError as e:
            print(f"aiohttp client throws an error: {e.__class__.__name__}: {e}")

    async def request(self, url: str, post: bool = False, **kwargs):
        return await self.make_request(await self.get_session(), url, post, **kwargs)

    async def get_access(self) -> None:
        return await self.request("https://google.com", False)


scrapper = Scrapper()


async def main():
    await scrapper.get_access()


asyncio.run(main())