mirror
/
pimoroni-pico
kopia lustrzana https://github.com/pimoroni/pimoroni-pico
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność

CI: More complete Python linting

pull/291/head
Phil Howard 2022-03-11 12:20:27 +00:00
rodzic b7061b9dd7
commit dece2aac85
4 zmienionych plików z 134 dodań i 139 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

35
.github/workflows/python.yml vendored
Wyświetl plik

@ -6,30 +6,25 @@ on:
jobs: jobs:
build: build:
name: ${{matrix.name}} name: Python Linting
strategy: runs-on: ubuntu-20.04
matrix:
include:
- os: ubuntu-20.04
name: Linux
cache-key: linux
apt-packages: python3 python3-pip
python-packages: flake8
runs-on: ${{matrix.os}}
steps: steps:
- uses: actions/checkout@v2 - uses: actions/checkout@v2
# Linux deps
- name: Install deps
if: runner.os == 'Linux'
run: |
sudo apt update && sudo apt install ${{matrix.apt-packages}}
- name: Install Python Deps - name: Install Python Deps
run: python3 -m pip install ${{matrix.python-packages}} run: python3 -m pip install flake8
- name: Lint - name: Lint micropython/modules_py
shell: bash shell: bash
run: | run: |
python3 -m flake8 --ignore E501 micropython/modules_py micropython/examples python3 -m flake8 --ignore E501 micropython/modules_py
- name: Lint micropython/examples
shell: bash
run: |
python3 -m flake8 --ignore E501 micropython/examples
- name: Lint .py tools in C++ examples
shell: bash
run: |
python3 -m flake8 --ignore E501 examples

221
examples/badger2040/hershey_font_converter/convert.py
Wyświetl plik

@ -3,156 +3,157 @@
# converts Hershey fonts into a format easier to consume by the Badger2040 # converts Hershey fonts into a format easier to consume by the Badger2040
# e-ink badge library - the result can be piped directly into a .hpp file. # e-ink badge library - the result can be piped directly into a .hpp file.
import argparse, sys, os, glob import argparse
from pathlib import Path from pathlib import Path
parser = argparse.ArgumentParser( parser = argparse.ArgumentParser(
description='Converts Hershey fonts into the format used by Badger2040.') description="Converts Hershey fonts into the format used by Badger2040."
parser.add_argument('file', nargs="+", help='input files to convert') )
parser.add_argument("file", nargs="+", help="input files to convert")
options = parser.parse_args()
options = None
try:
options = parser.parse_args()
except:
parser.print_help()
sys.exit(0)
def convert_font(data): def convert_font(data):
# parse hershey font data file, the file format contains one record per # parse hershey font data file, the file format contains one record per
# character with the format: # character with the format:
# #
# 2761 8MXP[OZPYQZQ[P]N_ # 2761 8MXP[OZPYQZQ[P]N_
# #
# first 5 characters: represent the character id (or a dummy value # first 5 characters: represent the character id (or a dummy value
# of 12345). if it is a character id then a separate file contains the # of 12345). if it is a character id then a separate file contains the
# mapping information to convert that into an ascii table entry. if all of # mapping information to convert that into an ascii table entry. if all of
# the ids are 12345 then it seems that the files contain 95 entries that # the ids are 12345 then it seems that the files contain 95 entries that
# start from ascii character 32 (space) in order # start from ascii character 32 (space) in order
# #
# next 3 characters: number of vertices (including special left/right # next 3 characters: number of vertices (including special left/right
# bounds value) # bounds value)
# #
# next 2 characters: represent the "left" and "right" offsets for this # next 2 characters: represent the "left" and "right" offsets for this
# character, to convert you must subtract 'R' from them. this pair counts # character, to convert you must subtract 'R' from them. this pair counts
# as the first "vertex" # as the first "vertex"
# #
# subsequent pairs of characters: represent each vertex, as before converted # subsequent pairs of characters: represent each vertex, as before converted
# into numbers by subtracting 'R'. there are vertex count (-1) of these # into numbers by subtracting 'R'. there are vertex count (-1) of these
# #
# note! within the vertex data can be extra newline characters which must # note! within the vertex data can be extra newline characters which must
# be ignored. # be ignored.
vertex_data = [] vertex_data = []
char_data = {} char_data = {}
auto_char_code = 0 auto_char_code = 0
# we'll loop, extracting one character per iteration, until all of the # we'll loop, extracting one character per iteration, until all of the
# data is consumed # data is consumed
while(len(data) > 0): while len(data) > 0:
# extract character id char_code = auto_char_code
char_id = int(data[0:5]) auto_char_code += 1
char_code = auto_char_code # extract vertex count
auto_char_code += 1 vertex_count = int(data[5:8])
vertex_count -= 1 # remove one for the bounds data
# extract vertex count # extract bounds
vertex_count = int(data[5:8]) left = ord(data[8:9]) - ord("R")
vertex_count -= 1 # remove one for the bounds data right = ord(data[9:10]) - ord("R")
# extract bounds char_data[char_code] = {
left = ord(data[8:9]) - ord("R") "width": right - left,
right = ord(data[9:10]) - ord("R") "vertex_count": vertex_count,
"first_vertex_offset": len(vertex_data),
}
char_data[char_code] = { # work out expected total length of character data
"width": right - left, char_data_len = 10 + (vertex_count * 2)
"vertex_count": vertex_count,
"first_vertex_offset": len(vertex_data)
}
# work out expected total length of character data # if there are any newlines within this data then remove them before we
char_data_len = 10 + (vertex_count * 2) # move on the parse the vertices
while data.find("\n", char_data_len) != -1:
data = data.replace("\n", "", 1)
# if there are any newlines within this data then remove them before we for i in range(0, vertex_count):
# move on the parse the vertices offset = 10 + (i * 2)
while data.find('\n', char_data_len) != -1: if data[offset:offset + 2] == " R":
data = data.replace('\n', '', 1) # pen up for one
x = -128
y = -128
else:
x = ord(data[offset + 0:offset + 1]) - ord("R") - left
y = ord(data[offset + 1:offset + 2]) - ord("R")
for i in range(0, vertex_count): vertex_data.append(str(x))
offset = 10 + (i * 2) vertex_data.append(str(y))
if data[offset:offset + 2] == " R":
# pen up for one
x = -128
y = -128
else:
x = ord(data[offset + 0:offset + 1]) - ord("R") - left
y = ord(data[offset + 1:offset + 2]) - ord("R")
vertex_data.append(str(x)) data = data[char_data_len:]
vertex_data.append(str(y))
data = data[char_data_len:] font_name = Path(input_filename).stem
font_name = Path(input_filename).stem # create code for all of the vertices
vertex_code = """\
# create code for all of the vertices
vertex_code = '''\
static const int8_t {font_name}_vertices[{count}] = {{ static const int8_t {font_name}_vertices[{count}] = {{
{vertices} {vertices}
}}; }};
'''.format(font_name=font_name, count=len(vertex_data), vertices=", ".join(vertex_data)) """.format(
font_name=font_name, count=len(vertex_data), vertices=", ".join(vertex_data)
)
# create code for chars and font # create code for chars and font
# #
# struct hershey_font_glyph_t { # struct hershey_font_glyph_t {
# uint32_t width; // character width # uint32_t width; // character width
# uint32_t vertex_count; // number of vertices # uint32_t vertex_count; // number of vertices
# int8_t *vertices; // vertex data (indices: even = x, odd = y) # int8_t *vertices; // vertex data (indices: even = x, odd = y)
# }; # };
chars = [] chars = []
for i in range(0, 95): for i in range(0, 95):
if i in char_data: if i in char_data:
chars.append( chars.append(
" {{.width={width}, .vertex_count={vertex_count}, .vertices=&{font_name}_vertices[{offset}]}}".format( " {{.width={width}, .vertex_count={vertex_count}, .vertices=&{font_name}_vertices[{offset}]}}".format(
width=char_data[i]["width"], width=char_data[i]["width"],
vertex_count=char_data[i]["vertex_count"], vertex_count=char_data[i]["vertex_count"],
font_name=font_name, font_name=font_name,
offset=char_data[i]["first_vertex_offset"] offset=char_data[i]["first_vertex_offset"],
)) )
else: )
chars.append(" {.width=0, .vertex_count=0, .vertices=nullptr}") else:
chars.append(" {.width=0, .vertex_count=0, .vertices=nullptr}")
# struct hershey_font_t { # struct hershey_font_t {
# hershey_font_glyph_t chars[95]; # hershey_font_glyph_t chars[95];
# }; # };
font_code = '''\ font_code = """\
static const hershey_font_t {font_name} {{ static const hershey_font_t {font_name} {{
.chars = {{ .chars = {{
{chars} {chars}
}} }}
}}; }};
'''.format(font_name=font_name, chars=",\n".join(chars)) """.format(
font_name=font_name, chars=",\n".join(chars)
)
print(vertex_code) print(vertex_code)
print(font_code) print(font_code)
return """ {{ \"{font_name}\", &{font_name} }}""".format(font_name=font_name) return """ {{ \"{font_name}\", &{font_name} }}""".format(font_name=font_name)
# create map of font name to font structure # create map of font name to font structure
font_list = [] font_list = []
for input_filename in options.file: for input_filename in options.file:
input_file = open(input_filename, mode='r') input_file = open(input_filename, mode="r")
data = input_file.read() data = input_file.read()
input_file.close() input_file.close()
font_list.append(convert_font(data)) font_list.append(convert_font(data))
map_code = '''\ map_code = """\
std::map<std::string, const hershey_font_t*> fonts = {{ std::map<std::string, const hershey_font_t*> fonts = {{
{font_list} {font_list}
}}; }};
'''.format(font_list=",\n".join(font_list)) """.format(
font_list=",\n".join(font_list)
)
print(map_code) print(map_code)

12
examples/badger2040/image_converter/convert.py
Wyświetl plik

@ -23,13 +23,13 @@ options = parser.parse_args()
def convert_image(img): def convert_image(img):
if options.resize: if options.resize:
img = img.resize((296, 128)) # resize img = img.resize((296, 128)) # resize
try: try:
enhancer = ImageEnhance.Contrast(img) enhancer = ImageEnhance.Contrast(img)
img = enhancer.enhance(2.0) img = enhancer.enhance(2.0)
except ValueError: except ValueError:
pass pass
img = img.convert("1") # convert to black and white img = img.convert("1") # convert to black and white
return img return img
@ -68,5 +68,3 @@ static const uint8_t {image_name}[{count}] = {{
'''.format(image_name=image_name, count=len(output_data), byte_data=", ".join(str(b) for b in output_data)) '''.format(image_name=image_name, count=len(output_data), byte_data=", ".join(str(b) for b in output_data))
print(image_code) print(image_code)

5
examples/badger2040/image_converter/data_to_py.py
Wyświetl plik

@ -85,9 +85,10 @@ STR02 = """_mvdata = memoryview(_data)
def data(): def data():
return _mvdata return _mvdata
""" """
def write_func(stream, name, arg): def write_func(stream, name, arg):
stream.write('def {}():\n return {}\n\n'.format(name, arg)) stream.write('def {}():\n return {}\n\n'.format(name, arg))
@ -123,6 +124,7 @@ def quit(msg):
print(msg) print(msg)
sys.exit(1) sys.exit(1)
DESC = """data_to_py.py DESC = """data_to_py.py
Utility to convert an arbitrary binary file to Python source. Utility to convert an arbitrary binary file to Python source.
Sample usage: Sample usage:
@ -137,7 +139,6 @@ if __name__ == "__main__":
parser.add_argument('outfile', type=str, parser.add_argument('outfile', type=str,
help='Path and name of output file. Must have .py extension.') help='Path and name of output file. Must have .py extension.')
args = parser.parse_args() args = parser.parse_args()
if not os.path.isfile(args.infile): if not os.path.isfile(args.infile):