booktype / python-ooxml Goto Github PK

We do great things with paragraph style and styling done on the elements but we do not mark character styles at all. What we should do is check if character styling is defined on the elements, and if it was just add the name of the style as the CSS class to that element.

Table serialization fails when we pass None as root element. Clearly, we need to see why do we have root element as None. This should not happen but we should also not fail with exception when this happens.

Add couple of sample files. We need for parsing, how to extend and how to use import. For now it will be just enough.

Seems like we sometimes serialise text twice. For multiple <w:r> references we sometimes add text to .text and .tail. What we should do is just check if text has already been added.

Underline tags in docx files are missed. The offending lines are parse.py:88 and parse.py:31 on commit 833e658.

The master branch treats the underline tag as having only two possible states, on or off and does not account for the fact the underline tag will actually contain string values such as 'single', 'double', 'dashed' etc. I have a branch of the code that will update the rpr dictionary accordingly by altering the code around the two lines that I mentioned, a 'u' field of the dictionary will be added with a string value representing the type of underlining.

However I do not know what further implication this will have. Does another part of this project assume that the 'u' field of rpr will either not exist or take on a true or false value.

parse_drawing function fails on some documents. The issues seems to be that drawing element does not have element <a:blip> inside.

Increase the version, update documentation and tag the release.

We need to be able to support smartTag element. Detail description for this tag is here: http://www.datypic.com/sc/ooxml/e-w_smartTag-1.html

Here is example of the XML structure from the document:

    <w:p w14:paraId="700B8014" w14:textId="77777777" w:rsidR="00BA11BE" w:rsidRDefault="00BA11BE" w:rsidP="00AA4ADD">
      <w:pPr>
        <w:pStyle w:val="C1Heading"/>
      </w:pPr>
      <w:bookmarkStart w:id="0" w:name="_Hlk397609529"/>
      <w:smartTag w:uri="urn:schemas-microsoft-com:office:smarttags" w:element="country-region">
        <w:smartTag w:uri="urn:schemas-microsoft-com:office:smarttags" w:element="place">
          <w:r>
            <w:t>Benin</w:t>
          </w:r>
        </w:smartTag>
      </w:smartTag>
    </w:p>

We are only parsing document relationships, and not endnotes ones. We should just make it work with both, and specify where to look for the content.

We should use fixed ratio to scale font size, instead calculate as we do now.

Footnotes support only one paragraph while they could be made out of multiple paragraphs. This is exactly like it is for endnotes. Just parse all the paragraphs and store them together.

Parsing properties will fail because we do not check if our parent has valid attributes. We assume it does have 'ppr' attribute and we try to check if it contains certain values. Because it does not exist we fail at this point with an exception.

We have support for footnotes but we need to be able to read endnotes also. Just like footnotes, endnotes are placed in separate file endnotes.xml. We need to parse it and store in similar to footnotes.

We were only parsing endnotes and not the footnotes. We should be able to parse the footnotes and be able to render them correctly.

By default we always used pretty_print=True. There are some situations when we do not want that. Just add this switch to the list of options and check during the serialization what the options is saying.

setup.py and README file needs some organising. Write some basic info about the library.

There are situations where it just does not work as expected. Mainly, the problem is when the paragraph has style 1, part of the text has style 2, and the rest of the text inherits whatever is in the paragraph.

We do not leave class and style definitions for main chapter header. We do it for subheaders, but not main header.

Just leave whatever was defined in the imported chapter also.

We are parsing commentRangeStart and commentRangeEnd but commentReference (used by older Word) is not being parsed.

We should parse it, create comment mark for it and not have commented text (for obvious reasons).

OOXML seems to be the family of document types, not just word type of files. Hence, the library's name is misleading.

Hi guys! There is a minor error that I faced. I fixed it changing int to float. Please review and give response is it correct or not?

My suggestion firstly convert to float and after that convert to int !

Thanks in advance.

We need to be able to parse the comments and remember text which they reference in original document.

Comments are in separate file comments.xml. It would be hard to mark the text which was tagged by user but we can figure out start and end of the text which is being commented.

We end up with output code i

<p style="font-size: 120%;">
  <span style="font-size: 120%">Text</span>
</p>

We should end up with something like this:

<p style="font-size: 120%;">
 Text
</p>

There is a code for scaling font size in the importer but it seems to be setting wrong options which are never used. (in importer.py; function _serialize_chapter). It should set this option on the serialize_options variable.

Scaling should be defined for the HTML and CSS serialisation.

Link and image could be referencing relationship which is missing. In that case it will fail with an exception. What we should do is just not add "href" and "src" to these tags at that point. Just leave them empty.

We are in need of extra support in terms of Tables/Drawing objects in Footnotes, Endnotes and Comments

We are missing some basic Sphinx documentation. This is about basic usage and documenting source code.

Hi, i have a project which the idea is to parse ooxml omath tags into latex. If you are interessed here is the link

In the importer base font size is not calculated correctly. What we were using was just the biggest possible font size which was not always correct number.

With the importer we ignore document default style because people don't use it always. What we do is calculate font size usage in the document and then pick up the highest possible font size usage as default paragraph size.

In the hyperlink we only parse for the first <w:r> tag. In case there are multiple text references inside we will not be aware of them. Besides that, we also do not serialise all the elements we parse. We only look for the first element and use it.

It was fine while we only had one type of Break. Now when we have page break and inline break (break to new line) it breaks. We need to mock Break object and test it for these two lines now. We used to use None as value because it didn't matter.

During parsing of a table in docx, sdt control is found in a cell. Now parser errorneously post 1 column output for the row below. (it thinks that there is only 1 column in this table row). How to fix/handle this?

Cell structure looks like as below.