openpyxl

https://openpyxl.readthedocs.io/en/stable
Admin
openpyxl is a Python library for reading and writing Excel 2010 xlsx/xlsm/xltx/xltm files, enabling...
Tokens:390,835
Snippets:2,896
Trust Score:8.3
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Create virtual environment and install dependencies

Source: https://openpyxl.readthedocs.io/en/stable/_sources/development.rst.txt

Create a virtual environment, activate it, and install development and production dependencies along with the package itself.

```bash
$ cd openpyxl
$ virtualenv openpyxl-env
```

```bash
$ source bin/activate  # or ./openpyxl-env/Scripts/activate on Windows
```

```bash
(openpyxl-env) $ pip install -U -r requirements.txt
(openpyxl-env) $ pip install -e .
```

--------------------------------

### Install dependencies and package in editable mode

Source: https://openpyxl.readthedocs.io/en/stable/development.html

Install the development and production dependencies from requirements.txt and install the package in editable mode.

```bash
(openpyxl-env) $ pip install -U -r requirements.txt
(openpyxl-env) $ pip install -e .

```

--------------------------------

### Install openpyxl from a checkout

Source: https://openpyxl.readthedocs.io/en/stable/_sources/tutorial.rst.txt

Install a checkout of a particular version of openpyxl, useful when bugs have been fixed but a release has not yet been made.

```bash
$ pip install -e hg+https://foss.heptapod.net/openpyxl/openpyxl/@\ |version|\ #egg=openpyxl
```

--------------------------------

### Edit page setup with orientation and paper size

Source: https://openpyxl.readthedocs.io/en/stable/_sources/styles.rst.txt

Configures page setup: landscape orientation, tabloid paper size, and fit-to-width (1) with fit-to-height disabled (0).

```python
>>> from openpyxl.workbook import Workbook
>>>
>>> wb = Workbook()
>>> ws = wb.active
>>>
>>> ws.page_setup.orientation = ws.ORIENTATION_LANDSCAPE
>>> ws.page_setup.paperSize = ws.PAPERSIZE_TABLOID
>>> ws.page_setup.fitToHeight = 0
>>> ws.page_setup.fitToWidth = 1
```

--------------------------------

### PrintPageSetup

Source: https://openpyxl.readthedocs.io/en/stable/api/openpyxl.worksheet.page.html

Class representing worksheet print page setup.

```APIDOC
## PrintPageSetup

### Description
Worksheet print page setup.

### Constructor
`PrintPageSetup(worksheet=None, orientation=None, paperSize=None, scale=None, fitToHeight=None, fitToWidth=None, firstPageNumber=None, useFirstPageNumber=None, paperHeight=None, paperWidth=None, pageOrder=None, usePrinterDefaults=None, blackAndWhite=None, draft=None, cellComments=None, errors=None, horizontalDpi=None, verticalDpi=None, copies=None, id=None)`

### Parameters
- **worksheet** (object) - Optional - The worksheet object.
- **orientation** (str) - Optional - Page orientation. Must be one of {'portrait', 'default', 'landscape'}.
- **paperSize** (int) - Optional - Paper size.
- **scale** (int) - Optional - Scale factor.
- **fitToHeight** (int) - Optional - Fit to height.
- **fitToWidth** (int) - Optional - Fit to width.
- **firstPageNumber** (int) - Optional - First page number.
- **useFirstPageNumber** (bool) - Optional - Whether to use first page number.
- **paperHeight** (str) - Optional - Paper height.
- **paperWidth** (str) - Optional - Paper width.
- **pageOrder** (str) - Optional - Page order. Must be one of {'downThenOver', 'overThenDown'}.
- **usePrinterDefaults** (bool) - Optional - Whether to use printer defaults.
- **blackAndWhite** (bool) - Optional - Whether to print in black and white.
- **draft** (bool) - Optional - Whether to print in draft mode.
- **cellComments** (str) - Optional - Cell comments. Must be one of {'atEnd', 'asDisplayed'}.
- **errors** (str) - Optional - Error handling. Must be one of {'dash', 'blank', 'displayed', 'NA'}.
- **horizontalDpi** (int) - Optional - Horizontal DPI.
- **verticalDpi** (int) - Optional - Vertical DPI.
- **copies** (int) - Optional - Number of copies.
- **id** (str) - Optional - Identifier.

### Attributes
- **autoPageBreaks** (property) - Auto page breaks property.
- **blackAndWhite** (bool) - Whether to print in black and white.
- **cellComments** (str) - Cell comments. Must be one of {'atEnd', 'asDisplayed'}.
- **copies** (int) - Number of copies.
- **draft** (bool) - Whether to print in draft mode.
- **errors** (str) - Error handling. Must be one of {'dash', 'blank', 'displayed', 'NA'}.
- **firstPageNumber** (int) - First page number.
- **fitToHeight** (int) - Fit to height.
- **fitToPage** (property) - Fit to page property.
- **fitToWidth** (int) - Fit to width.
- **horizontalDpi** (int) - Horizontal DPI.
- **id** (str) - Identifier.
- **orientation** (str) - Page orientation. Must be one of {'portrait', 'default', 'landscape'}.
- **pageOrder** (str) - Page order. Must be one of {'downThenOver', 'overThenDown'}.
- **paperHeight** (str) - Paper height.
- **paperSize** (int) - Paper size.
- **paperWidth** (str) - Paper width.
- **scale** (int) - Scale factor.
- **sheet_properties** (property) - Proxy property.
- **tagname** (str) - XML tag name: 'pageSetup'.
- **useFirstPageNumber** (bool) - Whether to use first page number.
- **usePrinterDefaults** (bool) - Whether to use printer defaults.
- **verticalDpi** (int) - Vertical DPI.

### Methods
#### from_tree(node)
Create object from XML.

##### Parameters
- **node** (object) - Required - XML node.

##### Returns
- **object** - The created object.
```

--------------------------------

### Install pillow for image support

Source: https://openpyxl.readthedocs.io/en/stable/_sources/tutorial.rst.txt

Install the pillow library, required to include images (jpeg, png, bmp,...) into an openpyxl file.

```bash
$ pip install pillow
```

--------------------------------

### Set worksheet properties and page setup

Source: https://openpyxl.readthedocs.io/en/stable/_sources/worksheet_properties.rst.txt

Initializes a workbook and sets worksheet properties: tabColor, filterMode, pageSetUpPr with fitToPage and autoPageBreaks, and outline properties summaryBelow and applyStyles. Note that page setup properties require initializing a PageSetupProperties object first, while outline properties are initialized by default.

```python
>>> from openpyxl.workbook import Workbook
>>> from openpyxl.worksheet.properties import WorksheetProperties, PageSetupProperties
>>>
>>> wb = Workbook()
>>> ws = wb.active
>>>
>>> wsprops = ws.sheet_properties
>>> wsprops.tabColor = "1072BA"
>>> wsprops.filterMode = False
>>> wsprops.pageSetUpPr = PageSetupProperties(fitToPage=True, autoPageBreaks=False)
>>> wsprops.outlinePr.summaryBelow = False
>>> wsprops.outlinePr.applyStyles = True
>>> wsprops.pageSetUpPr.autoPageBreaks = True
```

--------------------------------

### Install openpyxl with pip

Source: https://openpyxl.readthedocs.io/en/stable/_sources/tutorial.rst.txt

Install openpyxl using pip. It is advisable to do this in a Python virtualenv without system packages.

```bash
$ pip install openpyxl
```

--------------------------------

### Import openpyxl and create a workbook

Source: https://openpyxl.readthedocs.io/en/stable/usage.html

Loads the openpyxl library and creates a new workbook, getting the active worksheet. Also defines the tree data as a list of lists.

```python
>>> from openpyxl import Workbook

```

```python
>>> wb = Workbook()
>>> ws = wb.active
>>> treeData = [["Type", "Leaf Color", "Height"], ["Maple", "Red", 549], ["Oak", "Green", 783], ["Pine", "Green", 1204]]

```

--------------------------------

### FileVersion class definition (truncated)

Source: https://openpyxl.readthedocs.io/en/stable/_modules/openpyxl/workbook/properties.html

Starts the FileVersion class definition with the XML tag 'fileVersion'. The source is truncated at this point, so the full class body is not shown.

```python
[docs]
class FileVersion(Serialisable):

    tagname = "fileVersion"
```

--------------------------------

### PrintPageSetup

Source: https://openpyxl.readthedocs.io/en/stable/_modules/openpyxl/worksheet/page.html

Documentation for the PrintPageSetup class, its constructor parameters, properties, and methods.

```APIDOC
## PrintPageSetup

### Description
Represents the print page setup for a worksheet, including orientation, paper size, scaling, and other print-related settings.

### Class
`openpyxl.worksheet.page.PrintPageSetup`

### Constructor Parameters
- **worksheet** (Worksheet) - Optional - The parent worksheet.
- **orientation** (str) - Optional - Page orientation: 'default', 'portrait', or 'landscape'.
- **paperSize** (int) - Optional - Paper size code.
- **scale** (int) - Optional - Scaling percentage.
- **fitToHeight** (int) - Optional - Number of pages tall to fit.
- **fitToWidth** (int) - Optional - Number of pages wide to fit.
- **firstPageNumber** (int) - Optional - First page number.
- **useFirstPageNumber** (bool) - Optional - Whether to use the first page number.
- **paperHeight** (str) - Optional - Paper height in universal measure.
- **paperWidth** (str) - Optional - Paper width in universal measure.
- **pageOrder** (str) - Optional - Page order: 'downThenOver' or 'overThenDown'.
- **usePrinterDefaults** (bool) - Optional - Use printer defaults.
- **blackAndWhite** (bool) - Optional - Print in black and white.
- **draft** (bool) - Optional - Draft quality.
- **cellComments** (str) - Optional - Cell comment printing: 'asDisplayed' or 'atEnd'.
- **errors** (str) - Optional - Error handling: 'displayed', 'blank', 'dash', or 'NA'.
- **horizontalDpi** (int) - Optional - Horizontal DPI.
- **verticalDpi** (int) - Optional - Vertical DPI.
- **copies** (int) - Optional - Number of copies.
- **id** (str) - Optional - Relation ID.

### Properties
- **sheet_properties** - Proxy property to the parent worksheet's sheet properties.
- **fitToPage** (bool) - Get or set whether to fit to page.
- **autoPageBreaks** (bool) - Get or set whether to use automatic page breaks.

### Methods
- **from_tree(cls, node)** - Class method to create an instance from an XML tree. Strips the id attribute.

### Example
```python
from openpyxl.worksheet.page import PrintPageSetup

page_setup = PrintPageSetup(
    worksheet=ws,
    orientation='landscape',
    paperSize=9,
    fitToWidth=1,
    fitToHeight=1
)
```
```

--------------------------------

### get_column_interval(start, end)

Source: https://openpyxl.readthedocs.io/en/stable/api/openpyxl.utils.cell.html

Given the start and end columns, returns all the columns in the series.

```APIDOC
## get_column_interval(start, end)

### Description
Given the start and end columns, return all the columns in the series. The start and end columns can be either column letters or 1-based indexes.

### Parameters
- **start** (str or int) - Required - The start column (letter or 1-based index).
- **end** (str or int) - Required - The end column (letter or 1-based index).

### Returns
- **list** - A list of column letters in the interval.

```

--------------------------------

### _write_chartsheets method for ExcelWriter

Source: https://openpyxl.readthedocs.io/en/stable/_modules/openpyxl/writer/excel.html

Starts the _write_chartsheets method, iterating over workbook chartsheets with an index starting at 1.

```python
def _write_chartsheets(self):
    for idx, sheet in enumerate(self.workbook.chartsheets, 1):
```

--------------------------------

### Build documentation with tox -e doc

Source: https://openpyxl.readthedocs.io/en/stable/_sources/development.rst.txt

Run the documentation build with tox to check that documentation is syntactically correct.

```bash
tox -e doc
```

--------------------------------

### Create a spreadsheet and bar chart with openpyxl

Source: https://openpyxl.readthedocs.io/en/stable/_sources/usage.rst.txt

This is a step-by-step example that creates a workbook, adds tree data, applies bold font to the header row, creates a bar chart, and saves the file. The steps are sequential and build on each other, so they are grouped together.

```python
>>> from openpyxl import Workbook

>>> wb = Workbook()
>>> ws = wb.active
>>> treeData = [["Type", "Leaf Color", "Height"], ["Maple", "Red", 549], ["Oak", "Green", 783], ["Pine", "Green", 1204]]
```

```python
>>> for row in treeData:
...     ws.append(row)
```

```python
>>> from openpyxl.styles import Font

>>> ft = Font(bold=True)
>>> for row in ws["A1:C1"]:
...     for cell in row:
...         cell.font = ft
```

```python
>>> from openpyxl.chart import BarChart, Series, Reference

>>> chart = BarChart()
>>> chart.type = "col"
>>> chart.title = "Tree Height"
>>> chart.y_axis.title = 'Height (cm)'
>>> chart.x_axis.title = 'Tree Type'
>>> chart.legend = None
```

```python
>>> data = Reference(ws, min_col=3, min_row=2, max_row=4, max_col=3)
>>> categories = Reference(ws, min_col=1, min_row=2, max_row=4, max_col=1)

>>> chart.add_data(data)
>>> chart.set_categories(categories)
```

```python
>>> ws.add_chart(chart, "E1")
>>> wb.save("TreeData.xlsx")
```

--------------------------------

### Get the active worksheet

Source: https://openpyxl.readthedocs.io/en/stable/_sources/tutorial.rst.txt

Get the first worksheet using the Workbook.active property. It is set to 0 by default.

```python
>>> ws = wb.active
```

--------------------------------

### Complete example: chart and legend layouts

Source: https://openpyxl.readthedocs.io/en/stable/charts/chart_layout.html

Creates a workbook with four scatter charts demonstrating default layout, manual chart layout, edge mode, and manual legend layout. Saves the result to 'chart_layout.xlsx'.

```python
from openpyxl import Workbook, load_workbook
from openpyxl.chart import ScatterChart, Series, Reference
from openpyxl.chart.layout import Layout, ManualLayout

wb = Workbook()
ws = wb.active

rows = [
    ['Size', 'Batch 1', 'Batch 2'],
    [2, 40, 30],
    [3, 40, 25],
    [4, 50, 30],
    [5, 30, 25],
    [6, 25, 35],
    [7, 20, 40],
]

for row in rows:
    ws.append(row)

ch1 = ScatterChart()
xvalues = Reference(ws, min_col=1, min_row=2, max_row=7)
for i in range(2, 4):
    values = Reference(ws, min_col=i, min_row=1, max_row=7)
    series = Series(values, xvalues, title_from_data=True)
    ch1.series.append(series)


ch1.title = "Default layout"
ch1.style = 13
ch1.x_axis.title = 'Size'
ch1.y_axis.title = 'Percentage'
ch1.legend.position = 'r'

ws.add_chart(ch1, "B10")

from copy import deepcopy

# Half-size chart, bottom right
ch2 = deepcopy(ch1)
ch2.title = "Manual chart layout"
ch2.legend.position = "tr"
ch2.layout=Layout(
    manualLayout=ManualLayout(
        x=0.25, y=0.25,
        h=0.5, w=0.5,
    )
)
ws.add_chart(ch2, "H10")

# Half-size chart, centred
ch3 = deepcopy(ch1)
ch3.layout = Layout(
    ManualLayout(
    x=0.25, y=0.25,
    h=0.5, w=0.5,
    xMode="edge",
    yMode="edge",
    )
)
ch3.title = "Manual chart layout, edge mode"
ws.add_chart(ch3, "B27")

# Manually position the legend bottom left
ch4 = deepcopy(ch1)
ch4.title = "Manual legend layout"
ch4.legend.layout = Layout(
    manualLayout=ManualLayout(
        yMode='edge',
        xMode='edge',
        x=0, y=0.9,
        h=0.1, w=0.5
    )
)

ws.add_chart(ch4, "H27")

wb.save("chart_layout.xlsx")

```

--------------------------------

### Use indexed and theme colors

Source: https://openpyxl.readthedocs.io/en/stable/styles.html

Shows how to create Color objects using indexed or theme and tint parameters for legacy indexed colors and theme colors.

```python
>>> from openpyxl.styles.colors import Color
>>> c = Color(indexed=32)
>>> c = Color(theme=6, tint=0.5)
```

--------------------------------

### Create a workbook with openpyxl

Source: https://openpyxl.readthedocs.io/en/stable/_sources/tutorial.rst.txt

Import the Workbook class and create a new workbook. No file is created on the filesystem.

```python
>>> from openpyxl import Workbook
>>> wb = Workbook()
```

--------------------------------

### Workbook.active

Source: https://openpyxl.readthedocs.io/en/stable/api/openpyxl.workbook.workbook.html

Gets the currently active sheet or None.

```APIDOC
## Workbook.active

### Description
Get the currently active sheet or None.

### Property
`active`

### Returns
- `openpyxl.worksheet.worksheet.Worksheet` or `None` - The active worksheet.
```

--------------------------------

### DashStopList

Source: https://openpyxl.readthedocs.io/en/stable/api/openpyxl.drawing.line.html

Documentation for the DashStopList class, its constructor, and its attributes.

```APIDOC
## Class: DashStopList

### Description
Represents a list of dash stops.

### Constructor
`DashStopList(_ds=None)`

### Attributes
- **ds** (sequence of DashStop) - A sequence of DashStop objects.

```

--------------------------------

### Access worksheet by name

Source: https://openpyxl.readthedocs.io/en/stable/_sources/tutorial.rst.txt

Get a worksheet by its name as a key of the workbook.

```python
>>> ws3 = wb["New Title"]
```

--------------------------------

### Run tests with tox

Source: https://openpyxl.readthedocs.io/en/stable/_sources/development.rst.txt

Run tests on different Python versions and configurations using tox.

```bash
$ tox openpyxl
```

--------------------------------

### Append sample data to worksheet

Source: https://openpyxl.readthedocs.io/en/stable/formatting.html

Populates a worksheet with sample data for the conditional formatting example. The data includes software names, developers, and versions, with rows for Excel, openpyxl, OpenOffice, and Word.

```python
>>> ws.append(['Software', 'Developer', 'Version'])
>>> ws.append(['Excel', 'Microsoft', '2016'])
>>> ws.append(['openpyxl', 'Open source', '2.6'])
>>> ws.append(['OpenOffice', 'Apache', '4.1.4'])
>>> ws.append(['Word', 'Microsoft', '2010'])
```

--------------------------------

### Worksheet.delete_rows(idx, amount=1)

Source: https://openpyxl.readthedocs.io/en/stable/api/openpyxl.worksheet.worksheet.html

Deletes a row or rows starting from the given index.

```APIDOC
## Worksheet.delete_rows(idx, amount=1)

### Description
Delete row or rows from row==idx.

### Method
delete_rows

### Parameters
- **idx** (int) - Required - Row index to start deleting from.
- **amount** (int) - Optional - Number of rows to delete. Default is 1.

### Return Type
None
```

--------------------------------

### Worksheet.delete_cols(idx, amount=1)

Source: https://openpyxl.readthedocs.io/en/stable/api/openpyxl.worksheet.worksheet.html

Deletes a column or columns starting from the given index.

```APIDOC
## Worksheet.delete_cols(idx, amount=1)

### Description
Delete column or columns from col==idx.

### Method
delete_cols

### Parameters
- **idx** (int) - Required - Column index to start deleting from.
- **amount** (int) - Optional - Number of columns to delete. Default is 1.

### Return Type
None
```

--------------------------------

### Create sample bar charts with openpyxl

Source: https://openpyxl.readthedocs.io/en/stable/charts/anchors.html

Creates a workbook with sample data and four bar charts (vertical, horizontal, stacked, percent stacked) using openpyxl. The charts are added to specific cells (A10, G10, A27, G27) and saved as bar.xlsx. This is the base chart setup used to demonstrate anchor changes.

```python
from openpyxl import Workbook
from openpyxl.chart import BarChart, Series, Reference

wb = Workbook(write_only=True)
ws = wb.create_sheet()

rows = [
    ('Number', 'Batch 1', 'Batch 2'),
    (2, 10, 30),
    (3, 40, 60),
    (4, 50, 70),
    (5, 20, 10),
    (6, 10, 40),
    (7, 50, 30),
]


for row in rows:
    ws.append(row)


chart1 = BarChart()
chart1.type = "col"
chart1.style = 10
chart1.title = "Bar Chart"
chart1.y_axis.title = 'Test number'
chart1.x_axis.title = 'Sample length (mm)'

data = Reference(ws, min_col=2, min_row=1, max_row=7, max_col=3)
cats = Reference(ws, min_col=1, min_row=2, max_row=7)
chart1.add_data(data, titles_from_data=True)
chart1.set_categories(cats)
chart1.shape = 4
ws.add_chart(chart1, "A10")

from copy import deepcopy

chart2 = deepcopy(chart1)
chart2.style = 11
chart2.type = "bar"
chart2.title = "Horizontal Bar Chart"

ws.add_chart(chart2, "G10")


chart3 = deepcopy(chart1)
chart3.type = "col"
chart3.style = 12
chart3.grouping = "stacked"
chart3.overlap = 100
chart3.title = 'Stacked Chart'

ws.add_chart(chart3, "A27")


chart4 = deepcopy(chart1)
chart4.type = "bar"
chart4.style = 13
chart4.grouping = "percentStacked"
chart4.overlap = 100
chart4.title = 'Percent Stacked Chart'

ws.add_chart(chart4, "G27")

wb.save("bar.xlsx")
```

--------------------------------

### PhoneticText

Source: https://openpyxl.readthedocs.io/en/stable/api/openpyxl.cell.text.html

Represents a phonetic text run with start and end indices and the text content.

```APIDOC
## PhoneticText

### Description
Represents a phonetic text run.

### Class
`openpyxl.cell.text.PhoneticText`

### Bases
`Serialisable`

### Attributes
- **eb** (int) - Values must be of type <class 'int'>
- **sb** (int) - Values must be of type <class 'int'>
- **t** (str) - Values must be of type <class 'str'>

### Aliases
- **text** - Alias for the 't' attribute.

### Class Attributes
- **tagname** = 'rPh'
```

--------------------------------

### Create a ColorScale rule with FormatObject and Color

Source: https://openpyxl.readthedocs.io/en/stable/_sources/formatting.rst.txt

Full syntax for creating a ColorScale rule with 2 or 3 colors. The example builds a 2-color scale and then extends it to a 3-color scale by inserting a middle FormatObject and color.

```python
>>> from openpyxl.formatting.rule import ColorScale, FormatObject
>>> from openpyxl.styles import Color
>>> first = FormatObject(type='min')
>>> last = FormatObject(type='max')
>>> # colors match the format objects:
>>> colors = [Color('AA0000'), Color('00AA00')]
>>> cs2 = ColorScale(cfvo=[first, last], color=colors)
>>> # a three color scale would extend the sequences
>>> mid = FormatObject(type='num', val=40)
>>> colors.insert(1, Color('00AA00'))
>>> cs3 = ColorScale(cfvo=[first, mid, last], color=colors)
>>> # create a rule with the color scale
>>> from openpyxl.formatting.rule import Rule
>>> rule = Rule(type='colorScale', colorScale=cs3)
```

--------------------------------

### Get coverage information

Source: https://openpyxl.readthedocs.io/en/stable/_sources/development.rst.txt

Obtain coverage information for unit tests using pytest-cov.

```bash
py.test --cov openpyxl
```

--------------------------------

### PrintOptions

Source: https://openpyxl.readthedocs.io/en/stable/_modules/openpyxl/worksheet/page.html

Documentation for the PrintOptions class and its constructor parameters.

```APIDOC
## PrintOptions

### Description
Represents print options for a worksheet, such as centering, headings, and grid lines.

### Class
`openpyxl.worksheet.page.PrintOptions`

### Constructor Parameters
- **horizontalCentered** (bool) - Optional - Center horizontally on the page.
- **verticalCentered** (bool) - Optional - Center vertically on the page.
- **headings** (bool) - Optional - Print row and column headings.
- **gridLines** (bool) - Optional - Print grid lines.
- **gridLinesSet** (bool) - Optional - Whether grid lines are set.

### Example
```python
from openpyxl.worksheet.page import PrintOptions

print_options = PrintOptions(
    horizontalCentered=True,
    verticalCentered=True,
    headings=False,
    gridLines=True
)
```
```

--------------------------------

### OneCellAnchor class definition

Source: https://openpyxl.readthedocs.io/en/stable/_modules/openpyxl/drawing/spreadsheet_drawing.html

Defines the OneCellAnchor class with a starting marker and extent, inheriting from _AnchorBase.

```python
[docs]
class OneCellAnchor(_AnchorBase):

    tagname = "oneCellAnchor"

    _from = Typed(expected_type=AnchorMarker)
    ext = Typed(expected_type=XDRPositiveSize2D)

    sp = _AnchorBase.sp
    grpSp = _AnchorBase.grpSp
    graphicFrame = _AnchorBase.graphicFrame
    cxnSp = _AnchorBase.cxnSp
    pic = _AnchorBase.pic
    contentPart = _AnchorBase.contentPart
    clientData = _AnchorBase.clientData

    __elements__ = ('_from', 'ext') + _AnchorBase.__elements__


    def __init__(self,
                 _from=None,
                 ext=None,
                 **kw
                ):
        if _from is None:
            _from = AnchorMarker()
        self._from = _from
        if ext is None:
            ext = XDRPositiveSize2D(0, 0)
        self.ext = ext
        super(OneCellAnchor, self).__init__(**kw)
```

--------------------------------

### PrintSettings

Source: https://openpyxl.readthedocs.io/en/stable/api/openpyxl.chart.print_settings.html

Represents print settings for a chart, including header/footer, page margins, and page setup.

```APIDOC
## PrintSettings

### Description
Represents print settings for a chart, including header/footer, page margins, and page setup.

### Constructor
`PrintSettings(headerFooter=None, pageMargins=None, pageSetup=None)`

### Parameters
- `headerFooter` (HeaderFooter) - Optional - Header and footer settings.
- `pageMargins` (PageMargins) - Optional - Page margins.
- `pageSetup` (PrintPageSetup) - Optional - Page setup settings.

### Attributes
- `headerFooter` (HeaderFooter) - Header and footer settings. Values must be of type openpyxl.worksheet.header_footer.HeaderFooter.
- `pageMargins` (PageMargins) - Page margins. Values must be of type openpyxl.chart.print_settings.PageMargins.
- `pageSetup` (PrintPageSetup) - Page setup settings. Values must be of type openpyxl.worksheet.page.PrintPageSetup.
- `tagname` (str) - XML tag name for the element. Default: 'printSettings'.
```

--------------------------------

### Manifest find and findall methods

Source: https://openpyxl.readthedocs.io/en/stable/_modules/openpyxl/packaging/manifest.html

Find the first or all elements of a specific content type in the overrides. find returns None if not found.

```python
[docs]
    def find(self, content_type):
        """
        Find specific content-type
        """
        try:
            return next(self.findall(content_type))
        except StopIteration:
            return






[docs]
    def findall(self, content_type):
        """
        Find all elements of a specific content-type
        """
        for t in self.Override:
            if t.ContentType == content_type:
                yield t
```

--------------------------------

### dataframe_to_rows function

Source: https://openpyxl.readthedocs.io/en/stable/_modules/openpyxl/utils/dataframe.html

Converts a Pandas DataFrame into rows suitable for a worksheet. If index is True, the index is included starting one row below the header; if header is True, column headers are included starting one column to the right. Handles MultiIndex columns and index levels, converting numpy.datetime64 values to pandas Timestamp. Formatting is left to client code.

```python
def dataframe_to_rows(df, index=True, header=True):
    """
    Convert a Pandas dataframe into something suitable for passing into a worksheet.
    If index is True then the index will be included, starting one row below the header.
    If header is True then column headers will be included starting one column to the right.
    Formatting should be done by client code.
    """
    from pandas import Timestamp

    if header:
        if df.columns.nlevels > 1:
            rows = expand_index(df.columns, header)
        else:
            rows = [list(df.columns.values)]
        for row in rows:
            n = []
            for v in row:
                if isinstance(v, numpy.datetime64):
                    v = Timestamp(v)
                n.append(v)
            row = n
            if index:
                row = [None]*df.index.nlevels + row
            yield row

    if index:
        yield df.index.names

    expanded = ([v] for v in df.index)
    if df.index.nlevels > 1:
        expanded = expand_index(df.index)

    # Using the expanded index is preferable to df.itertuples(index=True) so that we have 'None' inserted where applicable
    for (df_index, row) in zip(expanded, df.itertuples(index=False)):
        row = list(row)
        if index:
            row = df_index + row
        yield row
```

--------------------------------

### DataBarRule

Source: https://openpyxl.readthedocs.io/en/stable/api/openpyxl.formatting.rule.html

Creates a data bar rule with start and end types, values, color, and display options.

```APIDOC
## DataBarRule

### Description
Creates a data bar rule for conditional formatting. It allows specifying the start and end types, values, color, and whether to show the value.

### Constructor
`DataBarRule(start_type=None, start_value=None, end_type=None, end_value=None, color=None, showValue=None, minLength=None, maxLength=None)`

### Parameters
- **start_type** (str) - Optional - The type for the start of the data bar (e.g., 'min', 'num', 'percent').
- **start_value** (float) - Optional - The value for the start of the data bar.
- **end_type** (str) - Optional - The type for the end of the data bar.
- **end_value** (float) - Optional - The value for the end of the data bar.
- **color** (Color) - Optional - The color of the data bar.
- **showValue** (bool) - Optional - Whether to show the cell value.
- **minLength** (int) - Optional - The minimum length of the data bar.
- **maxLength** (int) - Optional - The maximum length of the data bar.

### Returns
A `DataBarRule` object.
```

--------------------------------

### Create an IconSet rule with IconSet and FormatObject

Source: https://openpyxl.readthedocs.io/en/stable/_sources/formatting.rst.txt

Full syntax for creating an IconSet rule using the IconSet class and FormatObject. The example uses the '3TrafficLights1' icon set with percent thresholds at 0, 33, and 67.

```python
>>> from openpyxl.formatting.rule import IconSet, FormatObject
>>> first = FormatObject(type='percent', val=0)
>>> second = FormatObject(type='percent', val=33)
>>> third = FormatObject(type='percent', val=67)
>>> iconset = IconSet(iconSet='3TrafficLights1', cfvo=[first, second, third], showValue=None, percent=None, reverse=None)
>>> # assign the icon set to a rule
>>> from openpyxl.formatting.rule import Rule
>>> rule = Rule(type='iconSet', iconSet=iconset)
```

--------------------------------

### Create and save an Excel workbook with openpyxl

Source: https://openpyxl.readthedocs.io/en/stable/index.html

Sample code from the openpyxl documentation showing how to create a workbook, access the active worksheet, assign values to cells, append rows, convert Python types automatically, and save the file.

```python
from openpyxl import Workbook
wb = Workbook()

# grab the active worksheet
ws = wb.active

# Data can be assigned directly to cells
ws['A1'] = 42

# Rows can also be appended
ws.append([1, 2, 3])

# Python types will automatically be converted
import datetime
ws['A2'] = datetime.datetime.now()

# Save the file
wb.save("sample.xlsx")
```

--------------------------------

### NonVisualConnectorProperties

Source: https://openpyxl.readthedocs.io/en/stable/api/openpyxl.drawing.connector.html

Represents non-visual properties for a connector, including locking, start and end connections, and extension list.

```APIDOC
## NonVisualConnectorProperties

### Description
Represents non-visual properties for a connector.

### Attributes
- **cxnSpLocks** (ConnectorLocking) - Required - Values must be of type <class 'openpyxl.drawing.connector.ConnectorLocking'>
- **endCxn** (Connection) - Required - Values must be of type <class 'openpyxl.drawing.connector.Connection'>
- **extLst** (ExtensionList) - Required - Values must be of type <class 'openpyxl.descriptors.excel.ExtensionList'>
- **stCxn** (Connection) - Required - Values must be of type <class 'openpyxl.drawing.connector.Connection'>

```

--------------------------------

### cols_from_range(range_string)

Source: https://openpyxl.readthedocs.io/en/stable/api/openpyxl.utils.cell.html

Gets individual addresses for every cell in a range, yielding one row at a time.

```APIDOC
## cols_from_range(range_string)

### Description
Get individual addresses for every cell in a range. Yields one row at a time.

### Parameters
- **range_string** (str) - Required - The range string (e.g., 'A1:C3').

### Yields
- **str** - Individual cell addresses.

```

--------------------------------

### Create a workbook with Workbook()

Source: https://openpyxl.readthedocs.io/en/stable/tutorial.html

Creates a new workbook in memory without creating a file on the filesystem. The workbook is always created with at least one worksheet.

```python
>>> from openpyxl import Workbook
>>> wb = Workbook()

```

--------------------------------

### Run tests for a specific module

Source: https://openpyxl.readthedocs.io/en/stable/_sources/development.rst.txt

Run tests for a specific package/module to get statistics for code under development.

```bash
py.test --cov openpyxl/cell openpyxl/cell
```
Tokens:
Raw