def make_ansimarkup(color):
color = ansimarkup.parse(color)
custom_markup = dict(level=color, lvl=color)
am = ansimarkup.AnsiMarkup(tags=custom_markup, strict=True)
return am
def test_ansi(writer):
logger.start(writer, format="<red>a</red> {message}", colorize=True)
logger.opt(ansi=True).debug("<blue>b</blue>")
logger.opt(ansi=True).log(20, "<y>c</y>")
assert writer.read() == ansimarkup.parse("<red>a</red> <blue>b</blue>\n"
"<red>a</red> <y>c</y>\n")
import os
from pathlib import Path
#import platform
#import pprint
#import psutil
#from psutil._common import bytes2human
#import random
#import re
#import shlex
#import subprocess
import sys
import tarfile
import traceback
user_tags = {
'unknown_device': parse('<red>'),
'regular_file': parse('<green>'),
'directory': parse('<yellow>'),
'symbolic_link': parse('<blue>'),
'hard_link': parse('<magenta>'),
'generic_device': parse('<cyan>'),
'character_device': parse('<bold><green>'),
'block_device': parse('<bold><yellow>'),
'fifo_device': parse('<bold><blue>'),
'file_size': parse('<red>'),
#'regular_file' : parse('<green>'),
#'directory' : parse('<yellow>'),
#'symbolic_link' : parse('<blue>'),
#'hard_link' : parse('<magenta>'),
#'generic_device' : parse('<cyan>'),
#: parse('<white>'),
import functools
import json
from xml.dom.minidom import parseString
import ansimarkup
import colorama
from jinja2 import Environment, PackageLoader
from dicttoxml import dicttoxml
JINJA2_ENV = Environment(loader=PackageLoader("greynoise.cli"))
colorama.init()
ANSI_MARKUP = ansimarkup.AnsiMarkup(
tags={
"header": ansimarkup.parse("<bold>"),
"key": ansimarkup.parse("<blue>"),
"value": ansimarkup.parse("<green>"),
"noise": ansimarkup.parse("<light-yellow>"),
"not-noise": ansimarkup.parse("<dim>"),
"malicious": ansimarkup.parse("<light-red>"),
"unknown": ansimarkup.parse("<dim>"),
"benign": ansimarkup.parse("<light-green>"),
})
def colored_output(function):
"""Decorator that converts ansi markup into ansi escape sequences.
:param function: Function that will return text using ansi markup.
:type function: callable
def test_ansi_with_dynamic_formatter_colorized(writer):
logger.start(writer,
format=lambda r: "<red>{message}</red>",
colorize=True)
logger.opt(ansi=True).debug("<b>a</b> <y>b</y>")
assert writer.read() == ansimarkup.parse("<red><b>a</b> <y>b</y></red>")
#!/usr/bin/env python3
# vim:softtabstop=4:ts=4:sw=4:expandtab:tw=120
from ansimarkup import AnsiMarkup, parse
import csv
import datetime
import operator
import os
from pathlib import Path
import re
import sys
import traceback
_VERBOSE = False
user_tags = {
'error' : parse('<bold><red>'),
'name' : parse('<bold><cyan>'),
'value' : parse('<bold><white>'),
}
am = AnsiMarkup(tags=user_tags)
def _assert_msg(msg):
return am.ansistring(f'<error>{msg}</error>')
def _print_name_value(name, max_name_len, value, prefix=None, postfix=None):
prefix = prefix if prefix is not None else ''
postfix = postfix if postfix is not None else ''
lh = am.ansistring(f'<name>{name}</name>')
rh = am.ansistring(f'<value>{value}</value>')
print(f'{prefix}{lh:{max_name_len + lh.delta}} {rh}{postfix}')
#!/usr/bin/env python3
# vim: awa:sts=4:ts=4:sw=4:et:cin:fdm=manual:tw=120:ft=python
# autowriteall, softtabstop, tabstop, shiftwidth, expandtab, cindent, foldmethod, textwidth, filetype
from ansimarkup import AnsiMarkup, parse
import argparse
import os
import pathlib
import regex
import sqlite3
import sys
import traceback
user_tags = {
'info': parse('<bold><green>'), # bold green
'lowinfo': parse('<green>'), # green
'error': parse('<bold><red>'), # bold red
'warn': parse('<bold><yellow>'), # bold yellow
}
am = AnsiMarkup(tags=user_tags)
_VERBOSE = 0
_SQL_SCHEMA = '''
CREATE TABLE IF NOT EXISTS fortunes (
id INTEGER PRIMARY KEY,
quote TEXT,
author TEXT,
subject_id INTEGER
);
def test_ansi_with_args(writer):
logger.start(writer, format="=> {message} <=", colorize=True)
logger.opt(ansi=True).debug("the {0}test{end}", "<red>", end="</red>")
assert writer.read() == ansimarkup.parse("=> the <red>test</red> <=\n")
from app_settings import app_settings
import argparse
import datetime
import json
import os
from pathlib import Path
import requests
import shlex
import shutil
import subprocess
import sys
import tarfile
import traceback
user_tags = {
'info' : parse('<bold><green>'), # bold green
'error' : parse('<bold><red>'), # bold red
'mail' : parse('<blink><red>'), # bliink red
'label' : parse('<bold><cyan>'), # bold cyan
'value' : parse('<reset>'), # white
'sysinfo' : parse('<bold><yellow>'), # bold yellow
'quote' : parse('<bold><cyan>'), # bold cyan
'location' : parse('<bold><cyan>'), # bold cyan
'weather' : parse('<reset>'), # white
'greeting' : parse('<bold><green>'), # bold green
'loginout' : parse('<bold><green>'), # bold green
'apt' : parse('<bold><yellow>'), # bold yellow
'reboot' : parse('<bold><red>'), # bold red
}
am = AnsiMarkup(tags=user_tags)
_COMMANDS_SHOW = 'show'
_COMMANDS_CREATE = 'create'
_COMMANDS_ADD = 'add'
_COMMANDS_UPDATE = 'update'
_WEEKDAYS = [
'Monday',
'Tuesday',
'Wednesday',
'Thursday',
'Friday',
'Saturday',
'Sunday',
]
user_tags = {
'info': parse('<bold><green>'),
'error': parse('<bold><red>'),
'text': parse('<bold><white>'),
'output': parse('<bold><cyan>'),
'arg': parse('<bold><yellow>'),
}
am = AnsiMarkup(tags=user_tags)
def _print_info(msg):
if _VERBOSE_OUTPUT:
am.ansiprint(f'<info>INFO:</info> <text>{msg}</text>')
def _print_error(msg):
from ansimarkup import AnsiMarkup, parse
import argparse
import ipaddress
import os
import psutil
import re
import shlex
import socket
import subprocess
import sys
import traceback
import location_info
user_tags = {
'info': parse('<bold><green>'), # bold green
'error': parse('<bold><red>'), # bold red
'label': parse('<bold><cyan>'), # bold cyan
'value': parse('<light-blue>'), # magenta
}
am = AnsiMarkup(tags=user_tags)
_VERBOSE = False
def _verbose_print(msg):
if _VERBOSE:
am.ansiprint(f'<info>INFO: {msg}</info>', file=sys.stdout)
def format(self, record):
record.levelname = parse(
ColorFormatter.ANSI_PALETTE[record.levelname].format(
record.levelname))
return parse(super().format(record))
# vim:softtabstop=4:ts=4:sw=4:expandtab:tw=120:ft=python
from ansimarkup import AnsiMarkup, parse
import argparse
import json
import os
from pymediainfo import MediaInfo
from pathlib import Path
import shlex
import shutil
import subprocess
import sys
import traceback
user_tags = {
'info': parse('<bold><cyan>'),
'text': parse('<bold><white>'),
'error': parse('<bold><red>'),
'status': parse('<bold><green>'),
}
am = AnsiMarkup(tags=user_tags)
_COUNTER_WIDTH = 2
_VERBOSE = False
_EXTENSIONS = [
'.webm', '.mpg', '.mp2', '.mpeg', '.mpe', '.mpv', '.ogg', '.mp4', '.m4p',
'.m4v', '.avi', '.wmv', '.mov', '.qt', '.flv', '.swf', '.avchd', '.mkv'
]
def test_ansi_dont_color_unrelated(writer):
logger.start(writer, format="{message} {extra[trap]}", colorize=True)
logger.bind(trap="<red>B</red>").opt(ansi=True).debug("<red>A</red>")
assert writer.read(
) == ansimarkup.parse("<red>A</red>") + " <red>B</red>\n"
#!/usr/bin/env python3
# vim: awa:sts=4:ts=4:sw=4:et:cin:fdm=manual:tw=120:ft=python
# autowriteall, softtabstop, tabstop, shiftwidth, expandtab, cindent, foldmethod, textwidth, filetype
from ansimarkup import AnsiMarkup, parse
import argparse
import os
from pathlib import Path
import sys
import traceback
from app_settings import app_settings
user_tags = {
'title' : parse('<bold><green>'), # bold green
'text' : parse('<bold><white>'), # bold white
'alttext' : parse('<white>'), # white
'name' : parse('<bold><cyan>'), # bold cyan
'altname' : parse('<cyan>'), # cyan
'error' : parse('<bold><red>'), # bold red
}
am = AnsiMarkup(tags=user_tags)
def _parse_args():
parser = argparse.ArgumentParser(description='Manage all aspects of keeping icons up-to-date with macOS')
parser.add_argument('-v', '--verbose', action='count', default=0, help='increase output verbosity')
parser.add_argument_group('install', help='Install icon manager by querying all the installed apps and setting up ' \
'a dictionary with the application name and the custom icon. If an icon ' \
?!?jedi=10, 'named "Icon$'\r'" we will use this as some value or key')?!? (*name_or_flags: Text, action: Union[Text, Type[Action]]=..., nargs: Union[int, Text]=..., const: Any=..., default: Any=..., type: Union[Callable[[Text], _T], Callable[[str], _T], FileType]=..., choices: Iterable[_T]=..., required: bool=..., help: Optional[Text]=..., metavar: Optional[Union[Text, Tuple[Text, ...]]]=..., dest: Optional[Text]=..., version: Text=..., *_***kwargs: Any*_*) ?!?jedi?!?' " ' '" '
parser.add_argument('-c', '--command', choice=['create-mappings', 'update-mappings', 'apply-changes-mappings', 'remove_mappings'
def test_ansi_nested(writer):
logger.start(writer, format="(<red>[{message}]</red>)", colorize=True)
logger.opt(ansi=True).debug("A<green>B</green>C<blue>D</blue>E")
assert writer.read() == ansimarkup.parse(
"(<red>[A<green>B</green>C<blue>D</blue>E]</red>)\n")
(lambda r: r["level"] == "DEBUG", True),
(lambda r: r["level"].no != 10, False),
],
)
def test_filter(filter, should_output, writer):
message = "Test Filter"
logger.add(writer, filter=filter, format="{message}")
logger.debug(message)
assert writer.read() == (message + "\n") * should_output
@pytest.mark.parametrize(
"message, format, expected, colorize",
[
("a", "<red>{message}</red>", "a\n", False),
("b", "<red>{message}</red>", ansimarkup.parse("<red>b</red>\n"),
True),
("c", lambda _: "<red>{message}</red>", "c", False),
("d", lambda _: "<red>{message}</red>",
ansimarkup.parse("<red>d</red>"), True),
("<red>nope</red>", "{message}", "<red>nope</red>\n", True),
],
)
def test_colorize(message, format, expected, colorize, writer):
logger.add(writer, format=format, colorize=colorize)
logger.debug(message)
assert writer.read() == expected
@pytest.mark.parametrize("colorize", [True, False, None])
@pytest.mark.parametrize("tty", [True, False])
def test_ansi_with_level(writer):
logger.start(writer, format="{message}", colorize=True)
logger.level("DEBUG", color="<green>")
logger.opt(ansi=True).debug("a <level>level</level> b")
assert writer.read() == ansimarkup.parse("a <green>level</green> b\n")
import pytest
import ansimarkup
from loguru import logger
am = ansimarkup.AnsiMarkup(tags={"empty": ansimarkup.parse("")})
def test_log_int_level(writer):
logger.add(writer,
format="{level.name} -> {level.no} -> {message}",
colorize=False)
logger.log(10, "test")
assert writer.read() == "Level 10 -> 10 -> test\n"
def test_log_str_level(writer):
logger.add(writer,
format="{level.name} -> {level.no} -> {message}",
colorize=False)
logger.log("DEBUG", "test")
assert writer.read() == "DEBUG -> 10 -> test\n"
def test_add_level(writer):
name = "L3V3L"
icon = "[o]"
level = 10
logger.level(name, level, color="<red>", icon=icon)
def test_raw_with_ansi_colorized(writer):
logger.start(writer, format="XYZ", colorize=True)
logger.opt(raw=True,
ansi=True).info("Raw <red>colors</red> and <lvl>level</lvl>")
assert writer.read() == ansimarkup.parse(
"Raw <red>colors</red> and <b>level</b>")
from enum import IntEnum
import os
import sys
import traceback
class OutputType(IntEnum):
NONE = 0
INFO = 1
LOWINFO = 2
DEBUG = 3
WARN = 4
ERROR = 5
ASSERT = 6
user_tags = {
OutputType.NONE.name : parse('<bold><white>'), # bold white
OutputType.INFO.name : parse('<bold><green>'), # bold green
OutputType.LOWINFO.name : parse('<bold><cyan>'), # bold cyan
OutputType.DEBUG.name : parse('<bold><blue>'), # bold blue
OutputType.WARN.name : parse('<bold><yellow>'), # bold yellow
OutputType.ERROR.name : parse('<bold><red>'), # bold red
OutputType.ASSERT.name : parse('<bold><magenta>'), # bold magenta
}
am = AnsiMarkup(tags=user_tags)
class AppSettings(UserDict):
def __init__(self):
UserDict.__init__(self)
def __getattr__(self, name):
