Esempio n. 1
0
    def _base_stats(self, chat):
        base_stats = []

        cards_count = get_plural(
            chat.cards_count,
            'валентинка отправлена, валентинки отправлено, валентинок отправлено'
        )
        base_stats.append(cards_count)

        # если только один юзер подмигнул, то делаем вид, что никто не мигал
        uniq_migs_count = len(set(chat.migs))
        migs_count = get_plural(
            len(chat.migs) if uniq_migs_count > 1 else 0,
            'подмигивание произведено, подмигивания произведено, подмигиваний произведено'
        )
        base_stats.append(migs_count)

        revns_count = get_plural(
            len(chat.revns),
            'ревность источена, ревности источено, ревностей источено')
        base_stats.append(revns_count)

        poop_count = get_plural(chat.poop_count, 'раз, раза, раз')
        base_stats.append(f'До 💩 доревновали {poop_count}')

        avg_text_len = get_plural(statistics.median(chat.text_lengths),
                                  'символ, символа, символов')
        base_stats.append(
            f'Средняя длина валентинки: {avg_text_len} с пробелами')

        base_stats.append(self._most_popular_user(chat))
        base_stats.append(self._gay(chat))

        return ''.join((f'• {stat}\n' for stat in base_stats if stat)).strip()
Esempio n. 2
0
    def get_photos(self):
        # Получаем id всех постов
        media_ids = self.bot.get_total_user_medias(user_id=self.target)

        if len(media_ids) == 0:
            print("Пользователя с таким именем не существует")
            exit()

        # Создаём папку с фотографиями пользователя, если её нет
        if not self.user_photos_path.exists():
            self.user_photos_path.mkdir()
            print(f"Создаём папку с фотографиями {self.target}")

        print("{} {} {}".format(
            numeral.choose_plural(len(media_ids), "Будет, Будут, Будут"),
            numeral.choose_plural(len(media_ids), "скачена, скачены, скачены"),
            numeral.get_plural(len(media_ids),
                               "фотография, фотографии, фотографий")))

        time_start = time.time()
        self.download_photos(media_ids)

        time_finish = time.time()
        download_time = round(time_finish - time_start)
        print("{} {} за {}".format(
            numeral.choose_plural(len(media_ids), "Скачена, Скачены, Скачены"),
            numeral.get_plural(len(media_ids),
                               "фотография, фотографии, фотографий"),
            numeral.get_plural(download_time, "секунду, секунды, секунд")))
Esempio n. 3
0
    async def main(self):
        chat_title = utils.get_chat_title(self.chat_id)
        photos_path = DOWNLOADS_DIR.joinpath(chat_title)
        if not photos_path.exists():
            logging.info(f"Создаём папку с фотографиями беседы '{chat_title}'")
            photos_path.mkdir()

        photos = self.get_attachments()

        logging.info("{} {} {}".format(
            numeral.choose_plural(len(photos), "Будет, Будут, Будут"),
            numeral.choose_plural(len(photos), "скачена, скачены, скачены"),
            numeral.get_plural(len(photos),
                               "фотография, фотографии, фотографий")))

        time_start = time.time()

        # Скачиваем вложения беседы
        await download_photos(photos_path, photos)

        time_finish = time.time()
        download_time = math.ceil(time_finish - time_start)

        logging.info("{} {} за {}".format(
            numeral.choose_plural(len(photos), "Скачена, Скачены, Скачены"),
            numeral.get_plural(len(photos),
                               "фотография, фотографии, фотографий"),
            numeral.get_plural(download_time, "секунду, секунды, секунд")))

        logging.info("Проверка на дубликаты")
        dublicates_count = check_for_duplicates(photos_path)
        logging.info(f"Дубликатов удалено: {dublicates_count}")

        logging.info(f"Итого скачено: {len(photos) - dublicates_count} фото")
Esempio n. 4
0
    def post(self, request):
        data, errors = RequestSchema().load(request.data)

        errand_boy_transport = UNIXSocketTransport()
        out, err, returncode = errand_boy_transport.run_cmd("wkhtmltopdf -V")

        translified_text = translify(data["text_for_translite"])

        result = {
            "type":
            str(data["type"]),
            "type_value":
            str(data["type"].value),
            "payment_method":
            str(data["payment_method"]),
            "payment_method_value":
            str(data["payment_method"].value),
            "wkhtml":
            out,
            "slug":
            slugify(data["text_for_slug"]),
            "translite":
            translified_text,
            "detranslite":
            detranslify(translified_text),
            "plural_first":
            get_plural(data["int_for_plural"],
                       ("клиенту", "клиентам", "клиентам")),
            "plural_second":
            get_plural(data["int_for_plural"], "секунду,секунды,секунд"),
        }

        return render(request, "test.html", result)
Esempio n. 5
0
    async def main(self):
        # Получаем информацию о группе
        group_info = vk.groups.getById(group_id=self.group_id)[0]
        group_name = group_info["name"].replace("/",
                                                " ").replace("|", " ").replace(
                                                    ".", " ").strip()

        group_dir = DOWNLOADS_DIR.joinpath(group_name)
        utils.create_dir(group_dir)

        self.photos = []

        # Группа закрыта
        if group_info["is_closed"]:
            logging.info(f"Группа '{group_name}' закрыта :(")
            self.photos = [{
                "id": self.group_id,
                "owner_id": self.group_id,
                "url": "https://vk.com/images/community_200.png"
            }]
        else:
            logging.info(f"Получаем фотографии группы '{group_name}'...")

            # Получаем фотографии со стены группы
            self.get_photos()

        # Сортируем фотографии по количеству лайков
        self.photos.sort(key=lambda k: k["likes"], reverse=True)

        logging.info("{} {} {}".format(
            numeral.choose_plural(len(self.photos), "Будет, Будут, Будут"),
            numeral.choose_plural(len(self.photos),
                                  "скачена, скачены, скачены"),
            numeral.get_plural(len(self.photos),
                               "фотография, фотографии, фотографий")))

        time_start = time.time()

        # Скачиваем фотографии со стены группы
        await download_photos(group_dir, self.photos)

        time_finish = time.time()
        download_time = math.ceil(time_finish - time_start)

        logging.info("{} {} за {}".format(
            numeral.choose_plural(len(self.photos),
                                  "Скачена, Скачены, Скачены"),
            numeral.get_plural(len(self.photos),
                               "фотография, фотографии, фотографий"),
            numeral.get_plural(download_time, "секунду, секунды, секунд")))

        logging.info("Проверка на дубликаты")
        dublicates_count = check_for_duplicates(group_dir)
        logging.info(f"Дубликатов удалено: {dublicates_count}")

        logging.info(
            f"Итого скачено: {len(self.photos) - dublicates_count} фото")
Esempio n. 6
0
def relative_date(value):
    date, delta = date_and_delta(value)
    if date is None:
        return value

    use_months = True

    seconds = abs(delta.seconds)
    days = abs(delta.days)
    years = days // 365
    days = days % 365
    months = int(days // 30.5)

    if not years and days < 1:
        if seconds == 0:
            return 'только что'
        elif seconds == 1:
            return 'секунду назад'
        elif seconds < 60:
            return get_plural(seconds, 'секунду назад, секунды назад, секунд назад')
        elif 60 <= seconds < 120:
            return 'минуту назад'
        elif 120 <= seconds < 3600:
            minutes = seconds // 60
            return get_plural(minutes, 'минуту назад, минуты назад, минут назад')
        elif 3600 <= seconds < 3600 * 2:
            return 'час назад'
        elif 3600 < seconds:
            hours = seconds // 3600
            return get_plural(hours, 'час назад, часа назад, часов назад')
    elif years == 0:
        if days == 1:
            return 'день назад'
        if not use_months:
            return get_plural(days, 'день назад, дня назад, дней назад')
        else:
            if not months:
                return get_plural(days, 'день назад, дня назад, дней назад')
            elif months == 1:
                return 'месяц назад'
            else:
                return get_plural(months, 'месяц назад, месяца назад, месяцев назад')
    elif years == 1:
        if not months and not days:
            return 'год назад'
        elif not months:
            return '1 год и ' + get_plural(days, 'день назад, дня назад, дней назад')
        elif use_months:
            if months == 1:
                return '1 год и месяц назад'
            else:
                return '1 год и ' + get_plural(months, 'месяц назад, месяца назад, месяцев назад')
        else:
            return '1 год и ' + get_plural(days, 'день назад, дня назад, дней назад')
    else:
        return get_plural(years, 'год назад, года назад, лет назад')
Esempio n. 7
0
    async def main(self):
        user_info = vk.users.get(user_ids=self.user_id,
                                 fields="sex, photo_max_orig")[0]

        decline_username = decline(first_name=user_info["first_name"],
                                   last_name=user_info["last_name"],
                                   sex=user_info["sex"])

        username = utils.get_username(self.user_id)

        photos_path = self.parent_dir.joinpath(username)
        utils.create_dir(photos_path)

        # Страница пользователя удалена
        if "deactivated" in user_info:
            logging.info("Эта страница удалена")
            utils.remove_dir(photos_path)
        else:
            # Профиль закрыт
            if user_info["is_closed"] and not user_info["can_access_closed"]:
                logging.info(f"Профиль {decline_username} закрыт :(")
                photos = [{
                    "id": self.user_id,
                    "owner_id": self.user_id,
                    "url": user_info["photo_max_orig"],
                    "likes": 0
                }]
            else:
                logging.info(f"Получаем фотографии {decline_username}...")

                # Получаем фотографии пользователя
                photos = self.get_photos()

            # Сортируем фотографии пользователя по дате
            photos.sort(key=lambda k: k["date"], reverse=True)

            logging.info("{} {} {}".format(
                numeral.choose_plural(len(photos), "Будет, Будут, Будут"),
                numeral.choose_plural(len(photos),
                                      "скачена, скачены, скачены"),
                numeral.get_plural(len(photos),
                                   "фотография, фотографии, фотографий")))

            time_start = time.time()

            # Скачиваем фотографии пользователя
            await download_photos(photos_path, photos)

            time_finish = time.time()
            download_time = math.ceil(time_finish - time_start)
            logging.info("{} {} за {}".format(
                numeral.choose_plural(len(photos),
                                      "Скачена, Скачены, Скачены"),
                numeral.get_plural(len(photos),
                                   "фотография, фотографии, фотографий"),
                numeral.get_plural(download_time, "секунду, секунды, секунд")))
Esempio n. 8
0
    async def announce(self):
        stream = await self.bot.my_get_stream(self.bot.user_id)
        game = self.bot.my_get_game(stream['game_id'])
        delta = self.bot.countdown_to - datetime.datetime.now()
        delta_m = delta.seconds // 60
        if delta_m > 0:
            delta_text = numeral.get_plural(delta_m,
                                            ('минута', 'минуты', 'минут'))
        else:
            delta_text = "одна минута"

        announcement = f"@{discord_role} Паучок запустил стрим \"{stream['title']}\" " \
                       f"по игре \"{game['name']}\"! У вас есть примерно {delta_text} чтобы" \
                       " открыть стрим - <https://twitch.tv/iarspider>!"

        connection = pika.BlockingConnection(pika.URLParameters(rabbit_url))
        channel = connection.channel()
        channel.queue_declare(queue='discord')
        channel.basic_publish(exchange='',
                              routing_key='discord',
                              body=simplejson.dumps({
                                  'action': 'send',
                                  'message': announcement,
                                  'channel': discord_channel
                              }))
        channel.close()
        connection.close()
Esempio n. 9
0
 def __get_count(key: str, plural_forms: str) -> typing.Union[None, str]:
     count = cache.get(key)
     if not count:
         count = 0
     if isinstance(count, (set, list, dict)):
         count = len(count)
     return get_plural(count, plural_forms)
 def __get_total(cls) -> str:
     stats = [
         get_plural(
             cls.total_cards.get(),
             'валентинка отправлена, валентинки отправлено, валентинок отправлено'
         ),
         get_plural(
             cls.total_migs.get(),
             'подмигивание произведено, подмигивания произведено, подмигиваний произведено'
         ),
         get_plural(
             cls.total_revn.get(),
             'ревность источена, ревности источено, ревностей источено'),
     ]
     text = ''.join((f'• {stat}\n' for stat in stats if stat)).strip()
     return text
Esempio n. 11
0
 def write_plusch(self):
     with codecs.open("plusch.txt", "w", "utf8") as f:
         if self.plusches == 0:
             f.write("Пока что никого не плющило")
         else:
             f.write("Кого-то поплющило {0}...".format(
                 numeral.get_plural(self.plusches, ('раз', 'раза', 'раз'))))
Esempio n. 12
0
 def get_room_filter(self):
     rooms = self.query_parameters.get('rooms') or []
     if len(rooms) == 1:
         return get_plural(int(rooms[0]),
                           (_(u"комната"), _(u"комнаты"), _(u"комнат")),
                           u'')
     elif rooms:
         return _(u'%s комнат') % u'-'.join(rooms)
Esempio n. 13
0
 def __get_engage_users_count(cls):
     users = cache.get(cls.key_engage_users)
     if not users:
         return None
     return get_plural(
         len(users),
         'человек принял участие, человека приняло участие, человек приняло участие'
     )
Esempio n. 14
0
    async def main(self):
        groups_name = ", ".join(
            [utils.get_group_title(group_id) for group_id in self.group_ids])
        photos_path = DOWNLOADS_DIR.joinpath(groups_name)
        utils.create_dir(photos_path)

        self.photos = []

        for group_id in self.group_ids:
            logging.info(
                f"Получаем фотографии группы '{utils.get_group_title(group_id)}'..."
            )
            self.get_photos(group_id)

        # Сортируем фотографии по количеству лайков
        self.photos.sort(key=lambda k: k["likes"], reverse=True)

        logging.info("{} {} {}".format(
            numeral.choose_plural(len(self.photos), "Будет, Будут, Будут"),
            numeral.choose_plural(len(self.photos),
                                  "скачена, скачены, скачены"),
            numeral.get_plural(len(self.photos),
                               "фотография, фотографии, фотографий")))

        time_start = time.time()

        # Скачиваем фотографии со стены группы
        await download_photos(photos_path, self.photos)

        time_finish = time.time()
        download_time = math.ceil(time_finish - time_start)

        logging.info("{} {} за {}".format(
            numeral.choose_plural(len(self.photos),
                                  "Скачена, Скачены, Скачены"),
            numeral.get_plural(len(self.photos),
                               "фотография, фотографии, фотографий"),
            numeral.get_plural(download_time, "секунду, секунды, секунд")))

        logging.info("Проверка на дубликаты")
        dublicates_count = check_for_duplicates(photos_path)
        logging.info(f"Дубликатов удалено: {dublicates_count}")

        logging.info(
            f"Итого скачено: {len(self.photos) - dublicates_count} фото")
Esempio n. 15
0
 def _most_popular_user(self, chat: ChatStats) -> str:
     counter = collections.Counter(chat.addressees)
     common = counter.most_common(1)
     if len(common) == 0:
         return ''
     user_id, count = common[0]
     if count == 1:
         return ''
     pl_count = get_plural(count, 'валентинки, валентинок, валентинок')
     fem = 'Одна девушка получила' if user_id in self.stats.females else 'Один юноша получил'
     return f'{fem} больше {pl_count}'
    def set_status(self):
        """Меняет статус у группы и у пользователя"""
        conversations_count = self.get_conversations_count()
        message = "🔥Ютуб бот работает в {}!🔥".format(
            numeral.get_plural(conversations_count,
                               "беседе, беседах, беседах"))

        # Меняем статус в группе
        self.vk.status.set(text=message, group_id=config["group"]["group_id"])

        # Меняем статус пользователя
        self.vk.status.set(text=message)
    def anniversary_tweet(self, user_artist, anniversary):
        if anniversary == 1:
            text = "год не слушал"
        else:
            text = "%s не слушаю" % get_plural(anniversary, ("год", "года", "лет"))

        scrobble = db.session.query(Scrobble).\
                              filter(Scrobble.user == user_artist.user,
                                     Scrobble.artist == user_artist.artist.name).\
                              order_by(Scrobble.uts.desc()).\
                              first()

        return "Уже %s %s: %s :(" % (text, scrobble.artist, scrobble.track)
    def anniversary_tweet(self, user_artist, anniversary):
        if anniversary == 1:
            text = "год"
        else:
            text = get_plural(anniversary, ("год", "года", "лет"))

        scrobble = db.session.query(Scrobble).\
                              filter(Scrobble.user == user_artist.user,
                                     Scrobble.artist == user_artist.artist.name,
                                     Scrobble.uts >= user_artist.first_real_scrobble).\
                              first()

        return "Уже %s слушаю %s: %s!" % (text, scrobble.artist, scrobble.track.rstrip("!"))
Esempio n. 19
0
    def _poll_queues(self):
        while True:
            now = datetime.now()
            disorders = [(lambda size: {"is_disorder": size > 10,
                                        "disorder": {"datetime": now,
                                                     "reason": "%s в очереди" % get_plural(size, ("запись", "записи", "записей"), "Нет записей"),
                                                     "data": {}},
                                        "title": name})
                         (queue.qsize())
                         for name, queue in self.handler_manager.queues.items()]
            self.state_disorder(any(disorder["is_disorder"] for disorder in disorders),
                                Disorder(now, disorders, {}))

            time.sleep(10)
Esempio n. 20
0
    def get(self, *args, **kwargs):
        try:
            user_id = self.kwargs['user_id']
        except KeyError:
            return HttpResponseBadRequest()

        try:
            user = User.objects.get(pk=user_id)
        except User.DoesNotExist:
            raise Http404

        try:
            uvb = vbUser(user, extend=True, genres=True, friends=True)
            days = (timezone.now() - uvb.data['regdate']).days
            how_long = numeral.get_plural(days, (u'день', u'дня', u'дней'))

            default_user = uvb.data
            default_user.update({
                'regdate': uvb.data['regdate'].strftime("%Y-%m-%d"),
                'how_long': how_long
            })

            films = Films.objects.filter(uf_films_rel__user=user, uf_films_rel__subscribed=APP_USERFILM_SUBS_TRUE)
            films = Paginator(films, APP_USERS_API_DEFAULT_PER_PAGE).page(APP_USERS_API_DEFAULT_PAGE)
            vbf = vbFilm(films.object_list, many=True)

            actors = Persons.objects.filter(up_persons_rel__user=user, pf_persons_rel__p_type=APP_PERSON_ACTOR).distinct('id')
            actors = Paginator(actors, APP_USERS_API_DEFAULT_PER_PAGE).page(APP_USERS_API_DEFAULT_PAGE)
            vba = vbPerson(actors.object_list, many=True)

            directors = Persons.objects.filter(up_persons_rel__user=user, pf_persons_rel__p_type=APP_PERSON_DIRECTOR).distinct()
            directors = Paginator(directors, APP_USERS_API_DEFAULT_PER_PAGE).page(APP_USERS_API_DEFAULT_PAGE)
            vbd = vbPerson(directors.object_list, many=True)

            # Сериализуем
            o_feed = vbFeedElement(calc_feed(user.id), many=True).data

            default_user.update({
                'films': vbf.data,
                'actors': vba.data,
                'feed': o_feed,
                'directors': vbd.data,
            })

            return HttpResponse(render_page('user', {'user': default_user}))

        except Exception as e:
            return HttpResponseServerError(e)
Esempio n. 21
0
    def get(self, *args, **kwargs):
        try:
            user_id = self.kwargs['user_id']
        except KeyError:
            return HttpResponseBadRequest()

        try:
            user = User.objects.get(pk=user_id)
        except User.DoesNotExist:
            raise Http404

        try:
            uvb = vbUser(user, extend=True, genres=True, friends=True)
            days = (timezone.now() - uvb.data['regdate']).days
            how_long = numeral.get_plural(days, (u'день', u'дня', u'дней'))

            default_user = uvb.data
            default_user.update({
                'regdate': uvb.data['regdate'].strftime("%Y-%m-%d"),
                'how_long': how_long
            })

            films = Films.objects.filter(uf_films_rel__user=user, uf_films_rel__subscribed=APP_USERFILM_SUBS_TRUE)
            films = Paginator(films, APP_USERS_API_DEFAULT_PER_PAGE).page(APP_USERS_API_DEFAULT_PAGE)
            vbf = vbFilm(films.object_list, many=True)

            actors = Persons.objects.filter(up_persons_rel__user=user, pf_persons_rel__p_type=APP_PERSON_ACTOR).distinct('id')
            actors = Paginator(actors, APP_USERS_API_DEFAULT_PER_PAGE).page(APP_USERS_API_DEFAULT_PAGE)
            vba = vbPerson(actors.object_list, many=True)

            directors = Persons.objects.filter(up_persons_rel__user=user, pf_persons_rel__p_type=APP_PERSON_DIRECTOR).distinct()
            directors = Paginator(directors, APP_USERS_API_DEFAULT_PER_PAGE).page(APP_USERS_API_DEFAULT_PAGE)
            vbd = vbPerson(directors.object_list, many=True)

            # Сериализуем
            o_feed = vbFeedElement(calc_feed(user.id), many=True).data

            default_user.update({
                'films': vbf.data,
                'actors': vba.data,
                'feed': o_feed,
                'directors': vbd.data,
            })

            return HttpResponse(render_page('user', {'user': default_user}))

        except Exception as e:
            return HttpResponseServerError(e)
Esempio n. 22
0
    async def resume(self, ctx: Context):
        """
            Отменяет перерыв

            %%resume
        """
        if not self.bot.check_sender(ctx, 'iarspider'):
            asyncio.ensure_future(
                ctx.send('/timeout ' + ctx.author.name + ' 1'))
            return

        # self.logger.info("get_player()")
        # self.get_player()
        # self.logger.info("player_play_pause()")
        # self.player_play_pause()

        if self.ws is not None:
            if self.vr:
                self.switch_to('VR Game')
                self.ws.call(
                    obsws_requests.SetMute(self.aud_sources.getMic2(), False))
            else:
                self.logger.info("switch to game")
                self.switch_to('Game')
                self.logger.info("unmute mic")
                self.ws.call(
                    obsws_requests.SetMute(self.aud_sources.getMic1(), False))

            self.ws.call(obsws_requests.SetMute(True, 'Радио'))
            self.ws.call(obsws_requests.ResumeRecording())

        try:
            self.logger.info("get stream")
            res = await self.bot.my_get_stream(self.bot.user_id)
            self.logger.info("got stream")
            viewers = numeral.get_plural(res['viewer_count'],
                                         ('зритель', 'зрителя', 'зрителей'))
            self.logger.info("prepared message")
            asyncio.ensure_future(
                ctx.send('Перепись населения завершена успешно! '
                         f'Население стрима составляет {viewers}'))
            self.logger.info("sent message")
        except (KeyError, TypeError) as exc:
            asyncio.ensure_future(ctx.send('Перепись населения не удалась :('))
            self.logger.error(str(exc))
Esempio n. 23
0
    def get_user_albums(self, user_id, chat_id):
        user_info = bot.users.get(
            user_ids=user_id,
            fields="sex"
        )[0]

        decline_username = decline(
            first_name=user_info["first_name"],
            last_name=user_info["last_name"],
            sex=user_info["sex"]
        )

        if user_info["is_closed"]:
            # Профиль закрыт
            message = "Профиль [id{}|{}] закрыт❌".format(user_id, decline_username)
        else:
            # Профиль открыт
            user_albums = vk_audio.get_albums(owner_id=user_id)
            if len(user_albums) != 0:
                # Есть хотя бы один альбом
                message = "У [id{}|{}] {}\n".format(
                    user_id,
                    decline_username,
                    numeral.get_plural(len(user_albums), "альбом, альбома, альбомов")
                )
                album_number = 1
                for album in user_albums:
                    message += "{}. {}\n".format(
                        album_number,
                        album["title"]
                    )
                    album_number += 1
            else:
                message = "У [id{}|{}] нет альбомов".format(user_id, decline_username)

        bot.messages.send(
            chat_id=chat_id,
            message=message,
            random_id=get_random_id()
        )
Esempio n. 24
0
    def get_text(self, chat_id: Optional[int]) -> str:
        chat = self.stats.all_chats if chat_id is None else self.stats.chats.get(
            chat_id)

        if chat is None or chat.cards_count == 0:
            return '<i>Ниии отпьявляи!? 🐉</i>'

        if chat.cards_count == 1:
            return '<i>Всиго одню отпьявии, чиго тют считять 🐉</i>'

        if chat.cards_count == 2:
            return '<i>Цилых дви штюки? 🐉</i>'

        chats_count = ''
        if chat_id is None:
            chats_count = get_plural(
                len(self.stats.chats),
                'чат участвовал, чата участвовало, чатов участвовало')
        base_stats = self._base_stats(chat)

        senders_gender = self._senders_gender(chat)
        addressees_gender = self._addressees_gender(chat)
        renvs_gender = self._revns_gender(chat)

        popular_hearts = self._popular_hearts(chat)

        return f"""
{chats_count}

{base_stats}

Отправители: {senders_gender}
Получатели: {addressees_gender}
Ревнивцы: {renvs_gender}

Самые популярные сердечки: {popular_hearts}

<i>Осинь хойоша, чиовики. А типейь пьикязывяю любеть дьюг дьюгя. Ебитес 🐉</i>
            """.strip()
Esempio n. 25
0
    def receive_record(self, record):
        if match_record(self.condition, record):
            self.group_to_times[self.group_by(record)].append(record)

        reason = OrderedDict()
        for group, items in sorted(self.group_to_times.iteritems(), key=lambda (g, m): g.lower()
                                                                                       if isinstance(g, (str, unicode))
                                                                                       else g):
            items = filter(lambda record: record.datetime > datetime.now() - self.interval, items)
            self.group_to_times[group] = items
            if len(items) > self.times:
                is_disorder = True
                disorder_datetime = items[self.times].datetime
            else:
                is_disorder = False
                disorder_datetime = items[-1].datetime
            reason[group] = MaybeDisorder(is_disorder, Disorder(
                disorder_datetime,
                "Событие произошло %s" % get_plural(len(items), ("раз", "раза", "раз")),
                {"records": items}
            ))

        if any(maybe.is_disorder for maybe in reason.values()):
            is_disorder = True
            disorder_datetime = min(maybe.disorder.datetime
                                    for maybe in reason.values()
                                    if maybe.is_disorder)
        else:
            is_disorder = False
            disorder_datetime = max(maybe.disorder.datetime for maybe in reason.values()) if reason else datetime.now()
        self.state_disorder(is_disorder, Disorder(
            disorder_datetime,
            ([maybe_with_title(maybe, group) for group, maybe in reason.iteritems()]
             if self.group_by else (reason.values()[0].disorder if reason.values() else "Неприятностей не произошло")),
            {"counts": {group: len(items)
             for group, items in self.group_to_times.iteritems()}}
             if self.group_by else {"count": len(self.group_to_times.values()[0])}
        ))
Esempio n. 26
0
    def upload(self, request):
        model = self.model
        opts = model._meta

        if request.POST:
            form = UploadAdminForm(request.POST, request.FILES)
            if form.is_valid():
                updated_items = 0
                type_ = int(form.cleaned_data['type'])

                price_field = {
                    1: 'price',
                    2: 'wholesale_price',
                    3: 'franchisee_price',
                }[type_]
                quantity_field = {
                    1: 'quantity',
                    2: 'wholesale_quantity',
                    3: 'wholesale_quantity',
                }[type_]

                visibility_field = 'is_retail' if price_field == 'price' else 'is_wholesale'

                for code, price, quantity in parse_1c(form.cleaned_data['file'].read()):
                    kwargs = {
                        price_field: price,
                        quantity_field: quantity,

                        # Временно убрали включение галочки
                        # visibility_field: True,

                        # Velina: когда загружаешь 1С файл, все товары, имеющие розничную и оптовую цену,
                        #   сразу автоматом попадают в эти разделы. на наборы из полирезина была установлена "левая" цена розничная,
                        #   они вообще в рознице только по 1 шт. продаваться будут, а тут целый набор за 100 р.
                        #   и вот каждый день обновляя базу цен и кол-ва на сайте я вручную убирала их из розничных товаров,
                        #   как и Снежные шары, которых вообще еще нет в наличии и предзаказ доступен только для опта
                        # Velina: а сегодня видно не успела убрать
                        # SvartalF: Так. А мы специально делали же, что все загружаемые из 1С товары сразу делаются и публикуемыми. Теперь это не надо?
                        # Velina: они публикуемыми не делаются, они просто помечаются как "Розничный товар" и "Оптовый товар",
                        #   если заполнены соотв. поля цен в файле 1С
                        # SvartalF: Да, точно
                        # SvartalF: То есть с загрузкой 1С файлов никаких проблем нет?
                        # SvartalF: Тогда как нам решить эту проблему с заказом?
                        # Velina: никак
                        # Velina: давай уберем эту автоматическую простановку галок "Розничны", "Оптовый"?
                    }
                    updated_items += Product.objects.filter(code=code).update(**kwargs)

                messages.success(request, u'В базе сайта обновлено %s' % get_plural(updated_items,
                    [u'товар', u'товара', u'товаров']))

                return HttpResponseRedirect('..')

        else:
            form = UploadAdminForm()

        context = {
            'form': form,
            'current_app': self.admin_site.name,
            'opts': opts,
            'app_label': opts.app_label,
            'object': None,
        }

        return render(request, 'admin/products/upload.html', context)
Esempio n. 27
0
# 2) variants, варианты
# варианты - это кортеж из вариантов склонения
# его легко составить по мнемоническому правилу:
# (один, два, пять)
# т.е. для 1, 2 и 5 объектов, например для слова "пример"
# (пример, примера, примеров)
print_(numeral.choose_plural(21, ("пример", "примера", "примеров")))
#-> пример
print_(numeral.choose_plural(12, ("пример", "примера", "примеров")))
#-> примеров
print_(numeral.choose_plural(32, ("пример", "примера", "примеров")))
#-> примера

# также можно задавать варианты в одну строку, разделенные запятой
print_(numeral.choose_plural(32, "пример,примера, примеров"))
#-> примера

# если в варианте используется запятая, она экранируется слешем
print_(numeral.choose_plural(35, "гвоздь, гвоздя, гвоздей\, шпунтов"))
#-> гвоздей, шпунтов

# зачастую требуется не просто вариант, а вместе с числительным
# в этом случае следует использовать get_plural
print_(numeral.get_plural(32, "пример,примера, примеров"))
#-> 32 примера

# часто хочется, чтобы в случае отсутсвия значения (т.е. количество равно нулю)
# выводилось не "0 примеров", а "примеров нет"
# в этом случае используйте третий параметр get_plural:
print_(numeral.get_plural(0, "пример,примера, примеров", "без примеров"))
# -> без примеров
Esempio n. 28
0
 def msg(self, request, message):
     
     try:
         
         msg_re = re.compile(u"(.*?) \"(.*?)\" был успешно добавлен")
         if msg_re.match(message):
             grp = msg_re.search(message).groups(1)
                  
             message = message.replace(u"один "+grp[0],u"одну "+self.VerboseNameCaseReplace[grp[0]]._change_name)
             message = message.replace(u"был",u"была").replace(u"добавлен",u"добавлена")    
             message = message.replace(u"Ниже вы можете снова его отредактировать", u"Ниже вы можете снова её отредактировать")
 		
         msg_addmore_re = re.compile(u"(.*?)Ниже вы можете добавить еще один (.*?)\.")        
         if msg_addmore_re.match(message):
             grp = msg_addmore_re.search(message).groups(1)
             message = message.replace(u"Ниже вы можете добавить еще один %s." % grp[1], u"Ниже вы можете добавить еще одну %s." % self.VerboseNameCaseReplace[grp[1]]._change_name)
 				
         msg_save_re = re.compile(u"(.*?) \"(.*?)\" был успешно изменён")
         if msg_save_re.match(message):
 		    message = message.replace(u"был",u"была").replace(u"изменён",u"изменена")
             
         message = message.replace(u"удалено", u"удалена")     
         msg_delete_re = re.compile(u"Успешно удалены (.*?) (.*)\.")
         if msg_delete_re.match(message):
             grp = msg_delete_re.search(message).groups(1)
             
             if grp[0] > 1:
                 message = message.replace(u"удалены %s %s" % (grp[0], grp[1]), u"удалено %s" % (get_plural(int(grp[0]), ",".join(self.VerboseNameCaseReplace[grp[1]]._plural))))
     except:
         pass
     
     messages.info(request, message)
Esempio n. 29
0
# варианты - это кортеж из вариантов склонения
# его легко составить по мнемоническому правилу:
# (один, два, пять)
# т.е. для 1, 2 и 5 объектов, например для слова "пример"
# (пример, примера, примеров)
print numeral.choose_plural(21, (u"пример", u"примера", u"примеров"))
# -> пример
print numeral.choose_plural(12, (u"пример", u"примера", u"примеров"))
# -> примеров
print numeral.choose_plural(32, (u"пример", u"примера", u"примеров"))
# -> примера

# также можно задавать варианты в одну строку, разделенные запятой
print numeral.choose_plural(32, u"пример,примера, примеров")
# -> примера

# если в варианте используется запятая, она экранируется слешем
print numeral.choose_plural(35, u"гвоздь, гвоздя, гвоздей\, шпунтов")
# -> гвоздей, шпунтов

# зачастую требуется не просто вариант, а вместе с числительным
# в этом случае следует использовать get_plural
print numeral.get_plural(32, u"пример,примера, примеров")
# -> 32 примера

# часто хочется, чтобы в случае отсутсвия значения (т.е. количество равно нулю)
# выводилось не "0 примеров", а "примеров нет"
# в этом случае используйте третий параметр get_plural:
print numeral.get_plural(0, u"пример,примера, примеров", u"без примеров")
# -> без примеров
Esempio n. 30
0
def pluralize(*args):
    return get_plural(*args)
Esempio n. 31
0
# 2) variants, варианты
# варианты - это кортеж из вариантов склонения
# его легко составить по мнемоническому правилу:
# (один, два, пять)
# т.е. для 1, 2 и 5 объектов, например для слова "пример"
# (пример, примера, примеров)
print_(numeral.choose_plural(21, ("пример", "примера", "примеров")))
#-> пример
print_(numeral.choose_plural(12, ("пример", "примера", "примеров")))
#-> примеров
print_(numeral.choose_plural(32, ("пример", "примера", "примеров")))
#-> примера

# также можно задавать варианты в одну строку, разделенные запятой
print_(numeral.choose_plural(32, "пример,примера, примеров"))
#-> примера

# если в варианте используется запятая, она экранируется слешем
print_(numeral.choose_plural(35, "гвоздь, гвоздя, гвоздей\, шпунтов"))
#-> гвоздей, шпунтов

# зачастую требуется не просто вариант, а вместе с числительным
# в этом случае следует использовать get_plural
print_(numeral.get_plural(32, "пример,примера, примеров"))
#-> 32 примера

# часто хочется, чтобы в случае отсутсвия значения (т.е. количество равно нулю)
# выводилось не "0 примеров", а "примеров нет"
# в этом случае используйте третий параметр get_plural:
print_(numeral.get_plural(0, "пример,примера, примеров", "без примеров"))
# -> без примеров
# -*- coding: utf-8 -*-
# crontab(minute="*/10")
# title = "Очередь Celery"
from __future__ import unicode_literals

from pytils.numeral import get_plural
import subprocess

from themylog.disorder.script import Disorder


def rabbitmqctl_list(*args):
    return subprocess.check_output(["sudo", "rabbitmqctl"] + list(args)).split("\n")[1:][:-2]


if __name__ == "__main__":
    for vhost in rabbitmqctl_list("list_vhosts")[1:]:
        for queue, tasks in map(lambda s: s.split("\t"), rabbitmqctl_list("list_queues", "-p", vhost)):
            if queue == "celery":
                tasks = int(tasks)
                disorder = Disorder(vhost)
                disorder.state(tasks < 25,
                               "%s в очереди" % get_plural(tasks, ("задача", "задачи", "задач"), "Нет задач"))
Esempio n. 33
0
# 2) variants, варианты
# варианты - это кортеж из вариантов склонения
# его легко составить по мнемоническому правилу:
# (один, два, пять)
# т.е. для 1, 2 и 5 объектов, например для слова "пример"
# (пример, примера, примеров)
print numeral.choose_plural(21, (u"пример", u"примера", u"примеров"))
#-> пример
print numeral.choose_plural(12, (u"пример", u"примера", u"примеров"))
#-> примеров
print numeral.choose_plural(32, (u"пример", u"примера", u"примеров"))
#-> примера

# также можно задавать варианты в одну строку, разделенные запятой
print numeral.choose_plural(32, u"пример,примера, примеров")
#-> примера

# если в варианте используется запятая, она экранируется слешем
print numeral.choose_plural(35, u"гвоздь, гвоздя, гвоздей\, шпунтов")
#-> гвоздей, шпунтов

# зачастую требуется не просто вариант, а вместе с числительным
# в этом случае следует использовать get_plural
print numeral.get_plural(32, u"пример,примера, примеров")
#-> 32 примера

# часто хочется, чтобы в случае отсутсвия значения (т.е. количество равно нулю)
# выводилось не "0 примеров", а "примеров нет"
# в этом случае используйте третий параметр get_plural:
print numeral.get_plural(0, u"пример,примера, примеров", u"без примеров")
# -> без примеров