async def qrcode_api(
request: Request,
*,
text: str,
size: int = 200,
logo: Optional[HostUrl] = None,
encode: ReturnEncode = ReturnEncode.raw,
level: QRCodeLevel = QRCodeLevel.M,
bgcolor: Color = Color("FFFFFF"),
fgcolor: Color = Color("000000"),
fun: str = "qrcode",
):
qr = await QRInfo.new(text,
size=size,
logo=logo,
level=level,
bgcolor=bgcolor,
fgcolor=fgcolor)
qr.url = TempFile.to_url(request, qr.path) # type:ignore
"""function {fun}(){document.write('<img class="qrcode" src="{url}"/>');}"""
return (qr if encode == ReturnEncode.json else Response(
content=qr.json(),
media_type="application/json",
headers={"Location": qr.url},
status_code=302,
) if encode == ReturnEncode.raw else Response(
content="{fun}({json})".format(json=qr.json(), fun=fun),
media_type="text/javascript",
) if encode == ReturnEncode.jsc else Response(
content="function " + fun +
'''(){document.write('<img class="qrcode" src="''' + qr.url +
""""/>');}""",
media_type="text/javascript",
))
async def qrcode_api(
request: Request,
*,
text: str,
size: int = 200,
logo: Optional[HostUrl] = None,
encode: ReturnEncode = ReturnEncode.raw,
level: QRCodeLevel = QRCodeLevel.M,
bgcolor: Color = Color("FFFFFF"),
fgcolor: Color = Color("000000"),
fun: str = "qrcode",
):
qr = await QRInfo.new(
text, size=size, logo=logo, level=level, bgcolor=bgcolor, fgcolor=fgcolor
)
qr.url = ParseResult( # type:ignore
scheme=request.url.scheme,
netloc=request.url.netloc,
path=f"temp/{qr.path.relative_to(TempFile.path)}",
params="",
query="",
fragment="",
).geturl()
return (
qr
if encode == ReturnEncode.json
else Response(headers={"Location": qr.url}, status_code=302)
if encode == ReturnEncode.raw
else Response(content=f"{fun}({qr.json()})", media_type="text/javascript")
)
async def read_color(*,setColor:Color):
return {
"Color":setColor,
"Name":setColor.as_named(),
"Hex":setColor.as_hex(),
"RGB":setColor.as_rgb()
}
async def update_item(*, setColor: Color):
return {
"item color": setColor,
"Name": setColor.as_named(),
"Hex": setColor.as_hex(),
"RGB": setColor.as_rgb_tuple()
}
async def new(
cls,
text: str,
*,
size: conint( # type:ignore
strict=True,
gt=Config["qrcode"]["min-size"].as_number(), # noqa:F821
lt=Config["qrcode"]["max-size"].as_number(), # noqa:F821
) = 200,
logo: Optional[HostUrl] = None,
level: QRCodeLevel = QRCodeLevel.M,
bgcolor: Color = Color("FFFFFF"),
fgcolor: Color = Color("000000"),
):
icon_stream = None
if logo is not None:
async with BaseNetClient() as client:
response = await client.get(
logo, headers={"user-agent": "HibiAPI@GitHub"}, timeout=6)
response.raise_for_status()
icon_stream = BytesIO(response.content)
return cls(
data=text,
logo=logo,
level=level,
size=size,
path=await cls._generate(
text,
size=size,
level=level,
icon_stream=icon_stream,
bgcolor=bgcolor.as_hex(),
fgcolor=fgcolor.as_hex(),
),
)
def set(self, new_value):
if self.type == 'color':
try:
color_val = Color(new_value)
r, g, b = color_val.as_rgb_tuple(alpha=False)
val = (r << 16) + (g << 8) + b
except (ValueError, TypeError):
return f'\u274c Invalid {self.description}. ' \
f'Use `{self.ctx.prefix}csettings {self.setting_key} reset` to reset it to {self.default}.'
elif self.type == 'number':
try:
val = int(new_value)
except (ValueError, TypeError):
return f'\u274c Invalid {self.description}. ' \
f'Use `{self.ctx.prefix}csettings {self.setting_key} reset` to reset it to {self.default}.'
elif self.type == 'boolean':
try:
val = get_positivity(new_value)
except AttributeError:
return f'\u274c Invalid {self.description}.' \
f'Use `{self.ctx.prefix}csettings {self.setting_key} false` to reset it.'
else:
log.warning(f"No setting type for {self.type} found")
return
try:
setattr(self.character.options, self.setting_key, val)
except ValidationError as e:
return f"\u274c Invalid {self.description}: {e!s}.\n" \
f"Use `{self.ctx.prefix}csettings {self.setting_key} reset` to reset it to {self.default}."
return f"\u2705 {self.description.capitalize()} set to {self.display_func(val)}.\n"
class Shape(ABC):
z: float = field(default=None)
c: int = field(default=None)
t: int = field(default=None)
fill_color: Color = field(default=Color((10, 10, 10, 0.1)))
stroke_color: Color = field(default=Color((255, 255, 255, 1.0)))
stroke_width: int = field(default=1)
label: str = field(default=None)
def test_simple(ctx: DepContext):
map_set_paths: MapSetPaths = ctx.get(MapSetPaths)
map_set_io: MapSetIO = ctx.get(MapSetIO)
map_set_cache: MapSetCache = ctx.get(MapSetCache)
map_set_manager: MapSetManager = ctx.get(MapSetManager)
assert map_set_io.get_map_set_uuid_to_name_mapping() == {}
map_set = map_set_manager.create('Test1')
assert map_set.name == 'Test1'
map_set_file = map_set_paths.get_map_set_path(map_set.uuid)
assert isfile(map_set_file)
battle_maps = map_set.get_battle_maps()
assert len(battle_maps) == 1
battle_map_file = map_set_paths.get_battle_map_path(
map_set.uuid, battle_maps[0].uuid)
background_file = map_set_paths.get_background_path(
map_set.uuid, battle_maps[0].uuid)
assert isfile(battle_map_file)
assert not isfile(background_file)
map_set.name = 'Changed1'
battle_maps[0].name = 'Changed2'
battle_maps[0].set_background_image(media_type='image/svg+xml',
image_data=SOME_SVG)
battle_maps[0].process_token_action(
TokenAction(action_type=TokenActionType.Added,
uuid=uuid4(),
token_type=0,
color=Color('Black'),
mark='23',
mark_color=Color('White'),
position=Coordinate(x=17, y=27),
rotation=1.2))
map_set_manager.save(map_set)
assert isfile(background_file)
map_set_cache.delete(map_set)
fresh_map_set = map_set_manager.get_by_uuid(map_set.uuid)
assert fresh_map_set.name == 'Changed1'
fresh_battle_maps = fresh_map_set.get_battle_maps()
assert len(fresh_battle_maps) == 1
assert fresh_battle_maps[0].name == 'Changed2'
assert fresh_battle_maps[0].get_background_image() == SOME_SVG
assert len(fresh_battle_maps[0].tokens)
assert fresh_battle_maps[0].tokens[0].mark == '23'
map_set_manager.delete(fresh_map_set)
assert not isfile(map_set_file)
assert not isfile(battle_map_file)
assert not isfile(background_file)
def get_test_move(data=None):
if data is None:
data = {}
raw_data = {
'action_type': TokenActionType.Added,
'uuid': uuid4(),
'token_type': 17,
'color': Color('Black'),
'mark': '23',
'mark_color': Color('White'),
'position': Coordinate(x=27, y=13),
'rotation': 2.3,
**data
}
return TokenAction(**raw_data)
def test_draw_bg(config):
config.text_fields[0].bg = Color("#ff000066")
config.text_fields[0].padding = fmcardgen.config.PaddingConfig(
horizontal=10, vertical=10
)
im = fmcardgen.draw.draw({"title": "Hello World"}, config)
assert_images_equal(im, Image.open("test_draw_bg_expected.png"))
class StyleCloudRequest(BaseModel):
url: str = Schema(None, description="URL of webpage to extract text")
text: str = Schema(None, description="Source text")
size: int = Schema(512, description="Output width and height in pixels")
icon_name: FontAwesomeIcon = Schema(
"fas fa-grin",
description=
"[Font Awesome](https://fontawesome.com/icons?d=gallery&m=free) icon mask",
alias="icon",
)
palette: Palette = Schema(
"cartocolors.qualitative.Bold_6",
description=
"Color palette to use from [palettable](https://jiffyclub.github.io/palettable/)",
)
background_color: Color = Color("white")
max_font_size: int = 200
max_words: int = Schema(
2000,
description="Maximum number of words to include in the stylecloud",
gt=0)
stopwords: bool = Schema(
True, description="Boolean to filter out common stopwords")
gradient: Gradient = Schema(
"horizontal",
description="Direction of gradient. Set to 'none' to disable gradient.",
)
async def test_bson_encoders_filed_types():
custom = DocumentWithBsonEncodersFiledsTypes(
color="7fffd4", timestamp=datetime.datetime.utcnow())
c = await custom.insert()
c_fromdb = await DocumentWithBsonEncodersFiledsTypes.find_one(
DocumentWithBsonEncodersFiledsTypes.color == Color("7fffd4"))
assert c_fromdb.color.as_hex() == c.color.as_hex()
def test_draw_wrapped(config: CardGenConfig):
config.text_fields[0].font_size = 40
config.text_fields[0].wrap = True
config.text_fields[0].max_width = 400
config.text_fields[0].bg = Color("#00ff0066")
fm = {"title": "This is a longer title that I expect to wrap some."}
im = fmcardgen.draw.draw(fm, config)
assert_images_equal(im, Image.open("test_draw_wrapped.png"))
def test_pretty_color():
c = Color('red')
assert str(c) == 'red'
assert repr(c) == "Color('red', rgb=(255, 0, 0))"
assert list(c.__pretty__(lambda x: f'fmt: {x!r}')) == [
'Color(',
1,
"fmt: 'red'",
',',
0,
'rgb=',
'fmt: (255, 0, 0)',
',',
0,
-1,
')',
]
def test_as_rgb_tuple():
assert Color((1, 2, 3)).as_rgb_tuple(alpha=None) == (1, 2, 3)
assert Color((1, 2, 3, 1)).as_rgb_tuple(alpha=None) == (1, 2, 3)
assert Color((1, 2, 3, 0.3)).as_rgb_tuple(alpha=None) == (1, 2, 3, 0.3)
assert Color((1, 2, 3, 0.3)).as_rgb_tuple(alpha=None) == (1, 2, 3, 0.3)
assert Color((1, 2, 3)).as_rgb_tuple(alpha=False) == (1, 2, 3)
assert Color((1, 2, 3, 0.3)).as_rgb_tuple(alpha=False) == (1, 2, 3)
assert Color((1, 2, 3)).as_rgb_tuple(alpha=True) == (1, 2, 3, 1)
assert Color((1, 2, 3, 0.3)).as_rgb_tuple(alpha=True) == (1, 2, 3, 0.3)
class ConfigDefaults(BaseModel):
font: Union[str, Path] = "default"
font_size: int = 40
fg: Color = Color((0, 0, 0))
bg: Optional[Color] = None
padding: int = 0
class Config:
extra = "forbid"
validate_assignment = True
def test_as_hsl_tuple():
c = Color('016997')
h, s, l, a = c.as_hsl_tuple(alpha=True)
assert almost_equal_floats(h, 0.551, delta=0.01)
assert almost_equal_floats(s, 0.986, delta=0.01)
assert almost_equal_floats(l, 0.298, delta=0.01)
assert a == 1
assert c.as_hsl_tuple(alpha=False) == c.as_hsl_tuple(alpha=None) == (h, s, l)
c = Color((3, 40, 50, 0.5))
hsla = c.as_hsl_tuple(alpha=None)
assert len(hsla) == 4
assert hsla[3] == 0.5
def test_as_hex():
assert Color((1, 2, 3)).as_hex() == '#010203'
assert Color((119, 119, 119)).as_hex() == '#777'
assert Color((119, 0, 238)).as_hex() == '#70e'
assert Color('B0B').as_hex() == '#b0b'
assert Color((1, 2, 3, 0.123456)).as_hex() == '#0102031f'
assert Color((1, 2, 3, 0.1)).as_hex() == '#0102031a'
def test_as_named():
assert Color((0, 255, 255)).as_named() == 'cyan'
assert Color('#808000').as_named() == 'olive'
assert Color('hsl(180, 100%, 50%)').as_named() == 'cyan'
assert Color((240, 248, 255)).as_named() == 'aliceblue'
with pytest.raises(ValueError) as exc_info:
Color((1, 2, 3)).as_named()
assert exc_info.value.args[0] == 'no named color found, use fallback=True, as_hex() or as_rgb()'
assert Color((1, 2, 3)).as_named(fallback=True) == '#010203'
assert Color((1, 2, 3, 0.1)).as_named(fallback=True) == '#0102031a'
def to_pil_color(color: Color) -> PILColorTuple:
"""
Convert a pydantic Color to a PIL color 4-tuple
Color.as_rgb_tuple() _almost_ works, but it returns the alpha channel as
a float between 0 and 1, and PIL expects an int 0-255
"""
# cast() business is a mypy workaround for
# https://github.com/python/mypy/issues/1178
c = color.as_rgb_tuple()
if len(c) == 3:
return cast(Tuple[int, int, int], c)
else:
r, g, b, a = cast(Tuple[int, int, int, float], c)
return r, g, b, round(a * 255)
def read_quotes(
db: Session = Depends(get_db),
skip: int = 0,
limit: int = 100,
anywhere: str = None,
title: str = None,
author: str = None,
text: str = None,
quote_type: str = None,
description: str = None,
color: Color = None,
tag_ids: List[int] = None,
current_user: DBUser = Depends(get_current_active_user),
):
"""
Retrieve quotes.
"""
tags = []
if tag_ids:
for each_tag in tag_ids:
tag = crud.tag.get(db_session=db, id=each_tag)
if not tag:
raise HTTPException(status_code=404, detail="Tag not found")
tags.append(tag)
search: QuoteSearch = QuoteSearch(anywhere=anywhere,
title=title,
author=author,
text=text,
quote_type=quote_type,
description=description,
color=color.as_hex() if color else None,
tags=tags)
if crud.user.is_superuser(current_user):
quotes = crud.quote.get_multi_by_search(db,
search=search,
skip=skip,
limit=limit)
else:
quotes = crud.quote.get_multi_by_search_owner(db_session=db,
owner_id=current_user.id,
search=search,
skip=skip,
limit=limit)
return quotes
def test_model_validation():
class Model(BaseModel):
color: Color
assert Model(color='red').color.as_hex() == '#f00'
assert Model(color=Color('red')).color.as_hex() == '#f00'
with pytest.raises(ValidationError) as exc_info:
Model(color='snot')
assert exc_info.value.errors() == [{
'loc': ('color', ),
'msg':
'value is not a valid color: string not recognised as a valid color',
'type': 'value_error.color',
'ctx': {
'reason': 'string not recognised as a valid color'
},
}]
from pydantic.json import pydantic_encoder, timedelta_isoformat
from pydantic.types import DirectoryPath, FilePath, SecretBytes, SecretStr
class MyEnum(Enum):
foo = 'bar'
snap = 'crackle'
@pytest.mark.parametrize(
'input,output',
[
(UUID('ebcdab58-6eb8-46fb-a190-d07a33e9eac8'),
'"ebcdab58-6eb8-46fb-a190-d07a33e9eac8"'),
(IPv4Address('192.168.0.1'), '"192.168.0.1"'),
(Color('#000'), '"black"'),
(Color((1, 12, 123)), '"#010c7b"'),
(SecretStr('abcd'), '"**********"'),
(SecretStr(''), '""'),
(SecretBytes(b'xyz'), '"**********"'),
(SecretBytes(b''), '""'),
(IPv6Address('::1:0:1'), '"::1:0:1"'),
(IPv4Interface('192.168.0.0/24'), '"192.168.0.0/24"'),
(IPv6Interface('2001:db00::/120'), '"2001:db00::/120"'),
(IPv4Network('192.168.0.0/24'), '"192.168.0.0/24"'),
(IPv6Network('2001:db00::/120'), '"2001:db00::/120"'),
(datetime.datetime(2032, 1, 1, 1, 1), '"2032-01-01T01:01:00"'),
(datetime.datetime(2032, 1, 1, 1, 1, tzinfo=datetime.timezone.utc),
'"2032-01-01T01:01:00+00:00"'),
(datetime.datetime(2032, 1, 1), '"2032-01-01T00:00:00"'),
(datetime.time(12, 34, 56), '"12:34:56"'),
def test_color_fail(color):
with pytest.raises(ColorError):
Color(color)
def test_color_success(raw_color, as_tuple):
c = Color(raw_color)
assert c.as_rgb_tuple() == as_tuple
assert c.original() == raw_color
def test_str_repr():
assert str(Color('red')) == 'red'
assert repr(Color('red')) == "Color('red', rgb=(255, 0, 0))"
assert str(Color((1, 2, 3))) == '#010203'
assert repr(Color((1, 2, 3))) == "Color('#010203', rgb=(1, 2, 3))"
def test_as_hsl():
assert Color('bad').as_hsl() == 'hsl(260, 43%, 77%)'
assert Color((1, 2, 3, 0.123456)).as_hsl() == 'hsl(210, 50%, 1%, 0.12)'
assert Color('hsl(260, 43%, 77%)').as_hsl() == 'hsl(260, 43%, 77%)'
def test_as_rgb():
assert Color('bad').as_rgb() == 'rgb(187, 170, 221)'
assert Color((1, 2, 3, 0.123456)).as_rgb() == 'rgba(1, 2, 3, 0.12)'
assert Color((1, 2, 3, 0.1)).as_rgb() == 'rgba(1, 2, 3, 0.1)'
def run(self):
logger.info("Validating requirements...") # You may use the logger function to log info
# It is a good practice to verify all the requirements before running the analysis
# This will verify that all the non optional requirements are provided
if len(self.list_unmet_requirements()):
# we can use the logger to report errors
logger.error(f"The following metadata requirements ara not met: {self.list_unmet_requirements()}")
return False # The run method should return False upon unsuccessful execution
logger.info("Finding lines...")
# Lets find some lines in the image using skimage
# If you remember, we did not provide a default value for the line_length. This does not make much sense
# but for the sake of demonstration. You can access the metadata as properties of the analysis (self) input
if not self.input.line_length.value: # We check if the value of the line_length is None
self.input.line_length.value = 50 # and if it is, we give it a value
lines = probabilistic_hough_line(
image=self.input.data['image_with_lines'], # The input image data is accessible through the input.data
threshold=self.get_metadata_values('threshold'), # You may access the metadata like this too
line_length=self.input.line_length.value,
)
# 'lines' is now a list of lines defined by the coordinates ((x1, y1), (x2, y2))
# We may add some rois to the output
shapes = [model.Line(x1=x1, y1=y1, x2=x2, y2=y2, stroke_color=Color('red')) # With some color
for (x1, y1), (x2, y2) in lines]
self.output.append(model.Roi(name='lines',
description='lines found using a progressive probabilistic hough transform',
shapes=shapes))
# We may create a table with the coordinates...
lines_df = DataFrame.from_records([(a, b, c, d) for (a, b), (c, d) in lines],
columns=['x_1', 'y_1', 'x_2', 'y_2'])
# ... and add some very interesting measurements
lines_df['length'] = lines_df.apply(lambda l: distance.euclidean([l.x_1, l.y_1], [l.x_2, l.y_2]), axis=1)
lines_df['angle'] = lines_df.apply(lambda l: atan2(l.x_1 - l.x_2, l.y_1 - l.y_2), axis=1)
# We append the dataframe into the output
self.output.append(model.Table(name='lines_table',
description='Dataframe containing coordinates, length and angle for every line',
table=lines_df))
# Lets extract some statistics...
stats = {'mean_length': lines_df.length.mean(),
'median_length': lines_df.length.median(),
'std_length': lines_df.length.std(),
'mean_angle': lines_df.angle.mean(),
'median_angle': lines_df.angle.median(),
'std_angle': lines_df.angle.std()}
# ... and save them as key-value pairs
self.output.append(model.KeyValues(name='stats',
description='Some basic statistics about the lines found',
key_values=stats))
# And that's about it. Don't forget to return True at the end
return True
from pydantic import BaseModel, ValidationError
from pydantic.color import Color
c = Color('ff00ff')
print(c.as_named())
print(c.as_hex())
c2 = Color('green')
print(c2.as_rgb_tuple())
print(c2.original())
print(repr(Color('hsl(180, 100%, 50%)')))
class Model(BaseModel):
color: Color
print(Model(color='purple'))
try:
Model(color='hello')
except ValidationError as e:
print(e)
