Python indexed_list.IndexedList类代码示例

    def _setup_styles(self):
        """Bootstrap styles"""
        from openpyxl.styles.alignment import Alignment
        from openpyxl.styles.borders import DEFAULT_BORDER
        from openpyxl.styles.fills import DEFAULT_EMPTY_FILL, DEFAULT_GRAY_FILL
        from openpyxl.styles.fonts import DEFAULT_FONT
        from openpyxl.styles.protection import Protection
        from openpyxl.styles.colors import COLOR_INDEX
        from openpyxl.styles.named_styles import NamedStyleList

        self._fonts = IndexedList()
        self._fonts.add(DEFAULT_FONT)

        self._alignments = IndexedList([Alignment()])

        self._borders = IndexedList()
        self._borders.add(DEFAULT_BORDER)

        self._fills = IndexedList()
        self._fills.add(DEFAULT_EMPTY_FILL)
        self._fills.add(DEFAULT_GRAY_FILL)

        self._number_formats = IndexedList()

        self._protections = IndexedList([Protection()])

        self._colors = COLOR_INDEX
        self._cell_styles = IndexedList([StyleArray()])
        self._named_styles = NamedStyleList()
        self.add_named_style(NamedStyle(font=DEFAULT_FONT, builtinId=0))

class DummyWorkbook:

    def __init__(self):
        self.shared_styles = IndexedList()
        self._cell_styles = IndexedList()
        self._cell_styles.add(StyleArray())
        self._cell_styles.add(StyleArray([10,0,0,0,0,0,0,0,0,0]))
        self.sheetnames = []

class DummyWorkbook:

    def __init__(self):
        self.shared_styles = IndexedList()
        self._cell_styles = IndexedList()
        self._cell_styles.add(StyleId())
        self._cell_styles.add(StyleId(fontId=10, numFmtId=0, borderId=0, fillId=0, protectionId=0, alignmentId=0))

    def get_sheet_names(self):
        return []

    def from_comments(cls, comments):
        """
        Create a comment sheet from a list of comments for a particular worksheet
        """
        authors = IndexedList()

        # dedupe authors and get indexes
        for comment in comments:
            comment.authorId = authors.add(comment.author)

        return cls(authors=AuthorList(authors), commentList=comments)

 def __init__(self, xml_source):
     self.root = fromstring(xml_source)
     self.cell_styles = IndexedList()
     self.differential_styles = []
     self.color_index = COLOR_INDEX
     self.font_list = IndexedList()
     self.fill_list = IndexedList()
     self.border_list = IndexedList()
     self.alignments = IndexedList([Alignment()])
     self.protections = IndexedList([Protection()])
     self.custom_number_formats = {}
     self.number_formats = IndexedList()

    def write_comments(self):
        """
        Create list of comments and authors
        """

        authors = IndexedList()

        # dedupe authors and get indexes
        for comment in self.comments:
            comment.authorId = authors.add(comment.author)

        root = CommentSheet(authors=AuthorList(authors), commentList=self.comments)
        return tostring(root.to_tree())

 def _to_array(self):
     """
     Extract protection and alignments, convert to style array
     """
     self.prots = IndexedList([Protection()])
     self.alignments = IndexedList([Alignment()])
     styles = [] # allow duplicates
     for xf in self.xf:
         style = xf.to_array()
         if xf.alignment is not None:
             style.alignmentId = self.alignments.add(xf.alignment)
         if xf.protection is not None:
             style.protectionId = self.prots.add(xf.protection)
         styles.append(style)
     return IndexedList(styles)

    def write_comments(self):
        """
        Create list of comments and authors
        Sorted by row, col
        """
        # produce xml
        authors = IndexedList()

        for comment in self.comments:
            comment.authorId = authors.add(comment.author)

        author_list = AuthorList(authors)
        root = CommentSheet(authors=author_list, commentList=self.comments)

        return tostring(root.to_tree())

 def __init__(self):
     self._differential_styles = []
     self.shared_strings = IndexedList()
     self.shared_strings.add("hello world")
     self._fonts = IndexedList()
     self._fills = IndexedList()
     self._number_formats = IndexedList()
     self._borders = IndexedList()
     self._alignments = IndexedList()
     self._protections = IndexedList()
     self._cell_styles = IndexedList()
     self.vba_archive = None
     for i in range(29):
         self._cell_styles.add((StyleArray([i]*9)))
     self._cell_styles.add(StyleArray([0,4,6,0,0,1,0,0,0])) #fillId=4, borderId=6, alignmentId=1))
     self.sheetnames = []

 def __init__(self):
     self.shared_strings = IndexedList()
     self.shared_strings.add("hello world")
     self.shared_styles = 28*[DummyStyle()]
     self.shared_styles.append(Style())
     self._fonts = IndexedList()
     self._fills = IndexedList()
     self._number_formats = IndexedList()
     self._borders = IndexedList()
     self._alignments = IndexedList()
     self._protections = IndexedList()
     self._cell_styles = IndexedList()
     self.vba_archive = None
     for i in range(29):
         self._cell_styles.add((StyleId(i, i, i, i, i, i)))
     self._cell_styles.add(StyleId(fillId=4, borderId=6, alignmentId=1, protectionId=0))

class CellStyleList(Serialisable):

    tagname = "cellXfs"

    __attrs__ = ("count",)

    count = Integer(allow_none=True)
    xf = Sequence(expected_type=CellStyle)
    alignment = Sequence(expected_type=Alignment)
    protection = Sequence(expected_type=Protection)

    __elements__ = ('xf',)

    def __init__(self,
                 count=None,
                 xf=(),
                ):
        self.xf = xf


    @property
    def count(self):
        return len(self.xf)


    def __getitem__(self, idx):
        return self.xf[idx]


    def _to_array(self):
        """
        Extract protection and alignments, convert to style array
        """
        self.prots = IndexedList([Protection()])
        self.alignments = IndexedList([Alignment()])
        styles = [] # allow duplicates
        for xf in self.xf:
            style = xf.to_array()
            if xf.alignment is not None:
                style.alignmentId = self.alignments.add(xf.alignment)
            if xf.protection is not None:
                style.protectionId = self.prots.add(xf.protection)
            styles.append(style)
        return IndexedList(styles)

    def write_comments(self):
        """
        Create list of comments and authors
        Sorted by row, col
        """
        # produce xml
        authors = IndexedList()

        for _coord, cell in sorted(self.sheet._cells.items()):
            if cell.comment is not None:
                comment = Comment(ref=cell.coordinate)
                comment.authorId = authors.add(cell.comment.author)
                comment.text.t = cell.comment.text
                comment.height = cell.comment.height
                comment.width = cell.comment.width
                self.comments.append(comment)

        author_list = AuthorList(authors)
        root = CommentSheet(authors=author_list, commentList=self.comments)

        return tostring(root.to_tree())

    def _setup_styles(self):
        """Bootstrap styles"""

        self._fonts = IndexedList()
        self._fonts.add(DEFAULT_FONT)

        self._alignments = IndexedList([Alignment()])

        self._borders = IndexedList()
        self._borders.add(DEFAULT_BORDER)

        self._fills = IndexedList()
        self._fills.add(DEFAULT_EMPTY_FILL)
        self._fills.add(DEFAULT_GRAY_FILL)

        self._number_formats = IndexedList()

        self._protections = IndexedList([Protection()])

        self._colors = COLOR_INDEX
        self._cell_styles = IndexedList([StyleArray()])
        self._named_styles = NamedStyleList()
        self.add_named_style(NamedStyle(font=DEFAULT_FONT, builtinId=0))
        self._table_styles = TableStyleList()

    def __init__(self, sheet):
        self.sheet = sheet
        self.authors = IndexedList()
        self.comments = []

        self.extract_comments()

class SharedStylesParser(object):

    def __init__(self, xml_source):
        self.root = fromstring(xml_source)
        self.cell_styles = IndexedList()
        self.differential_styles = []
        self.color_index = COLOR_INDEX
        self.font_list = IndexedList()
        self.fill_list = IndexedList()
        self.border_list = IndexedList()
        self.alignments = IndexedList([Alignment()])
        self.protections = IndexedList([Protection()])
        self.custom_number_formats = {}
        self.number_formats = IndexedList()

    def parse(self):
        self.parse_custom_num_formats()
        self.parse_color_index()
        self.font_list = IndexedList(self.parse_fonts())
        self.fill_list = IndexedList(self.parse_fills())
        self.border_list = IndexedList(self.parse_borders())
        self.parse_dxfs()
        self.parse_cell_styles()
        self.parse_named_styles()


    def parse_custom_num_formats(self):
        """Read in custom numeric formatting rules from the shared style table"""
        custom_formats = {}
        num_fmts = self.root.findall('{%s}numFmts/{%s}numFmt' % (SHEET_MAIN_NS, SHEET_MAIN_NS))
        for node in num_fmts:
            idx = int(node.get('numFmtId'))
            self.custom_number_formats[idx] = node.get('formatCode')
            self.number_formats.append(node.get('formatCode'))


    def parse_color_index(self):
        """Read in the list of indexed colors"""
        colors =\
            self.root.findall('{%s}colors/{%s}indexedColors/{%s}rgbColor' %
                              (SHEET_MAIN_NS, SHEET_MAIN_NS, SHEET_MAIN_NS))
        if not colors:
            return
        self.color_index = IndexedList([node.get('rgb') for node in colors])


    def parse_dxfs(self):
        """Read in the dxfs effects - used by conditional formatting."""
        for node in self.root.findall("{%s}dxfs/{%s}dxf" % (SHEET_MAIN_NS, SHEET_MAIN_NS) ):
            self.differential_styles.append(DifferentialStyle.from_tree(node))


    def parse_fonts(self):
        """Read in the fonts"""
        fonts = self.root.findall('{%s}fonts/{%s}font' % (SHEET_MAIN_NS, SHEET_MAIN_NS))
        for node in fonts:
            yield Font.from_tree(node)


    def parse_fills(self):
        """Read in the list of fills"""
        fills = self.root.findall('{%s}fills/{%s}fill' % (SHEET_MAIN_NS, SHEET_MAIN_NS))
        for fill in fills:
            yield Fill.from_tree(fill)

    def parse_borders(self):
        """Read in the boarders"""
        borders = self.root.findall('{%s}borders/{%s}border' % (SHEET_MAIN_NS, SHEET_MAIN_NS))
        for border_node in borders:
            yield Border.from_tree(border_node)


    def parse_named_styles(self):
        """
        Extract named styles
        """
        node = self.root.find("{%s}cellStyleXfs" % SHEET_MAIN_NS)
        styles = self._parse_xfs(node)

        names = self._parse_style_names()
        for style in names.values():
            _id = styles[style.xfId]
            style.border = self.border_list[_id.borderId]
            style.fill = self.fill_list[_id.fillId]
            style.font = self.font_list[_id.fontId]
            if _id.alignmentId:
                style.alignment = self.alignments[_id.alignmentId]
            if _id.protectionId:
                style.protection = self.protections[_id.protectionId]
        self.named_styles = names


    def _parse_style_names(self):
        """
        Extract style names. There can be duplicates in which case last wins
        """
        node = self.root.find("{%s}cellStyles" % SHEET_MAIN_NS)
        names = {}
        for _name in safe_iterator(node, '{%s}cellStyle' % SHEET_MAIN_NS):
            name = _name.get("name")
#.........这里部分代码省略.........