def match_default_fixture(self, request):
partname_str, ext, content_type = request.param
partname = PackURI(partname_str)
ct_map = _ContentTypeMap()
ct_map._add_override(PackURI('/bar/foo.xyz'), 'application/xyz')
ct_map._add_default(ext, content_type)
return ct_map, partname, content_type
def it_adds_a_notes_slide_part_to_help(
self, request, package_, slide_part_, notes_master_part_, notes_slide_part_
):
NotesSlidePart_ = class_mock(
request, "pptx.parts.slide.NotesSlidePart", return_value=notes_slide_part_
)
notes = element("p:notes")
new_ = method_mock(
request, CT_NotesSlide, "new", autospec=False, return_value=notes
)
package_.next_partname.return_value = PackURI(
"/ppt/notesSlides/notesSlide42.xml"
)
notes_slide_part = NotesSlidePart._add_notes_slide_part(
package_, slide_part_, notes_master_part_
)
package_.next_partname.assert_called_once_with(
"/ppt/notesSlides/notesSlide%d.xml"
)
new_.assert_called_once_with()
NotesSlidePart_.assert_called_once_with(
PackURI("/ppt/notesSlides/notesSlide42.xml"),
CT.PML_NOTES_SLIDE,
package_,
notes,
)
assert notes_slide_part_.relate_to.call_args_list == [
call(notes_master_part_, RT.NOTES_MASTER),
call(slide_part_, RT.SLIDE),
]
assert notes_slide_part is notes_slide_part_
def match_override_fixture(self, request):
partname_str, should_match_partname_str = request.param
partname = PackURI(partname_str)
should_match_partname = PackURI(should_match_partname_str)
content_type = 'appl/vnd-foobar'
ct_map = _ContentTypeMap()
ct_map._add_override(partname, content_type)
return ct_map, should_match_partname, content_type
def it_can_write_a_blob(self, _zipf_prop_):
"""Integrates with zipfile.ZipFile."""
pack_uri = PackURI("/part/name.xml")
_zipf_prop_.return_value = zipf = zipfile.ZipFile(BytesIO(), "w")
pkg_writer = _ZipPkgWriter(None)
pkg_writer.write(pack_uri, b"blob")
members = {
PackURI("/%s" % name): zipf.read(name)
for name in zipf.namelist()
}
assert len(members) == 1
assert members[pack_uri] == b"blob"
def rename_fixture(self, related_parts_prop_):
prs_part = PresentationPart(None, None, None)
rIds = ('rId1', 'rId2')
getitem_ = related_parts_prop_.return_value.__getitem__
calls = [call('rId1'), call('rId2')]
slide_parts = [
SlidePart(None, None, None),
SlidePart(None, None, None),
]
expected_names = [
PackURI('/ppt/slides/slide1.xml'),
PackURI('/ppt/slides/slide2.xml'),
]
getitem_.side_effect = slide_parts
return (prs_part, rIds, getitem_, calls, slide_parts, expected_names)
def _mock_part(self, request, name, partname_str, content_type):
partname = PackURI(partname_str)
return instance_mock(request,
Part,
name=name,
partname=partname,
content_type=content_type)
def _blobs(self):
"""dict mapping partname to package part binaries."""
with zipfile.ZipFile(self._pkg_file, "r") as z:
return {
PackURI("/%s" % name): z.read(name)
for name in z.namelist()
}
def it_knows_the_next_available_slide_partname(self,
slides_with_slide_parts_):
slides = slides_with_slide_parts_[0]
expected_partname = PackURI('/ppt/slides/slide3.xml')
partname = slides._next_partname
assert isinstance(partname, PackURI)
assert partname == expected_partname
def it_creates_a_new_notes_master_part_to_help(
self, request, package_, notes_master_part_
):
NotesMasterPart_ = class_mock(
request, "pptx.parts.slide.NotesMasterPart", return_value=notes_master_part_
)
notesMaster = element("p:notesMaster")
method_mock(
request,
CT_NotesMaster,
"new_default",
autospec=False,
return_value=notesMaster,
)
notes_master_part = NotesMasterPart._new(package_)
CT_NotesMaster.new_default.assert_called_once_with()
NotesMasterPart_.assert_called_once_with(
PackURI("/ppt/notesMasters/notesMaster1.xml"),
CT.PML_NOTES_MASTER,
package_,
notesMaster,
)
assert notes_master_part is notes_master_part_
def add_fixture(
self,
package_,
slide_part_,
notes_master_part_,
notes_slide_part_,
NotesSlidePart_,
new_,
):
partname = PackURI("/ppt/notesSlides/notesSlide42.xml")
content_type = CT.PML_NOTES_SLIDE
notes = element("p:notes")
calls = [
call(notes_master_part_, RT.NOTES_MASTER),
call(slide_part_, RT.SLIDE)
]
package_.next_partname.return_value = partname
new_.return_value = notes
return (
package_,
slide_part_,
notes_master_part_,
notes_slide_part_,
NotesSlidePart_,
partname,
content_type,
notes,
calls,
)
def new_fixture(self, package_, NotesMasterPart_, notesMaster_,
notes_master_part_, new_default_):
partname = PackURI('/ppt/notesMasters/notesMaster1.xml')
return (
package_, NotesMasterPart_, partname, notesMaster_,
notes_master_part_
)
def theme_fixture(self, package_, XmlPart_, theme_elm_, theme_part_,
theme_new_default_):
pn_tmpl = '/ppt/theme/theme%d.xml'
partname = PackURI('/ppt/theme/theme2.xml')
package_.next_partname.return_value = partname
return (
package_, pn_tmpl, XmlPart_, partname, theme_elm_, theme_part_
)
def new(cls, slide, notesMaster, package):
notes_slide_elm = CT_SlideNotes.new()
partname = PackURI(re.sub("slide", "notesSlide", slide.partname))
notes_slide = cls(partname, CONTENT_TYPE.PML_NOTES_SLIDE,
notes_slide_elm, package)
notes_slide.relate_to(notesMaster, RT.NOTES_MASTER)
notes_slide.shapes.clone_slide_placeholders(notesMaster)
return notes_slide
def it_can_get_the_rels_xml_for_a_partname(self, _blob_reader_prop_):
_blob_reader_prop_.return_value = {
"/ppt/_rels/presentation.xml.rels": b"blob"
}
package_reader = PackageReader(None)
assert package_reader.rels_xml_for(
PackURI("/ppt/presentation.xml")) == b"blob"
def it_can_add_a_new_slide(self, slides, slidelayout_, Slide_, slide_):
slide = slides.add_slide(slidelayout_)
Slide_.new.assert_called_once_with(slidelayout_,
PackURI('/ppt/slides/slide3.xml'),
slides._prs.package)
slides._prs.relate_to.assert_called_once_with(slide_, RT.SLIDE)
slides._sldIdLst.add_sldId.assert_called_once_with(ANY)
assert slide is slide_
def _new(cls, package):
"""Return new empty |CorePropertiesPart| instance."""
return CorePropertiesPart(
PackURI("/docProps/core.xml"),
CT.OPC_CORE_PROPERTIES,
package,
CT_CoreProperties.new_coreProperties(),
)
def but_it_returns_None_when_the_part_has_no_rels(self,
_blob_reader_prop_):
_blob_reader_prop_.return_value = {
"/ppt/_rels/presentation.xml.rels": b"blob"
}
package_reader = PackageReader(None)
assert package_reader.rels_xml_for(
PackURI("/ppt/slides.slide1.xml")) is None
def _new(cls, package):
"""
Create and return a standalone, default notes master part based on
the built-in template (without any related parts, such as theme).
"""
partname = PackURI("/ppt/notesMasters/notesMaster1.xml")
content_type = CT.PML_NOTES_MASTER
notesMaster = CT_NotesMaster.new_default()
return NotesMasterPart(partname, content_type, notesMaster, package)
def test_construction_from_file(self):
"""Image(path) constructor produces correct attribute values"""
# exercise ---------------------
partname = PackURI('/ppt/media/image1.jpeg')
image = Image.new(partname, test_image_path)
# verify -----------------------
assert image.ext == 'jpeg'
assert image.content_type == 'image/jpeg'
assert len(image._blob) == 3277
assert image._desc == 'python-icon.jpeg'
def test_construction_from_file(self):
"""Image(path) constructor produces correct attribute values"""
# exercise ---------------------
partname = PackURI('/ppt/media/image1.jpeg')
image = Image.new(partname, test_image_path)
# verify -----------------------
assert_that(image.ext, is_(equal_to('jpeg')))
assert_that(image.content_type, is_(equal_to('image/jpeg')))
assert_that(len(image._blob), is_(equal_to(3277)))
assert_that(image._desc, is_(equal_to('python-icon.jpeg')))
def it_should_have_relative_ref_for_internal_rel(self):
"""
Internal relationships (TargetMode == 'Internal' in the XML) should
have a relative ref, e.g. '../slideLayouts/slideLayout1.xml', for
the target_ref attribute.
"""
part = Mock(name="part", partname=PackURI("/ppt/media/image1.png"))
baseURI = "/ppt/slides"
rel = _Relationship(None, None, part, baseURI) # external=False
assert rel.target_ref == "../media/image1.png"
def _rename_images(self):
"""
Assign partnames like ``/ppt/media/image9.png`` to all images in the
collection. The name portion is always ``image``. The number part
forms a continuous sequence starting at 1 (e.g. 1, 2, 3, ...). The
extension is preserved during renaming.
"""
for idx, image in enumerate(self._values):
partname_str = '/ppt/media/image%d.%s' % (idx + 1, image.ext)
image.partname = PackURI(partname_str)
def cases(self, expected_values):
"""
Return list of tuples zipped from uri_str cases and
*expected_values*. Raise if lengths don't match.
"""
uri_str_cases = ["/", "/ppt/presentation.xml", "/ppt/slides/slide1.xml"]
if len(expected_values) != len(uri_str_cases):
msg = "len(expected_values) differs from len(uri_str_cases)"
raise AssertionError(msg)
pack_uris = [PackURI(uri_str) for uri_str in uri_str_cases]
return zip(pack_uris, expected_values)
def _new(cls, package):
"""
Create and return a standalone, default notes master part based on
the built-in template (without any related parts, such as theme).
"""
return NotesMasterPart(
PackURI("/ppt/notesMasters/notesMaster1.xml"),
CT.PML_NOTES_MASTER,
package,
CT_NotesMaster.new_default(),
)
def test_add_part_preserves_sort_order(self):
partname1 = PackURI('/ppt/slides/slide1.xml')
partname2 = PackURI('/ppt/slides/slide2.xml')
partname3 = PackURI('/ppt/slides/slide3.xml')
part1 = Mock(name='part1')
part1.partname = partname1
part2 = Mock(name='part2')
part2.partname = partname2
part3 = Mock(name='part3')
part3.partname = partname3
parts = PartCollection()
# exercise ---------------------
parts.add_part(part2)
parts.add_part(part3)
parts.add_part(part1)
# verify -----------------------
expected = [partname1, partname2, partname3]
actual = [part.partname for part in parts]
msg = "expected %s, got %s" % (expected, actual)
self.assertEqual(expected, actual, msg)
def it_can_calculate_relative_ref_value(self):
cases = (
('/', '/ppt/presentation.xml', 'ppt/presentation.xml'),
('/ppt', '/ppt/slideMasters/slideMaster1.xml',
'slideMasters/slideMaster1.xml'),
('/ppt/slides', '/ppt/slideLayouts/slideLayout1.xml',
'../slideLayouts/slideLayout1.xml'),
)
for baseURI, uri_str, expected_relative_ref in cases:
pack_uri = PackURI(uri_str)
assert pack_uri.relative_ref(baseURI) == expected_relative_ref
def add_part(self, part):
"""
Insert a new part into the collection such that list remains sorted
in logical partname order (e.g. slide10.xml comes after slide9.xml).
"""
new_partidx = part.partname.idx
for idx, seq_part in enumerate(self._values):
partidx = PackURI(seq_part.partname).idx
if partidx > new_partidx:
self._values.insert(idx, part)
return
self._values.append(part)
def test_construction_from_stream(self):
"""Image(stream) construction produces correct attribute values"""
# exercise ---------------------
partname = PackURI('/ppt/media/image1.jpeg')
with open(test_image_path, 'rb') as f:
stream = StringIO(f.read())
image = Image.new(partname, stream)
# verify -----------------------
assert image.ext == 'jpg'
assert image.content_type == 'image/jpeg'
assert len(image._blob) == 3277
assert image._desc == 'image.jpg'
def rename_slide_parts(self, rIds):
"""Assign incrementing partnames to the slide parts identified by `rIds`.
Partnames are like `/ppt/slides/slide9.xml` and are assigned in the order their
id appears in the `rIds` sequence. The name portion is always ``slide``. The
number part forms a continuous sequence starting at 1 (e.g. 1, 2, ... 10, ...).
The extension is always ``.xml``.
"""
for idx, rId in enumerate(rIds):
slide_part = self.related_part(rId)
slide_part.partname = PackURI("/ppt/slides/slide%d.xml" %
(idx + 1))
def next_partname_fixture(self, request, iter_parts_):
existing_partname_numbers, next_partname_number = request.param
package = OpcPackage()
parts = [
instance_mock(
request, Part, name="part[%d]" % idx, partname="/foo/bar/baz%d.xml" % n
)
for idx, n in enumerate(existing_partname_numbers)
]
iter_parts_.return_value = iter(parts)
partname_template = "/foo/bar/baz%d.xml"
expected_partname = PackURI("/foo/bar/baz%d.xml" % next_partname_number)
return package, partname_template, expected_partname
