Author SHA1 Message Date
ari 14ba20be55 - better repr for curves and colors 2019-01-23 22:12:14 -05:00
ari 18938d91ea - better names for commands 2019-01-23 22:11:58 -05:00
ari eb38854076 updated gitinore 2019-01-23 22:11:46 -05:00
ari 671ae5bc4a running tests before every pip deploy 2019-01-23 22:10:51 -05:00
ari 844408c6e3 - ensured that all tests are working
- added a main test script
2019-01-23 22:06:12 -05:00
ari bab104885f - fixed caching error when running the interpreter multiple times on items with xobjects 2019-01-23 15:56:46 -05:00
ari 98f18c3e32 - corrected caching error
- added lorem ipsum pdf test docs
- introduced a new test for detecting if some unwanted caching is occuring
- muting "Unsupported" warning
2019-01-23 15:56:25 -05:00
ari ac2c462561 - improved html converter 2019-01-22 13:16:46 -05:00
ari 19712f1f0f cleaner html converter 2019-01-22 13:16:17 -05:00
24 changed files with 262 additions and 250 deletions

No files matched your search

+1
View File
@@ -10,4 +10,5 @@ tests/*.txt
.idea/ .idea/
.vscode .vscode
tests/samples/output tests/samples/output
samples
**__pycache** **__pycache**
+1 -1
View File
@@ -1 +1 @@
v1.3.4 v1.3.6
+12 -7
View File
@@ -6,13 +6,18 @@ cd ..
./bin/clean.sh ./bin/clean.sh
python setup.py sdist bdist_wheel
git add . if ./bin/run_tests.sh; then
git commit python setup.py sdist bdist_wheel
git push
git tag $(cat .version) git add .
git push -u origin $(cat .version) git commit
git push
twine upload dist/* git tag $(cat .version)
git push -u origin $(cat .version)
twine upload dist/*
else
echo ">>> Stopped due to test failure!"
fi
+13
View File
@@ -0,0 +1,13 @@
#!/bin/bash
# Get working dir (this will make sure that the script will work the same anywhere you run it)
WK_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
cd $WK_DIR
cd ..
for filename in ./tests/test*.py; do
if python $filename ; then
echo woohoo
else
exit 1
fi
done
+1 -1
View File
@@ -97,7 +97,7 @@ OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
""" """
__version__ = (1, 3, 4) __version__ = (1, 3, 6)
if __name__ == '__main__': if __name__ == '__main__':
print( print(
+2 -2
View File
@@ -27,9 +27,9 @@ def convert_file(
): ):
if output_file is None: if output_file is None:
output_file = os.path.join( output_file = os.path.join(
os.path.dirname(input_file.name), os.path.dirname(input_file),
os.path.basename( os.path.basename(
re.sub(r"\.\w+$", "."+out_type, input_file.name) re.sub(r"\.\w+$", "."+out_type, input_file)
) )
) )
if re.search(re.escape(out_type) + r'$', output_file ) is None: if re.search(re.escape(out_type) + r'$', output_file ) is None:
+38 -101
View File
@@ -5,6 +5,8 @@ from ..interpreter import LTImage, LTTextBlock, LTCharBlock, LTChar, LTCurve, LT
from ..interpreter.commands import LTItem from ..interpreter.commands import LTItem
from ..interpreter.commands.state import CurvePath, PDFColor from ..interpreter.commands.state import CurvePath, PDFColor
INF = (1<<31) - 1
def convert_to_html( def convert_to_html(
input_file_path: str, input_file_path: str,
output_file_path: str, output_file_path: str,
@@ -79,33 +81,33 @@ def render_page(html: HTMLMaker, ltpage: PageInterpreter):
}): }):
html.write(item.get_text()) html.write(item.get_text())
elif isinstance(item, LTTextBlock): elif isinstance(item, LTTextBlock):
for char in item: with html.elm('span', {'class': 'text-block'}):
render(char) for char in item:
render(char)
elif isinstance(item, LTCharBlock): elif isinstance(item, LTCharBlock):
with html.elm('span', {'class': 'char-block'}): with html.elm('span', { 'class': 'char-block' }, {
with html.elm('p', { 'class': 'text-block' }, { 'position': 'absolute',
'position': 'absolute', 'left': f'{item.x0}',
'left': f'{item.x0}', 'bottom': f'{item.y0}',
'bottom': f'{item.y0}', 'font-size': f'{item.size}px',
'font-size': f'{item.size}px', 'font-family': item.fontname,
'font-family': item.fontname, 'font-weight': item.font.font_weight,
'font-weight': item.font.font_weight, 'color': get_color(item.color, default="black"),
'color': get_color(item.color, default="black"), 'width': str(item.width) + "px",
'width': str(item.width) + "px", 'min-width': str(item.width) + "px",
'min-width': str(item.width) + "px", 'max-width': str(item.width) + "px",
'max-width': str(item.width) + "px", 'height': str(item.height) + "px",
'height': str(item.height) + "px", 'min-height': str(item.height) + "px",
'min-height': str(item.height) + "px", 'max-height': str(item.height) + "px",
'max-height': str(item.height) + "px", 'transform': f'skew({item.font.italic_angle}deg, 0deg)',
'transform': f'skew({item.font.italic_angle}deg, 0deg)', 'text-align': 'center',
'text-align': 'center', 'display': 'flex',
'display': 'flex', 'flex-flow': 'row nowrap',
'flex-flow': 'row nowrap', 'justify-content': 'space-between',
'justify-content': 'space-between', # 'padding-left': item.font.leading
# 'padding-left': item.font.leading }):
}): for char in item:
for char in item: render(char)
render(char)
with html.elm('div', { "class": 'page', "id": f"page-{ltpage.page_num}" }, { with html.elm('div', { "class": 'page', "id": f"page-{ltpage.page_num}" }, {
'width': f'{ltpage.width}px', 'width': f'{ltpage.width}px',
@@ -147,7 +149,7 @@ def render_curve(html: HTMLMaker, ltpage: PageInterpreter, item: LTCurve):
'right': f'{item.x1}px', 'right': f'{item.x1}px',
'width': f'{item.width}px', 'width': f'{item.width}px',
'height': f'{item.height}px', 'height': f'{item.height}px',
}) as svg: }):
html.singleton('path', { html.singleton('path', {
"d": path, "d": path,
**path_css **path_css
@@ -156,11 +158,6 @@ def render_curve(html: HTMLMaker, ltpage: PageInterpreter, item: LTCurve):
}) })
def create_svg_path(item: LTCurve): def create_svg_path(item: LTCurve):
css = {
'position': 'absolute',
'left': f'{item.x0}px',
'bottom': f'{item.y0}px',
}
path = "" path = ""
svg_attr = { svg_attr = {
'class': 'curve', 'class': 'curve',
@@ -169,7 +166,7 @@ def create_svg_path(item: LTCurve):
if item.height > 0: if item.height > 0:
dy = 1.0/item.height dy = 1.0/item.height
dx = (item.width/item.height)/(item.x1-item.x0) dx = (item.width/item.height)/max([(item.x1-item.x0),0.01])
svg_attr.update({ svg_attr.update({
"viewBox": "0 0 %s %s" % ( item.width/item.height, 1 ) "viewBox": "0 0 %s %s" % ( item.width/item.height, 1 )
}) })
@@ -215,73 +212,13 @@ def create_svg_path(item: LTCurve):
return path, svg_attr return path, svg_attr
def __render_curve(html: HTMLMaker, ltpage: PageInterpreter, item: LTCurve): # def render_textblock(html: HTMLMaker, ltpage: PageInterpreter, item: LTTextBlock):
css = { # (x0, y0, x1, y1) = (INF, INF, -INF, -INF)
'position': 'absolute',
'left': f'{item.x0}px',
'bottom': f'{item.y0}px',
'top': f'{item.y1}px',
'right': f'{item.x1}px',
'width': f'{item.width}px',
'height': f'{item.height}px',
}
path = ""
svg_attr = {
'class': 'curve',
'z-index': 2
}
path_css = {
} # for c_block in item:
# x0 = min(x0, c_block.x0)
# y0 = min(y0, c_block.y0)
# x1 = max(x1, c_block.x1)
# y1 = max(y1, c_block.y1)
# Compute ViewBox # with html.elm('span')
p_vals = { "x": [], "y": [] }
for p in item.paths:
for pt in p.points:
p_vals['x'].append(pt.x)
p_vals['y'].append(pt.y)
mx_x = max([*p_vals['x'], 1])
mn_x = min([*p_vals['x'], 0])
mx_y = max([*p_vals['y'], 1])
mn_y = min([*p_vals['y'], 0])
if mx_x == mn_x:
mn_x -= 1
if mx_y == mn_y:
mn_y -= 1
dx = 1/( mx_x - mn_x )
dy = (item.height/item.width)/( mx_y - mn_y )
ROUND_VAL = 5
svg_attr.update({
# "viewBox": f"{min(p_vals['x'])} {min(p_vals['y'])} {max(p_vals['x'])} {max(p_vals['y'])}",
"viewBox": f"{round(mn_x*dx, ROUND_VAL)} {round(mn_y*dy, ROUND_VAL)} {round(mx_x*dx , ROUND_VAL)} {round(mx_y*dy, ROUND_VAL)}",
})
# Compute shape
for p in item.paths:
if p.method == CurvePath.METHOD.MOVE_TO:
path += f'M{" ".join( f"{round(dx*pt.x, ROUND_VAL)} {round(dy*pt.y, ROUND_VAL)}" for pt in p.points )} '
elif p.method == CurvePath.METHOD.LINE_TO:
path += f'L{" ".join( f"{round(dx*pt.x, ROUND_VAL)} {round(dy*pt.y, ROUND_VAL)}" for pt in p.points )} '
elif p.method == CurvePath.METHOD.CLOSE_PATH:
path += 'Z'
elif p.method == CurvePath.METHOD.CURVE_BOTH_TO:
path += f'C{" ".join( f"{round(dx*pt.x, ROUND_VAL)} {round(dy*pt.y, ROUND_VAL)}" for pt in p.points )} '
stroke_col = get_color(item.stroke)
fill_col = get_color(item.fill)
if fill_col:
path_css['fill'] = fill_col
if stroke_col:
path_css['stroke'] = stroke_col
with html.elm('svg', svg_attr, css):
html.singleton('path', {
"d": path,
**path_css
}, {
**path_css
})
+4 -2
View File
@@ -50,7 +50,8 @@ class JSONMakerObject:
self.write_prop(key, val) self.write_prop(key, val)
def string(self, key: str, val: str): def string(self, key: str, val: str):
self.write_prop(key, f'"{val}"') val_sant = str(val).replace('"', '\\"')
self.write_prop(key, f'"{val_sant}"')
@contextmanager @contextmanager
def object(self, key: str): def object(self, key: str):
@@ -109,7 +110,8 @@ class JSONMakerArray:
self.write_prop(val) self.write_prop(val)
def string(self, val: str): def string(self, val: str):
self.write_prop(f'"{val}"') val_sant = str(val).replace('"', '\\"')
self.write_prop(f'"{val_sant}"')
@contextmanager @contextmanager
def object(self): def object(self):
+80 -80
View File
@@ -14,42 +14,42 @@ log = get_logger('commands')
# No Support # No Support
# @PDFCommands.add('W','W_a', 'sh', 'ET', 'BX', 'EX' ,'BI', 'ID', 'gs') # @PDFCommands.add('W','W_a', 'sh', 'ET', 'BX', 'EX' ,'BI', 'ID', 'gs')
# def do_no_support(stack: PDFStateStack) -> PDFStateStack: # def do_no_support(stack: PDFStateStack) -> PDFStateStack:
# # log.warning("Unsupported command") # # log.debug("Unsupported command")
# return stack # return stack
# marked content operators # marked content operators
@PDFCommands.add('MP') # @PDFCommands.add('MP')
def do_MP(stack: PDFStateStack, tag) -> PDFStateStack: # def do_MP(stack: PDFStateStack, tag) -> PDFStateStack:
log.warning(f"Unsupported command - do_tag {[tag]}") # log.debug(f"Unsupported command - do_tag {[tag]}")
# self.device.do_tag(tag) # # self.device.do_tag(tag)
return stack # return stack
@PDFCommands.add('DP') # @PDFCommands.add('DP')
def do_DP(stack: PDFStateStack, tag, props=None) -> PDFStateStack: # def do_DP(stack: PDFStateStack, tag, props=None) -> PDFStateStack:
log.warning(f"Unsupported command - do_tag {[tag.name, type(tag), props]}") # log.debug(f"Unsupported command - do_tag {[tag.name, type(tag), props]}")
# self.device.do_tag(tag) # # self.device.do_tag(tag)
return stack # return stack
@PDFCommands.add('BMC') # @PDFCommands.add('BMC')
def do_BMC(stack: PDFStateStack, tag) -> PDFStateStack: # def do_BMC(stack: PDFStateStack, tag) -> PDFStateStack:
log.warning(f"Unsupported command - begin_tag {[tag.name, type(tag)]}") # log.debug(f"Unsupported command - begin_tag {[tag.name, type(tag)]}")
# self.device.begin_tag(tag) # # self.device.begin_tag(tag)
return stack # return stack
@PDFCommands.add('BDC') # @PDFCommands.add('BDC')
def do_BDC(stack: PDFStateStack, tag, props=None) -> PDFStateStack: # def do_BDC(stack: PDFStateStack, tag, props=None) -> PDFStateStack:
log.warning(f"Unsupported command - begin_tag {[tag.name, type(tag), props]}") # log.debug(f"Unsupported command - begin_tag {[tag.name, type(tag), props]}")
# self.device.begin_tag(tag) # # self.device.begin_tag(tag)
return stack # return stack
@PDFCommands.add('EMC') # @PDFCommands.add('EMC')
def do_EMC(stack: PDFStateStack) -> PDFStateStack: # def do_EMC(stack: PDFStateStack) -> PDFStateStack:
# self.device.end_tag(tag) # # self.device.end_tag(tag)
log.warning("Unsupported command - end_tag") # log.debug("Unsupported command - end_tag")
return stack # return stack
@PDFCommands.add('q') @PDFCommands.add('q')
def do_q(stack: PDFStateStack) -> PDFStateStack: def save_state(stack: PDFStateStack) -> PDFStateStack:
stack.gstack.append([ stack.gstack.append([
stack.t_matrix, stack.t_matrix,
stack.text.copy(), stack.text.copy(),
@@ -58,62 +58,62 @@ def do_q(stack: PDFStateStack) -> PDFStateStack:
return stack return stack
@PDFCommands.add('Q') @PDFCommands.add('Q')
def do_Q(stack: PDFStateStack) -> PDFStateStack: def restore_state(stack: PDFStateStack) -> PDFStateStack:
if len(stack.gstack) > 0: if len(stack.gstack) > 0:
stack.t_matrix, stack.text, stack.graphicstate = stack.gstack.pop() stack.t_matrix, stack.text, stack.graphicstate = stack.gstack.pop()
return stack return stack
# concat-matrix # concat-matrix
@PDFCommands.add('cm') @PDFCommands.add('cm')
def do_cm(stack: PDFStateStack, a1, b1, c1, d1, e1, f1) -> PDFStateStack: def concat_transition_matrix(stack: PDFStateStack, a1, b1, c1, d1, e1, f1) -> PDFStateStack:
stack.t_matrix = mult_matrix((a1, b1, c1, d1, e1, f1), stack.t_matrix) stack.t_matrix = mult_matrix((a1, b1, c1, d1, e1, f1), stack.t_matrix)
return stack return stack
# setlinewidth # setlinewidth
@PDFCommands.add('w') @PDFCommands.add('w')
def do_w(stack: PDFStateStack, linewidth) -> PDFStateStack: def set_line_width(stack: PDFStateStack, linewidth) -> PDFStateStack:
stack.graphics.linewidth = linewidth stack.graphics.linewidth = linewidth
return stack return stack
# setlinecap # setlinecap
@PDFCommands.add('J') @PDFCommands.add('J')
def do_J(stack: PDFStateStack, linecap) -> PDFStateStack: def set_linecap(stack: PDFStateStack, linecap) -> PDFStateStack:
stack.graphics.linecap = linecap stack.graphics.linecap = linecap
return stack return stack
# setlinejoin # setlinejoin
@PDFCommands.add('j') @PDFCommands.add('j')
def do_j(stack: PDFStateStack, linejoin) -> PDFStateStack: def set_linejoin(stack: PDFStateStack, linejoin) -> PDFStateStack:
stack.graphics.linejoin = linejoin stack.graphics.linejoin = linejoin
return stack return stack
# setmiterlimit # setmiterlimit
@PDFCommands.add('M') @PDFCommands.add('M')
def do_M(stack: PDFStateStack, miterlimit) -> PDFStateStack: def set_miterlimit(stack: PDFStateStack, miterlimit) -> PDFStateStack:
stack.graphics.miterlimit = miterlimit stack.graphics.miterlimit = miterlimit
return stack return stack
# setdash # setdash
@PDFCommands.add('d') @PDFCommands.add('d')
def do_d(stack: PDFStateStack, dash, phase) -> PDFStateStack: def set_dash(stack: PDFStateStack, dash, phase) -> PDFStateStack:
stack.graphics.dash = (dash, phase) stack.graphics.dash = (dash, phase)
return stack return stack
# setintent # setintent
@PDFCommands.add('ri') @PDFCommands.add('ri')
def do_ri(stack: PDFStateStack, intent) -> PDFStateStack: def set_intent(stack: PDFStateStack, intent) -> PDFStateStack:
stack.graphics.intent = intent stack.graphics.intent = intent
return stack return stack
# setflatness # setflatness
@PDFCommands.add('i') @PDFCommands.add('i')
def do_i(stack: PDFStateStack, flatness) -> PDFStateStack: def set_flatness(stack: PDFStateStack, flatness) -> PDFStateStack:
stack.graphics.flatness = flatness stack.graphics.flatness = flatness
return stack return stack
# moveto # moveto
@PDFCommands.add('m') @PDFCommands.add('m')
def do_m(stack: PDFStateStack, x: float, y: float) -> PDFStateStack: def curve_moveto(stack: PDFStateStack, x: float, y: float) -> PDFStateStack:
stack.curvestacks.append(CurvePath( stack.curvestacks.append(CurvePath(
CurvePath.METHOD.MOVE_TO, CurvePath.METHOD.MOVE_TO,
CurvePoint(stack.t_matrix, x, y) CurvePoint(stack.t_matrix, x, y)
@@ -122,7 +122,7 @@ def do_m(stack: PDFStateStack, x: float, y: float) -> PDFStateStack:
# lineto # lineto
@PDFCommands.add('l') @PDFCommands.add('l')
def do_l(stack: PDFStateStack, x: float, y: float) -> PDFStateStack: def curve_lineto(stack: PDFStateStack, x: float, y: float) -> PDFStateStack:
stack.curvestacks.append(CurvePath( stack.curvestacks.append(CurvePath(
CurvePath.METHOD.LINE_TO, CurvePath.METHOD.LINE_TO,
CurvePoint(stack.t_matrix, x, y) CurvePoint(stack.t_matrix, x, y)
@@ -131,7 +131,7 @@ def do_l(stack: PDFStateStack, x: float, y: float) -> PDFStateStack:
# curveto # curveto
@PDFCommands.add('c') @PDFCommands.add('c')
def do_c(stack: PDFStateStack, def curve_curveto(stack: PDFStateStack,
x1: float, y1: float, x1: float, y1: float,
x2: float, y2: float, x2: float, y2: float,
x3: float, y3: float ) -> PDFStateStack: x3: float, y3: float ) -> PDFStateStack:
@@ -145,7 +145,7 @@ def do_c(stack: PDFStateStack,
# urveto # urveto
@PDFCommands.add('v') @PDFCommands.add('v')
def do_v(stack: PDFStateStack, def curve_urveto(stack: PDFStateStack,
x2: float, y2: float, x2: float, y2: float,
x3: float, y3: float) -> PDFStateStack: x3: float, y3: float) -> PDFStateStack:
stack.curvestacks.append(CurvePath( stack.curvestacks.append(CurvePath(
@@ -157,7 +157,7 @@ def do_v(stack: PDFStateStack,
# rveto # rveto
@PDFCommands.add('y') @PDFCommands.add('y')
def do_y(stack: PDFStateStack, def curve_rveto(stack: PDFStateStack,
x1: float, y1: float, x1: float, y1: float,
x3: float, y3: float) -> PDFStateStack: x3: float, y3: float) -> PDFStateStack:
stack.curvestacks.append(CurvePath( stack.curvestacks.append(CurvePath(
@@ -169,13 +169,13 @@ def do_y(stack: PDFStateStack,
# closepath # closepath
@PDFCommands.add('h') @PDFCommands.add('h')
def do_h(stack: PDFStateStack) -> PDFStateStack: def curve_close(stack: PDFStateStack) -> PDFStateStack:
stack.curvestacks.append(CurvePath(CurvePath.METHOD.CLOSE_PATH)) stack.curvestacks.append(CurvePath(CurvePath.METHOD.CLOSE_PATH))
return stack return stack
# rectangle # rectangle
@PDFCommands.add('re') @PDFCommands.add('re')
def do_re(stack: PDFStateStack, x, y, w, h) -> PDFStateStack: def curve_rect(stack: PDFStateStack, x, y, w, h) -> PDFStateStack:
stack.curvestacks.extend([ stack.curvestacks.extend([
CurvePath(CurvePath.METHOD.MOVE_TO, CurvePoint(stack.t_matrix, x, y) ), CurvePath(CurvePath.METHOD.MOVE_TO, CurvePoint(stack.t_matrix, x, y) ),
CurvePath(CurvePath.METHOD.LINE_TO, CurvePoint(stack.t_matrix, x+w, y) ), CurvePath(CurvePath.METHOD.LINE_TO, CurvePoint(stack.t_matrix, x+w, y) ),
@@ -187,7 +187,7 @@ def do_re(stack: PDFStateStack, x, y, w, h) -> PDFStateStack:
# stroke, fill # stroke, fill
@PDFCommands.add('S', 'f', 'F', 'B') @PDFCommands.add('S', 'f', 'F', 'B')
def do_complete_path(stack: PDFStateStack) -> PDFStateStack: def curve_complete_path(stack: PDFStateStack) -> PDFStateStack:
stack.complete_layout_items.append(make_curve( stack.complete_layout_items.append(make_curve(
stack.t_matrix, stack.t_matrix,
stack.graphics.copy(), stack.graphics.copy(),
@@ -199,7 +199,7 @@ def do_complete_path(stack: PDFStateStack) -> PDFStateStack:
# sroke, fill-even-odd # sroke, fill-even-odd
@PDFCommands.add('f_a', 'B_a') @PDFCommands.add('f_a', 'B_a')
def do_complete_path_evenodd(stack: PDFStateStack) -> PDFStateStack: def curve_complete_path_evenodd(stack: PDFStateStack) -> PDFStateStack:
stack.complete_layout_items.append(make_curve( stack.complete_layout_items.append(make_curve(
stack.t_matrix, stack.t_matrix,
stack.graphics.copy(), stack.graphics.copy(),
@@ -211,7 +211,7 @@ def do_complete_path_evenodd(stack: PDFStateStack) -> PDFStateStack:
# close-and-stroke (do_h, do_S) # close-and-stroke (do_h, do_S)
@PDFCommands.add('s', 'b') @PDFCommands.add('s', 'b')
def do_close_complete(stack: PDFStateStack) -> PDFStateStack: def curve_close_complete(stack: PDFStateStack) -> PDFStateStack:
stack.curvestacks.append(CurvePath( stack.curvestacks.append(CurvePath(
CurvePath.METHOD.CLOSE_PATH CurvePath.METHOD.CLOSE_PATH
)) ))
@@ -226,7 +226,7 @@ def do_close_complete(stack: PDFStateStack) -> PDFStateStack:
# close-fill-and-stroke-even-odd # close-fill-and-stroke-even-odd
@PDFCommands.add('b_a') @PDFCommands.add('b_a')
def do_close_complete_evenodd(stack: PDFStateStack) -> PDFStateStack: def curve_close_complete_evenodd(stack: PDFStateStack) -> PDFStateStack:
stack.curvestacks.append(CurvePath( stack.curvestacks.append(CurvePath(
CurvePath.METHOD.CLOSE_PATH CurvePath.METHOD.CLOSE_PATH
)) ))
@@ -241,14 +241,14 @@ def do_close_complete_evenodd(stack: PDFStateStack) -> PDFStateStack:
# close-only (empty path) # close-only (empty path)
@PDFCommands.add('n') @PDFCommands.add('n')
def do_n(stack: PDFStateStack) -> PDFStateStack: def curve_close_only(stack: PDFStateStack) -> PDFStateStack:
stack.curvestacks = [] stack.curvestacks = []
return stack return stack
# setcolorspace-stroking # setcolorspace-stroking
@PDFCommands.add('CS') @PDFCommands.add('CS')
def do_CS(stack: PDFStateStack, name: str) -> PDFStateStack: def set_stroke_colorspace(stack: PDFStateStack, name: str) -> PDFStateStack:
try: try:
stack.graphics.scolspace = stack.colorspace_map[literal_name(name)] stack.graphics.scolspace = stack.colorspace_map[literal_name(name)]
return stack return stack
@@ -257,7 +257,7 @@ def do_CS(stack: PDFStateStack, name: str) -> PDFStateStack:
# setcolorspace-non-strokine # setcolorspace-non-strokine
@PDFCommands.add('cs') @PDFCommands.add('cs')
def do_cs(stack: PDFStateStack, name: str) -> PDFStateStack: def set_nonstroke_colorspace(stack: PDFStateStack, name: str) -> PDFStateStack:
try: try:
stack.graphics.ncolspace = stack.colorspace_map[literal_name(name)] stack.graphics.ncolspace = stack.colorspace_map[literal_name(name)]
return stack return stack
@@ -266,7 +266,7 @@ def do_cs(stack: PDFStateStack, name: str) -> PDFStateStack:
# setgray-stroking # setgray-stroking
@PDFCommands.add('G') @PDFCommands.add('G')
def do_G(stack: PDFStateStack, gray: float) -> PDFStateStack: def set_stroke_gray(stack: PDFStateStack, gray: float) -> PDFStateStack:
stack.graphics.set_stroke_color( stack.graphics.set_stroke_color(
stack.colorspace_map['DeviceGray'], stack.colorspace_map['DeviceGray'],
gray gray
@@ -275,7 +275,7 @@ def do_G(stack: PDFStateStack, gray: float) -> PDFStateStack:
# setgray-non-stroking # setgray-non-stroking
@PDFCommands.add('g') @PDFCommands.add('g')
def do_g(stack: PDFStateStack, gray: float) -> PDFStateStack: def set_nonstroke_gray(stack: PDFStateStack, gray: float) -> PDFStateStack:
stack.graphics.set_nostroke_color( stack.graphics.set_nostroke_color(
stack.colorspace_map['DeviceGray'], stack.colorspace_map['DeviceGray'],
gray gray
@@ -285,7 +285,7 @@ def do_g(stack: PDFStateStack, gray: float) -> PDFStateStack:
# setrgb-stroking # setrgb-stroking
@PDFCommands.add('RG') @PDFCommands.add('RG')
def do_RG(stack: PDFStateStack, r, g, b) -> PDFStateStack: def set_stroke_rgb(stack: PDFStateStack, r, g, b) -> PDFStateStack:
stack.graphics.set_stroke_color( stack.graphics.set_stroke_color(
stack.colorspace_map['DeviceRGB'], stack.colorspace_map['DeviceRGB'],
round(r*255), round(r*255),
@@ -296,7 +296,7 @@ def do_RG(stack: PDFStateStack, r, g, b) -> PDFStateStack:
# setrgb-non-stroking # setrgb-non-stroking
@PDFCommands.add('rg') @PDFCommands.add('rg')
def do_rg(stack: PDFStateStack, r, g, b) -> PDFStateStack: def set_nonstroke_rgb(stack: PDFStateStack, r, g, b) -> PDFStateStack:
stack.graphics.set_nostroke_color( stack.graphics.set_nostroke_color(
stack.colorspace_map['DeviceRGB'], stack.colorspace_map['DeviceRGB'],
round(r*255), round(r*255),
@@ -307,7 +307,7 @@ def do_rg(stack: PDFStateStack, r, g, b) -> PDFStateStack:
# setcmyk-stroking # setcmyk-stroking
@PDFCommands.add('K') @PDFCommands.add('K')
def do_K(stack: PDFStateStack, c, m, y, k) -> PDFStateStack: def set_stroke_cmyk(stack: PDFStateStack, c, m, y, k) -> PDFStateStack:
stack.graphics.set_stroke_color( stack.graphics.set_stroke_color(
stack.colorspace_map['DeviceCMYK'], stack.colorspace_map['DeviceCMYK'],
c, m, y, k c, m, y, k
@@ -316,7 +316,7 @@ def do_K(stack: PDFStateStack, c, m, y, k) -> PDFStateStack:
# setcmyk-non-stroking # setcmyk-non-stroking
@PDFCommands.add('k') @PDFCommands.add('k')
def do_k(stack: PDFStateStack, c, m, y, k) -> PDFStateStack: def set_nonstroke_cmyk(stack: PDFStateStack, c, m, y, k) -> PDFStateStack:
stack.graphics.set_stroke_color( stack.graphics.set_stroke_color(
stack.colorspace_map['DeviceCMYK'], stack.colorspace_map['DeviceCMYK'],
c, m, y, k c, m, y, k
@@ -324,7 +324,7 @@ def do_k(stack: PDFStateStack, c, m, y, k) -> PDFStateStack:
return stack return stack
@PDFCommands.add('SCN','SC') @PDFCommands.add('SCN','SC')
def do_SCN(stack: PDFStateStack) -> PDFStateStack: def set_stroke_colorspace_custom(stack: PDFStateStack) -> PDFStateStack:
if stack.graphics.scolspace is None: if stack.graphics.scolspace is None:
raise PDFCommands.InvalidOperation('No colorspace specified!') raise PDFCommands.InvalidOperation('No colorspace specified!')
components = stack.pop(stack.graphics.scolspace.ncomponents) components = stack.pop(stack.graphics.scolspace.ncomponents)
@@ -335,7 +335,7 @@ def do_SCN(stack: PDFStateStack) -> PDFStateStack:
return stack return stack
@PDFCommands.add('scn','sc') @PDFCommands.add('scn','sc')
def do_scn(stack: PDFStateStack) -> PDFStateStack: def set_nonstroke_colorspace_custom(stack: PDFStateStack) -> PDFStateStack:
if stack.graphics.ncolspace is None: if stack.graphics.ncolspace is None:
raise PDFCommands.InvalidOperation('No colorspace specified!') raise PDFCommands.InvalidOperation('No colorspace specified!')
components = stack.pop(stack.graphics.ncolspace.ncomponents) components = stack.pop(stack.graphics.ncolspace.ncomponents)
@@ -347,7 +347,7 @@ def do_scn(stack: PDFStateStack) -> PDFStateStack:
# begin-text # begin-text
@PDFCommands.add('BT') @PDFCommands.add('BT')
def do_BT(stack: PDFStateStack) -> PDFStateStack: def begin_text(stack: PDFStateStack) -> PDFStateStack:
stack.text.matrix = MATRIX_IDENTITY stack.text.matrix = MATRIX_IDENTITY
stack.text.linematrix = [0, 0] stack.text.linematrix = [0, 0]
if stack.current_textblock is None: if stack.current_textblock is None:
@@ -357,38 +357,38 @@ def do_BT(stack: PDFStateStack) -> PDFStateStack:
return stack return stack
@PDFCommands.add('ET') @PDFCommands.add('ET')
def do_ET(stack: PDFStateStack) -> PDFStateStack: def end_text(stack: PDFStateStack) -> PDFStateStack:
stack.complete_layout_items.append(stack.current_textblock) stack.complete_layout_items.append(stack.current_textblock)
stack.current_textblock = None stack.current_textblock = None
return stack return stack
# setcharspace # setcharspace
@PDFCommands.add('Tc') @PDFCommands.add('Tc')
def do_Tc(stack: PDFStateStack, charspace) -> PDFStateStack: def set_charspace(stack: PDFStateStack, charspace) -> PDFStateStack:
stack.text.charspace = charspace stack.text.charspace = charspace
return stack return stack
# setwordspace # setwordspace
@PDFCommands.add('Tw') @PDFCommands.add('Tw')
def do_Tw(stack: PDFStateStack, wordspace) -> PDFStateStack: def set_wordspace(stack: PDFStateStack, wordspace) -> PDFStateStack:
stack.text.wordspace = wordspace stack.text.wordspace = wordspace
return stack return stack
# textscale # textscale
@PDFCommands.add('Tz') @PDFCommands.add('Tz')
def do_Tz(stack: PDFStateStack, scaling) -> PDFStateStack: def set_textscale(stack: PDFStateStack, scaling) -> PDFStateStack:
stack.text.scaling = scaling stack.text.scaling = scaling
return stack return stack
# setleading # setleading
@PDFCommands.add('TL') @PDFCommands.add('TL')
def do_TL(stack: PDFStateStack, leading) -> PDFStateStack: def set_text_leading(stack: PDFStateStack, leading) -> PDFStateStack:
stack.text.leading = -leading stack.text.leading = -leading
return stack return stack
# selectfont # selectfont
@PDFCommands.add('Tf') @PDFCommands.add('Tf')
def do_Tf(stack: PDFStateStack, fontid, fontsize) -> PDFStateStack: def set_font(stack: PDFStateStack, fontid, fontsize) -> PDFStateStack:
stack.text.fontsize = fontsize stack.text.fontsize = fontsize
try: try:
stack.text.font = stack.fontmap[literal_name(fontid)] stack.text.font = stack.fontmap[literal_name(fontid)]
@@ -398,19 +398,19 @@ def do_Tf(stack: PDFStateStack, fontid, fontsize) -> PDFStateStack:
# setrendering # setrendering
@PDFCommands.add('Tr') @PDFCommands.add('Tr')
def do_Tr(stack: PDFStateStack, render) -> PDFStateStack: def set_text_rendering(stack: PDFStateStack, render) -> PDFStateStack:
stack.text.render = render stack.text.render = render
return stack return stack
# settextrise # settextrise
@PDFCommands.add('Ts') @PDFCommands.add('Ts')
def do_Ts(stack: PDFStateStack, rise) -> PDFStateStack: def set_textrise(stack: PDFStateStack, rise) -> PDFStateStack:
stack.text.rise = rise stack.text.rise = rise
return stack return stack
# text-move # text-move
@PDFCommands.add('Td') @PDFCommands.add('Td')
def do_Td(stack: PDFStateStack, tx, ty) -> PDFStateStack: def move_text_x(stack: PDFStateStack, tx, ty) -> PDFStateStack:
(a, b, c, d, e, f) = stack.text.matrix (a, b, c, d, e, f) = stack.text.matrix
stack.text.matrix = (a, b, c, d, tx*a+ty*c+e, tx*b+ty*d+f) stack.text.matrix = (a, b, c, d, tx*a+ty*c+e, tx*b+ty*d+f)
stack.text.linematrix = [0, 0] stack.text.linematrix = [0, 0]
@@ -418,7 +418,7 @@ def do_Td(stack: PDFStateStack, tx, ty) -> PDFStateStack:
# text-move # text-move
@PDFCommands.add('TD') @PDFCommands.add('TD')
def do_TD(stack: PDFStateStack, tx, ty) -> PDFStateStack: def move_text_y(stack: PDFStateStack, tx, ty) -> PDFStateStack:
(a, b, c, d, e, f) = stack.text.matrix (a, b, c, d, e, f) = stack.text.matrix
stack.text.matrix = (a, b, c, d, tx*a+ty*c+e, tx*b+ty*d+f) stack.text.matrix = (a, b, c, d, tx*a+ty*c+e, tx*b+ty*d+f)
stack.text.leading = ty stack.text.leading = ty
@@ -427,14 +427,14 @@ def do_TD(stack: PDFStateStack, tx, ty) -> PDFStateStack:
# textmatrix # textmatrix
@PDFCommands.add('Tm') @PDFCommands.add('Tm')
def do_Tm(stack: PDFStateStack, a, b, c, d, e, f) -> PDFStateStack: def set_text_matrix(stack: PDFStateStack, a, b, c, d, e, f) -> PDFStateStack:
stack.text.matrix = (a, b, c, d, e, f) stack.text.matrix = (a, b, c, d, e, f)
stack.text.linematrix = [0, 0] stack.text.linematrix = [0, 0]
return stack return stack
# nextline # nextline
@PDFCommands.add('T_a') @PDFCommands.add('T_a')
def do_T_a(stack: PDFStateStack) -> PDFStateStack: def nextline(stack: PDFStateStack) -> PDFStateStack:
(a, b, c, d, e, f) = stack.text.matrix (a, b, c, d, e, f) = stack.text.matrix
stack.text.matrix = (a, b, c, d, stack.text.leading*c+e, stack.text.leading*d+f) stack.text.matrix = (a, b, c, d, stack.text.leading*c+e, stack.text.leading*d+f)
stack.text.linematrix = [0, 0] stack.text.linematrix = [0, 0]
@@ -442,7 +442,7 @@ def do_T_a(stack: PDFStateStack) -> PDFStateStack:
# show-pos # show-pos
@PDFCommands.add('TJ') @PDFCommands.add('TJ')
def do_TJ(stack: PDFStateStack, seq: bytearray) -> PDFStateStack: def add_char_blocks(stack: PDFStateStack, seq: bytearray) -> PDFStateStack:
if stack.text.font is None: if stack.text.font is None:
raise PDFCommands.InvalidOperation("No Font Specified") raise PDFCommands.InvalidOperation("No Font Specified")
if stack.current_textblock is None: if stack.current_textblock is None:
@@ -457,23 +457,23 @@ def do_TJ(stack: PDFStateStack, seq: bytearray) -> PDFStateStack:
# show # show
@PDFCommands.add('Tj') @PDFCommands.add('Tj')
def do_Tj(stack: PDFStateStack, b: bytes) -> PDFStateStack: def add_char_block(stack: PDFStateStack, b: bytes) -> PDFStateStack:
return do_TJ(stack, [b]) return add_char_blocks(stack, [b])
# quote # quote
@PDFCommands.add('_q') @PDFCommands.add('_q')
def do__q(stack: PDFStateStack, b: bytes) -> PDFStateStack: def add_quoted_char_blocks(stack: PDFStateStack, b: bytes) -> PDFStateStack:
return do_TJ(do_T_a(stack), [b]) return add_char_blocks(nextline(stack), [b])
# doublequote # doublequote
@PDFCommands.add('_w') @PDFCommands.add('_w')
def do__w(stack: PDFStateStack, wordspace, charspace, b) -> PDFStateStack: def add_dbquoted_char_blocks(stack: PDFStateStack, wordspace, charspace, b) -> PDFStateStack:
stack.text.wordspace = wordspace stack.text.wordspace = wordspace
stack.text.charspace = charspace stack.text.charspace = charspace
return do_TJ(stack, [b]) return add_char_blocks(stack, [b])
@PDFCommands.add('EI') @PDFCommands.add('EI')
def do_EI(stack: PDFStateStack, obj) -> PDFStateStack: def insert_image(stack: PDFStateStack, obj) -> PDFStateStack:
if 'W' in obj and 'H' in obj: if 'W' in obj and 'H' in obj:
stack.complete_layout_items.append(make_image( stack.complete_layout_items.append(make_image(
obj, stack.t_matrix obj, stack.t_matrix
@@ -482,7 +482,7 @@ def do_EI(stack: PDFStateStack, obj) -> PDFStateStack:
# invoke an XObject # invoke an XObject
@PDFCommands.add('Do') @PDFCommands.add('Do')
def do_Do(stack: PDFStateStack, xobjid) -> PDFStateStack: def insert_xobject(stack: PDFStateStack, xobjid) -> PDFStateStack:
xobjid = literal_name(xobjid) xobjid = literal_name(xobjid)
try: try:
xobj = PDFStream.validated_stream(stack.xobjmap[xobjid]) xobj = PDFStream.validated_stream(stack.xobjmap[xobjid])
@@ -13,4 +13,6 @@ class PDFColor:
) )
def __repr__(self): def __repr__(self):
return f"<PDFColor space={self.color_space} values={self.values}/>" return f"""<PDFColor space="{
None if self.color_space is None else self.color_space.name
}" values={self.values}/>"""
@@ -24,6 +24,14 @@ class LTCurve(LTComponent):
self.stroke = stroke self.stroke = stroke
self.fill = fill self.fill = fill
def __repr__(self):
return ('<%s [%s] fill=%s stroke=%s>' % (
self.__class__.__name__,
str(self.bbox),
self.fill,
self.stroke
))
## LTLine ## LTLine
## ##
class LTLine(LTCurve): class LTLine(LTCurve):
@@ -90,9 +90,9 @@ class LTComponent(LTItem):
## ##
class LTContainer(LTComponent): class LTContainer(LTComponent):
def __init__(self, bbox: Bbox, objs: List[LTItem] = []): def __init__(self, bbox: Bbox, objs: List[LTItem] = None):
LTComponent.__init__(self, bbox) LTComponent.__init__(self, bbox)
self._objs: List[LTItem] = objs self._objs: List[LTItem] = [] if objs is None else objs
return return
def __iter__(self): def __iter__(self):
+1 -1
View File
@@ -10,7 +10,7 @@ import sys
with open('README.md') as readme_file: with open('README.md') as readme_file:
SETUP = { SETUP = {
"name": "pdfmajor", "name": "pdfmajor",
"version": "1.3.4", "version": "1.3.6",
"packages": find_packages(include=['pdfmajor*']), "packages": find_packages(include=['pdfmajor*']),
"install_requires": [ "install_requires": [
'pycryptodome', 'pycryptodome',
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
+35
View File
@@ -0,0 +1,35 @@
import os
from tqdm import tqdm
# from pdfmajor.extractor import extract_items_from_pdf
from pdfmajor.interpreter import LTCharBlock, PDFInterpreter, logging
from pdfmajor.interpreter import PageInterpreter
from pdfmajor.interpreter.commands import LTContainer
CUR_PATH = os.path.dirname(os.path.dirname(__file__))
INPUT_FOLDER = os.path.join(
CUR_PATH, "tests/samples/pdf"
)
FILES = os.listdir(INPUT_FOLDER)
NUM_LOOPS = 10
def count_elms(file_path: str):
count = 0
for page in PDFInterpreter(file_path):
for item in page:
if isinstance(item, LTContainer):
count += len([*item])
else:
count += 1
return count
with tqdm(desc='Cache Test', total=len(FILES)*NUM_LOOPS) as waiter:
for file_name in FILES:
waiter.set_description(f"Cache Test - [{file_name}]")
file_path = os.path.join(INPUT_FOLDER, file_name)
last_count = count_elms(file_path)
for _ in range(NUM_LOOPS):
new_count = count_elms(file_path)
assert new_count == last_count
last_count = new_count
waiter.update()
+24 -26
View File
@@ -22,30 +22,28 @@ if not os.path.exists(OUTPUT_FOLDER):
files = os.listdir(INPUT_FOLDER) files = os.listdir(INPUT_FOLDER)
TOTAL = len(files)*len(EXTS) TOTAL = len(files)*len(EXTS)
waiter = tqdm(total=TOTAL) with tqdm(total=TOTAL) as waiter:
for idx, file_name in enumerate(files): for idx, file_name in enumerate(files):
file_name_no_ext = re.sub(r'\.pdf$',"", file_name) file_name_no_ext = re.sub(r'\.pdf$',"", file_name)
input_file_path = os.path.join(INPUT_FOLDER, file_name) input_file_path = os.path.join(INPUT_FOLDER, file_name)
for ext in EXTS: for ext in EXTS:
if not os.path.exists(os.path.join(OUTPUT_FOLDER, ext)): if not os.path.exists(os.path.join(OUTPUT_FOLDER, ext)):
os.makedirs(os.path.join(OUTPUT_FOLDER, ext)) os.makedirs(os.path.join(OUTPUT_FOLDER, ext))
output_file_path = os.path.join(OUTPUT_FOLDER, ext, file_name_no_ext + "." + ext) output_file_path = os.path.join(OUTPUT_FOLDER, ext, file_name_no_ext + "." + ext)
if len(file_name) > len(file_name_no_ext): if len(file_name) > len(file_name_no_ext):
waiter.set_description(f"Processing {file_name}") waiter.set_description(f"Conversion test -- {file_name}")
convert_file( convert_file(
input_file=input_file_path, input_file=input_file_path,
output_file=output_file_path, output_file=output_file_path,
out_type=ext, out_type=ext,
debug_level=logging.WARN, debug_level=logging.WARN,
) )
if ext == 'xml': if ext == 'xml':
waiter.set_description(f" > testing format {file_name}") waiter.set_description(f" > testing format {file_name}")
ElementTree.parse(output_file_path) ElementTree.parse(output_file_path)
elif ext == 'json': elif ext == 'json':
waiter.set_description(f" > testing format {file_name}") waiter.set_description(f" > testing format {file_name}")
json_load(open(output_file_path, 'r')) json_load(open(output_file_path, 'r'))
waiter.refresh() waiter.update()
waiter.update() waiter.set_description("Done")
waiter.set_description("Done")
waiter.close()
+5 -4
View File
@@ -1,4 +1,5 @@
import os import os
from tqdm import tqdm
from pdfmajor.interpreter import LTImage, logging from pdfmajor.interpreter import LTImage, logging
from pdfmajor.interpreter import PageInterpreter, PDFInterpreter from pdfmajor.interpreter import PageInterpreter, PDFInterpreter
@@ -18,16 +19,16 @@ OUTPUT_FOLDER = os.path.join(
if not os.path.exists(OUTPUT_FOLDER): if not os.path.exists(OUTPUT_FOLDER):
os.makedirs(OUTPUT_FOLDER) os.makedirs(OUTPUT_FOLDER)
for file_name in FILES: for file_name in tqdm(FILES, desc='Image Writer Test'):
for page in PDFInterpreter(os.path.join( for page in PDFInterpreter(os.path.join(
CUR_PATH, CUR_PATH,
f"samples/pdf/{file_name}.pdf" f"tests/samples/pdf/{file_name}.pdf"
), debug_level=logging.ERROR): ), debug_level=logging.ERROR):
assert isinstance(page, PageInterpreter) assert isinstance(page, PageInterpreter)
for item_idx, item in enumerate(page): for item_idx, item in enumerate(page):
assert isinstance(item, LTItem) assert isinstance(item, LTItem)
if isinstance(item, LTImage): if isinstance(item, LTImage):
print(item.save_image( item.save_image(
OUTPUT_FOLDER, OUTPUT_FOLDER,
file_name=f'{file_name}_p{page.page_num}i{item_idx}' file_name=f'{file_name}_p{page.page_num}i{item_idx}'
)) )
+13 -12
View File
@@ -1,21 +1,22 @@
import os import os
from tqdm import tqdm
# from pdfmajor.extractor import extract_items_from_pdf
from pdfmajor.interpreter import LTCharBlock, PDFInterpreter, logging from pdfmajor.interpreter import LTCharBlock, PDFInterpreter, logging
from pdfmajor.interpreter import PageInterpreter from pdfmajor.interpreter import PageInterpreter
from pdfmajor.interpreter.commands import LTItem from pdfmajor.interpreter.commands import LTItem
from pdfmajor.interpreter.commands import LTCharBlock, LTChar from pdfmajor.interpreter.commands import LTCharBlock, LTChar
CUR_PATH = os.path.dirname(os.path.dirname(__file__)) CUR_PATH = os.path.dirname(os.path.dirname(__file__))
FILE_NAME = os.path.join( INPUT_FOLDER = os.path.join(
CUR_PATH, CUR_PATH, "tests/samples/pdf"
"samples/pdf/tables.pdf"
) )
FILES = os.listdir(INPUT_FOLDER)
for page in PDFInterpreter(FILE_NAME, debug_level=logging.INFO): for file_name in tqdm(FILES, desc="Interpreter Test"):
assert isinstance(page, PageInterpreter) file_path = os.path.join(INPUT_FOLDER, file_name)
for item in page: for page in PDFInterpreter(file_path, debug_level=logging.ERROR):
assert isinstance(item, LTItem) assert isinstance(page, PageInterpreter)
if isinstance(item, LTCharBlock): for item in page:
for char in item: assert isinstance(item, LTItem)
assert(char, LTChar) if isinstance(item, LTCharBlock):
for char in item:
assert isinstance(char, LTChar)
-1
View File
@@ -80,7 +80,6 @@ with JSONMaker(FILE_NAME) as obj:
item.number("x1", 4.2) item.number("x1", 4.2)
item.number("y0", 231.12) item.number("y0", 231.12)
item.number("y1", 331.12) item.number("y1", 331.12)
print(open(FILE_NAME, 'r').read())
assert(open(FILE_NAME, 'r').read() == """{ assert(open(FILE_NAME, 'r').read() == """{
"pages": [ "pages": [
{ {
+15 -4
View File
@@ -20,7 +20,6 @@ with YAMLMaker(FILE_NAME) as yml:
toys.write("bear") toys.write("bear")
with yml.object("computer") as computer: with yml.object("computer") as computer:
computer.write("type", "awesome") computer.write("type", "awesome")
print(open(FILE_NAME, 'r').read())
assert(open(FILE_NAME, 'r').read() == """name: bob assert(open(FILE_NAME, 'r').read() == """name: bob
age: 20 age: 20
wife: wife:
@@ -48,7 +47,6 @@ with YAMLMaker(FILE_NAME) as yml:
"lion", "bear" "lion", "bear"
]) ])
yml.place_object("computer", {"type": "awesome"}) yml.place_object("computer", {"type": "awesome"})
print(open(FILE_NAME, 'r').read())
assert(open(FILE_NAME, 'r').read() == """name: bob assert(open(FILE_NAME, 'r').read() == """name: bob
age: 20 age: 20
wife: wife:
@@ -81,8 +79,21 @@ with YAMLMaker(FILE_NAME) as yml:
curve.write("y0", 0) curve.write("y0", 0)
curve.write("y1", 1) curve.write("y1", 1)
print(open(FILE_NAME, 'r').read()) assert(open(FILE_NAME, 'r').read() == """pages:
assert(open(FILE_NAME, 'r').read() == """""") - id: 0
width: 100
height: 200
children:
- stroke:
type: DeviceRGB
value: ['1', '2', '3']
x0: 0
x1: 1
fill:
type: DeviceRGB
value: ['1', '2', '3']
y0: 0
y1: 1""")
+4 -5
View File
@@ -52,11 +52,10 @@ def main(args=None):
if len(parsed_args.files) == 1: if len(parsed_args.files) == 1:
if parsed_args.output_file != "-": if parsed_args.output_file != "-":
func_args['output_file'] = open(parsed_args.output_file, "wb") func_args['output_file'] = open(parsed_args.output_file, "wb")
with open(parsed_args.files[0], 'rb') as input_file: convert_file(
convert_file( parsed_args.files[0],
input_file, **func_args
**func_args )
)
else: else:
print("Multiple files not supported yet.") print("Multiple files not supported yet.")
return 1 return 1