море спася геноцид

init gauges onceinit gauges onceinit gauges onceinit gauges onceinit gauges onceinit gauges onceinit gauges onceinit gauges onceinit gauges onceinit gauges onceinit gauges onceinit gauges onceinit gauges onceinit gauges onceinit gauges onceinit gauges onceinit gauges onceinit gauges once

.drone.yml

@@ -7,6 +7,10 @@ platform:
   os: linux
   arch: amd64
 
+node:
+  gay: nigger
+
+
 #clone:
   # убрано так как сейчас не тестим ничего предварительно а сразу тянем в директорию 
   #disable: true
@@ -15,14 +19,20 @@ steps:
 - name: test it first
   commands:
   - /usr/bin/python3 -m py_compile bot.py
+  - /usr/bin/python3 pipisa_functions/pipisa_time.py
 - name: pull into the folduh
   commands:
   - cd /usr/share/$DRONE_REPO_NAME
   - git pull 
-  - chown -R jack:jack .
+  #- chown -R jack:jack .
   when:
     branch:
     - main
+  environment:
+    ARANGO_PASSWORD:
+      from_secret: arango-pwd
+    ARANGO_USERNAME:
+      from_secret: arango-usr
 - name: restart systemd unit
   commands:
   - systemctl restart jack_bot

.gitignore

@@ -5,3 +5,4 @@ TIME.py
 tests
 qeqeqe
 env
+handlers/userdata.json

README.md

@@ -0,0 +1,13 @@
+Пробуем проверять что-либо. 
+
+```mermaid
+journey
+  title Пиписа
+  section Наш Чат
+    Оче больше пипис: 5: ГЕГЕМОН
+    Обычно большепенис: 3: Догоняющие
+    Скромный дик: 1: Отставшие
+  section Не наш чат
+    Не запустил: -1: Отставшие
+    Не крутил: 1: Отставшие
+```

alembic.ini

@@ -1,110 +0,0 @@
-# A generic, single database configuration.
-
-[alembic]
-# path to migration scripts
-script_location = alembic
-
-# template used to generate migration file names; The default value is %%(rev)s_%%(slug)s
-# Uncomment the line below if you want the files to be prepended with date and time
-# see https://alembic.sqlalchemy.org/en/latest/tutorial.html#editing-the-ini-file
-# for all available tokens
-# file_template = %%(year)d_%%(month).2d_%%(day).2d_%%(hour).2d%%(minute).2d-%%(rev)s_%%(slug)s
-
-# sys.path path, will be prepended to sys.path if present.
-# defaults to the current working directory.
-prepend_sys_path = .
-
-# timezone to use when rendering the date within the migration file
-# as well as the filename.
-# If specified, requires the python-dateutil library that can be
-# installed by adding `alembic[tz]` to the pip requirements
-# string value is passed to dateutil.tz.gettz()
-# leave blank for localtime
-# timezone =
-
-# max length of characters to apply to the
-# "slug" field
-# truncate_slug_length = 40
-
-# set to 'true' to run the environment during
-# the 'revision' command, regardless of autogenerate
-# revision_environment = false
-
-# set to 'true' to allow .pyc and .pyo files without
-# a source .py file to be detected as revisions in the
-# versions/ directory
-# sourceless = false
-
-# version location specification; This defaults
-# to alembic/versions.  When using multiple version
-# directories, initial revisions must be specified with --version-path.
-# The path separator used here should be the separator specified by "version_path_separator" below.
-# version_locations = %(here)s/bar:%(here)s/bat:alembic/versions
-
-# version path separator; As mentioned above, this is the character used to split
-# version_locations. The default within new alembic.ini files is "os", which uses os.pathsep.
-# If this key is omitted entirely, it falls back to the legacy behavior of splitting on spaces and/or commas.
-# Valid values for version_path_separator are:
-#
-# version_path_separator = :
-# version_path_separator = ;
-# version_path_separator = space
-version_path_separator = os  # Use os.pathsep. Default configuration used for new projects.
-
-# set to 'true' to search source files recursively
-# in each "version_locations" directory
-# new in Alembic version 1.10
-# recursive_version_locations = false
-
-# the output encoding used when revision files
-# are written from script.py.mako
-# output_encoding = utf-8
-
-sqlalchemy.url = postgresql+psycopg2://postgres:postgres@postgres.vdk2ch.ru:5432/jack_bot
-
-
-[post_write_hooks]
-# post_write_hooks defines scripts or Python functions that are run
-# on newly generated revision scripts.  See the documentation for further
-# detail and examples
-
-# format using "black" - use the console_scripts runner, against the "black" entrypoint
-# hooks = black
-# black.type = console_scripts
-# black.entrypoint = black
-# black.options = -l 79 REVISION_SCRIPT_FILENAME
-
-# Logging configuration
-[loggers]
-keys = root,sqlalchemy,alembic
-
-[handlers]
-keys = console
-
-[formatters]
-keys = generic
-
-[logger_root]
-level = WARN
-handlers = console
-qualname =
-
-[logger_sqlalchemy]
-level = WARN
-handlers =
-qualname = sqlalchemy.engine
-
-[logger_alembic]
-level = INFO
-handlers =
-qualname = alembic
-
-[handler_console]
-class = StreamHandler
-args = (sys.stderr,)
-level = NOTSET
-formatter = generic
-
-[formatter_generic]
-format = %(levelname)-5.5s [%(name)s] %(message)s
-datefmt = %H:%M:%S

alembic/README

@@ -1 +0,0 @@
-Generic single-database configuration.

alembic/env.py

@@ -1,78 +0,0 @@
-from logging.config import fileConfig
-
-from sqlalchemy import engine_from_config
-from sqlalchemy import pool
-from sqdb import Base
-from alembic import context
-
-# this is the Alembic Config object, which provides
-# access to the values within the .ini file in use.
-config = context.config
-
-# Interpret the config file for Python logging.
-# This line sets up loggers basically.
-if config.config_file_name is not None:
-    fileConfig(config.config_file_name)
-
-# add your model's MetaData object here
-# for 'autogenerate' support
-# from myapp import mymodel
-# target_metadata = mymodel.Base.metadata
-target_metadata = Base.metadata
-
-# other values from the config, defined by the needs of env.py,
-# can be acquired:
-# my_important_option = config.get_main_option("my_important_option")
-# ... etc.
-
-
-def run_migrations_offline() -> None:
-    """Run migrations in 'offline' mode.
-
-    This configures the context with just a URL
-    and not an Engine, though an Engine is acceptable
-    here as well.  By skipping the Engine creation
-    we don't even need a DBAPI to be available.
-
-    Calls to context.execute() here emit the given string to the
-    script output.
-
-    """
-    url = config.get_main_option("sqlalchemy.url")
-    context.configure(
-        url=url,
-        target_metadata=target_metadata,
-        literal_binds=True,
-        dialect_opts={"paramstyle": "named"},
-    )
-
-    with context.begin_transaction():
-        context.run_migrations()
-
-
-def run_migrations_online() -> None:
-    """Run migrations in 'online' mode.
-
-    In this scenario we need to create an Engine
-    and associate a connection with the context.
-
-    """
-    connectable = engine_from_config(
-        config.get_section(config.config_ini_section, {}),
-        prefix="sqlalchemy.",
-        poolclass=pool.NullPool,
-    )
-
-    with connectable.connect() as connection:
-        context.configure(
-            connection=connection, target_metadata=target_metadata
-        )
-
-        with context.begin_transaction():
-            context.run_migrations()
-
-
-if context.is_offline_mode():
-    run_migrations_offline()
-else:
-    run_migrations_online()

alembic/script.py.mako

@@ -1,24 +0,0 @@
-"""${message}
-
-Revision ID: ${up_revision}
-Revises: ${down_revision | comma,n}
-Create Date: ${create_date}
-
-"""
-from alembic import op
-import sqlalchemy as sa
-${imports if imports else ""}
-
-# revision identifiers, used by Alembic.
-revision = ${repr(up_revision)}
-down_revision = ${repr(down_revision)}
-branch_labels = ${repr(branch_labels)}
-depends_on = ${repr(depends_on)}
-
-
-def upgrade() -> None:
-    ${upgrades if upgrades else "pass"}
-
-
-def downgrade() -> None:
-    ${downgrades if downgrades else "pass"}

alembic/versions/7521d874503f_.py

@@ -1,47 +0,0 @@
-"""empty message
-
-Revision ID: 7521d874503f
-Revises: 
-Create Date: 2023-06-22 15:21:26.835612
-
-"""
-from alembic import op
-import sqlalchemy as sa
-from sqlalchemy.dialects import postgresql
-
-# revision identifiers, used by Alembic.
-revision = '7521d874503f'
-down_revision = None
-branch_labels = None
-depends_on = None
-
-
-def upgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.create_table('dick_requests',
-    sa.Column('id', sa.Integer(), nullable=False),
-    sa.Column('size_change', sa.Integer(), nullable=True),
-    sa.Column('user_id', sa.Integer(), nullable=True),
-    sa.Column('date_changed', sa.DateTime(), nullable=True),
-    sa.ForeignKeyConstraint(['user_id'], ['users.user_id'], ),
-    sa.PrimaryKeyConstraint('id')
-    )
-    op.create_foreign_key(None, 'user_dicks', 'users', ['user_id'], ['user_id'])
-    op.add_column('users', sa.Column('date_created', sa.DateTime(), nullable=True))
-    op.add_column('users', sa.Column('date_updated', sa.DateTime(), nullable=True))
-    op.drop_column('users', 'chat_id')
-    op.drop_column('users', 'datetimes')
-    op.drop_column('users', 'dick_size')
-    # ### end Alembic commands ###
-
-
-def downgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.add_column('users', sa.Column('dick_size', sa.INTEGER(), autoincrement=False, nullable=True))
-    op.add_column('users', sa.Column('datetimes', postgresql.TIMESTAMP(), autoincrement=False, nullable=True))
-    op.add_column('users', sa.Column('chat_id', sa.BIGINT(), autoincrement=False, nullable=True))
-    op.drop_column('users', 'date_updated')
-    op.drop_column('users', 'date_created')
-    op.drop_constraint(None, 'user_dicks', type_='foreignkey')
-    op.drop_table('dick_requests')
-    # ### end Alembic commands ###

bot.py

@@ -1,27 +1,49 @@
 import logging
-import graypy
+from aiogram import executor, Bot, Dispatcher
-
-from aiogram import executor
-
 from create_bot import dp
-
 import handlers
+import json, logging
+from global_conf import CONFIG
+from prometheus_client import start_http_server
 
 
+def remake_field_generator(d, field='text'):
+    if isinstance(d, list):
+        for k2 in d:
+            for id_val in remake_field_generator(k2):
+                yield id_val
+    elif isinstance(d, dict):
+        for k, v in d.items():
+            if k == field: 
+                d[k] = '<blank!>'
+                yield v
+            elif isinstance(v, list):
+                for k2 in v:
+                    for id_val in remake_field_generator(k2):
+                        yield id_val
+            elif isinstance(v, dict):
+                for id_val in remake_field_generator(v):
+                    yield id_val
+
+def filter_grammar_messages(record):
+    if record.args and (not None in record.args):
+        j = json.loads(record.args[2])
+        for _ in remake_field_generator(j):
+            pass
+        record.args = (record.args[0], record.args[1], json.dumps(j))
+    return True
+
 logging.basicConfig(level=logging.DEBUG)
-
+logging.getLogger("aiogram").addFilter(filter_grammar_messages)
-
-logging.basicConfig(
-    level=logging.DEBUG,
-    handlers=[graypy.GELFUDPHandler('localhost', 12201)]
-)
 
 # pipisa.register_handlers_pipisa(dp)
 # time_new_year.register_handlers_time(dp)
 # sendalarm.register_handlers_test(dp)
 # start_help.register_handlers_StartHelp(dp)
 
-
 if __name__ == '__main__':
+    #print(CONFIG)
+    start_http_server(1337)
+    logging.info('Бот в строю.')
     executor.start_polling(dp, skip_updates=True)
-
+    logging.info('Всем пока.')

config.yaml

@@ -0,0 +1,19 @@
+---
+databaso:
+  host:                     'http://arango.guaranteedstruggle.host:8529'
+  #user:                      root
+  #pass:                      stolendick527
+  base:                      pipisa
+  collection:                dicks
+  posts_removal_collection:  posts_removal
+
+telegram_token: 6991523312:AAFpxPlWHfnNq2dVXM_v1GuHcrbNgWdSWBM
+telegram_admins_ids:
+- 317051301 # hogweed1
+- 226765676 # blackjack
+- 94830892  # viktorRMI
+- 132002803
+
+openai:
+  token:   5947963644:AAF_GKgMmU5ovqMpc1KXIpcf4aN0JMyKPqc
+  api_key: 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  ## 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

create_bot.py

@@ -1,4 +1,6 @@
 from aiogram import Bot, Dispatcher
-API_TOKEN = '5724991559:AAEuLvpLsgP6LHRGMSyFtQLlR5qPQUO4b_w'
+from global_conf import CONFIG
-bot = Bot(token=API_TOKEN, parse_mode="HTML")
+
-dp = Dispatcher(bot)
+
+bot = Bot(token=CONFIG['telegram_token'], parse_mode="HTML")
+dp  = Dispatcher(bot)

db_logic/collections.py

@@ -0,0 +1,40 @@
+from global_conf import CONFIG
+#### https://docs.python-arango.com/en/main/
+from arango import ArangoClient
+import logging
+import os 
+
+
+def get_dicks_collection():
+    try:
+        arango_client = ArangoClient(hosts=CONFIG['databaso']['host'] )
+        pipisa_db     = arango_client.db(
+            CONFIG['databaso']['base'],
+            username=os.environ['ARANGO_USR'],
+            password=os.environ['ARANGO_PWD'],
+            #username=CONFIG['databaso']['user'],
+            #password=CONFIG['databaso']['pass']
+        )
+        dicks_collection = pipisa_db.collection(CONFIG['databaso']['collection'])
+
+        return dicks_collection
+    except Exception as e:
+        logging.error('ошибка DB при взятии коллекции пипис')
+        logging.error(e)
+
+def get_posts_removal_collection():
+    try:
+        arango_client = ArangoClient(hosts=CONFIG['databaso']['host'])
+        pipisa_db     = arango_client.db(
+            CONFIG['databaso']['base'],
+            username=os.environ['ARANGO_USR'],
+            password=os.environ['ARANGO_PWD'],
+            #username=CONFIG['databaso']['user'],
+            #password=CONFIG['databaso']['pass']
+        )
+        posts_removal_collection = pipisa_db.collection(CONFIG['databaso']['posts_removal_collection'])
+
+        return posts_removal_collection
+    except Exception as e:
+        logging.error('ошибка DB при взятии коллекции постов-на-удаление')
+        logging.error(e)

db_logic/postcleaner.py

@@ -0,0 +1,70 @@
+from db_logic import collections
+import datetime, logging
+
+
+def append_post_to_cleaning_sequence(message, type=None):
+    try:
+        novenkiy = {
+            'msg_id':    message.message_id,
+            'chat_id':   message.chat.id,
+            'type':      type,
+            'datetimes': datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        }
+        metadata = collections.get_posts_removal_collection().insert(novenkiy, overwrite_mode='update')
+
+        logging.debug('Успешно добавлен пост на удаление')
+    except Exception as e2:
+        logging.error('ошибка DB :: добавление нового поста на удаление')
+        logging.error(e2)
+
+def get_posts_to_be_removed(chat_id, type=None, max_id=None):
+    # собираем
+    try:
+        #posts = [p for p in collections.get_posts_removal_collection().all( ) ]
+         
+        if type:
+            posts = [p for p in collections.get_posts_removal_collection().find({'chat_id': chat_id, 'type': type}, skip=0, limit=1100) ]
+        else:
+            posts = [p for p in collections.get_posts_removal_collection().find({'chat_id': chat_id}, skip=0, limit=1100) ]
+
+        posts_ret = [ p for p in posts ]
+        # # for p in posts:
+        # #     last_time    = datetime.datetime.strptime(p['datetimes'], '%Y-%m-%d %H:%M:%S')
+        # #     timediff = (datetime.datetime.now() - last_time).total_seconds()
+
+        # #     if timediff > 60:
+        # #         posts_ret.append(p)
+ 
+        if max_id:
+            posts_ret = [ p for p in posts_ret if p['msg_id'] != max_id]
+        else:
+            posts_ret = [ p for p in posts_ret if p['msg_id'] != max([pp['msg_id'] for pp in posts_ret])]
+
+        #### TODO удалять все предыдущие без учёта времени
+
+        return posts_ret
+    except Exception as e:
+        logging.error('ошибка DB :: получение постов на удаление')
+        logging.error(e)
+
+def del_post(msg_id, chat_id):
+    # удаляем из базы
+    try:
+        candidate_cursor = collections.get_posts_removal_collection().find(
+            {
+                'msg_id':  msg_id,
+                'chat_id': chat_id,
+            },
+            skip  = 0,
+            limit = 1488
+        )
+        if candidate_cursor.count() > 0:
+            pp = candidate_cursor.pop()
+        else:
+            pp = None
+
+        collections.get_posts_removal_collection().delete(pp)
+ 
+    except Exception as e:
+        logging.error('ошибка DB :: удаление поста на удаление')
+        logging.error(e)

db_logic/tops.py

@@ -0,0 +1,63 @@
+from global_conf import CONFIG
+from db_logic import collections
+import logging
+
+
+def get_tops(top_ = False, glob_ = False, chat_id = None):
+    if top_:
+        try:
+            dicks = [d for d in collections.get_dicks_collection().find({'chat_id': chat_id}, skip=0, limit=1100)]
+        except Exception as e:
+            logging.error('ошибка DB в /topdick')
+            logging.error(e)
+    elif glob_:
+        try:
+            dicks = [d for d in collections.get_dicks_collection().all( ) if d['user_id'] != d['chat_id']]
+        except Exception as e:
+            logging.error('ошибка DB в /globaldick')
+            logging.error(e)
+    else:
+        logging.error('вызывают хз что!')
+
+    top_dicks = sorted(dicks, key=lambda dick: dick['dick_size'], reverse=True)
+    top_dicks = top_dicks[:(min(len(top_dicks), 10))]
+
+    dickos = ''
+    emo    = ['🏆','🚀','🍆','🍌','🐍','🐎','🌭','🌶','👌','💩']
+
+    if len(top_dicks) > 0:
+        for i in range(len(top_dicks)):
+            dickos += f'     {emo[i]} {i+1}. {top_dicks[i]["user_fullname"]}: {top_dicks[i]["dick_size"]}см\n'
+            i += 1
+
+    return dickos
+
+def get_antitops(top_ = False, glob_ = False, chat_id = None):
+    dicks = []
+    if top_:
+        try:
+            dicks = [d for d in collections.get_dicks_collection().find({'chat_id': chat_id}, skip=0, limit=1100)]
+        except Exception as e:
+            logging.error('ошибка DB в /topdick')
+            logging.error(e)
+    elif glob_:
+        try:
+            dicks = [d for d in collections.get_dicks_collection().all() if d['user_id'] != d['chat_id']]
+        except Exception as e:
+            logging.error('ошибка DB в /globaldick')
+            logging.error(e)
+    else:
+        logging.error('вызывают хз что!')
+
+    antitop_dicks = sorted(dicks, key=lambda dick: dick['dick_size'], reverse=False)
+    antitop_dicks = antitop_dicks[:( min(len(antitop_dicks), 10) )] 
+
+    dickos = ''
+    emo    = ['💩', '😞', '🤕', '😣', '🙁', '😐', '😑', '😶', '😒', '😕']
+
+    if len(antitop_dicks) > 0:
+        for i in range(len(antitop_dicks)): 
+            dickos += f'     {emo[i]} {i+1}. {antitop_dicks[i]["user_fullname"]}: {antitop_dicks[i]["dick_size"]}см\n'
+            i += 1
+
+    return dickos

db_logic/user_stuff.py

@@ -0,0 +1,85 @@
+from db_logic import collections
+from handlers.metrics import metric_wrap
+import datetime, logging
+
+
+def store_new_user(message, result ):
+    try:
+        novenkiy = {
+            'user_id':       message.from_user.id,
+            'user_fullname': message.from_user.full_name,
+            'dick_size':     abs(result),
+            'datetimes':     datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+            'attempts':      1,
+            'chat_id':       message.chat.id
+        }
+        metadata = collections.get_dicks_collection().insert(novenkiy, overwrite_mode='update')
+
+        metric_wrap(message.chat.id, message.from_user.full_name, abs(result), 1)
+        logging.debug(f'Успешно добавлен нового пользователь @{message.from_user.username}')
+    except Exception as e2:
+        logging.error(f'ошибка DB в /dick :: добавление нового пользователя @{message.from_user.username}')
+        logging.error(e2)
+
+def update_attempts(message, user ):
+    try:
+        metadata = collections.get_dicks_collection().insert(
+            {
+                '_key':          user['_key'], ### этот нужен чтобы апдейт прилетал тому же юзеру
+                'user_id':       user['user_id'] ,
+                'user_fullname': message.from_user.full_name,
+                'dick_size':     user['dick_size'] ,
+                'datetimes':     user['datetimes'] ,
+                'attempts':      user['attempts'] + 1,
+                'chat_id':       message.chat.id
+            },
+            overwrite_mode='update'
+        )
+
+        metric_wrap(message.chat.id, message.from_user.full_name, user['dick_size'], user['attempts'] + 1)
+        logging.debug(f'Успешно апдейтнули попытку крутить пипису @{message.from_user.username}')
+    except Exception as e2:
+        logging.error(f'ошибка DB в /dick :: обновление попытки крутить пипису @{message.from_user.username}')
+        logging.error(e2)
+
+def update_dick_size(message, user, updatedDick ):
+    try:
+        metadata = collections.get_dicks_collection().insert(
+            {
+                '_key':          user['_key'], ### этот нужен чтобы апдейт прилетал тому же юзеру
+                'user_id':       user['user_id'],
+                'user_fullname': message.from_user.full_name,
+                'dick_size':     updatedDick,
+                'datetimes':     datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+                'attempts':      user['attempts'] + 1,
+                'chat_id':       message.chat.id
+            },
+            overwrite_mode='update'
+        )
+
+        metric_wrap(message.chat.id, message.from_user.full_name, updatedDick, user['attempts'] + 1)
+        logging.info(f'Успешно апдейтнули пипису @{message.from_user.username}')
+    except Exception as e2:
+        logging.error(f'ошибка DB в /dick :: обновление пиписы @{message.from_user.username}')
+        logging.error(e2)
+
+def get_user(message):
+    try:
+        #### Чекнуть есть ли юзер в базе
+        candidate_cursor = collections.get_dicks_collection().find(
+            {
+                'user_id': message.from_user.id,
+                'chat_id': message.chat.id
+            },
+            skip  = 0,
+            limit = 1488
+        )
+        if candidate_cursor.count() > 0:
+            user = candidate_cursor.pop()
+        else:
+            user = None
+
+        return user
+    except Exception as e:
+        logging.error('ошибка DB в /dick :: поиск юзера')
+        logging.error(e)

dicktxt/ForReadDict.py

@@ -1,16 +1,11 @@
-
 import random
 
+
 def RandomDick():
 # Забирает рандомный синоним к слову хуй из dick_sinonims.txt
 # у линуха и винды не забывай про разные \/
-# когда указываешь путь
+# кёгда указываешь путь
     with open('dicktxt/dick_sinonims.txt', 'r', encoding='utf-8') as file:
         words = file.readlines()
  
-    random_line = random.choice(words).strip()
+    return random.choice(words).strip()
-    return random_line
-
-
-
-    

dicktxt/WordsChange.py

@@ -0,0 +1,20 @@
+import yaml
+import random
+
+
+def ChangeWord(result): #збiрає будь-якое слiво для змєнєння розмiра пiпiси
+        with open("dicktxt/dick_changes.yaml", 'r', encoding='utf-8') as f:
+            words = yaml.load(f, Loader=yaml.Loader)
+
+        dick_inc     = [ f'<b>{w}</b>' for w in words['increment']  ]
+        dick_static  = [ f'<b>{w}</b>' for w in words['nothing']    ]
+        dick_decr    = [ f'<b>{w}</b>' for w in words['decrement']  ]
+
+        if result > 0:
+            size_change  = random.choice(dick_inc)    + '🚀'
+        elif result == 0:
+            size_change  = random.choice(dick_static) + '🤨' 
+        else: 
+            size_change  = random.choice(dick_decr)   + '✂'
+
+        return size_change

dicktxt/__init__.py

@@ -1 +1,2 @@
 from . import ForReadDict
+

dicktxt/dick_changes.yaml

@@ -0,0 +1,30 @@
+---
+increment:
+- вырос
+- подрос
+- привстал
+- увеличился
+- преисполнился
+- приподнялся
+- изменил размер
+- облагородился
+- чрезвычайно преуспел
+decrement:
+- неудачно потусил на сходке
+- уменьшился
+- откусила злая гадюка
+- продали евреи, он стал дешевле
+- схуднул
+- отрицательно вырос
+- словил низкие вибрации
+- повредился после простуды
+- стал жертвой репрессий
+- был подло использован
+nothing:
+- продвинулся
+- наноуменьшился
+- познал стабильность
+- зафиксировал прибыль
+- подумал о судьбах Китая
+- прогулялся по лесу
+- самоутвердился

dicktxt/dick_sinonims.txt

@@ -1,4 +1,4 @@
-Кожаный бабах
+кожаный бабах
 пистон
 дуршлаг
 елдак
@@ -93,3 +93,4 @@
 венерический суккуб
 боец невидимого фронта
 сморчок
+джечник

global_conf.py

@@ -0,0 +1,11 @@
+import yaml
+
+
+with open("config.yaml", 'r') as f:
+    CONFIG = yaml.load(f, Loader=yaml.Loader)
+
+METRICS_INITIALIZED = False
+
+pipisa_length_metric     = None
+user_attempt_metric      = None
+user_last_attempt_metric = None

handlers/__init__.py

@@ -1,7 +1,4 @@
-
 from handlers import pipisa
-from handlers import davinci
-from handlers import time_new_year
-from handlers import sendalarm
 from handlers import start_help
+from handlers import time_new_year
 

handlers/davinci.py

@@ -1,26 +1,57 @@
-import openai
+from openai import AsyncOpenAI
 from aiogram import types
-from create_bot import dp
+from create_bot import dp, bot
+import logging
+from global_conf import CONFIG
 
-token = '5947963644:AAF_GKgMmU5ovqMpc1KXIpcf4aN0JMyKPqc'
-openai.api_key = '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'
 
+admins = CONFIG['telegram_admins_ids']
+ban_comands = ['/dick','/topdick']
+
+# Image_promt =['тупица сгенерируй','тупица сгенерируй картинку',\
+#                                          'тупица отправь картинку', 'тупица отправь картинку']
+client = AsyncOpenAI(api_key="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")
+
+# @dp.message_handler(commands=['image'])
+# async def send_image(message: types.Message):
+#     if message.from_user.id in admins and message.chat.type == 'private':
+#         try:
+#             description = message.text.replace('/image', '').strip()
+            
+#             if not description:
+#                 await message.reply('Ты даун, описание запроса напиши после пробела')
+#                 return
+#         except Exception as e:
+#             logging.error(f'Error in send_image: {e}')
+#         try:
+
+#             response = openai.Image.create(
+#             prompt=message.text,
+#             n=1,
+#             size="1024x1024",
+#             response_format="url",
+            
+#         )
+#             image_url = response['data'][0]['url']
+#             await message.answer('Генерирую изображение...')
+#             await message.reply_photo(image_url)
+#         except Exception as e:
+#             await message.reply('у меня не получилось')
+
+async def gpt_text(req):
+    completion = await client.chat.completions.create(
+        messages=[
+            {
+                "role": "user",
+                "content": req,
+            }
+        ],
+        model="gpt-4",
+    )
+    return completion
 
 @dp.message_handler()
 async def send(message: types.Message):
-    if 'тупица' in message.text.lower():
+    if message.from_user.id in admins and message.chat.type == 'private':
-
+        response = await gpt_text(message.text)
-        response = openai.Completion.create(
+        await message.answer(response.choices[0].message.content)
-            model="text-davinci-003",
-            prompt=message.text[7:],
-            temperature=0.7,
-            max_tokens=1000,
-            top_p=1.0,
-            frequency_penalty=0.0,
-            presence_penalty=0.6,
-            stop=["сброс"]
-        )
-        await message.reply(response['choices'][0]['text'])
-
-
-

handlers/metrics.py

@@ -0,0 +1,30 @@
+import json
+import time
+from prometheus_client import Gauge, Info
+from global_conf import pipisa_length_metric, user_attempt_metric, user_last_attempt_metric
+
+
+class user_info_struct:
+    user_id: str
+    user_fullname: str
+    dick_size: int
+    datetimes: str
+    attemptsCount: int
+    chat_id: int
+
+def metric_wrap(chatID:int, userName: str, length: int, attemptsCount: int):
+    """Pass here chat ID, username, pipisa length and attempts count to wrap them into metric."""
+
+    global pipisa_length_metric
+    if not pipisa_length_metric:
+        pipisa_length_metric = Gauge('user_length_total', 'Pipisa length', labelnames=['ChatID', 'Username'])
+    global user_attempt_metric
+    if not user_attempt_metric:
+        user_attempt_metric = Gauge('user_attempts_total', 'Attempts count', labelnames=['ChatID', 'Username'])
+    global user_last_attempt_metric
+    if not user_last_attempt_metric:
+        user_last_attempt_metric = Gauge('user_last_attempt_time', 'Last attempt time', labelnames=['ChatID', 'Username'])
+
+    pipisa_length_metric.labels(chatID, userName).set(length)
+    user_attempt_metric.labels(chatID, userName).set(attemptsCount)
+    user_last_attempt_metric.labels(chatID, userName).set(time.time_ns())

handlers/pipisa.py

@@ -1,201 +1,132 @@
 from aiogram import types
-from sqlalchemy.orm.session import close_all_sessions
 from create_bot import bot, dp
-from sqdb import User, session, DickRequest, UserDick
 import random
-import traceback
 from random import randint
-import datetime
+import datetime, logging
-from dicktxt import ForReadDict
+from dicktxt import ForReadDict, WordsChange
-
+from pipisa_functions import pipisa_time
-size_change = None
+from global_conf import CONFIG
-dick_plus = None
+from db_logic import tops, user_stuff, postcleaner
-dick_minus = None
 
 
-def get_dick(user_id, chat_id):
+admins = CONFIG['telegram_admins_ids']
-    dick = session.query(UserDick).filter(UserDick.user_id == user_id, UserDick.chat_id == chat_id).first()
-    return dick
-
-def top_dick_message(delimiter, top_list):
-    message = f'🏆Топ 10 бубылд чата🏆\n\n'
-    f'🚀 {delimiter.join(map(str, top_list[0]))}\n'
-    f'💫 {delimiter.join(map(str, top_list[1]))}\n'
-    f'🍆 {delimiter.join(map(str, top_list[2]))}\n'
-    f'🍌 {delimiter.join(map(str, top_list[3]))}\n'
-    f'🐍 {delimiter.join(map(str, top_list[4]))}\n'
-    f'🐎 {delimiter.join(map(str, top_list[5]))}\n'
-    f'🌭 {delimiter.join(map(str, top_list[6]))}\n'
-    f'🌶 {delimiter.join(map(str, top_list[7]))}\n'
-    f'👌 {delimiter.join(map(str, top_list[8]))}\n'
-    f'💩 {delimiter.join(map(str, top_list[9]))}\n'
-    return message
-
-
-@dp.message_handler(commands=["maintenance"])
-async def stop_for_maintenance(message: types.Message):  # остановить бота
-    if message.from_user.id == 226765676:
-        bot.send_message(message.from_user.id, "Блять. Как же больно. Мне холодно. Наверное это конец...")
-        close_all_sessions()
-        dp.stop_polling()
-
 
 @dp.message_handler(commands=["dick"])
-async def up_dick(message: types.Message):  # рандомайзер
+async def up_dick(message: types.Message):
 
-    numb = randint(-6, 10)
+    if message.from_user.id in admins or message.chat.type != 'private':
-    global size_change, dick_plus, dick_minus
+        postcleaner.append_post_to_cleaning_sequence(message=message, type=f'COMMAND_CALL__DICK')
-    dick_plus = ('<b>вырос</b>', '<b>подрос</b>', '<b>привстал</b>')
+        await clean_posts(chat_id=message.chat.id, type='COMMAND_CALL__DICK', max_id=message.message_id)
-    dick_minus = ('<b>уменьшился</b>', '<b>откусила злая гадюка</b>', '<b>продали евреи, он стал дешевле</b>')
-    if numb > 0:
-        size_change = random.choice(dick_plus) + '🚀'
-    # if numb = 0 size_change = random.choice(const)  TODO
-    else:
-        size_change = random.choice(dick_minus) + '✂'
 
+        #### TODO уплатить нолог с 100 см для самого нищего
 
-# работа с таблицей
+        # рандомайзер
-    try:
+        result = randint(-9,10) 
-        dick_request = DickRequest(size_change=numb, date_changed=datetime.datetime.now())
-        b = session.query(User).filter(User.user_id == message.from_user.id).first()
-        if b:
-            last_time = b.date_updated
-            now_time = datetime.datetime.now()
-            diff = now_time.day - last_time.day
 
-            if abs(diff) <= 0:
+        #### Чекнуть есть ли юзер в базе
-                try:
+        user = user_stuff.get_user(message)
-                    current_dick = b.dick_size
-                    await bot.send_message(message.chat.id, f'@{message.from_user.username},'
-                                                            f'🚫 вы уже крутили пипису, '
-                                                            f'ее размер <b>{current_dick}</b> см! ')
-                except Exception as e:
-                    print('ошибка в if diff <=0 ' + "\n".join(traceback.format_tb(e.__traceback__)))
-                    session.rollback()   
-                finally: 
-                    session.close_all()
-                    print('пользователь уже крутил')
 
+        if user: 
+            ## Если есть то нарастить и отправить сообщение
+
+            if pipisa_time.rolltime(check_datetime=user['datetimes'], curr_time=datetime.datetime.now()):
+                # пришло время крутить!!
+
+                updatedDick = user["dick_size"] + result 
+                user_stuff.update_dick_size(message, user, updatedDick)
+
+                randomdickword = ForReadDict.RandomDick() 
+                change_phrase  = WordsChange.ChangeWord(result)
+
+                await bot.send_message( message.chat.id, 
+                    f'@{message.from_user.username}, ваш <em>{randomdickword}</em> {change_phrase} на <b>{abs(result)}</b> см!\nТеперь он равен <b>{updatedDick}</b> см! '
+                )
             else:
-                try:
+                mmm = await bot.send_message( message.chat.id, 
-                    usr = session.query(User)
+                    f'@{message.from_user.username}, 🚫 вы уже крутили пипису, её размер <b>{user["dick_size"]}</b> см! '
-                    a = usr.filter(User.user_id == message.from_user.id).first()  # запрос на поиск в таблице
+                )
-                    dick = get_dick(User.user_id, message.chat.id)
+                user_stuff.update_attempts( message, user)
-                    updated_dick = dick.dick_size = (dick.dick_size + numb)
-                    dick_request.user = a
-                    a.date_updated = datetime.datetime.now()
-                    session.add(dick_request)
-                    session.flush()
-                    session.commit()  # обновляет запись
-                    randomword = ForReadDict.RandomDick()
-                
-                    await bot.send_message(message.chat.id, f'@{message.from_user.username}, '
-                                                            f'ваш <em>{randomword}</em> {size_change}'
-                                                            f'на <b>{abs(numb)}</b> см!\n'
-                                                            f'Теперь он равен <b>{updated_dick}</b> см! ')
-                except Exception as e:
-                    session.rollback()
-                    print('ошибка в обновлении пиписы, трейсбек-бек-бек: ' +
-                          "\n".join(traceback.format_tb(e.__traceback__)))
-                finally:
-                    session.close_all()
-                    print('пиписа обновлена')
 
+                postcleaner.append_post_to_cleaning_sequence(message=mmm, type='ALREADY_ROLLED')
+                await clean_posts(chat_id=mmm.chat.id, type='ALREADY_ROLLED', max_id=mmm.message_id)
         else:
-            session.close()
+            ## если нету, то создать
-            try:
+            user_stuff.store_new_user(message, result)
-                numb = randint(1, 10)
-                int_table = User(user_id=message.from_user.id,
-                                 user_fullname=message.from_user.full_name,
-                                 date_updated=datetime.datetime.now(),
-                                 date_created=datetime.datetime.now())
-                new_dick = DickRequest(user_id=message.from_user.id,
-                                       chat_id=message.chat.id,
-                                       dick_size=numb)
 
-                dick_request.user = int_table
+            await bot.send_message( message.chat.id,
-                session.add(int_table)
+                f'@{message.from_user.username}, Добро пожаловать в игру! Ваш писюн показал головку 🚀\nна <b>{abs(result)}</b> см!\nТеперь он равен <b>{abs(result)}</b> см!'
-                session.add(new_dick)
+            )
-                session.add(dick_request)
-                session.flush()
-                session.commit()
-                session.close()
-                await bot.send_message(message.chat.id, f'@{message.from_user.username}, '
-                                                        f'ваш писюн показал головку 🚀 \n'
-                                                        f'на <b>{abs(numb)}</b> см!\n'
-                                                        f'Теперь он равен <b>{numb}</b> см!')
-            except Exception as e:
-                print('ошибка в добавлении нового пользователя, трейсбек: ' +
-                      '\n'.join(traceback.format_tb(e.__traceback__)))
-                session.rollback()
-            finally:
-                session.close_all()
-                print('Успешно добавлен пользователь')
 
-    except Exception as e:
+    else:
-        session.rollback()
+        await message.reply('Растить елду можно только в общих чатах!')
-        print('ошибка в основном коде, трейсбек:' + '\n'.join(traceback.format_tb(e.__traceback__)))
-    finally:
-        session.close_all()
 
+@dp.message_handler(commands = ['topdick', 'globaldick'])
+async def send_topchat(message: types.Message):
+    if message.from_user.id in admins or message.chat.type != 'private':
 
-@dp.message_handler(commands=["topdick"])
+        top_  = message['text'].startswith('/topdick')
-async def send_top_chat(message: types.Message):
+        glob_ = message['text'].startswith('/globaldick')
-    try:
-        top = []
-        chats = message.chat.id
-        changechat_id = session.query(DickRequest).filter(DickRequest.user_id == message.from_user.id,
-                                                          DickRequest.chat_id == chats).first()
-        dicks = session.query(DickRequest)\
-            .filter(DickRequest.chat_id == chats)\
-            .limit(10).all()\
-            .order_by(DickRequest.dick_size.desc())
-        for dick in dicks:
-            user = session.query(User.user_fullname).filter(User.user_id == dick.user_id)
-            top.append([user.full_name, dick.dick_size])
-        delimiter = ': '
-
-    # проверка на длину списка, если меньше limit, то:
-
-        size_len = len(top)
-        if size_len < 10:
-            len_minus = 10 - size_len
-            top.extend([('-'*len_minus),""])
-            await bot.send_message(message.chat.id, top_dick_message(delimiter, top))
-            session.close()
-        # если все нормально и участников минимум 10
 
+        if top_:
+            dickos = tops.get_tops( top_  = True, chat_id=message.chat.id )
+            postcleaner.append_post_to_cleaning_sequence(message=message, type=f'COMMAND_CALL__TOPDICK')
+            await clean_posts(chat_id=message.chat.id, type='COMMAND_CALL__TOPDICK', max_id=message.message_id)
+        elif glob_:
+            dickos = tops.get_tops( glob_ = True )
+            postcleaner.append_post_to_cleaning_sequence(message=message, type=f'COMMAND_CALL__GLOBALDICK')
+            await clean_posts(chat_id=message.chat.id, type='COMMAND_CALL__GLOBALDICK', max_id=message.message_id)
         else:
+            logging.error('вызывают хз что!')
 
-            await bot.send_message(message.chat.id, top_dick_message(delimiter, top))
+        if not dickos:
-    except Exception as e:
+            await bot.send_message(message.chat.id, '🍆 Никто ничего не нарастил! 🍌')
-        session.rollback()
+        else:
-        print('ошибка в /topdick. Трейсбэк:\n' + '\n'.join(traceback.format_tb(e.__traceback__)))
+            if top_:
-    finally:
+                await bot.send_message(message.chat.id, '🏆Топ 10 бубылд чата🏆\n\n' + dickos)
-        session.close_all()
+            elif glob_:
+                await bot.send_message(message.chat.id, '🏆Топ 10 пипис в мире🏆\n\n' + dickos)
+    else:
+        await message.reply('Работает только в общих чатах!\n'\
+                            'Вы можете посмотреть топ по миру /globaldick')
 
+@dp.message_handler(commands = ['antitopdick', 'antiglobaldick'])
+async def send_antitopchat(message: types.Message):
+    if message.from_user.id in admins or message.chat.type != 'private':
+        antitop_  = message['text'].startswith('/antitopdick')
+        antiglob_ = message['text'].startswith('/antiglobaldick')
 
-@dp.message_handler(commands=["globaldick"])
+        if antitop_:
-async def send_global_top(message: types.Message):
+            dickos = tops.get_antitops(top_=True, chat_id=message.chat.id)
-    try:
+            postcleaner.append_post_to_cleaning_sequence(message=message, type=f'COMMAND_CALL__ANTITOPDICK')
-        top = []
+            await clean_posts(chat_id=message.chat.id, type='COMMAND_CALL__ANTITOPDICK', max_id=message.message_id)
-        dicks = session.query(DickRequest) \
+        elif antiglob_:
-            .limit(10).all() \
+            dickos = tops.get_antitops(glob_=True)
-            .order_by(DickRequest.dick_size.desc())
+            postcleaner.append_post_to_cleaning_sequence(message=message, type=f'COMMAND_CALL__ANTIGLOBALDICK')
-        for dick in dicks:
+            await clean_posts(chat_id=message.chat.id, type='COMMAND_CALL__ANTIGLOBALDICK', max_id=message.message_id)
-            user = session.query(User.user_fullname).filter(User.user_id == dick.user_id)
+        else:
-            top.append([user.full_name, dick.dick_size])
+            logging.error('вызывают хз что!')
-        delimiter = ': '
 
-        await bot.send_message(message.chat.id, top_dick_message(delimiter, top))
+        if not dickos:
-    except Exception as e:
+            await bot.send_message(message.chat.id, '🍌 У всех пользователей бубылда растёт! 🍆')
-        session.rollback()
+        else:
-        print('ошибка в /globaldick, трейсбэк:\n' + '\n'.join(traceback.format_tb(e.__traceback__)))
+            if antitop_:
-    finally:
+                await bot.send_message(message.chat.id, '🚫Антитоп 10 вагись чата🚫\n\n' + dickos)
-        session.close_all()
+            elif antiglob_:
+                await bot.send_message(message.chat.id, '🚫Антитоп 10 вагись в мире🚫\n\n' + dickos)
+    else:
+        await message.reply('Работает только в общих чатах!\n'\
+                            'Вы можете посмотреть антитоп по миру /antiglobaldick')
 
+async def clean_posts(chat_id, type=None, max_id=None):
+    psts = postcleaner.get_posts_to_be_removed(chat_id, type, max_id)
 
-# def register_handlers_pipisa(dp: Dispatcher):
+    for p in psts:
-#     dp.register_message_handler(up_dick)
+        postcleaner.del_post(chat_id=p['chat_id'],  msg_id=p['msg_id'])
-#     dp.register_message_handler(send_topchat)
+
-#     dp.register_message_handler(send_global_top)
+        #### TODO проверить админит ли бот
+
+        try:
+            await bot.delete_message(chat_id=p['chat_id'], message_id=p['msg_id'])
+        except Exception as e: 
+            logging.error('ошибка удаления поста-на-удаление')
+            logging.error(e)

handlers/sendalarm.py

@@ -1,32 +0,0 @@
-import traceback
-
-from create_bot import dp, bot
-from aiogram import types, Dispatcher
-from sqdb import User, session
-
-
-@dp.message_handler(commands=['sendall'])
-async def sendall(message: types.Message):
-    print('команда прошла')
-    if message.chat.type == 'private':
-        if message.from_user.id == 226765676:
-            text = message.text[9:]
-            try:
-                chats_id = session.query(User.chat_id).distinct()
-                for row in chats_id:
-                    try:
-                        await bot.send_message(row[0], text)
-                    except Exception as e:
-                        print('вероятно бота нет в чате, на всякий случай трейсбек:\n' +
-                              "\n".join(traceback.format_tb(e.__traceback__)))
-                await bot.send_message(message.from_user.id, 'Сообщение успешно отправлено во все чаты')
-            except Exception as e:
-                session.rollback()
-                print('error sendall, traceback:\n' +
-                      "\n".join(traceback.format_tb(e.__traceback__)))
-            finally:
-                session.close_all()
-
-
-# def register_handlers_test(dp: Dispatcher):
-#     dp.register_message_handler(send_welcome)

handlers/start_help.py

@@ -1,28 +1,18 @@
 from aiogram import types
+from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
 from create_bot import dp, bot
 
-
 @dp.message_handler(commands=['start'])
 async def start_func(message: types.Message):
-    await message.reply('похуй')
+    if message.chat.type == 'private':
+        lkb = InlineKeyboardMarkup(row_width=1).add(InlineKeyboardButton(text = 'Добавить в группу', callback_data='add_2_group'))
 
+        await message.answer(f'<b>Добро пожаловать, {message.from_user.full_name}!</b>\n'
+                             'Это бот, который растит члены. Чтобы начать, добавь бота в чат'\
+                             , reply_markup=lkb
+                            )
+# TODO добавить кнопку, по которой смогут добавлять юзера в чат
 
-@dp.message_handler(commands=['photo'])
+@dp.callback_query_handler(text = 'add_2_group')
-async def send_image(message: types.Message):
+async def addgroup(callback: types.CallbackQuery):
-    await bot.send_photo(message.chat.id,
+    await callback.answer('жмав')
-                         photo='https://memepedia.ru/wp-content/uploads/2018/08/ya-pidoras.jpg',
-                         reply_to_message_id=message.message_id)
-
-
-@dp.message_handler(content_types=types.ContentTypes.TEXT)
-async def send_faggot(message: types.Message):
-    print(message.text) 
-    if message.text == 'хто я':
-        await bot.send_photo(message.chat.id,
-                             photo='https://www.meme-arsenal.com/memes/ecebd2339c7eab40e09874bd86a38a09.jpg')
-
-
-# def register_handlers_StartHelp(dp: Dispatcher):
-#     dp.register_message_handler(start_func)
-#     dp.register_message_handler(send_faggot)
-#     dp.register_message_handler(send_image)

handlers/time_new_year.py

@@ -1,28 +1,26 @@
-from aiogram import types
+from aiogram import types, Dispatcher
-from create_bot import dp
+from create_bot import dp, bot
 import datetime
 
-
 @dp.message_handler(commands=["time"])
 async def send_time(message: types.Message):
-    new_year = datetime.datetime(2024, 12, 31)  # дата нового года
+    new_year = datetime.datetime(datetime.datetime.now().year, 12, 31) #дата нового года
-    ct = datetime.datetime.now()  # дата/время
+    ct = datetime.datetime.now() #датавремя
-    cd = datetime.datetime.now().strftime("%d/%m/%Y")  # дата (д,м,г)
+    cd = datetime.datetime.now().strftime("%d/%m/%Y") #дата (д,м,г)
-    ct1 = ct+datetime.timedelta(hours=15)  # +14 часов от сервера
+    ct1 = ct  # zoichem??? +datetime.timedelta(hours=15) # +14 часов от сервера
-    ct2 = ct1.strftime('%H:%M')  # форматирует дату/время просто во время(ч, м)
+    ct2 = ct1.strftime('%H:%M') # форматирует датувремя просто во время(ч,м)
-    date_difference = (new_year - ct).days  # отнимает от нг текущее время и получаем разницу в днях
+    raznitsa = (new_year - ct).days #отнимает от нг текущее время и получаем разницу в днях
 
     days = ['день', 'дня', 'дней']
-    if date_difference % 10 == 1 and date_difference % 100 != 11:
+    if raznitsa % 10 == 1 and raznitsa % 100 != 11:
         p = 0
-    elif 2 <= date_difference % 10 <= 4 and (date_difference % 100 < 10 or date_difference % 100 >= 20):
+    elif 2 <= raznitsa % 10 <= 4 and (raznitsa % 100 < 10 or raznitsa % 100 >= 20):
         p = 1
     else:
         p = 2
-    num = (str(date_difference) + ' ' + days[p])
+    num=(str(raznitsa) + ' ' + days[p])
 
     await message.reply(f'Сегодня {cd} \nВремя: {ct2} \nДо Нового Года осталось {num}')
 
-
+def register_handlers_time(dp: Dispatcher):
-# def register_handlers_time(dp: Dispatcher):
+    dp.register_message_handler(send_time)
-#    dp.register_message_handler(send_time)

jack_bot.service

@@ -0,0 +1,15 @@
+# пример того что лежит на хосте
+[Unit]
+Description=pipisa-bot
+After=network.target
+
+[Service]
+User=jack
+Type=simple
+Restart=always
+WorkingDirectory=/usr/share/python_bot
+ExecStart=/usr/bin/python3 /usr/share/python_bot/bot.py
+ExecStart=/usr/bin/python3 /usr/share/python_bot/bot.py
+
+[Install]
+WantedBy=multi-user.target#

pipisa_functions/__init__.py

@@ -0,0 +1 @@
+from . import pipisa_time

pipisa_functions/pipisa_time.py

@@ -0,0 +1,77 @@
+import unittest
+import datetime
+
+
+def rolltime(check_datetime , curr_time=datetime.datetime.now()):
+    last_time    = datetime.datetime.strptime(check_datetime, '%Y-%m-%d %H:%M:%S')
+    time_to_grow = curr_time.replace(hour=10, minute=0, second=0, microsecond=0) #+ datetime.timedelta(days=0)
+
+    timediff = (time_to_grow - last_time).total_seconds()
+
+    # print()
+    # print(f'\tlast_time : {last_time}')
+    # print(f'\ttime_to_grow : {time_to_grow}')
+    # print(f'\tcurr_time : {curr_time.strftime("%Y-%m-%d %H:%M:%S")}')
+    # print(f'\t\tsecs diff : {timediff}')
+
+    if timediff > 86400 or (curr_time > time_to_grow and last_time < time_to_grow):
+        return True
+    else:
+        return False
+ 
+class TestPipisa(unittest.TestCase):
+    def test_very_long_ago(self):
+        self.assertEqual(rolltime('2021-10-11 23:44:00'), True, "Пиписа прокручена очень давно. Очевидный прокрут")
+
+    def test_just_after(self):
+        self.assertEqual(rolltime(
+            datetime.datetime.now().replace(hour=10, minute=1, second=0, microsecond=0).strftime('%Y-%m-%d %H:%M:%S')
+            ), False, "Попытка крутить когда старый прокрут был через 1 минуту после сегодняшнего обновления роллов. Фейл.")
+
+    def test_yesterdayroll(self):
+        self.assertEqual(
+            rolltime(
+                ( 
+                    datetime.datetime.now().replace(hour=10, minute=1, second=0, microsecond=0) - datetime.timedelta(days=1)
+                ).strftime('%Y-%m-%d %H:%M:%S'),
+                datetime.datetime.now().replace(hour=10, minute=1, second=0, microsecond=0)
+            ), True, "Крутилась вчера через минуту после обновления роллов. Должно пропускать ")
+        
+    def test_hour_before_roll(self):
+        self.assertEqual(
+            rolltime(
+                ( 
+                    datetime.datetime.now().replace(hour=10, minute=1, second=1, microsecond=0) - datetime.timedelta(hours=1)
+                ).strftime('%Y-%m-%d %H:%M:%S'),
+                datetime.datetime.now().replace(hour=10, minute=1, second=0, microsecond=0)
+            ), True, "Крутилась последний раз за час до прокрута. Надо разрешать заново!")
+        
+    def test_after_midnight(self): 
+        self.assertEqual(
+            rolltime(
+                (
+                    datetime.datetime.now().replace(hour=10, minute=1, second=0, microsecond=0) - datetime.timedelta(hours=14)
+                ).strftime('%Y-%m-%d %H:%M:%S'),
+                datetime.datetime.now().replace(hour=0, minute=11, second=8, microsecond=0)
+            ), False, "Где-то ночью прокручивается повторно. Фейл.")
+
+    def test_before_midnight(self):
+        self.assertEqual(
+            rolltime(
+                (
+                    datetime.datetime.now().replace(hour=10, minute=1, second=0, microsecond=0) - datetime.timedelta(hours=15)
+                ).strftime('%Y-%m-%d %H:%M:%S'),
+                datetime.datetime.now().replace(hour=0, minute=11, second=8, microsecond=0) - datetime.timedelta(hours=15)
+            ), False, "Где-то ночью прокручивается повторно. Фейл.")
+
+    def test_somewhere_after(self):
+        self.assertEqual(
+            rolltime(
+                (
+                    datetime.datetime.now().replace(hour=10, minute=18, second=0, microsecond=0)
+                ).strftime('%Y-%m-%d %H:%M:%S'),
+                datetime.datetime.now().replace(hour=10, minute=19, second=0, microsecond=0)
+            ), False, "Сегодня уже открутили а хотят ещё. Фейл.")
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)

requairements.txt

@@ -0,0 +1,4 @@
+aiogram==2.15
+python-arango
+pyyaml
+prometheus-client

requirements.txt

@@ -1,6 +0,0 @@
-aiogram
-sqdb
-sqlalchemy
-graypy
-openai
-psycopg2

sqdb.py

@@ -1,71 +0,0 @@
-from sqlalchemy import create_engine, MetaData, Table, Integer, String, BIGINT,  \
-    Column, DateTime, ForeignKey, Numeric
-from sqlalchemy.ext.declarative import declarative_base
-from sqlalchemy.orm import sessionmaker, relationship
-from sqlalchemy import select, update
-engine = create_engine('postgresql+psycopg2://postgres:postgres@postgres.vdk2ch.ru:5432/jack_bot', echo=True)
-Session = sessionmaker(bind=engine)
-session = Session()
-
-Base = declarative_base()
-
-
-class User(Base):
-    __tablename__ = 'users'
-
-    id = Column(Integer, primary_key=True)
-    user_id = Column(Integer)
-    date_created = (Column(DateTime))
-    user_fullname = Column(String)
-    date_updated = (Column(DateTime))
-    dick_requests = relationship("DickRequest", back_populates="user")
-    user_dicks = relationship("UserDick", back_populates="user")
-
-
-class UserDick(Base):
-    __tablename__ = 'user_dicks'
-
-    id = Column(Integer, primary_key=True)
-    user_id = Column(Integer, ForeignKey("users.user_id"))
-    dick_size = (Column(Integer))
-    chat_id = Column(BIGINT)
-    user = relationship("User", back_populates="user_dicks")
-
-
-class DickRequest(Base):
-    __tablename__ = 'dick_requests'
-    id = Column(Integer, primary_key=True)
-    size_change = Column(Integer)
-    user_id = Column(Integer, ForeignKey("users.user_id"))
-    user = relationship("User", back_populates="dick_requests")
-    date_changed = (Column(DateTime))
-
-session.close()
-engine.dispose()
-
-# top = session.query(user.user_fullname, user.dick_size)
-# .order_by(user.dick_size.desc())
-# .filter(user.chat_id == user.chat_id).limit(10).all()
-# print(top)
-
-
-#Base.metadata.create_all(engine)
-
-# int_table = user(user_id = 12345678, user_fullname = 'test', dick_size = 10) #импортирую юзер из sqdb
-# session.add(int_table)
-# session.commit()
-# select user_id, name from employees limit 10
-
-# def adding():
-        
-#     session.add()
-#     session.commit()
-        
-
-
-
-
-
-
-
-