def _write_test_status(self, test_repr: str, location: tp.Tuple[str, int, str], with_progress: bool = False, rewrite: bool = False, newline: bool = False, **markup): w = self._tw.fullwidth loc = location[2].replace('.', '::') if len(loc) > w // 2 - 8: loc = textwrap.shorten(loc, w // 2 - 8) right = loc + ' [100%]' l_left = len(test_repr) l_right = len(right) + 1 if l_left + l_right >= w: test_repr = textwrap.shorten(test_repr, w - l_right - 1) l_left = len(test_repr) if rewrite: self.write('\r') self.write(test_repr, **markup) self.write(' ' * (w - l_left - l_right) + loc, light=True) if with_progress: self.write(self._get_progress_information_message(), cyan=True) else: self.write(' [ ~ %]', cyan=True) if newline: self.write_line('')
def _display(self, correct, answer, answers=None): self._message_window.refresh() self._message_window.border() text_width = self._width - 2 text_height = self._height - 2 self._message_window.refresh() if correct: self._message_window.addstr(1, int((text_width - 8)/2), "CORRECT!") else: self._message_window.addstr(1, int((text_width - 6)/2), "WRONG!") if self._show_answers_on_fail: self._answers_window.clear() self._answers_window.border() self._answers_window.addstr(0, 1, "[Accepted answers]") max_answers = self._answers_height - 2 display_all_answers = len(answers) <= max_answers displayed_answers = answers if display_all_answers else answers[0:max_answers] if not display_all_answers: self._answers_window.addstr(self._answers_height - 1, self._width - 7, "[...]") for index, answer in enumerate(displayed_answers): self._answers_window.addstr(index + 1, 1, textwrap.shorten(answer, text_width, placeholder = "...")) self._answers_window.refresh()
def sendChatPushNotification(user, message): device = FCMDevice.objects.filter(user = user, active = True).first() if not device is None: serializer = ChatSerializer(message) json_r = json.dumps(serializer.data) json_r = json.loads(json_r) info = {} info["data"] = {} info["data"]["messages"] = [] info["data"]["message_sent"] = json_r info["message"] = "" info["type"] = "" info["title"] = "" info["success"] = True info["number"] = 1 info['extra'] = 0 response = json.dumps(info) title = str(message.user).join(_(" sent a message")) simple_notify = textwrap.shorten(strip_tags(message.text), width = 30, placeholder = "...") if message.image: simple_notify += " ".join(_("[Photo]")) device.send_message(title = str(message.user), body = simple_notify, data = {"response": response, "title": title, "body": simple_notify, "user_from": message.user.email, "user_name": str(message.user), "user_img": message.user.image_url, "type": 'chat', "click_action": 'FLUTTER_NOTIFICATION_CLICK'})
def pack_table(info): return '<table>\n' + "\n".join( '<tr><td align="right" width="90">{}:</td>\n' '<td width="40">{}</td></tr>\n'.format( d, textwrap.shorten(str(v), width=30, placeholder="...")) for d, v in info ) + "</table>\n"
def main(): url = 'http://feed.exileed.com/vk/feed/pynsk' _section_title = 'Колонка автора' _res_title = 'Александр Сапронов (PyNSK)' resource = Resource.objects.filter(title=_res_title) assert resource.count() == 1, "Not found resoure: %s" % _res_title resource = resource[0] section = Section.objects.filter(title=_section_title) assert section.count() == 1, "Not found section: %s" % _section_title section = section[0] r = re.compile(r"(htt(p|ps)://[^ ]+)") today = datetime.date.today() week_before = today - datetime.timedelta(weeks=1) rssnews = feedparser.parse(url) for n in reversed(rssnews.entries): if len(Item.objects.filter(link=n.link)[0:1]): continue # print("Parse: %s" % n.link) title = None content = None time_struct = getattr(n, 'published_parsed', None) if time_struct: _timestamp = mktime(time_struct) dt = datetime.datetime.fromtimestamp(_timestamp) if dt.date() < week_before: continue text = n.summary for x in l: if x in text and '<br><br>' in text.split(x)[1]: _ = text.split(x)[1].split('<br>') title = x + _[0] content = ' </br>\n'.join(filter(lambda x: x, _[1:])) content = r.sub(r'<a href="\1">\1</a>', content) break if title is not None and content is not None: content_link = "<a href='%s' target='_blank'>[Продолжение]</a>" % n.link content = textwrap.shorten(content, width=300, placeholder="...%s" % content_link)\ .replace('<a...', '...') _ = { 'link': n.link, 'description': content, 'title': title, 'resource': resource, 'language': 'ru', 'section': section, 'status': 'active', } save_item(_)
def print_content_entry(entry, index = 1): assert(isinstance(entry, dict)) name = entry.pop('name') xtype = entry.pop('type') print("Name: {} {}".format(name, xtype)) for k in sorted(entry.keys()): value = entry[k] if isinstance(value, str): value = textwrap.shorten(value, 60) print(" {}: {}".format(k, value))
def list_commands(): """ List all commands """ text = "" for n in sorted(Env.COMMANDS): c = Env.COMMANDS[n] d = c.doc a = c.arg_parser doc = textwrap.shorten(d,60) doc = "%- 20s %s %s\n" % (n, doc, a) text += doc Env.show(text)
def __enter__(self): if self._use_timer: self._enter_time = time() self._curr_ticks = 0 self._next_threshold = 0 # reserving space for percentage space = self._lineman.use_width - 4 line = shorten(self._description, width = space, placeholder = '...') line += wrap_color(2, '.' * (space - len(line))) self._prefix = line self._push_label(wrap_color(3, ' 0%')) return self
def string(self): properties = self._current['properties'] headline = ' '.join(properties['parameters']['NWSheadline']) start = dateutil.parser.parse(properties['effective']) end = dateutil.parser.parse(properties['expires']) return '{} [ {}({}): FROM {} TO {} -- {} ]'.format( self.location.name, properties['event'], properties['severity'], start.strftime('%b %d %X'), end.strftime('%b %d %X'), textwrap.shorten(headline, width=200))
def style_tweet(tweet, porcelain=False): if porcelain: return "{nick}\t{url}\t{tweet}".format( nick=tweet.source.nick, url=tweet.source.url, tweet=str(tweet)) else: styled_text = format_mentions(tweet.text) len_styling = len(styled_text) - len(click.unstyle(styled_text)) return "➤ {nick} ({time}):\n{tweet}".format( nick=click.style(tweet.source.nick, bold=True), tweet=textwrap.shorten(styled_text, 140 + len_styling), time=click.style(tweet.relative_datetime, dim=True))
def __repr__(self): import textwrap repr = '{cls}(id={id}, "{text}")' args = { 'cls': self.__class__.__name__, 'id': hex(id(self))[-4:], } try: args['text'] = textwrap.shorten(self.text, width=10, placeholder='...') except: repr = '{cls}(id={id})' return repr.format(**args)
def __enter__(self): '''Printing the subtask description and starts timer if needed''' # reverse space for okay/fail label on the right space = self._lineman.use_width - 4 line = shorten(self._description, width = space, placeholder = '...') # filling the space between the line end and the label with dots line += wrap_color(2, '.' * (space - len(line))) self._lineman.append(line, space) # whether we need to print label on the right # will be disabled when subtasks pushed self._need_status_label = True if self._use_timer: self._enter_time = time() return self
def notify_user_about_clarification(request, clarification): messages.add_message( request, msg_lvl.INFO_PERSISTENT, 'На Ваш вопрос был <a href="{}" data-clarification="{}">дан ответ</a>: "{}"'.format( clarification.get_absolute_url(), clarification.id, html.escape( textwrap.shorten(html.strip_tags(clarification.answer_html), 70, placeholder='...') ), ), extra_tags='safe', user=clarification.user, )
def truncate(self, length: int = 75, suffix: str = None) -> 'String': """ Returns the string truncated to fit the given length. Args: length: The position to truncate the string suffix: The string to add after the truncated string Returns: The truncated string """ return String(textwrap.shorten(self, width=length, placeholder=suffix or '...'))
def style_tweet(tweet, porcelain=False): conf = click.get_current_context().obj["conf"] limit = conf.character_limit if porcelain: return "{nick}\t{url}\t{tweet}".format(nick=tweet.source.nick, url=tweet.source.url, tweet=str(tweet)) else: if sys.stdout.isatty() and not tweet.text.isprintable(): return None styled_text = format_mentions(tweet.text) len_styling = len(styled_text) - len(click.unstyle(styled_text)) final_text = textwrap.shorten(styled_text, limit + len_styling) if limit else styled_text timestamp = tweet.absolute_datetime if conf.use_abs_time else tweet.relative_datetime return "➤ {nick} ({time}):\n{tweet}".format( nick=click.style(tweet.source.nick, bold=True), tweet=final_text, time=click.style(timestamp, dim=True) )
def style_tweet(tweet, porcelain=False): conf = click.get_current_context().obj["conf"] limit = conf.character_limit if porcelain: return "{nick}\t{url}\t{tweet}".format( nick=tweet.source.nick, url=tweet.source.url, tweet=str(tweet)) else: styled_text = format_mentions(tweet.text) len_styling = len(styled_text) - len(click.unstyle(styled_text)) final_text = textwrap.shorten(styled_text, limit + len_styling) if limit else styled_text return "➤ {nick} ({time}):\n{tweet}".format( nick=click.style(tweet.source.nick, bold=True), tweet=final_text, time=click.style(tweet.relative_datetime, dim=True))
def do_tweet(text, weather_location, tweet_location, variable_location, hashtag=None): """ Post a tweet. If set in the config, a hashtag will be applied to the end of the tweet. If variable_location is True, prepend the tweet with the location name. If tweet_location is True, the coordinates of the the location will be embedded in the tweet. If successful, the status id is returned, otherwise None. :type text: str :param text: text for the tweet :type weather_location: models.WeatherLocation :param weather_location: location information used for the tweet location and inline location name :type tweet_location: bool :param tweet_location: determines whether or not to include Twitter location :type variable_location: bool :param variable_location: determines whether or not to prefix the tweet with the location :type hashtag: str :param hashtag: :return: a tweepy status object """ api = get_tweepy_api() body = text # account for space before hashtag max_length = 279 - len(hashtag) if hashtag else 280 if variable_location: body = weather_location.name + ': ' + body logging.debug('Trying to tweet: %s', body) if len(body) > max_length: # horizontal ellipsis body = textwrap.shorten(body, width=max_length, placeholder='\u2026') logging.warning('Status text is too long, tweeting the following instead: %s', body) if hashtag: body += ' ' + hashtag try: if tweet_location: status = api.update_status(status=body, lat=weather_location.lat, long=weather_location.lng) else: status = api.update_status(status=body) logging.info('Tweet success: %s', body) return status except tweepy.TweepError as err: logging.error('Tweet failed: %s', err.reason) logging.warning('Tweet skipped due to error: %s', body) return None
def set_pastes(): pastes = list(db.get_pastes()) for index, element in enumerate(paste_elements): # To few pastes available if index >= len(pastes): element["text"].config(text="") element["date"].config(text="") element["button"].config(text="") element["button"].bind("<Button-1>", lambda x: None) element["button"].lower() continue element["text"].config(text=textwrap.shorten(pastes[index].text, width=50, placeholder="...")) element["date"].config(text=pastes[index].date.strftime("%d. %B %Y %H:%M:%S")) element["button"].config(text="Copy") element["button"].bind("<Button-1>", lambda x: copy_from_history(pastes[index].text))
def handle(self, sender, target, tokens, bot): if len(tokens) < 2: for line in self.help_text: bot.send_privmsg(sender, line) return search_title = ' '.join(tokens[1:]) try: page = wikipedia.page(search_title) except wikipedia.exceptions.DisambiguationError as err: m = 'Your query returned a disambiguation page.' bot.send_privmsg(sender, m) if len(err.options) < 6: m = 'Options: {}'.format(u'; '.join(err.options)) bot.send_privmsg(sender, m) else: opts_list = u'; '.join(err.options[:6]) m = 'Some options: {} ...'.format(opts_list) bot.send_privmsg(sender, m) return except wikipedia.exceptions.PageError as err: bot.send_privmsg(sender, str(err)) return summ = textwrap.shorten(page.summary, width=300, placeholder=' ...') m = '{} // {} [ {} ]'.format(page.title, summ, page.url) if not bot.is_irc_channel(target): bot.send_privmsg(sender, m) return now = int(time.time()) last = int(bot.c.get('wiki:last', 0)) wait = int(bot.c.get('wiki:wait', 0)) if last < now - wait: bot.send_privmsg(target, m) bot.c.set('wiki:last', now) else: bot.send_privmsg(sender, m) remaining = last + wait - now m = 'I am cooling down. You cannot use {}'.format(tokens[0]) m = '{} in {} for another'.format(m, target) m = '{} {} seconds.'.format(m, remaining) bot.send_privmsg(sender, m)
def form_valid(self, form): message = form.cleaned_data.get('comment') image = form.cleaned_data.get("image",'') users = (self.request.POST.get('users[]','')).split(",") user = self.request.user subject = self.questionary.topic.subject if (users[0] is not ''): for u in users: to_user = User.objects.get(email=u) talk, create = Conversation.objects.get_or_create(user_one=user,user_two=to_user) created = TalkMessages.objects.create(text=message,talk=talk,user=user,subject=subject,image=image) simple_notify = textwrap.shorten(strip_tags(message), width = 30, placeholder = "...") if image is not '': simple_notify += " ".join(_("[Photo]")) notification = { "type": "chat", "subtype": "subject", "space": subject.slug, "user_icon": created.user.image_url, "notify_title": str(created.user), "simple_notify": simple_notify, "view_url": reverse("chat:view_message", args = (created.id, ), kwargs = {}), "complete": render_to_string("chat/_message.html", {"talk_msg": created}, self.request), "container": "chat-" + str(created.user.id), "last_date": _("Last message in %s")%(formats.date_format(created.create_date, "SHORT_DATETIME_FORMAT")) } notification = json.dumps(notification) Group("user-%s" % to_user.id).send({'text': notification}) ChatVisualizations.objects.create(viewed = False, message = created, user = to_user) success = str(_('The message was successfull sent!')) return JsonResponse({"message":success}) erro = HttpResponse(str(_("No user selected!"))) erro.status_code = 404 return erro
def format_quote(quote, short=False): """Returns a human-readable string representation of a Quote object. :param quote: helga.plugins.quotes.Quote :param short: bool :return: str """ if short: return "#{quote_id}: „<{author}> {text}“".format( quote_id=quote.quote_id, author=quote.author.first_name, text=textwrap.shorten(quote.text, 50)) else: return "Quote #{quote_id}: „<{author}> {text}“ (added by {added_by} at {date})".format( quote_id=quote.quote_id, author=quote.author.first_name, text=quote.text.replace('\n', ' '), added_by=quote.added_by.first_name, date=format_timestamp(quote.date))
async def twitter_search(self, query, limit=5): """Searches for a Twitter user. To use a multi-word query, enclose it in quotes. """ try: results = await self.bot.loop.run_in_executor(None, self.api.search_users, query, limit) except tweepy.TweepError as e: log.error(str(e)) raise TwitterError('Unknown error from the Twitter API, this has been logged.') from e if not results: raise TwitterError('No result.') embed = discord.Embed(colour=0x738bd7) for user in results: name = '{} - @{}'.format(user.name, user.screen_name) description = textwrap.shorten(user.description, 1024) if user.description else 'No description.' embed.add_field(name=name, value=description, inline=False) await self.bot.say(embed=embed)
async def rip(self, ctx, member_or_text: str): """RIP\nCreates a tombstone for either a member or some text. Mention a member to get the avatar + name""" if ctx.message.mentions: user_name = ctx.message.mentions[0].name.replace(" ", "%20") rip_member = ctx.message.mentions[0] ava_url = rip_member.avatar_url url = "https://ripme.xyz/{}" msg = url.format(user_name) tomb = Image.open(os.path.join(asset_pos, "tombstone.png")) base_img = Image.new("RGBA", (tomb.width, tomb.height), color="White") with aiohttp.ClientSession() as session: async with session.get(ava_url) as resp: ava = await resp.content.read() ava_img = Image.open(io.BytesIO(ava)) ava_img_greyscale = ImageOps.autocontrast(ava_img.convert("L").filter(ImageFilter.CONTOUR)).filter( ImageFilter.SMOOTH).resize((200, 200)) base_img.paste(ava_img_greyscale, (140, 380, 340, 580)) final = ImageChops.multiply(base_img, tomb) f = ImageFont.truetype(os.path.join(asset_pos, "Symbola.ttf"), size=35) d = ImageDraw.Draw(final) w, h = d.textsize(rip_member.name, font=f) d.multiline_text(((60 + ((350 - w) / 2)), 315), rip_member.name, fill="Black", font=f, align="center") final.save(os.path.join(asset_pos, "rip.png")) await self.bot.send_file(ctx.message.channel, os.path.join(asset_pos, "rip.png"), content=msg) else: content = ctx.message.content.partition(" ") user_name = content[2].replace(" ", "_") url = "https://ripme.xyz/{}" msg = url.format(user_name) base_img = Image.new("RGB", (520, 640), color="White") tomb = Image.open(os.path.join(asset_pos, "tombstone.png")) base_img.paste(tomb) f = ImageFont.truetype(os.path.join(asset_pos, "Symbola.ttf"), size=35) d = ImageDraw.Draw(base_img) text = textwrap.shorten(content[2], width=25, placeholder="") w, h = d.textsize(text, font=f) d.text(((60 + ((350 - w) / 2)), 315), text, fill="Black", font=f, align="center") d.text((160, 450), "2016 - 2016", fill="Black", font=f) base_img.save(os.path.join(asset_pos, "rip.jpeg")) await self.bot.send_file(ctx.message.channel, os.path.join(asset_pos, "rip.jpeg"), content=msg)
async def wiki(self, ctx: cmds.Context, *, search_terms: str): """Look up information on Wikipedia.""" try: page = wikipedia.page(search_terms) except wikipedia.exceptions.DisambiguationError as err: await ctx.author.send('Your query returned a disambiguation page.') if len(err.options) < 6: opts_list = '; '.join(err.options) await ctx.author.send(f'Options: {opts_list}') else: opts_list = '; '.join(err.options[:6]) await ctx.author.send(f'Some options: {opts_list} ...') return except wikipedia.exceptions.PageError as err: await ctx.author.send(str(err)) return summary = textwrap.shorten(page.summary, width=300, placeholder=' ...') await ctx.send(f'{page.title} // {summary} [ {page.url} ]')
def api_request(url, data): response = requests.post( url, headers={'Content-Type': 'application/json'}, auth=(settings.API_USERNAME, settings.API_PASSWORD), data=json.dumps(data) ) try: return response.json() except json.JSONDecodeError: raise APIResponseInvalidJson( "The response from the Adyen API was invalid JSON:\n" " Status code: {}\n" " Body: {}".format( response.status_code, textwrap.shorten(response.text, width=75) ) )
def send_sms(self, message, ignore_last_sms_timestamp=False): if not ignore_last_sms_timestamp and ( datetime.utcnow() - self.last_sms_timestamp).total_seconds() < self.backoff_timeout_in_sec: log.warning('Not sending SMS, recently already sent an SMS') return log.info('Trying to send SMS with text: {}'.format(str(message))) try: trimmed_message = textwrap.shorten(str(message), 100) headers = {'Authorization': 'AccessKey ' + self.sms_api_key, 'accept': 'application/json'} payload = {'type': 'sms', 'originator': self.sms_from_number, 'body': 'Alarm notification! Unexpected event: {}'.format(trimmed_message), 'recipients': [self.sms_to_number]} resp = requests.post(MSG_BIRD_BASE_URI + MSG_BIRD_API_MESSAGE, headers=headers, data=payload) log.info('SMS response: ' + str(resp.json())) if not ignore_last_sms_timestamp: self.last_sms_timestamp = datetime.utcnow() except requests.exceptions.RequestException: log.exception('Failed to send SMS!')
def RecordPatch(*args, **kwargs): # raise_attr_exception=False mrm = MyRedmine() issueChoices = [(0, "None")] + [(i.id, "#{}: {}".format(i.id, i.subject)) for i in mrm.my_issues] releaseChoices = [(0, "None")] + [ (int(r['Nr']), "{}: {}".format(r['Nr'], shorten(r['Beschreibung'], 80))) for r in get_releasetest_issues(assignee=Config.GSPREAD_ASSIGNEE)] class RecordPatch(CancelDataset): prefix = di.ChoiceItem('Prefix', [(p, p.name) for p in Prefixes]) tracker = di.ChoiceItem("Tracker", issueChoices, default=0) rtest = di.ChoiceItem("Releasetest", releaseChoices, default=0) name = di.StringItem("Name", notempty=True) author = di.StringItem("Author", notempty=True, default=Config.AUTHOR) @property def Prefix(self): return self.prefix.Name(self.tracker, self.rtest) @property def FormattedName(self): return '{}: {}'.format(self.Prefix, self.name) def check_prefix(self): if not self.prefix.hasParameter: return False return self.tracker > 0 or self.rtest def read(self, p: Patch): prefix, name = p.title.split(': ', 1) self.name = name self.prefix, self.tracker, self.rtest = Prefixes.read(prefix) return RecordPatch(*args, **kwargs)
def brodcast_dificulties(request, message, subject): msg = TalkMessages() msg.text = message msg.user = request.user msg.subject = subject simple_notify = textwrap.shorten(strip_tags(msg.text), width = 30, placeholder = "...") for p in subject.professor.all(): talks = Conversation.objects.filter((Q(user_one = request.user) & Q(user_two__email = p.email)) | (Q(user_two = request.user) & Q(user_one__email = p.email))) if talks.count() > 0: msg.talk = talks[0] else: msg.talk = Conversation.objects.create(user_one = request.user, user_two = p) msg.save() notification = { "type": "chat", "subtype": subject.slug, "space": "subject", "user_icon": request.user.image_url, "notify_title": str(request.user), "simple_notify": simple_notify, "view_url": reverse("chat:view_message", args = (msg.id, ), kwargs = {}), "complete": render_to_string("chat/_message.html", {"talk_msg": msg}, request), "container": "chat-" + str(request.user.id), "last_date": _("Last message in %s")%(formats.date_format(msg.create_date, "SHORT_DATETIME_FORMAT")) } notification = json.dumps(notification) Group("user-%s" % p.id).send({'text': notification}) sendChatPushNotification(p, msg) ChatVisualizations.objects.create(viewed = False, message = msg, user = p)
def QuickEditIssue(*args, **kwargs): # raise_attr_exception=False mrm = MyRedmine() issueChoices = [(i, "#{} ({}: {}%)".format(i, i.status, i.done_ratio)) for i in mrm.my_issues_filtered(**kwargs)] statusChoices = [(0, "Dont Change")] + [(s, s.name) for s in mrm.issue_statuses] releaseChoices = [(int(r['Nr']), "{}: {}".format(r['Nr'], shorten(r['Beschreibung'], 50))) for r in get_releasetest_issues()] if not issueChoices: message("Nope", "There are no new Issues for you.") return class QuickIssue(CancelDataset): issue = di.ChoiceItem("Issue", issueChoices) rtest = di.ChoiceItem("Releasetest", releaseChoices) status = di.ChoiceItem("Status", statusChoices, default=0) progress = di.IntItem("Progress", min=0, max=100, slider=True, default=0) comment = di.TextItem("Comment") return QuickIssue(*args)
def __get_book(self, now): # Faz duas tentativas para obter o livro do dia, por questões de possível cache antigo. for _ in range(2): book = self.resources.get_packt_free_book() if book is None: continue delta = datetime.datetime.fromtimestamp(book.expires, tz=AJU_TZ) - now delta = delta.total_seconds() if delta < 0: continue summary = textwrap.shorten(book.summary, 150, placeholder=r' \[...]') response = ( "Confira o livro gratuito de hoje da Packt Publishing 🎁\n\n" "📖 [%s](%s)\n" "🔎 %s\n" ) % (book.name, Resources.BOOK_URL, summary) for left in TIME_LEFT: if delta <= left: return book, response, left else: left = None break # As tentativas falharam... else: Resources.cache.invalidate(Resources.get_packt_free_book, "get_packt_free_book") book = None response = "Parece que não tem um livro grátis hoje 😡\n\n" \ "Se acha que é um erro meu, veja com seus próprios olhos em " + Resources.BOOK_URL left = None return book, response, left
def test_width_too_small_for_placeholder(self): shorten("x" * 20, width=8, placeholder="(......)") with self.assertRaises(ValueError): shorten("x" * 20, width=8, placeholder="(.......)")
async def send_email(self, *, user: Dict[str, Any], user_ctx: Dict[str, Any], subject: str, title: str, body: str, template: str, e_from: str, reply_to: Optional[str], global_ctx: Dict[str, Any], attachment: Optional[Attachment], tags: Dict[str, str], company_id: int): base_url = global_ctx['base_url'] full_name = '{first_name} {last_name}'.format( first_name=user['first_name'] or '', last_name=user['last_name'] or '', ).strip(' ') user_email = user['email'] extra_ctx = dict( first_name=user['first_name'] or user['last_name'] or '', full_name=full_name or 'user', unsubscribe_link= f'/api/unsubscribe/{user["id"]}/?sig={unsubscribe_sig(user["id"], self.settings)}', ) ctx = clean_ctx({**global_ctx, **extra_ctx, **user_ctx}, base_url) markup_data = ctx.pop('markup_data', None) e_msg = EmailMessage(policy=SMTP) subject = chevron.render(subject, data=ctx) e_msg['Subject'] = subject e_msg['From'] = e_from if reply_to: e_msg['Reply-To'] = reply_to e_msg[ 'To'] = f'{full_name} <{user_email}>' if full_name else user_email e_msg['List-Unsubscribe'] = '<{unsubscribe_link}>'.format(**ctx) e_msg['X-SES-CONFIGURATION-SET'] = 'nosht' e_msg['X-SES-MESSAGE-TAGS'] = ', '.join(f'{k}={v}' for k, v in tags.items()) if DEBUG_PRINT_REGEX.search(body): ctx['__debug_context__'] = f'```{json.dumps(ctx, indent=2)}```' body = apply_macros(body) body = chevron.render(body, data=ctx) raw_body = re.sub(r'\n{3,}', '\n\n', body).strip('\n') e_msg.set_content(raw_body, cte='quoted-printable') ctx.update( styles=STYLES, main_message=safe_markdown(raw_body), message_preview=shorten(strip_markdown(raw_body), 60, placeholder='…'), ) if markup_data: ctx['markup_data'] = json.dumps(markup_data, separators=(',', ':')) html_body = chevron.render(template, data=ctx, partials_dict={'title': title}) e_msg.add_alternative(html_body, subtype='html', cte='quoted-printable') if attachment: maintype, subtype = attachment.mime_type.split('/') e_msg.add_attachment( attachment.content.encode(), maintype=maintype, subtype=subtype, filename=attachment.filename, ) if self.send_via_aws and user_email.endswith('example.com'): logger.info( 'email not sent "%s" to "%s" because it ends "example.com"', subject, user_email) return send_method = self.aws_send if self.send_via_aws else self.print_email msg_id = await send_method(e_from=e_from, to=[user_email], email_msg=e_msg) await self.pg.execute( """ insert into emails (company, user_id, ext_id, trigger, subject, address) values ($1, $2, $3, $4, $5, $6) """, company_id, user['id'], msg_id, tags['trigger'], subject, user_email)
async def apply_ban(self, ctx: Context, user: UserSnowflake, reason: t.Optional[str], purge_days: t.Optional[int] = 0, **kwargs) -> None: """ Apply a ban infraction with kwargs passed to `post_infraction`. Will also remove the banned user from the Big Brother watch list if applicable. """ # In the case of a permanent ban, we don't need get_active_infractions to tell us if one is active is_temporary = kwargs.get("expires_at") is not None active_infraction = await _utils.get_active_infraction( ctx, user, "ban", is_temporary) if active_infraction: if is_temporary: log.trace( "Tempban ignored as it cannot overwrite an active ban.") return if active_infraction.get('expires_at') is None: log.trace("Permaban already exists, notify.") await ctx.send( f":x: User is already permanently banned (#{active_infraction['id']})." ) return log.trace("Old tempban is being replaced by new permaban.") await self.pardon_infraction(ctx, "ban", user, is_temporary) infraction = await _utils.post_infraction(ctx, user, "ban", reason, active=True, **kwargs) if infraction is None: return self.mod_log.ignore(Event.member_remove, user.id) if reason: reason = textwrap.shorten(reason, width=512, placeholder="...") action = ctx.guild.ban(user, reason=reason, delete_message_days=purge_days) await self.apply_infraction(ctx, infraction, user, action) if infraction.get('expires_at') is not None: log.trace( f"Ban isn't permanent; user {user} won't be unwatched by Big Brother." ) return bb_cog = self.bot.get_cog("Big Brother") if not bb_cog: log.error( f"Big Brother cog not loaded; perma-banned user {user} won't be unwatched." ) return log.trace( f"Big Brother cog loaded; attempting to unwatch perma-banned user {user}." ) bb_reason = "User has been permanently banned from the server. Automatically removed." await bb_cog.apply_unwatch(ctx, user, bb_reason, send_message=False)
def build_status(self, text): return textwrap.shorten(text, width=280, placeholder="...")
def __str__(self): return textwrap.shorten("{0.name}".format(self), 40)
# print(textwrap.fill(dedented_text, width=width)) # print() # indenting blog # dedented_text = textwrap.dedent(sample_text) # wrapped = textwrap.fill(dedented_text, width=50) # wrapped += '\n\nSecond paragraph after a blank line.' # final = textwrap.indent(wrapped, '> ') # print('Quoted block:\n') # print(final) # hanging indent # dedented_text = textwrap.dedent(sample_text).strip() # print(textwrap.fill(dedented_text, # initial_indent='', # subsequent_indent=' ' * 4, # width=50, # )) # Truncating long text dedented_text = textwrap.dedent(sample_text) original = textwrap.fill(dedented_text, width=50) print('Original:\n') print(original) shortened = textwrap.shorten(original, 100) shortened_wrapped = textwrap.fill(shortened, width=50) print('\nShortened:\n') print(shortened_wrapped)
def cquery_render(s): terms = s mquery = ''' query { Page(page:1, perPage:5) { characters(search: %s) { name { full } media(perPage: 2) { nodes { id title { romaji native english } type format status description season startDate { year } episodes duration coverImage { medium large } genres isAdult tags { name } airingSchedule { nodes { timeUntilAiring episode } } } } } } } ''' % json.dumps(s) print('query is', mquery) media = simple_query(litquery=mquery) print('Got result', media) characters = media['data']['Page']['characters'] media = [(textwrap.shorten(x['name']['full'], width=15, placeholder='...'), y) for x in characters for y in x['media']['nodes']] responses = [ InlineQueryResultArticle( id=uuid4(), title= f"{'R' if len(media) else 'There were no r'}esults for query '{terms}'", input_message_content=InputTextMessageContent( 'Y u clickin\' this?')) ] def timefmt(t): if not t: return '???' if t < 3600: return 'about an hour or so' if t < 24 * 3600: return f'about {t/3600} hours or so' return f'{int(t/(3600*24))} days' def nextEpisode(episodes: list): eps, time = None, None for ex in episodes: if ex['timeUntilAiring'] > 0: eps = ex['episode'] time = ex['timeUntilAiring'] break return f"episode {eps or '???'} in {timefmt(time)}" for n, m in media: responses.append( InlineQueryResultArticle( id=uuid4(), title= (lambda t: f"[{n}] {'[🌶] ' if m['isAdult'] else ''}[{m['format']}] {t['english'] or t['romaji']}" )(m['title']), thumb_url=m['coverImage']['medium'], input_message_content=InputTextMessageContent(( f"<b>{m['title']['english'] or m['title']['romaji']} ({m['startDate']['year']})</b>\n" + f"Original name: {m['title']['native']}\n" + f"Romaji name: {m['title']['romaji']}\n" + f"Status: {m['status']}\n" + f"Genres: {', '.join(m.get('genres', None) or ['Nothing'])}\n" + f"Tags: {', '.join(i['name'] for i in (m.get('tags', []))) or 'Nothing'}\n" + f"Total episode count: {m['episodes']}\n" + (f"Next episode: {nextEpisode(m['airingSchedule']['nodes'])}\n" if m['status'] == 'RELEASING' else '') + '\nHere be dragons\n' + f"Description: {strip_tags(m['description'])}\n" + f"<a href=\"{m['coverImage']['large']}\"> Cover Image </a>" ), parse_mode='HTML' ))) return responses
# Text Wrap Module import textwrap websiteText = """ Learning can happen anywhere with our apps on your computer, mobile device, and TV, featuring enhanced navigation and faster streaming for anytime learning. Limitless learning, limitless possibilities.""" print("No Dedent:") print(textwrap.fill(websiteText)) print("Dedent") dedent_text = textwrap.dedent(websiteText).strip() print(dedent_text) print("Fill") print() print(textwrap.fill(dedent_text, width=50)) print(textwrap.fill(dedent_text, width=100)) print("Controlling Indent") print( textwrap.fill(dedent_text, initial_indent=" ", subsequent_indent=" ")) print("Shortening Text") short = textwrap.shorten("LinkedIn.com is great!", width=15, placeholder="...") print(short)
async def on_command_error(self, ctx, error): if ctx.command and ctx.command.has_error_handler(): return if ctx.cog and ctx.cog.has_error_handler(): return if isinstance(error, commands.CommandNotFound): return elif isinstance(error, commands.MissingRequiredArgument): argument = error.param.name await ctx.send(f"You are missing a required argument: `{argument}`" ) elif isinstance(error, commands.BadArgument): await ctx.send(error or "You are using a bad argument.") elif isinstance(error, commands.MissingPermissions): await ctx.send("You don't have enough permissions.") elif isinstance(error, checks.MemberOnCooldown): seconds = round(error.retry_after, 2) await ctx.send( f"You are on cooldown. Wait `{seconds}s` before running another command." ) elif isinstance(error, commands.CommandOnCooldown): command = ctx.command.qualified_name seconds = round(error.retry_after, 2) await ctx.send( f"You can't use `{command}` command for `{seconds}s`.") elif isinstance(error, commands.NoPrivateMessage): await ctx.author.send( "This command can't be used in direct messages.") elif isinstance(error, commands.NotOwner): await ctx.send("It seems you do not own this bot.") elif isinstance(error, commands.CheckFailure): if type(error) == checks.ProfileNotLinked: await ctx.send( f'You haven\'t linked a profile yet. Use "{ctx.prefix}profile link" to start.' ) elif type(error) == checks.ProfileLimitReached: if error.limit == 5: premium = self.bot.config.premium embed = discord.Embed(color=discord.Color.red()) embed.description = ( "Maximum limit of profiles reached.\n" f"[Upgrade to Premium]({premium}) to be able to link up to 25 profiles." ) await ctx.send(embed=embed) else: await ctx.send("Maximum limit of profiles reached.") elif type(error) == checks.MemberNotPremium: premium = self.bot.config.premium embed = discord.Embed(color=discord.Color.red()) embed.description = ( "This command requires a Premium membership.\n" f"[Click here]({premium}) to have a look at the Premium plans." ) await ctx.send(embed=embed) elif isinstance(error, commands.CommandInvokeError): original = error.original group = (RequestError, ProfileException, NoChoice, PaginationError) if isinstance(original, discord.HTTPException): return elif isinstance(original, DataError): await ctx.send("The argument you entered cannot be handled.") elif isinstance(original, group): await ctx.send(original) else: embed = discord.Embed(color=discord.Color.red()) embed.set_author(name=str(ctx.author), icon_url=ctx.author.display_avatar) embed.add_field(name="Command", value=ctx.command.qualified_name) content = textwrap.shorten(ctx.message.content, width=512) embed.add_field(name="Content", value=content) if ctx.guild: guild = f"{str(ctx.guild)} ({ctx.guild.id})" embed.add_field(name="Guild", value=guild, inline=False) try: exc = "".join( traceback.format_exception( type(original), original, original.__traceback__, chain=False, )) except AttributeError: exc = f"{type(original)}\n{original}" embed.description = f"```py\n{exc}\n```" embed.timestamp = ctx.message.created_at if not self.bot.debug: await self.bot.webhook.send(embed=embed) else: print(original, type(original)) await ctx.send( "This command ran into an error. The incident has been reported and will be fixed as soon as possible!" )
def snippet(self): body_snippet = textwrap.shorten(self.body, width=35, placeholder='...') # Define here rather than in __str__ so we can use it in the admin list_display return '{author} - {snippet}...'.format(author=self.author_text, snippet=body_snippet)
def news_scrapper(): import textwrap import requests from bs4 import BeautifulSoup import pandas as pd #API CALL TO Greek google news news_url=' https://news.google.com/rss?hl=el&gl=GR&ceid=GR:el.' # downloads the page rss_text = requests.get(news_url).text # create an instance in xml form soup_page=BeautifulSoup(rss_text,"xml") def get_items(soup): # function that gets all the headlines and contents of the news # INPUT: all the instance of beautiful soup # OUTPUT: the title and content of the news item # the process before the yield is performed one time for news in soup.findAll("item"): # # s = BeautifulSoup(news.description.text, 'lxml') # a = s.select('a')[-1] # a.extract() # extract lat 'See more on Google News..' link html = requests.get(news.link.text) soup_content = BeautifulSoup(html.text,"lxml") # # perform basic sanitization: # for t in soup_content.select('script, noscript, style, iframe, nav, footer, header'): # t.extract() # give the headline title and the content of the news # every time that the function is called give away one item yield news.title.text.strip(), str(soup_content.select_one('body').text) # increase the increment of the for loop at the end of the loop so to be ready # for the next iteration # Defining a dictionary for words relevant to coronavirus thisdict = {"κορωναϊό","κοροναϊό","COVID-19","κορονοϊό","κορωνοϊό","coronavirus"} titles=[] contents=[] # Initializing the first lines of the csv # titles.append("TITLE") # contents.append("CONTENT") # maximum width of the line width = 80 # Extracting only title and content of the articles that contain any of the words that we specify in the dictionary for (title,content) in get_items(soup_page): # wrap the headline in lines, per line maximim width of 80 characters title = '\n'.join(textwrap.wrap(title, width)) # wrap each line so that it has width of 80 characters, # and shorten the text so that it show 1024 characters content = '\n'.join(textwrap.wrap(textwrap.shorten(content, 1024), width)) # Filtering out the articles in which the titles does not contain any word relevant to coronavirus for value in thisdict: if title.find(value): titles.append(title) if content.find(value): contents.append(content) # zip means pair first element of one list with first element from the other df = pd.DataFrame(list(zip(titles, contents))) print(df.iloc[8]) df.columns = ['title', 'content'] return df
def parsePage(items, browser, occuranceCount): soup = browser.get_current_page() foldername = soup.select(".pp-subfolder-self")[0].get_text() for div in soup.find_all(class_="pp-pub-item"): initialdata = re.sub(r"<[^>]+>", "", div.find(ppdata=True)['ppdata']) jsondata = json.loads(initialdata) catpage = re.sub(r"(https://paperpile.com/shared/\w+)/[0-9]+$", r"\1", browser.get_url()) #print(catpage, browser.get_url()) jsondata['category_page'] = [catpage] if "keywords" in jsondata: jsondata['keywords'] = [ x.title().strip() for x in re.split(r'[;,] *', jsondata['keywords']) if x.title().strip() ] else: jsondata['keywords'] = ['No Keywords'] # pprint(jsondata) if "url" in jsondata: jsondata['docurls'] = jsondata['url'] del jsondata['url'] jsondata['jsonauthors'] = jsondata['author'] authors = [] citationauthor = [] for j, author in enumerate(jsondata['author']): if "last" in author and "first" in author: authors.append("{}, {}".format(author['last'], author['first'])) initials = "" for i, initial in enumerate(author['initials']): if initial != " ": initials += "{}.".format(initial) if i < len(author['initials'])-1: initials += " " citationauthor.append("{}, {}".format(author['last'], initials)) elif "last" in author: authors.append("{}".format(author['last'])) citationauthor.append("{}".format(author['last'])) elif "collective" in author: authors.append(re.sub(r' +', '_', "{}".format(author['collective']))) citationauthor.append(author['collective']) else: raise ValueError(author) authorout = authors if len(authorout) > 2: authorout = authors[:2]+['etal'] if authors == []: authorout.append(jsondata['title']) citationauthorstring = "" for i, a in enumerate(citationauthor): if i < len(citationauthor) -2: citationauthorstring += "{}, ".format(a) elif i == len(citationauthor)-2: citationauthorstring += "{}, & ".format(a) else: citationauthorstring += "{}".format(a) jsondata['citationauthor'] = citationauthorstring # authorstring= '-'.join([ "{}".format(author['last']) for author in jsondata['author']] ) authorstring = textwrap.shorten(re.sub(r'[^A-Za-z0-9-,;+]+', '-', '+'.join(authorout)), width=50, placeholder="+etal") jsondata['author'] = '; '.join(authors) if "published" in jsondata: year = jsondata['published']['year'] else: jsondata['published'] = {} jsondata['published']['year'] = "n.d." year = "n.d." occuranceKey = "{}-{}".format('-'.join(authorout).upper(), jsondata['title'].upper()) if occuranceKey in occuranceCount: occuranceCount[occuranceKey] += 1 else: occuranceCount[occuranceKey] = 1 jsondata['occuranceKey'] = occuranceKey key = "{}-{}-{}".format(year, '-'.join(authorout), textwrap.shorten(jsondata['title'], width=50, placeholder="")) jsondata['sortorder'] = "{}-{}-{}".format(' '.join(authors), year, jsondata['title']) if key in items: jsondata['category_page'] = jsondata['category_page'] + items[key]['category_page'] items[key] = jsondata
def __str__(self): return "[{0}] {1} {2}".format(self.category, self.question, shorten(self.answer, 140))
def form_valid(self, form): message = form.cleaned_data.get("comment") image = form.cleaned_data.get("image") users = (self.request.POST.get("users[]", "")).split(",") user = self.request.user subject = self.webpage.topic.subject if users[0] != "": for u in users: to_user = User.objects.get(email=u) talk, create = Conversation.objects.get_or_create( user_one=user, user_two=to_user) created = TalkMessages.objects.create(text=message, talk=talk, user=user, subject=subject, image=image) simple_notify = textwrap.shorten(strip_tags(message), width=30, placeholder="...") if image != "": simple_notify += " ".join(_("[Photo]")) notification = { "type": "chat", "subtype": "subject", "space": subject.slug, "user_icon": created.user.image_url, "notify_title": str(created.user), "simple_notify": simple_notify, "view_url": reverse("chat:view_message", args=(created.id, ), kwargs={}), "complete": render_to_string("chat/_message.html", {"talk_msg": created}, self.request), "container": "chat-" + str(created.user.id), "last_date": _("Last message in %s") % (formats.date_format( created.create_date, "SHORT_DATETIME_FORMAT")), } notification = json.dumps(notification) Group("user-%s" % to_user.id).send({"text": notification}) ChatVisualizations.objects.create(viewed=False, message=created, user=to_user) success = str(_("The message was successfull sent!")) return JsonResponse({"message": success}) erro = HttpResponse(str(_("No user selected!"))) erro.status_code = 404 return erro
def snippet(self): body_snippet = textwrap.shorten(self.body, width=35, placeholder="...") return "{author} - {snippet}...".format( author=self.creation_user.username, snippet=body_snippet)
def __str__(self): return textwrap.shorten(self.text, width=300)
def run(self, **kwargs): """ Run the celery task. """ # Set the arguments. for key, value in kwargs.items(): setattr(self, key, value) # If a time limit is set for using labs, # check how much time learner has already spent settings = get_xblock_settings() lab_usage_limit = settings.get("lab_usage_limit", None) policy_warn_message = None if lab_usage_limit: # don't look further than 365 days for lab launch cutoff = timezone.now() - timezone.timedelta(days=365) # get all learner stacks across the platform stacks = Stack.objects.filter(learner__id=self.learner_id).filter( launch_timestamp__gt=cutoff) # add up total time spent on labs in seconds total_time_spent = 0 for stack in stacks: # A stacklog is saved each time the stack status changes, # we only need to look at log entires with SUSPEND_COMPLETE # status to get all records of active lab sessions with # launch and suspend timestamps. stacklog = StackLog.objects.filter(stack_id=stack.id).filter( status="SUSPEND_COMPLETE") # add up time spent on labs for one stack in seconds time_spent = 0 for logentry in stacklog: time = (logentry.suspend_timestamp - logentry.launch_timestamp) time_spent += time.total_seconds() total_time_spent += time_spent if total_time_spent > lab_usage_limit: policy = settings.get("lab_usage_limit_breach_policy", "").lower() if policy: logger.error( f'Learner {stacks[0].learner.email} has gone over ' 'the lab usage limit!') if policy == 'block': raise LabAccessRestricted( "You've reached the time limit allocated to you " "for using labs.") elif policy == 'warn': policy_warn_message = ( "You've reached the time limit allocated to you " "for using labs.") # Get the stack stack = Stack.objects.get(id=self.stack_id) # Initialize parameters self.protocol = stack.protocol self.port = stack.port self.stack_run = stack.run self.stack_name = stack.name self.stack_user_name = stack.user self.course_id = stack.course_id self.student_id = stack.student_id self.hook_events = stack.hook_events # Initialize hook script self.hook_script = None if stack.hook_script: self.hook_script = read_from_contentstore(stack.course_id, stack.hook_script) # Initialize providers self.providers = [] for provider in stack.providers: p = Provider.init(provider["name"]) if p: p.set_logger(logger) p.set_capacity(provider["capacity"]) template = read_from_contentstore(stack.course_id, provider["template"]) p.set_template(template) environment_path = provider.get("environment") if environment_path: environment = read_from_contentstore( stack.course_id, environment_path) p.set_environment(environment) self.providers.append(p) else: logger.warning( f'Failed to initialize provider: {provider["name"]}, ' 'make sure the necessary settings are in place, or remove ' 'the provider from the list to silence this warning.') if not self.providers: logger.error("No providers were successfully initialized, " "make sure you have the necessary settings in place.") raise ProviderException() try: # Launch the stack and wait for it to complete. stack_data = self.launch_stack(stack.provider) except LaunchStackFailed as e: logger.error(e.error_msg) # In case of failure, only return the provider if this was a failed # resume attempt. provider_name = "" if e.suspend: provider_name = e.provider.name stack_data = { 'status': e.status, 'error_msg': textwrap.shorten(e.error_msg, width=256), 'ip': None, 'user': "", 'key': "", 'password': "", 'provider': provider_name } # Roll back in case of failure self.cleanup_stack(e) # Don't wait for the user to check results. Update the database # immediately. if policy_warn_message: stack_data["error_msg"] = policy_warn_message self.update_stack(stack_data)
def __str__(self): latest_revision = self.get_latest_revision() if not latest_revision: return str(self.pk) return textwrap.shorten(latest_revision.text, 70, placeholder='...')
def truncate(width, obj, right=False): stringified = str(obj or "") truncated = shorten(stringified, width=width, placeholder="...") return truncated.rjust(width) if right else truncated.ljust(width)
def get_shorten_text(self): return textwrap.shorten(self.explanation_text, 70, placeholder='...')
def audits(name, uuid): if name and uuid: data = db_query( "SELECT assets.fqdn, compliance.check_name, compliance.status FROM compliance LEFT OUTER JOIN assets ON " "assets.uuid = compliance.asset_uuid " "where compliance.audit_file='{}' and compliance.asset_uuid='{}';". format(name, uuid)) click.echo("{:65} {:65} {}".format("\nFQDN", " Check Name", " Status")) click.echo("-" * 150) click.echo() for finding in data: click.echo("{:65} {:65} {}".format( textwrap.shorten(str(finding[0]), width=65), textwrap.shorten(str(finding[1]), width=65), finding[2])) click.echo() elif name: data = db_query( "SELECT assets.fqdn, compliance.check_name, compliance.status FROM compliance LEFT OUTER JOIN assets ON " "assets.uuid = compliance.asset_uuid " "where audit_file='{}';".format(name)) click.echo("{:65} {:65} {}".format("\nFQDN", " Check Name", " Status")) click.echo("-" * 150) click.echo() for finding in data: click.echo("{:65} {:65} {}".format( textwrap.shorten(str(finding[0]), width=65), textwrap.shorten(str(finding[1]), width=65), finding[2])) click.echo() elif uuid: data = db_query( "SELECT assets.fqdn, compliance.check_name, compliance.status FROM compliance LEFT OUTER JOIN assets ON " "assets.uuid = compliance.asset_uuid " "where asset_uuid='{}';".format(uuid)) click.echo("{:65} {:65} {}".format("\nFQDN", " Check Name", " Status")) click.echo("-" * 150) click.echo() for finding in data: click.echo("{:65} {:65} {}".format( textwrap.shorten(str(finding[0]), width=65), textwrap.shorten(str(finding[1]), width=65), finding[2])) click.echo() else: compliance_data = db_query("SELECT audit_file from compliance;") compliance_list = [] for audit in compliance_data: if audit not in compliance_list: compliance_list.append(audit) click.echo("\nCompleted Audits") click.echo("-" * 80) click.echo() for name in compliance_list: click.echo(name[0]) click.echo()
def set_default(self, ctx: commands.Context, limit: int=30): """Sets embed author""" who = shorten(ctx.author.display_name, limit) self.set_author(name=f'Requested by {who}', icon_url=str(ctx.author.avatar_url)) return self
def shorten_str(full_string): """ Shorten string to 50 chars max, including an ending ellipsis Words are not truncated """ return textwrap.shorten(full_string, width=50, placeholder="...")
def get_grid_table_context(lessons, homeworks, current_day, week, context): """ Returns class schedule and homework for this week """ if len( lessons ) == 0: # If class shedule for the user is empty the program exits the function return context context['count_of_lessons'] = get_max_number_of_lessons( lessons) # getting the most lessons per week context['number_of_days'] = lessons.order_by( '-day').first().day # Getting all non empty days for day in context['days']: for _ in range(1, context['count_of_lessons'] + 1): lesson = lessons.filter(day=current_day.isoweekday(), number=_).first() if lesson != None: homework = homeworks.filter(lesson=lesson).first() if homework != None: day['lessons'].append({ 'none': False, 'name': lesson.name, 'number': lesson.number, 'classroom': lesson.classroom, 'homework': textwrap.shorten(text=homework.homework, width=25, placeholder='...'), 'homework_is_done': homework.is_done, 'details': homework.id, 'delete_id': lesson.id, 'edit_homework': { 'week': week, 'id': lesson.id }, }) else: day['lessons'].append({ 'none': False, 'number': lesson.number, 'name': lesson.name, 'classroom': lesson.classroom, 'delete_id': lesson.id, 'details': 0, 'edit_homework': { 'week': week, 'id': lesson.id }, }) elif lessons.filter(day=current_day.isoweekday()).exists(): day['lessons'].append({'none': True}) current_day += datetime.timedelta( days=1) # Taking the next day for processing in the next iteration context['number_of_lessons'] = context['count_of_lessons'] + 1 context['count_of_lessons'] = range(1, context['count_of_lessons'] + 1) return context
s(None, "Google Calculator:", f"**{tmp}** {h2t(str(answer))}")) return # sidepage card if card := soup.find("div", class_="liYKde g VjDLd"): if thumbnail := card.find("g-img", attrs={"data-lpage": True}): kwargs["thumbnail"] = thumbnail["data-lpage"] if title := soup.find("div", class_="SPZz6b"): if desc := card.find("div", class_="kno-rdesc"): if remove := desc.find(class_="Uo8X3b"): remove.decompose() desc = ( textwrap.shorten(h2t(str(desc)), 1024, placeholder="\N{HORIZONTAL ELLIPSIS}") + "\n") if more_info := card.findAll("div", class_="Z1hOCe"): for thing in more_info: tmp = thing.findAll("span") if len(tmp) == 2: desc2 = f"\n **{tmp[0].text}**`{tmp[1].text.lstrip(':')}`" # More jack advises :D MAX = 1024 MAX_LEN = MAX - len(desc2) if len(desc) > MAX_LEN: desc = (next( pagify( desc,
def feedback_review_3(feedback, size): return textwrap.shorten(feedback, size)
def render_snapin(self, snapin: UserSidebarSnapin) -> str: snapin_class = snapin.snapin_type name = snapin_class.type_name() snapin_instance = snapin_class() more_id = "sidebar_snapin_%s" % name show_more = user.get_show_more_setting(more_id) html.open_div(id_="snapin_container_%s" % name, class_=["snapin", ("more" if show_more else "less")]) self._render_snapin_styles(snapin_instance) # When not permitted to open/close snapins, the snapins are always opened if snapin.visible == SnapinVisibility.OPEN or not user.may( "general.configure_sidebar"): style = None else: style = "display:none" toggle_url = "sidebar_openclose.py?name=%s&state=" % name # If the user may modify the sidebar then add code for dragging the snapin head_actions: Dict[str, str] = {} if user.may("general.configure_sidebar"): head_actions = { "onmouseover": "document.body.style.cursor='move';", "onmouseout ": "document.body.style.cursor='';", "onmousedown": "cmk.sidebar.snapin_start_drag(event)", "onmouseup": "cmk.sidebar.snapin_stop_drag(event)", } html.open_div(class_=["head", snapin.visible.value], **head_actions) show_more = snapin_instance.has_show_more_items() may_configure = user.may("general.configure_sidebar") if show_more or may_configure: html.open_div(class_="snapin_buttons") if show_more: html.open_span(class_="moresnapin") html.more_button(more_id, dom_levels_up=4) html.close_span() if may_configure: # Button for closing (removing) a snapin html.open_span(class_="closesnapin") close_url = "sidebar_openclose.py?name=%s&state=off" % name html.icon_button( url=None, title=_("Remove this element"), icon="close", onclick="cmk.sidebar.remove_sidebar_snapin(this, '%s')" % close_url, ) html.close_span() html.close_div() # The heading. A click on the heading mini/maximizes the snapin toggle_actions: Dict[str, str] = {} if user.may("general.configure_sidebar"): toggle_actions = { "onclick": "cmk.sidebar.toggle_sidebar_snapin(this,'%s')" % toggle_url, "onmouseover": "this.style.cursor='pointer'", "onmouseout": "this.style.cursor='auto'", } html.b( textwrap.shorten(snapin_class.title(), width=27, placeholder="..."), class_=["heading"], **toggle_actions, ) if may_configure: # Icon for mini/maximizing html.span( "", class_="minisnapin", title=_("Open/close this element"), onclick="cmk.sidebar.toggle_sidebar_snapin(this, '%s')" % toggle_url, ) # End of header html.close_div() # Now comes the content html.open_div(class_="content", id_="snapin_%s" % name, style=style) refresh_url = "" try: # TODO: Refactor this confusing special case. Add deddicated method or something # to let the snapins make the sidebar know that there is a URL to fetch. url = snapin_instance.show() if url is not None: # Fetch the contents from an external URL. Don't render it on our own. refresh_url = url html.javascript( 'cmk.ajax.get_url("%s", cmk.utils.update_contents, "snapin_%s")' % (refresh_url, name)) except Exception as e: logger.exception("error rendering snapin %s", name) write_snapin_exception(e) html.close_div() html.close_div() return refresh_url
async def error_handler(ctx, error): error = getattr(error, "original", error) if isinstance( error, (commands.MissingPermissions, RuntimeError, discord.Forbidden)): ctx.bot.logger.info( "command raised no bot permissions: %s, author: %s, error: %s", ctx.invoked_with, ctx.author.id, error) return await ctx.send( str(error) if error else "Please double-check the bot's permissions and try again.") if isinstance(error, (checks.NoConfigFailure, paginator.CannotPaginate, commands.CheckFailure)): ctx.bot.logger.info("command raised checks failure: %s, author: %s", ctx.invoked_with, ctx.author.id) return await ctx.send(str(error)) if isinstance(error, (commands.BadArgument, commands.BadUnionArgument)): if str(error): return await ctx.send(str(error)) else: return if isinstance(error, commands.MissingRequiredArgument): ctx.bot.logger.info( "command missing required argument: %s, author: %s", ctx.invoked_with, ctx.author.id) return await ctx.send( f"Oops! That didn't look right... " f"please see how to use the command with `++help {ctx.command.qualified_name}`" ) if isinstance(error, commands.CommandOnCooldown): if await ctx.bot.is_owner(ctx.author): return await ctx.reinvoke() time = formats.readable_time(error.retry_after) ctx.bot.logger.info("command raised cooldown error: %s", ctx.invoked_with) return await ctx.send( f"You're on cooldown. Please try again in: {time}") if isinstance(error, coc.HTTPException): ctx.bot.logger.info("coc api raised %s for command %s", error, ctx.invoked_with) return await ctx.send(f"The COC API returned {error.message}. " f"If this persists, please tag TubaKid!") ctx.command.reset_cooldown(ctx) if isinstance( error, (discord.Forbidden, discord.NotFound, paginator.CannotPaginate)): return e = discord.Embed(title="Command Error", colour=0xcc3366) e.add_field(name="Name", value=ctx.command.qualified_name) e.add_field(name="Author", value=f"{ctx.author} (ID: {ctx.author.id})") fmt = f"Channel: {ctx.channel} (ID: {ctx.channel.id})" if ctx.guild: fmt = f"{fmt}\nGuild: {ctx.guild} (ID: {ctx.guild.id})" e.add_field(name="Location", value=fmt, inline=False) e.add_field(name="Content", value=textwrap.shorten(ctx.message.content, width=512)) exc = "".join( traceback.format_exception(type(error), error, error.__traceback__, chain=False)) ctx.bot.logger.error( f"Unhandled error occurred:\ncommand: {ctx.invoked_with}\nauthor: {ctx.author.id}" ) if len(exc) > 2000: fp = io.BytesIO(exc.encode("utf-8")) e.description = "Traceback was too long." return await ctx.send(embed=e, file=discord.File(fp, "traceback.txt")) e.description = f"```py\n{exc}\n```" e.timestamp = datetime.datetime.utcnow() if not ctx.bot.live: return await ctx.send(embed=e) await ctx.bot.error_webhook.send(embed=e) try: await ctx.send( "Uh oh! Something broke. You might want to tag TubaKid and tell him to get his crap together!" ) except discord.Forbidden: pass
def send_message(self, request): self.log_action = "send" self.log_resource = "message" self.log_context = {} if "file" in request.data: file = request.FILES["file"] data = json.loads(request.data["data"]) username = data["email"] user_two = data["user_two"] subject = data["subject"] msg_text = data["text"] create_date = data["create_date"] else: file = None data = (request.data if request.data else json.loads( request.body.decode("utf-8"))) username = data["email"] user_two = data["user_two"] subject = data["subject"] msg_text = data["text"] create_date = data["create_date"] info = {} if not user_two == "" and not username == "": user = User.objects.get(email=username) user_to = User.objects.get(email=user_two) talks = Conversation.objects.filter( (Q(user_one__email=username) & Q(user_two__email=user_two)) | (Q(user_two__email=username) & Q(user_one__email=user_two))) if talks.count() > 0: talk = talks[0] else: talk = Conversation() talk.user_one = user talk.user_two = user_to talk.save() if subject != "": subject = Subject.objects.get(slug=subject) space = subject.slug space_type = "subject" self.log_context["subject_id"] = subject.id self.log_context["subject_slug"] = space self.log_context["subject_name"] = subject.name else: subject = None space = 0 space_type = "general" message = TalkMessages() message.text = "<p>" + msg_text + "</p>" message.user = user message.talk = talk message.subject = subject if not file is None: message.image = file message.save() self.log_context["talk_id"] = talk.id self.log_context["user_id"] = user_to.id self.log_context["user_name"] = str(user_to) self.log_context["user_email"] = user_two if not message.pk is None: simple_notify = textwrap.shorten(strip_tags(message.text), width=30, placeholder="...") notification = { "type": "chat", "subtype": space_type, "space": space, "user_icon": message.user.image_url, "notify_title": str(message.user), "simple_notify": simple_notify, "view_url": reverse("chat:view_message", args=(message.id, ), kwargs={}), "complete": render_to_string("chat/_message.html", {"talk_msg": message}, request), "container": "chat-" + str(message.user.id), "last_date": _("Last message in %s") % (formats.date_format( message.create_date, "SHORT_DATETIME_FORMAT")), } notification = json.dumps(notification) Group("user-%s" % user_to.id).send({"text": notification}) ChatVisualizations.objects.create(viewed=False, message=message, user=user_to) serializer = ChatSerializer(message) json_r = json.dumps(serializer.data) json_r = json.loads(json_r) info["data"] = {} info["data"]["message_sent"] = json_r info["message"] = _("Message sent successfully!") info["success"] = True info["number"] = 1 sendChatPushNotification(user_to, message) super(ChatViewset, self).createLog( user, self.log_component, self.log_action, self.log_resource, self.log_context, ) else: info["message"] = _("Error while sending message!") info["success"] = False info["number"] = 0 else: info["data"] = {} info["data"]["message_sent"] = {} info["message"] = _("No information received!") info["success"] = False info["number"] = 0 info["data"]["messages"] = [] info["type"] = "" info["title"] = _("Amadeus") info["extra"] = 0 response = json.dumps(info) return HttpResponse(response)
def pack_table(info): return '<table>\n' + "\n".join( '<tr><td align="right" width="90">%s:</td>\n' '<td width="40">%s</td></tr>\n' % (d, textwrap.shorten(str(v), width=30, placeholder="...")) for d, v in info) + "</table>\n"