diff --git a/mplug_owl2/lib/python3.10/site-packages/pandas/io/__pycache__/_util.cpython-310.pyc b/mplug_owl2/lib/python3.10/site-packages/pandas/io/__pycache__/_util.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e4218eb995c21d43eeda66d33c407703141d40f9
Binary files /dev/null and b/mplug_owl2/lib/python3.10/site-packages/pandas/io/__pycache__/_util.cpython-310.pyc differ
diff --git a/mplug_owl2/lib/python3.10/site-packages/pandas/io/__pycache__/api.cpython-310.pyc b/mplug_owl2/lib/python3.10/site-packages/pandas/io/__pycache__/api.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4e0a44c7fc783c63bb4b8acbf2c7727798c52a5f
Binary files /dev/null and b/mplug_owl2/lib/python3.10/site-packages/pandas/io/__pycache__/api.cpython-310.pyc differ
diff --git a/mplug_owl2/lib/python3.10/site-packages/pandas/io/__pycache__/clipboards.cpython-310.pyc b/mplug_owl2/lib/python3.10/site-packages/pandas/io/__pycache__/clipboards.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8a3bce52c92174ce4ced0b8e4c6e95c745c44b02
Binary files /dev/null and b/mplug_owl2/lib/python3.10/site-packages/pandas/io/__pycache__/clipboards.cpython-310.pyc differ
diff --git a/mplug_owl2/lib/python3.10/site-packages/pandas/io/__pycache__/common.cpython-310.pyc b/mplug_owl2/lib/python3.10/site-packages/pandas/io/__pycache__/common.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b94fbe69ccb9198450ed82f43117bf11931be23c
Binary files /dev/null and b/mplug_owl2/lib/python3.10/site-packages/pandas/io/__pycache__/common.cpython-310.pyc differ
diff --git a/mplug_owl2/lib/python3.10/site-packages/pandas/io/__pycache__/feather_format.cpython-310.pyc b/mplug_owl2/lib/python3.10/site-packages/pandas/io/__pycache__/feather_format.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cbb2cbce60c72699e0459a3b7cf2c617ce76243d
Binary files /dev/null and b/mplug_owl2/lib/python3.10/site-packages/pandas/io/__pycache__/feather_format.cpython-310.pyc differ
diff --git a/mplug_owl2/lib/python3.10/site-packages/pandas/io/__pycache__/gbq.cpython-310.pyc b/mplug_owl2/lib/python3.10/site-packages/pandas/io/__pycache__/gbq.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a0051d1f437a1b2627d050514f81e401fc6ac1d6
Binary files /dev/null and b/mplug_owl2/lib/python3.10/site-packages/pandas/io/__pycache__/gbq.cpython-310.pyc differ
diff --git a/mplug_owl2/lib/python3.10/site-packages/pandas/io/__pycache__/html.cpython-310.pyc b/mplug_owl2/lib/python3.10/site-packages/pandas/io/__pycache__/html.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2d8746d6eec478d96a95faa9d32c8dbd486def8d
Binary files /dev/null and b/mplug_owl2/lib/python3.10/site-packages/pandas/io/__pycache__/html.cpython-310.pyc differ
diff --git a/mplug_owl2/lib/python3.10/site-packages/pandas/io/__pycache__/orc.cpython-310.pyc b/mplug_owl2/lib/python3.10/site-packages/pandas/io/__pycache__/orc.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..374e20025eb6291ba293619c6b6170cc5134e554
Binary files /dev/null and b/mplug_owl2/lib/python3.10/site-packages/pandas/io/__pycache__/orc.cpython-310.pyc differ
diff --git a/mplug_owl2/lib/python3.10/site-packages/pandas/io/__pycache__/parquet.cpython-310.pyc b/mplug_owl2/lib/python3.10/site-packages/pandas/io/__pycache__/parquet.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7669d7222d34d8495f235a7f30cc0503728ac5e7
Binary files /dev/null and b/mplug_owl2/lib/python3.10/site-packages/pandas/io/__pycache__/parquet.cpython-310.pyc differ
diff --git a/mplug_owl2/lib/python3.10/site-packages/pandas/io/__pycache__/sql.cpython-310.pyc b/mplug_owl2/lib/python3.10/site-packages/pandas/io/__pycache__/sql.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1812d32492dd1645443cea3925e0f99876e71ead
Binary files /dev/null and b/mplug_owl2/lib/python3.10/site-packages/pandas/io/__pycache__/sql.cpython-310.pyc differ
diff --git a/mplug_owl2/lib/python3.10/site-packages/pandas/io/__pycache__/xml.cpython-310.pyc b/mplug_owl2/lib/python3.10/site-packages/pandas/io/__pycache__/xml.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b28d9fb231c7abdc5df6b68b78b5dd5cfe7950fd
Binary files /dev/null and b/mplug_owl2/lib/python3.10/site-packages/pandas/io/__pycache__/xml.cpython-310.pyc differ
diff --git a/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/__init__.py b/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..275cbf0148f944eb04ca6c40c624cc5df77aa626
--- /dev/null
+++ b/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/__init__.py
@@ -0,0 +1,19 @@
+from pandas.io.excel._base import (
+ ExcelFile,
+ ExcelWriter,
+ read_excel,
+)
+from pandas.io.excel._odswriter import ODSWriter as _ODSWriter
+from pandas.io.excel._openpyxl import OpenpyxlWriter as _OpenpyxlWriter
+from pandas.io.excel._util import register_writer
+from pandas.io.excel._xlsxwriter import XlsxWriter as _XlsxWriter
+
+__all__ = ["read_excel", "ExcelWriter", "ExcelFile"]
+
+
+register_writer(_OpenpyxlWriter)
+
+register_writer(_XlsxWriter)
+
+
+register_writer(_ODSWriter)
diff --git a/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/__pycache__/__init__.cpython-310.pyc b/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ca97e120e96fc1d96c18adedfe0ac47875a4c985
Binary files /dev/null and b/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/__pycache__/__init__.cpython-310.pyc differ
diff --git a/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/__pycache__/_base.cpython-310.pyc b/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/__pycache__/_base.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..276174bc6ab6c7cc6a8204bd5a9691e745e47cbe
Binary files /dev/null and b/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/__pycache__/_base.cpython-310.pyc differ
diff --git a/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/__pycache__/_calamine.cpython-310.pyc b/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/__pycache__/_calamine.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ea9dc5aa76f93f9851ff34f491e772d55e7838f3
Binary files /dev/null and b/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/__pycache__/_calamine.cpython-310.pyc differ
diff --git a/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/__pycache__/_odfreader.cpython-310.pyc b/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/__pycache__/_odfreader.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..30801118f1c907899690231d287b004227383125
Binary files /dev/null and b/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/__pycache__/_odfreader.cpython-310.pyc differ
diff --git a/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/__pycache__/_odswriter.cpython-310.pyc b/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/__pycache__/_odswriter.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..dd3f5a6ae4a7d3f0142dfc444c26501ac87d3f4b
Binary files /dev/null and b/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/__pycache__/_odswriter.cpython-310.pyc differ
diff --git a/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/__pycache__/_openpyxl.cpython-310.pyc b/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/__pycache__/_openpyxl.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..700f85131b90c46f0642aae7fe71e573814db50f
Binary files /dev/null and b/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/__pycache__/_openpyxl.cpython-310.pyc differ
diff --git a/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/__pycache__/_pyxlsb.cpython-310.pyc b/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/__pycache__/_pyxlsb.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b3ea188fc09f5ed8397629821d412402e910a125
Binary files /dev/null and b/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/__pycache__/_pyxlsb.cpython-310.pyc differ
diff --git a/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/__pycache__/_util.cpython-310.pyc b/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/__pycache__/_util.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..17e4991734795249a04450a76d55bcafcff7c26d
Binary files /dev/null and b/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/__pycache__/_util.cpython-310.pyc differ
diff --git a/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/__pycache__/_xlrd.cpython-310.pyc b/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/__pycache__/_xlrd.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c27eccedd314c96baa97db4242cd5c2d6e9c6abe
Binary files /dev/null and b/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/__pycache__/_xlrd.cpython-310.pyc differ
diff --git a/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/__pycache__/_xlsxwriter.cpython-310.pyc b/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/__pycache__/_xlsxwriter.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9f7ff66dad0a335375fd69820e54f144c51f2969
Binary files /dev/null and b/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/__pycache__/_xlsxwriter.cpython-310.pyc differ
diff --git a/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/_base.py b/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/_base.py
new file mode 100644
index 0000000000000000000000000000000000000000..786f719337b84a29e5b6ea7577edd412b596920f
--- /dev/null
+++ b/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/_base.py
@@ -0,0 +1,1659 @@
+from __future__ import annotations
+
+from collections.abc import (
+ Hashable,
+ Iterable,
+ Mapping,
+ Sequence,
+)
+import datetime
+from functools import partial
+from io import BytesIO
+import os
+from textwrap import fill
+from typing import (
+ IO,
+ TYPE_CHECKING,
+ Any,
+ Callable,
+ Generic,
+ Literal,
+ TypeVar,
+ Union,
+ cast,
+ overload,
+)
+import warnings
+import zipfile
+
+from pandas._config import config
+
+from pandas._libs import lib
+from pandas._libs.parsers import STR_NA_VALUES
+from pandas.compat._optional import (
+ get_version,
+ import_optional_dependency,
+)
+from pandas.errors import EmptyDataError
+from pandas.util._decorators import (
+ Appender,
+ doc,
+)
+from pandas.util._exceptions import find_stack_level
+from pandas.util._validators import check_dtype_backend
+
+from pandas.core.dtypes.common import (
+ is_bool,
+ is_float,
+ is_integer,
+ is_list_like,
+)
+
+from pandas.core.frame import DataFrame
+from pandas.core.shared_docs import _shared_docs
+from pandas.util.version import Version
+
+from pandas.io.common import (
+ IOHandles,
+ get_handle,
+ stringify_path,
+ validate_header_arg,
+)
+from pandas.io.excel._util import (
+ fill_mi_header,
+ get_default_engine,
+ get_writer,
+ maybe_convert_usecols,
+ pop_header_name,
+)
+from pandas.io.parsers import TextParser
+from pandas.io.parsers.readers import validate_integer
+
+if TYPE_CHECKING:
+ from types import TracebackType
+
+ from pandas._typing import (
+ DtypeArg,
+ DtypeBackend,
+ ExcelWriterIfSheetExists,
+ FilePath,
+ IntStrT,
+ ReadBuffer,
+ Self,
+ SequenceNotStr,
+ StorageOptions,
+ WriteExcelBuffer,
+ )
+_read_excel_doc = (
+ """
+Read an Excel file into a ``pandas`` ``DataFrame``.
+
+Supports `xls`, `xlsx`, `xlsm`, `xlsb`, `odf`, `ods` and `odt` file extensions
+read from a local filesystem or URL. Supports an option to read
+a single sheet or a list of sheets.
+
+Parameters
+----------
+io : str, bytes, ExcelFile, xlrd.Book, path object, or file-like object
+ Any valid string path is acceptable. The string could be a URL. Valid
+ URL schemes include http, ftp, s3, and file. For file URLs, a host is
+ expected. A local file could be: ``file://localhost/path/to/table.xlsx``.
+
+ If you want to pass in a path object, pandas accepts any ``os.PathLike``.
+
+ By file-like object, we refer to objects with a ``read()`` method,
+ such as a file handle (e.g. via builtin ``open`` function)
+ or ``StringIO``.
+
+ .. deprecated:: 2.1.0
+ Passing byte strings is deprecated. To read from a
+ byte string, wrap it in a ``BytesIO`` object.
+sheet_name : str, int, list, or None, default 0
+ Strings are used for sheet names. Integers are used in zero-indexed
+ sheet positions (chart sheets do not count as a sheet position).
+ Lists of strings/integers are used to request multiple sheets.
+ Specify ``None`` to get all worksheets.
+
+ Available cases:
+
+ * Defaults to ``0``: 1st sheet as a `DataFrame`
+ * ``1``: 2nd sheet as a `DataFrame`
+ * ``"Sheet1"``: Load sheet with name "Sheet1"
+ * ``[0, 1, "Sheet5"]``: Load first, second and sheet named "Sheet5"
+ as a dict of `DataFrame`
+ * ``None``: All worksheets.
+
+header : int, list of int, default 0
+ Row (0-indexed) to use for the column labels of the parsed
+ DataFrame. If a list of integers is passed those row positions will
+ be combined into a ``MultiIndex``. Use None if there is no header.
+names : array-like, default None
+ List of column names to use. If file contains no header row,
+ then you should explicitly pass header=None.
+index_col : int, str, list of int, default None
+ Column (0-indexed) to use as the row labels of the DataFrame.
+ Pass None if there is no such column. If a list is passed,
+ those columns will be combined into a ``MultiIndex``. If a
+ subset of data is selected with ``usecols``, index_col
+ is based on the subset.
+
+ Missing values will be forward filled to allow roundtripping with
+ ``to_excel`` for ``merged_cells=True``. To avoid forward filling the
+ missing values use ``set_index`` after reading the data instead of
+ ``index_col``.
+usecols : str, list-like, or callable, default None
+ * If None, then parse all columns.
+ * If str, then indicates comma separated list of Excel column letters
+ and column ranges (e.g. "A:E" or "A,C,E:F"). Ranges are inclusive of
+ both sides.
+ * If list of int, then indicates list of column numbers to be parsed
+ (0-indexed).
+ * If list of string, then indicates list of column names to be parsed.
+ * If callable, then evaluate each column name against it and parse the
+ column if the callable returns ``True``.
+
+ Returns a subset of the columns according to behavior above.
+dtype : Type name or dict of column -> type, default None
+ Data type for data or columns. E.g. {{'a': np.float64, 'b': np.int32}}
+ Use ``object`` to preserve data as stored in Excel and not interpret dtype,
+ which will necessarily result in ``object`` dtype.
+ If converters are specified, they will be applied INSTEAD
+ of dtype conversion.
+ If you use ``None``, it will infer the dtype of each column based on the data.
+engine : {{'openpyxl', 'calamine', 'odf', 'pyxlsb', 'xlrd'}}, default None
+ If io is not a buffer or path, this must be set to identify io.
+ Engine compatibility :
+
+ - ``openpyxl`` supports newer Excel file formats.
+ - ``calamine`` supports Excel (.xls, .xlsx, .xlsm, .xlsb)
+ and OpenDocument (.ods) file formats.
+ - ``odf`` supports OpenDocument file formats (.odf, .ods, .odt).
+ - ``pyxlsb`` supports Binary Excel files.
+ - ``xlrd`` supports old-style Excel files (.xls).
+
+ When ``engine=None``, the following logic will be used to determine the engine:
+
+ - If ``path_or_buffer`` is an OpenDocument format (.odf, .ods, .odt),
+ then `odf `_ will be used.
+ - Otherwise if ``path_or_buffer`` is an xls format, ``xlrd`` will be used.
+ - Otherwise if ``path_or_buffer`` is in xlsb format, ``pyxlsb`` will be used.
+ - Otherwise ``openpyxl`` will be used.
+converters : dict, default None
+ Dict of functions for converting values in certain columns. Keys can
+ either be integers or column labels, values are functions that take one
+ input argument, the Excel cell content, and return the transformed
+ content.
+true_values : list, default None
+ Values to consider as True.
+false_values : list, default None
+ Values to consider as False.
+skiprows : list-like, int, or callable, optional
+ Line numbers to skip (0-indexed) or number of lines to skip (int) at the
+ start of the file. If callable, the callable function will be evaluated
+ against the row indices, returning True if the row should be skipped and
+ False otherwise. An example of a valid callable argument would be ``lambda
+ x: x in [0, 2]``.
+nrows : int, default None
+ Number of rows to parse.
+na_values : scalar, str, list-like, or dict, default None
+ Additional strings to recognize as NA/NaN. If dict passed, specific
+ per-column NA values. By default the following values are interpreted
+ as NaN: '"""
+ + fill("', '".join(sorted(STR_NA_VALUES)), 70, subsequent_indent=" ")
+ + """'.
+keep_default_na : bool, default True
+ Whether or not to include the default NaN values when parsing the data.
+ Depending on whether ``na_values`` is passed in, the behavior is as follows:
+
+ * If ``keep_default_na`` is True, and ``na_values`` are specified,
+ ``na_values`` is appended to the default NaN values used for parsing.
+ * If ``keep_default_na`` is True, and ``na_values`` are not specified, only
+ the default NaN values are used for parsing.
+ * If ``keep_default_na`` is False, and ``na_values`` are specified, only
+ the NaN values specified ``na_values`` are used for parsing.
+ * If ``keep_default_na`` is False, and ``na_values`` are not specified, no
+ strings will be parsed as NaN.
+
+ Note that if `na_filter` is passed in as False, the ``keep_default_na`` and
+ ``na_values`` parameters will be ignored.
+na_filter : bool, default True
+ Detect missing value markers (empty strings and the value of na_values). In
+ data without any NAs, passing ``na_filter=False`` can improve the
+ performance of reading a large file.
+verbose : bool, default False
+ Indicate number of NA values placed in non-numeric columns.
+parse_dates : bool, list-like, or dict, default False
+ The behavior is as follows:
+
+ * ``bool``. If True -> try parsing the index.
+ * ``list`` of int or names. e.g. If [1, 2, 3] -> try parsing columns 1, 2, 3
+ each as a separate date column.
+ * ``list`` of lists. e.g. If [[1, 3]] -> combine columns 1 and 3 and parse as
+ a single date column.
+ * ``dict``, e.g. {{'foo' : [1, 3]}} -> parse columns 1, 3 as date and call
+ result 'foo'
+
+ If a column or index contains an unparsable date, the entire column or
+ index will be returned unaltered as an object data type. If you don`t want to
+ parse some cells as date just change their type in Excel to "Text".
+ For non-standard datetime parsing, use ``pd.to_datetime`` after ``pd.read_excel``.
+
+ Note: A fast-path exists for iso8601-formatted dates.
+date_parser : function, optional
+ Function to use for converting a sequence of string columns to an array of
+ datetime instances. The default uses ``dateutil.parser.parser`` to do the
+ conversion. Pandas will try to call `date_parser` in three different ways,
+ advancing to the next if an exception occurs: 1) Pass one or more arrays
+ (as defined by `parse_dates`) as arguments; 2) concatenate (row-wise) the
+ string values from the columns defined by `parse_dates` into a single array
+ and pass that; and 3) call `date_parser` once for each row using one or
+ more strings (corresponding to the columns defined by `parse_dates`) as
+ arguments.
+
+ .. deprecated:: 2.0.0
+ Use ``date_format`` instead, or read in as ``object`` and then apply
+ :func:`to_datetime` as-needed.
+date_format : str or dict of column -> format, default ``None``
+ If used in conjunction with ``parse_dates``, will parse dates according to this
+ format. For anything more complex,
+ please read in as ``object`` and then apply :func:`to_datetime` as-needed.
+
+ .. versionadded:: 2.0.0
+thousands : str, default None
+ Thousands separator for parsing string columns to numeric. Note that
+ this parameter is only necessary for columns stored as TEXT in Excel,
+ any numeric columns will automatically be parsed, regardless of display
+ format.
+decimal : str, default '.'
+ Character to recognize as decimal point for parsing string columns to numeric.
+ Note that this parameter is only necessary for columns stored as TEXT in Excel,
+ any numeric columns will automatically be parsed, regardless of display
+ format.(e.g. use ',' for European data).
+
+ .. versionadded:: 1.4.0
+
+comment : str, default None
+ Comments out remainder of line. Pass a character or characters to this
+ argument to indicate comments in the input file. Any data between the
+ comment string and the end of the current line is ignored.
+skipfooter : int, default 0
+ Rows at the end to skip (0-indexed).
+{storage_options}
+
+dtype_backend : {{'numpy_nullable', 'pyarrow'}}, default 'numpy_nullable'
+ Back-end data type applied to the resultant :class:`DataFrame`
+ (still experimental). Behaviour is as follows:
+
+ * ``"numpy_nullable"``: returns nullable-dtype-backed :class:`DataFrame`
+ (default).
+ * ``"pyarrow"``: returns pyarrow-backed nullable :class:`ArrowDtype`
+ DataFrame.
+
+ .. versionadded:: 2.0
+
+engine_kwargs : dict, optional
+ Arbitrary keyword arguments passed to excel engine.
+
+Returns
+-------
+DataFrame or dict of DataFrames
+ DataFrame from the passed in Excel file. See notes in sheet_name
+ argument for more information on when a dict of DataFrames is returned.
+
+See Also
+--------
+DataFrame.to_excel : Write DataFrame to an Excel file.
+DataFrame.to_csv : Write DataFrame to a comma-separated values (csv) file.
+read_csv : Read a comma-separated values (csv) file into DataFrame.
+read_fwf : Read a table of fixed-width formatted lines into DataFrame.
+
+Notes
+-----
+For specific information on the methods used for each Excel engine, refer to the pandas
+:ref:`user guide `
+
+Examples
+--------
+The file can be read using the file name as string or an open file object:
+
+>>> pd.read_excel('tmp.xlsx', index_col=0) # doctest: +SKIP
+ Name Value
+0 string1 1
+1 string2 2
+2 #Comment 3
+
+>>> pd.read_excel(open('tmp.xlsx', 'rb'),
+... sheet_name='Sheet3') # doctest: +SKIP
+ Unnamed: 0 Name Value
+0 0 string1 1
+1 1 string2 2
+2 2 #Comment 3
+
+Index and header can be specified via the `index_col` and `header` arguments
+
+>>> pd.read_excel('tmp.xlsx', index_col=None, header=None) # doctest: +SKIP
+ 0 1 2
+0 NaN Name Value
+1 0.0 string1 1
+2 1.0 string2 2
+3 2.0 #Comment 3
+
+Column types are inferred but can be explicitly specified
+
+>>> pd.read_excel('tmp.xlsx', index_col=0,
+... dtype={{'Name': str, 'Value': float}}) # doctest: +SKIP
+ Name Value
+0 string1 1.0
+1 string2 2.0
+2 #Comment 3.0
+
+True, False, and NA values, and thousands separators have defaults,
+but can be explicitly specified, too. Supply the values you would like
+as strings or lists of strings!
+
+>>> pd.read_excel('tmp.xlsx', index_col=0,
+... na_values=['string1', 'string2']) # doctest: +SKIP
+ Name Value
+0 NaN 1
+1 NaN 2
+2 #Comment 3
+
+Comment lines in the excel input file can be skipped using the
+``comment`` kwarg.
+
+>>> pd.read_excel('tmp.xlsx', index_col=0, comment='#') # doctest: +SKIP
+ Name Value
+0 string1 1.0
+1 string2 2.0
+2 None NaN
+"""
+)
+
+
+@overload
+def read_excel(
+ io,
+ # sheet name is str or int -> DataFrame
+ sheet_name: str | int = ...,
+ *,
+ header: int | Sequence[int] | None = ...,
+ names: SequenceNotStr[Hashable] | range | None = ...,
+ index_col: int | str | Sequence[int] | None = ...,
+ usecols: int
+ | str
+ | Sequence[int]
+ | Sequence[str]
+ | Callable[[str], bool]
+ | None = ...,
+ dtype: DtypeArg | None = ...,
+ engine: Literal["xlrd", "openpyxl", "odf", "pyxlsb", "calamine"] | None = ...,
+ converters: dict[str, Callable] | dict[int, Callable] | None = ...,
+ true_values: Iterable[Hashable] | None = ...,
+ false_values: Iterable[Hashable] | None = ...,
+ skiprows: Sequence[int] | int | Callable[[int], object] | None = ...,
+ nrows: int | None = ...,
+ na_values=...,
+ keep_default_na: bool = ...,
+ na_filter: bool = ...,
+ verbose: bool = ...,
+ parse_dates: list | dict | bool = ...,
+ date_parser: Callable | lib.NoDefault = ...,
+ date_format: dict[Hashable, str] | str | None = ...,
+ thousands: str | None = ...,
+ decimal: str = ...,
+ comment: str | None = ...,
+ skipfooter: int = ...,
+ storage_options: StorageOptions = ...,
+ dtype_backend: DtypeBackend | lib.NoDefault = ...,
+) -> DataFrame:
+ ...
+
+
+@overload
+def read_excel(
+ io,
+ # sheet name is list or None -> dict[IntStrT, DataFrame]
+ sheet_name: list[IntStrT] | None,
+ *,
+ header: int | Sequence[int] | None = ...,
+ names: SequenceNotStr[Hashable] | range | None = ...,
+ index_col: int | str | Sequence[int] | None = ...,
+ usecols: int
+ | str
+ | Sequence[int]
+ | Sequence[str]
+ | Callable[[str], bool]
+ | None = ...,
+ dtype: DtypeArg | None = ...,
+ engine: Literal["xlrd", "openpyxl", "odf", "pyxlsb", "calamine"] | None = ...,
+ converters: dict[str, Callable] | dict[int, Callable] | None = ...,
+ true_values: Iterable[Hashable] | None = ...,
+ false_values: Iterable[Hashable] | None = ...,
+ skiprows: Sequence[int] | int | Callable[[int], object] | None = ...,
+ nrows: int | None = ...,
+ na_values=...,
+ keep_default_na: bool = ...,
+ na_filter: bool = ...,
+ verbose: bool = ...,
+ parse_dates: list | dict | bool = ...,
+ date_parser: Callable | lib.NoDefault = ...,
+ date_format: dict[Hashable, str] | str | None = ...,
+ thousands: str | None = ...,
+ decimal: str = ...,
+ comment: str | None = ...,
+ skipfooter: int = ...,
+ storage_options: StorageOptions = ...,
+ dtype_backend: DtypeBackend | lib.NoDefault = ...,
+) -> dict[IntStrT, DataFrame]:
+ ...
+
+
+@doc(storage_options=_shared_docs["storage_options"])
+@Appender(_read_excel_doc)
+def read_excel(
+ io,
+ sheet_name: str | int | list[IntStrT] | None = 0,
+ *,
+ header: int | Sequence[int] | None = 0,
+ names: SequenceNotStr[Hashable] | range | None = None,
+ index_col: int | str | Sequence[int] | None = None,
+ usecols: int
+ | str
+ | Sequence[int]
+ | Sequence[str]
+ | Callable[[str], bool]
+ | None = None,
+ dtype: DtypeArg | None = None,
+ engine: Literal["xlrd", "openpyxl", "odf", "pyxlsb", "calamine"] | None = None,
+ converters: dict[str, Callable] | dict[int, Callable] | None = None,
+ true_values: Iterable[Hashable] | None = None,
+ false_values: Iterable[Hashable] | None = None,
+ skiprows: Sequence[int] | int | Callable[[int], object] | None = None,
+ nrows: int | None = None,
+ na_values=None,
+ keep_default_na: bool = True,
+ na_filter: bool = True,
+ verbose: bool = False,
+ parse_dates: list | dict | bool = False,
+ date_parser: Callable | lib.NoDefault = lib.no_default,
+ date_format: dict[Hashable, str] | str | None = None,
+ thousands: str | None = None,
+ decimal: str = ".",
+ comment: str | None = None,
+ skipfooter: int = 0,
+ storage_options: StorageOptions | None = None,
+ dtype_backend: DtypeBackend | lib.NoDefault = lib.no_default,
+ engine_kwargs: dict | None = None,
+) -> DataFrame | dict[IntStrT, DataFrame]:
+ check_dtype_backend(dtype_backend)
+ should_close = False
+ if engine_kwargs is None:
+ engine_kwargs = {}
+
+ if not isinstance(io, ExcelFile):
+ should_close = True
+ io = ExcelFile(
+ io,
+ storage_options=storage_options,
+ engine=engine,
+ engine_kwargs=engine_kwargs,
+ )
+ elif engine and engine != io.engine:
+ raise ValueError(
+ "Engine should not be specified when passing "
+ "an ExcelFile - ExcelFile already has the engine set"
+ )
+
+ try:
+ data = io.parse(
+ sheet_name=sheet_name,
+ header=header,
+ names=names,
+ index_col=index_col,
+ usecols=usecols,
+ dtype=dtype,
+ converters=converters,
+ true_values=true_values,
+ false_values=false_values,
+ skiprows=skiprows,
+ nrows=nrows,
+ na_values=na_values,
+ keep_default_na=keep_default_na,
+ na_filter=na_filter,
+ verbose=verbose,
+ parse_dates=parse_dates,
+ date_parser=date_parser,
+ date_format=date_format,
+ thousands=thousands,
+ decimal=decimal,
+ comment=comment,
+ skipfooter=skipfooter,
+ dtype_backend=dtype_backend,
+ )
+ finally:
+ # make sure to close opened file handles
+ if should_close:
+ io.close()
+ return data
+
+
+_WorkbookT = TypeVar("_WorkbookT")
+
+
+class BaseExcelReader(Generic[_WorkbookT]):
+ book: _WorkbookT
+
+ def __init__(
+ self,
+ filepath_or_buffer,
+ storage_options: StorageOptions | None = None,
+ engine_kwargs: dict | None = None,
+ ) -> None:
+ if engine_kwargs is None:
+ engine_kwargs = {}
+
+ # First argument can also be bytes, so create a buffer
+ if isinstance(filepath_or_buffer, bytes):
+ filepath_or_buffer = BytesIO(filepath_or_buffer)
+
+ self.handles = IOHandles(
+ handle=filepath_or_buffer, compression={"method": None}
+ )
+ if not isinstance(filepath_or_buffer, (ExcelFile, self._workbook_class)):
+ self.handles = get_handle(
+ filepath_or_buffer, "rb", storage_options=storage_options, is_text=False
+ )
+
+ if isinstance(self.handles.handle, self._workbook_class):
+ self.book = self.handles.handle
+ elif hasattr(self.handles.handle, "read"):
+ # N.B. xlrd.Book has a read attribute too
+ self.handles.handle.seek(0)
+ try:
+ self.book = self.load_workbook(self.handles.handle, engine_kwargs)
+ except Exception:
+ self.close()
+ raise
+ else:
+ raise ValueError(
+ "Must explicitly set engine if not passing in buffer or path for io."
+ )
+
+ @property
+ def _workbook_class(self) -> type[_WorkbookT]:
+ raise NotImplementedError
+
+ def load_workbook(self, filepath_or_buffer, engine_kwargs) -> _WorkbookT:
+ raise NotImplementedError
+
+ def close(self) -> None:
+ if hasattr(self, "book"):
+ if hasattr(self.book, "close"):
+ # pyxlsb: opens a TemporaryFile
+ # openpyxl: https://stackoverflow.com/questions/31416842/
+ # openpyxl-does-not-close-excel-workbook-in-read-only-mode
+ self.book.close()
+ elif hasattr(self.book, "release_resources"):
+ # xlrd
+ # https://github.com/python-excel/xlrd/blob/2.0.1/xlrd/book.py#L548
+ self.book.release_resources()
+ self.handles.close()
+
+ @property
+ def sheet_names(self) -> list[str]:
+ raise NotImplementedError
+
+ def get_sheet_by_name(self, name: str):
+ raise NotImplementedError
+
+ def get_sheet_by_index(self, index: int):
+ raise NotImplementedError
+
+ def get_sheet_data(self, sheet, rows: int | None = None):
+ raise NotImplementedError
+
+ def raise_if_bad_sheet_by_index(self, index: int) -> None:
+ n_sheets = len(self.sheet_names)
+ if index >= n_sheets:
+ raise ValueError(
+ f"Worksheet index {index} is invalid, {n_sheets} worksheets found"
+ )
+
+ def raise_if_bad_sheet_by_name(self, name: str) -> None:
+ if name not in self.sheet_names:
+ raise ValueError(f"Worksheet named '{name}' not found")
+
+ def _check_skiprows_func(
+ self,
+ skiprows: Callable,
+ rows_to_use: int,
+ ) -> int:
+ """
+ Determine how many file rows are required to obtain `nrows` data
+ rows when `skiprows` is a function.
+
+ Parameters
+ ----------
+ skiprows : function
+ The function passed to read_excel by the user.
+ rows_to_use : int
+ The number of rows that will be needed for the header and
+ the data.
+
+ Returns
+ -------
+ int
+ """
+ i = 0
+ rows_used_so_far = 0
+ while rows_used_so_far < rows_to_use:
+ if not skiprows(i):
+ rows_used_so_far += 1
+ i += 1
+ return i
+
+ def _calc_rows(
+ self,
+ header: int | Sequence[int] | None,
+ index_col: int | Sequence[int] | None,
+ skiprows: Sequence[int] | int | Callable[[int], object] | None,
+ nrows: int | None,
+ ) -> int | None:
+ """
+ If nrows specified, find the number of rows needed from the
+ file, otherwise return None.
+
+
+ Parameters
+ ----------
+ header : int, list of int, or None
+ See read_excel docstring.
+ index_col : int, str, list of int, or None
+ See read_excel docstring.
+ skiprows : list-like, int, callable, or None
+ See read_excel docstring.
+ nrows : int or None
+ See read_excel docstring.
+
+ Returns
+ -------
+ int or None
+ """
+ if nrows is None:
+ return None
+ if header is None:
+ header_rows = 1
+ elif is_integer(header):
+ header = cast(int, header)
+ header_rows = 1 + header
+ else:
+ header = cast(Sequence, header)
+ header_rows = 1 + header[-1]
+ # If there is a MultiIndex header and an index then there is also
+ # a row containing just the index name(s)
+ if is_list_like(header) and index_col is not None:
+ header = cast(Sequence, header)
+ if len(header) > 1:
+ header_rows += 1
+ if skiprows is None:
+ return header_rows + nrows
+ if is_integer(skiprows):
+ skiprows = cast(int, skiprows)
+ return header_rows + nrows + skiprows
+ if is_list_like(skiprows):
+
+ def f(skiprows: Sequence, x: int) -> bool:
+ return x in skiprows
+
+ skiprows = cast(Sequence, skiprows)
+ return self._check_skiprows_func(partial(f, skiprows), header_rows + nrows)
+ if callable(skiprows):
+ return self._check_skiprows_func(
+ skiprows,
+ header_rows + nrows,
+ )
+ # else unexpected skiprows type: read_excel will not optimize
+ # the number of rows read from file
+ return None
+
+ def parse(
+ self,
+ sheet_name: str | int | list[int] | list[str] | None = 0,
+ header: int | Sequence[int] | None = 0,
+ names: SequenceNotStr[Hashable] | range | None = None,
+ index_col: int | Sequence[int] | None = None,
+ usecols=None,
+ dtype: DtypeArg | None = None,
+ true_values: Iterable[Hashable] | None = None,
+ false_values: Iterable[Hashable] | None = None,
+ skiprows: Sequence[int] | int | Callable[[int], object] | None = None,
+ nrows: int | None = None,
+ na_values=None,
+ verbose: bool = False,
+ parse_dates: list | dict | bool = False,
+ date_parser: Callable | lib.NoDefault = lib.no_default,
+ date_format: dict[Hashable, str] | str | None = None,
+ thousands: str | None = None,
+ decimal: str = ".",
+ comment: str | None = None,
+ skipfooter: int = 0,
+ dtype_backend: DtypeBackend | lib.NoDefault = lib.no_default,
+ **kwds,
+ ):
+ validate_header_arg(header)
+ validate_integer("nrows", nrows)
+
+ ret_dict = False
+
+ # Keep sheetname to maintain backwards compatibility.
+ sheets: list[int] | list[str]
+ if isinstance(sheet_name, list):
+ sheets = sheet_name
+ ret_dict = True
+ elif sheet_name is None:
+ sheets = self.sheet_names
+ ret_dict = True
+ elif isinstance(sheet_name, str):
+ sheets = [sheet_name]
+ else:
+ sheets = [sheet_name]
+
+ # handle same-type duplicates.
+ sheets = cast(Union[list[int], list[str]], list(dict.fromkeys(sheets).keys()))
+
+ output = {}
+
+ last_sheetname = None
+ for asheetname in sheets:
+ last_sheetname = asheetname
+ if verbose:
+ print(f"Reading sheet {asheetname}")
+
+ if isinstance(asheetname, str):
+ sheet = self.get_sheet_by_name(asheetname)
+ else: # assume an integer if not a string
+ sheet = self.get_sheet_by_index(asheetname)
+
+ file_rows_needed = self._calc_rows(header, index_col, skiprows, nrows)
+ data = self.get_sheet_data(sheet, file_rows_needed)
+ if hasattr(sheet, "close"):
+ # pyxlsb opens two TemporaryFiles
+ sheet.close()
+ usecols = maybe_convert_usecols(usecols)
+
+ if not data:
+ output[asheetname] = DataFrame()
+ continue
+
+ is_list_header = False
+ is_len_one_list_header = False
+ if is_list_like(header):
+ assert isinstance(header, Sequence)
+ is_list_header = True
+ if len(header) == 1:
+ is_len_one_list_header = True
+
+ if is_len_one_list_header:
+ header = cast(Sequence[int], header)[0]
+
+ # forward fill and pull out names for MultiIndex column
+ header_names = None
+ if header is not None and is_list_like(header):
+ assert isinstance(header, Sequence)
+
+ header_names = []
+ control_row = [True] * len(data[0])
+
+ for row in header:
+ if is_integer(skiprows):
+ assert isinstance(skiprows, int)
+ row += skiprows
+
+ if row > len(data) - 1:
+ raise ValueError(
+ f"header index {row} exceeds maximum index "
+ f"{len(data) - 1} of data.",
+ )
+
+ data[row], control_row = fill_mi_header(data[row], control_row)
+
+ if index_col is not None:
+ header_name, _ = pop_header_name(data[row], index_col)
+ header_names.append(header_name)
+
+ # If there is a MultiIndex header and an index then there is also
+ # a row containing just the index name(s)
+ has_index_names = False
+ if is_list_header and not is_len_one_list_header and index_col is not None:
+ index_col_list: Sequence[int]
+ if isinstance(index_col, int):
+ index_col_list = [index_col]
+ else:
+ assert isinstance(index_col, Sequence)
+ index_col_list = index_col
+
+ # We have to handle mi without names. If any of the entries in the data
+ # columns are not empty, this is a regular row
+ assert isinstance(header, Sequence)
+ if len(header) < len(data):
+ potential_index_names = data[len(header)]
+ potential_data = [
+ x
+ for i, x in enumerate(potential_index_names)
+ if not control_row[i] and i not in index_col_list
+ ]
+ has_index_names = all(x == "" or x is None for x in potential_data)
+
+ if is_list_like(index_col):
+ # Forward fill values for MultiIndex index.
+ if header is None:
+ offset = 0
+ elif isinstance(header, int):
+ offset = 1 + header
+ else:
+ offset = 1 + max(header)
+
+ # GH34673: if MultiIndex names present and not defined in the header,
+ # offset needs to be incremented so that forward filling starts
+ # from the first MI value instead of the name
+ if has_index_names:
+ offset += 1
+
+ # Check if we have an empty dataset
+ # before trying to collect data.
+ if offset < len(data):
+ assert isinstance(index_col, Sequence)
+
+ for col in index_col:
+ last = data[offset][col]
+
+ for row in range(offset + 1, len(data)):
+ if data[row][col] == "" or data[row][col] is None:
+ data[row][col] = last
+ else:
+ last = data[row][col]
+
+ # GH 12292 : error when read one empty column from excel file
+ try:
+ parser = TextParser(
+ data,
+ names=names,
+ header=header,
+ index_col=index_col,
+ has_index_names=has_index_names,
+ dtype=dtype,
+ true_values=true_values,
+ false_values=false_values,
+ skiprows=skiprows,
+ nrows=nrows,
+ na_values=na_values,
+ skip_blank_lines=False, # GH 39808
+ parse_dates=parse_dates,
+ date_parser=date_parser,
+ date_format=date_format,
+ thousands=thousands,
+ decimal=decimal,
+ comment=comment,
+ skipfooter=skipfooter,
+ usecols=usecols,
+ dtype_backend=dtype_backend,
+ **kwds,
+ )
+
+ output[asheetname] = parser.read(nrows=nrows)
+
+ if header_names:
+ output[asheetname].columns = output[asheetname].columns.set_names(
+ header_names
+ )
+
+ except EmptyDataError:
+ # No Data, return an empty DataFrame
+ output[asheetname] = DataFrame()
+
+ except Exception as err:
+ err.args = (f"{err.args[0]} (sheet: {asheetname})", *err.args[1:])
+ raise err
+
+ if last_sheetname is None:
+ raise ValueError("Sheet name is an empty list")
+
+ if ret_dict:
+ return output
+ else:
+ return output[last_sheetname]
+
+
+@doc(storage_options=_shared_docs["storage_options"])
+class ExcelWriter(Generic[_WorkbookT]):
+ """
+ Class for writing DataFrame objects into excel sheets.
+
+ Default is to use:
+
+ * `xlsxwriter `__ for xlsx files if xlsxwriter
+ is installed otherwise `openpyxl `__
+ * `odswriter `__ for ods files
+
+ See ``DataFrame.to_excel`` for typical usage.
+
+ The writer should be used as a context manager. Otherwise, call `close()` to save
+ and close any opened file handles.
+
+ Parameters
+ ----------
+ path : str or typing.BinaryIO
+ Path to xls or xlsx or ods file.
+ engine : str (optional)
+ Engine to use for writing. If None, defaults to
+ ``io.excel..writer``. NOTE: can only be passed as a keyword
+ argument.
+ date_format : str, default None
+ Format string for dates written into Excel files (e.g. 'YYYY-MM-DD').
+ datetime_format : str, default None
+ Format string for datetime objects written into Excel files.
+ (e.g. 'YYYY-MM-DD HH:MM:SS').
+ mode : {{'w', 'a'}}, default 'w'
+ File mode to use (write or append). Append does not work with fsspec URLs.
+ {storage_options}
+
+ if_sheet_exists : {{'error', 'new', 'replace', 'overlay'}}, default 'error'
+ How to behave when trying to write to a sheet that already
+ exists (append mode only).
+
+ * error: raise a ValueError.
+ * new: Create a new sheet, with a name determined by the engine.
+ * replace: Delete the contents of the sheet before writing to it.
+ * overlay: Write contents to the existing sheet without first removing,
+ but possibly over top of, the existing contents.
+
+ .. versionadded:: 1.3.0
+
+ .. versionchanged:: 1.4.0
+
+ Added ``overlay`` option
+
+ engine_kwargs : dict, optional
+ Keyword arguments to be passed into the engine. These will be passed to
+ the following functions of the respective engines:
+
+ * xlsxwriter: ``xlsxwriter.Workbook(file, **engine_kwargs)``
+ * openpyxl (write mode): ``openpyxl.Workbook(**engine_kwargs)``
+ * openpyxl (append mode): ``openpyxl.load_workbook(file, **engine_kwargs)``
+ * odswriter: ``odf.opendocument.OpenDocumentSpreadsheet(**engine_kwargs)``
+
+ .. versionadded:: 1.3.0
+
+ Notes
+ -----
+ For compatibility with CSV writers, ExcelWriter serializes lists
+ and dicts to strings before writing.
+
+ Examples
+ --------
+ Default usage:
+
+ >>> df = pd.DataFrame([["ABC", "XYZ"]], columns=["Foo", "Bar"]) # doctest: +SKIP
+ >>> with pd.ExcelWriter("path_to_file.xlsx") as writer:
+ ... df.to_excel(writer) # doctest: +SKIP
+
+ To write to separate sheets in a single file:
+
+ >>> df1 = pd.DataFrame([["AAA", "BBB"]], columns=["Spam", "Egg"]) # doctest: +SKIP
+ >>> df2 = pd.DataFrame([["ABC", "XYZ"]], columns=["Foo", "Bar"]) # doctest: +SKIP
+ >>> with pd.ExcelWriter("path_to_file.xlsx") as writer:
+ ... df1.to_excel(writer, sheet_name="Sheet1") # doctest: +SKIP
+ ... df2.to_excel(writer, sheet_name="Sheet2") # doctest: +SKIP
+
+ You can set the date format or datetime format:
+
+ >>> from datetime import date, datetime # doctest: +SKIP
+ >>> df = pd.DataFrame(
+ ... [
+ ... [date(2014, 1, 31), date(1999, 9, 24)],
+ ... [datetime(1998, 5, 26, 23, 33, 4), datetime(2014, 2, 28, 13, 5, 13)],
+ ... ],
+ ... index=["Date", "Datetime"],
+ ... columns=["X", "Y"],
+ ... ) # doctest: +SKIP
+ >>> with pd.ExcelWriter(
+ ... "path_to_file.xlsx",
+ ... date_format="YYYY-MM-DD",
+ ... datetime_format="YYYY-MM-DD HH:MM:SS"
+ ... ) as writer:
+ ... df.to_excel(writer) # doctest: +SKIP
+
+ You can also append to an existing Excel file:
+
+ >>> with pd.ExcelWriter("path_to_file.xlsx", mode="a", engine="openpyxl") as writer:
+ ... df.to_excel(writer, sheet_name="Sheet3") # doctest: +SKIP
+
+ Here, the `if_sheet_exists` parameter can be set to replace a sheet if it
+ already exists:
+
+ >>> with ExcelWriter(
+ ... "path_to_file.xlsx",
+ ... mode="a",
+ ... engine="openpyxl",
+ ... if_sheet_exists="replace",
+ ... ) as writer:
+ ... df.to_excel(writer, sheet_name="Sheet1") # doctest: +SKIP
+
+ You can also write multiple DataFrames to a single sheet. Note that the
+ ``if_sheet_exists`` parameter needs to be set to ``overlay``:
+
+ >>> with ExcelWriter("path_to_file.xlsx",
+ ... mode="a",
+ ... engine="openpyxl",
+ ... if_sheet_exists="overlay",
+ ... ) as writer:
+ ... df1.to_excel(writer, sheet_name="Sheet1")
+ ... df2.to_excel(writer, sheet_name="Sheet1", startcol=3) # doctest: +SKIP
+
+ You can store Excel file in RAM:
+
+ >>> import io
+ >>> df = pd.DataFrame([["ABC", "XYZ"]], columns=["Foo", "Bar"])
+ >>> buffer = io.BytesIO()
+ >>> with pd.ExcelWriter(buffer) as writer:
+ ... df.to_excel(writer)
+
+ You can pack Excel file into zip archive:
+
+ >>> import zipfile # doctest: +SKIP
+ >>> df = pd.DataFrame([["ABC", "XYZ"]], columns=["Foo", "Bar"]) # doctest: +SKIP
+ >>> with zipfile.ZipFile("path_to_file.zip", "w") as zf:
+ ... with zf.open("filename.xlsx", "w") as buffer:
+ ... with pd.ExcelWriter(buffer) as writer:
+ ... df.to_excel(writer) # doctest: +SKIP
+
+ You can specify additional arguments to the underlying engine:
+
+ >>> with pd.ExcelWriter(
+ ... "path_to_file.xlsx",
+ ... engine="xlsxwriter",
+ ... engine_kwargs={{"options": {{"nan_inf_to_errors": True}}}}
+ ... ) as writer:
+ ... df.to_excel(writer) # doctest: +SKIP
+
+ In append mode, ``engine_kwargs`` are passed through to
+ openpyxl's ``load_workbook``:
+
+ >>> with pd.ExcelWriter(
+ ... "path_to_file.xlsx",
+ ... engine="openpyxl",
+ ... mode="a",
+ ... engine_kwargs={{"keep_vba": True}}
+ ... ) as writer:
+ ... df.to_excel(writer, sheet_name="Sheet2") # doctest: +SKIP
+ """
+
+ # Defining an ExcelWriter implementation (see abstract methods for more...)
+
+ # - Mandatory
+ # - ``write_cells(self, cells, sheet_name=None, startrow=0, startcol=0)``
+ # --> called to write additional DataFrames to disk
+ # - ``_supported_extensions`` (tuple of supported extensions), used to
+ # check that engine supports the given extension.
+ # - ``_engine`` - string that gives the engine name. Necessary to
+ # instantiate class directly and bypass ``ExcelWriterMeta`` engine
+ # lookup.
+ # - ``save(self)`` --> called to save file to disk
+ # - Mostly mandatory (i.e. should at least exist)
+ # - book, cur_sheet, path
+
+ # - Optional:
+ # - ``__init__(self, path, engine=None, **kwargs)`` --> always called
+ # with path as first argument.
+
+ # You also need to register the class with ``register_writer()``.
+ # Technically, ExcelWriter implementations don't need to subclass
+ # ExcelWriter.
+
+ _engine: str
+ _supported_extensions: tuple[str, ...]
+
+ def __new__(
+ cls,
+ path: FilePath | WriteExcelBuffer | ExcelWriter,
+ engine: str | None = None,
+ date_format: str | None = None,
+ datetime_format: str | None = None,
+ mode: str = "w",
+ storage_options: StorageOptions | None = None,
+ if_sheet_exists: ExcelWriterIfSheetExists | None = None,
+ engine_kwargs: dict | None = None,
+ ) -> Self:
+ # only switch class if generic(ExcelWriter)
+ if cls is ExcelWriter:
+ if engine is None or (isinstance(engine, str) and engine == "auto"):
+ if isinstance(path, str):
+ ext = os.path.splitext(path)[-1][1:]
+ else:
+ ext = "xlsx"
+
+ try:
+ engine = config.get_option(f"io.excel.{ext}.writer", silent=True)
+ if engine == "auto":
+ engine = get_default_engine(ext, mode="writer")
+ except KeyError as err:
+ raise ValueError(f"No engine for filetype: '{ext}'") from err
+
+ # for mypy
+ assert engine is not None
+ # error: Incompatible types in assignment (expression has type
+ # "type[ExcelWriter[Any]]", variable has type "type[Self]")
+ cls = get_writer(engine) # type: ignore[assignment]
+
+ return object.__new__(cls)
+
+ # declare external properties you can count on
+ _path = None
+
+ @property
+ def supported_extensions(self) -> tuple[str, ...]:
+ """Extensions that writer engine supports."""
+ return self._supported_extensions
+
+ @property
+ def engine(self) -> str:
+ """Name of engine."""
+ return self._engine
+
+ @property
+ def sheets(self) -> dict[str, Any]:
+ """Mapping of sheet names to sheet objects."""
+ raise NotImplementedError
+
+ @property
+ def book(self) -> _WorkbookT:
+ """
+ Book instance. Class type will depend on the engine used.
+
+ This attribute can be used to access engine-specific features.
+ """
+ raise NotImplementedError
+
+ def _write_cells(
+ self,
+ cells,
+ sheet_name: str | None = None,
+ startrow: int = 0,
+ startcol: int = 0,
+ freeze_panes: tuple[int, int] | None = None,
+ ) -> None:
+ """
+ Write given formatted cells into Excel an excel sheet
+
+ Parameters
+ ----------
+ cells : generator
+ cell of formatted data to save to Excel sheet
+ sheet_name : str, default None
+ Name of Excel sheet, if None, then use self.cur_sheet
+ startrow : upper left cell row to dump data frame
+ startcol : upper left cell column to dump data frame
+ freeze_panes: int tuple of length 2
+ contains the bottom-most row and right-most column to freeze
+ """
+ raise NotImplementedError
+
+ def _save(self) -> None:
+ """
+ Save workbook to disk.
+ """
+ raise NotImplementedError
+
+ def __init__(
+ self,
+ path: FilePath | WriteExcelBuffer | ExcelWriter,
+ engine: str | None = None,
+ date_format: str | None = None,
+ datetime_format: str | None = None,
+ mode: str = "w",
+ storage_options: StorageOptions | None = None,
+ if_sheet_exists: ExcelWriterIfSheetExists | None = None,
+ engine_kwargs: dict[str, Any] | None = None,
+ ) -> None:
+ # validate that this engine can handle the extension
+ if isinstance(path, str):
+ ext = os.path.splitext(path)[-1]
+ self.check_extension(ext)
+
+ # use mode to open the file
+ if "b" not in mode:
+ mode += "b"
+ # use "a" for the user to append data to excel but internally use "r+" to let
+ # the excel backend first read the existing file and then write any data to it
+ mode = mode.replace("a", "r+")
+
+ if if_sheet_exists not in (None, "error", "new", "replace", "overlay"):
+ raise ValueError(
+ f"'{if_sheet_exists}' is not valid for if_sheet_exists. "
+ "Valid options are 'error', 'new', 'replace' and 'overlay'."
+ )
+ if if_sheet_exists and "r+" not in mode:
+ raise ValueError("if_sheet_exists is only valid in append mode (mode='a')")
+ if if_sheet_exists is None:
+ if_sheet_exists = "error"
+ self._if_sheet_exists = if_sheet_exists
+
+ # cast ExcelWriter to avoid adding 'if self._handles is not None'
+ self._handles = IOHandles(
+ cast(IO[bytes], path), compression={"compression": None}
+ )
+ if not isinstance(path, ExcelWriter):
+ self._handles = get_handle(
+ path, mode, storage_options=storage_options, is_text=False
+ )
+ self._cur_sheet = None
+
+ if date_format is None:
+ self._date_format = "YYYY-MM-DD"
+ else:
+ self._date_format = date_format
+ if datetime_format is None:
+ self._datetime_format = "YYYY-MM-DD HH:MM:SS"
+ else:
+ self._datetime_format = datetime_format
+
+ self._mode = mode
+
+ @property
+ def date_format(self) -> str:
+ """
+ Format string for dates written into Excel files (e.g. 'YYYY-MM-DD').
+ """
+ return self._date_format
+
+ @property
+ def datetime_format(self) -> str:
+ """
+ Format string for dates written into Excel files (e.g. 'YYYY-MM-DD').
+ """
+ return self._datetime_format
+
+ @property
+ def if_sheet_exists(self) -> str:
+ """
+ How to behave when writing to a sheet that already exists in append mode.
+ """
+ return self._if_sheet_exists
+
+ def __fspath__(self) -> str:
+ return getattr(self._handles.handle, "name", "")
+
+ def _get_sheet_name(self, sheet_name: str | None) -> str:
+ if sheet_name is None:
+ sheet_name = self._cur_sheet
+ if sheet_name is None: # pragma: no cover
+ raise ValueError("Must pass explicit sheet_name or set _cur_sheet property")
+ return sheet_name
+
+ def _value_with_fmt(
+ self, val
+ ) -> tuple[
+ int | float | bool | str | datetime.datetime | datetime.date, str | None
+ ]:
+ """
+ Convert numpy types to Python types for the Excel writers.
+
+ Parameters
+ ----------
+ val : object
+ Value to be written into cells
+
+ Returns
+ -------
+ Tuple with the first element being the converted value and the second
+ being an optional format
+ """
+ fmt = None
+
+ if is_integer(val):
+ val = int(val)
+ elif is_float(val):
+ val = float(val)
+ elif is_bool(val):
+ val = bool(val)
+ elif isinstance(val, datetime.datetime):
+ fmt = self._datetime_format
+ elif isinstance(val, datetime.date):
+ fmt = self._date_format
+ elif isinstance(val, datetime.timedelta):
+ val = val.total_seconds() / 86400
+ fmt = "0"
+ else:
+ val = str(val)
+
+ return val, fmt
+
+ @classmethod
+ def check_extension(cls, ext: str) -> Literal[True]:
+ """
+ checks that path's extension against the Writer's supported
+ extensions. If it isn't supported, raises UnsupportedFiletypeError.
+ """
+ if ext.startswith("."):
+ ext = ext[1:]
+ if not any(ext in extension for extension in cls._supported_extensions):
+ raise ValueError(f"Invalid extension for engine '{cls.engine}': '{ext}'")
+ return True
+
+ # Allow use as a contextmanager
+ def __enter__(self) -> Self:
+ return self
+
+ def __exit__(
+ self,
+ exc_type: type[BaseException] | None,
+ exc_value: BaseException | None,
+ traceback: TracebackType | None,
+ ) -> None:
+ self.close()
+
+ def close(self) -> None:
+ """synonym for save, to make it more file-like"""
+ self._save()
+ self._handles.close()
+
+
+XLS_SIGNATURES = (
+ b"\x09\x00\x04\x00\x07\x00\x10\x00", # BIFF2
+ b"\x09\x02\x06\x00\x00\x00\x10\x00", # BIFF3
+ b"\x09\x04\x06\x00\x00\x00\x10\x00", # BIFF4
+ b"\xD0\xCF\x11\xE0\xA1\xB1\x1A\xE1", # Compound File Binary
+)
+ZIP_SIGNATURE = b"PK\x03\x04"
+PEEK_SIZE = max(map(len, XLS_SIGNATURES + (ZIP_SIGNATURE,)))
+
+
+@doc(storage_options=_shared_docs["storage_options"])
+def inspect_excel_format(
+ content_or_path: FilePath | ReadBuffer[bytes],
+ storage_options: StorageOptions | None = None,
+) -> str | None:
+ """
+ Inspect the path or content of an excel file and get its format.
+
+ Adopted from xlrd: https://github.com/python-excel/xlrd.
+
+ Parameters
+ ----------
+ content_or_path : str or file-like object
+ Path to file or content of file to inspect. May be a URL.
+ {storage_options}
+
+ Returns
+ -------
+ str or None
+ Format of file if it can be determined.
+
+ Raises
+ ------
+ ValueError
+ If resulting stream is empty.
+ BadZipFile
+ If resulting stream does not have an XLS signature and is not a valid zipfile.
+ """
+ if isinstance(content_or_path, bytes):
+ content_or_path = BytesIO(content_or_path)
+
+ with get_handle(
+ content_or_path, "rb", storage_options=storage_options, is_text=False
+ ) as handle:
+ stream = handle.handle
+ stream.seek(0)
+ buf = stream.read(PEEK_SIZE)
+ if buf is None:
+ raise ValueError("stream is empty")
+ assert isinstance(buf, bytes)
+ peek = buf
+ stream.seek(0)
+
+ if any(peek.startswith(sig) for sig in XLS_SIGNATURES):
+ return "xls"
+ elif not peek.startswith(ZIP_SIGNATURE):
+ return None
+
+ with zipfile.ZipFile(stream) as zf:
+ # Workaround for some third party files that use forward slashes and
+ # lower case names.
+ component_names = [
+ name.replace("\\", "/").lower() for name in zf.namelist()
+ ]
+
+ if "xl/workbook.xml" in component_names:
+ return "xlsx"
+ if "xl/workbook.bin" in component_names:
+ return "xlsb"
+ if "content.xml" in component_names:
+ return "ods"
+ return "zip"
+
+
+class ExcelFile:
+ """
+ Class for parsing tabular Excel sheets into DataFrame objects.
+
+ See read_excel for more documentation.
+
+ Parameters
+ ----------
+ path_or_buffer : str, bytes, path object (pathlib.Path or py._path.local.LocalPath),
+ A file-like object, xlrd workbook or openpyxl workbook.
+ If a string or path object, expected to be a path to a
+ .xls, .xlsx, .xlsb, .xlsm, .odf, .ods, or .odt file.
+ engine : str, default None
+ If io is not a buffer or path, this must be set to identify io.
+ Supported engines: ``xlrd``, ``openpyxl``, ``odf``, ``pyxlsb``, ``calamine``
+ Engine compatibility :
+
+ - ``xlrd`` supports old-style Excel files (.xls).
+ - ``openpyxl`` supports newer Excel file formats.
+ - ``odf`` supports OpenDocument file formats (.odf, .ods, .odt).
+ - ``pyxlsb`` supports Binary Excel files.
+ - ``calamine`` supports Excel (.xls, .xlsx, .xlsm, .xlsb)
+ and OpenDocument (.ods) file formats.
+
+ .. versionchanged:: 1.2.0
+
+ The engine `xlrd `_
+ now only supports old-style ``.xls`` files.
+ When ``engine=None``, the following logic will be
+ used to determine the engine:
+
+ - If ``path_or_buffer`` is an OpenDocument format (.odf, .ods, .odt),
+ then `odf `_ will be used.
+ - Otherwise if ``path_or_buffer`` is an xls format,
+ ``xlrd`` will be used.
+ - Otherwise if ``path_or_buffer`` is in xlsb format,
+ `pyxlsb `_ will be used.
+
+ .. versionadded:: 1.3.0
+
+ - Otherwise if `openpyxl `_ is installed,
+ then ``openpyxl`` will be used.
+ - Otherwise if ``xlrd >= 2.0`` is installed, a ``ValueError`` will be raised.
+
+ .. warning::
+
+ Please do not report issues when using ``xlrd`` to read ``.xlsx`` files.
+ This is not supported, switch to using ``openpyxl`` instead.
+ engine_kwargs : dict, optional
+ Arbitrary keyword arguments passed to excel engine.
+
+ Examples
+ --------
+ >>> file = pd.ExcelFile('myfile.xlsx') # doctest: +SKIP
+ >>> with pd.ExcelFile("myfile.xls") as xls: # doctest: +SKIP
+ ... df1 = pd.read_excel(xls, "Sheet1") # doctest: +SKIP
+ """
+
+ from pandas.io.excel._calamine import CalamineReader
+ from pandas.io.excel._odfreader import ODFReader
+ from pandas.io.excel._openpyxl import OpenpyxlReader
+ from pandas.io.excel._pyxlsb import PyxlsbReader
+ from pandas.io.excel._xlrd import XlrdReader
+
+ _engines: Mapping[str, Any] = {
+ "xlrd": XlrdReader,
+ "openpyxl": OpenpyxlReader,
+ "odf": ODFReader,
+ "pyxlsb": PyxlsbReader,
+ "calamine": CalamineReader,
+ }
+
+ def __init__(
+ self,
+ path_or_buffer,
+ engine: str | None = None,
+ storage_options: StorageOptions | None = None,
+ engine_kwargs: dict | None = None,
+ ) -> None:
+ if engine_kwargs is None:
+ engine_kwargs = {}
+
+ if engine is not None and engine not in self._engines:
+ raise ValueError(f"Unknown engine: {engine}")
+
+ # First argument can also be bytes, so create a buffer
+ if isinstance(path_or_buffer, bytes):
+ path_or_buffer = BytesIO(path_or_buffer)
+ warnings.warn(
+ "Passing bytes to 'read_excel' is deprecated and "
+ "will be removed in a future version. To read from a "
+ "byte string, wrap it in a `BytesIO` object.",
+ FutureWarning,
+ stacklevel=find_stack_level(),
+ )
+
+ # Could be a str, ExcelFile, Book, etc.
+ self.io = path_or_buffer
+ # Always a string
+ self._io = stringify_path(path_or_buffer)
+
+ # Determine xlrd version if installed
+ if import_optional_dependency("xlrd", errors="ignore") is None:
+ xlrd_version = None
+ else:
+ import xlrd
+
+ xlrd_version = Version(get_version(xlrd))
+
+ if engine is None:
+ # Only determine ext if it is needed
+ ext: str | None
+ if xlrd_version is not None and isinstance(path_or_buffer, xlrd.Book):
+ ext = "xls"
+ else:
+ ext = inspect_excel_format(
+ content_or_path=path_or_buffer, storage_options=storage_options
+ )
+ if ext is None:
+ raise ValueError(
+ "Excel file format cannot be determined, you must specify "
+ "an engine manually."
+ )
+
+ engine = config.get_option(f"io.excel.{ext}.reader", silent=True)
+ if engine == "auto":
+ engine = get_default_engine(ext, mode="reader")
+
+ assert engine is not None
+ self.engine = engine
+ self.storage_options = storage_options
+
+ self._reader = self._engines[engine](
+ self._io,
+ storage_options=storage_options,
+ engine_kwargs=engine_kwargs,
+ )
+
+ def __fspath__(self):
+ return self._io
+
+ def parse(
+ self,
+ sheet_name: str | int | list[int] | list[str] | None = 0,
+ header: int | Sequence[int] | None = 0,
+ names: SequenceNotStr[Hashable] | range | None = None,
+ index_col: int | Sequence[int] | None = None,
+ usecols=None,
+ converters=None,
+ true_values: Iterable[Hashable] | None = None,
+ false_values: Iterable[Hashable] | None = None,
+ skiprows: Sequence[int] | int | Callable[[int], object] | None = None,
+ nrows: int | None = None,
+ na_values=None,
+ parse_dates: list | dict | bool = False,
+ date_parser: Callable | lib.NoDefault = lib.no_default,
+ date_format: str | dict[Hashable, str] | None = None,
+ thousands: str | None = None,
+ comment: str | None = None,
+ skipfooter: int = 0,
+ dtype_backend: DtypeBackend | lib.NoDefault = lib.no_default,
+ **kwds,
+ ) -> DataFrame | dict[str, DataFrame] | dict[int, DataFrame]:
+ """
+ Parse specified sheet(s) into a DataFrame.
+
+ Equivalent to read_excel(ExcelFile, ...) See the read_excel
+ docstring for more info on accepted parameters.
+
+ Returns
+ -------
+ DataFrame or dict of DataFrames
+ DataFrame from the passed in Excel file.
+
+ Examples
+ --------
+ >>> df = pd.DataFrame([[1, 2, 3], [4, 5, 6]], columns=['A', 'B', 'C'])
+ >>> df.to_excel('myfile.xlsx') # doctest: +SKIP
+ >>> file = pd.ExcelFile('myfile.xlsx') # doctest: +SKIP
+ >>> file.parse() # doctest: +SKIP
+ """
+ return self._reader.parse(
+ sheet_name=sheet_name,
+ header=header,
+ names=names,
+ index_col=index_col,
+ usecols=usecols,
+ converters=converters,
+ true_values=true_values,
+ false_values=false_values,
+ skiprows=skiprows,
+ nrows=nrows,
+ na_values=na_values,
+ parse_dates=parse_dates,
+ date_parser=date_parser,
+ date_format=date_format,
+ thousands=thousands,
+ comment=comment,
+ skipfooter=skipfooter,
+ dtype_backend=dtype_backend,
+ **kwds,
+ )
+
+ @property
+ def book(self):
+ return self._reader.book
+
+ @property
+ def sheet_names(self):
+ return self._reader.sheet_names
+
+ def close(self) -> None:
+ """close io if necessary"""
+ self._reader.close()
+
+ def __enter__(self) -> Self:
+ return self
+
+ def __exit__(
+ self,
+ exc_type: type[BaseException] | None,
+ exc_value: BaseException | None,
+ traceback: TracebackType | None,
+ ) -> None:
+ self.close()
diff --git a/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/_calamine.py b/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/_calamine.py
new file mode 100644
index 0000000000000000000000000000000000000000..5259469f7a569a1913aa49635b3c14e89a18d157
--- /dev/null
+++ b/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/_calamine.py
@@ -0,0 +1,121 @@
+from __future__ import annotations
+
+from datetime import (
+ date,
+ datetime,
+ time,
+ timedelta,
+)
+from typing import (
+ TYPE_CHECKING,
+ Any,
+ Union,
+)
+
+from pandas.compat._optional import import_optional_dependency
+from pandas.util._decorators import doc
+
+import pandas as pd
+from pandas.core.shared_docs import _shared_docs
+
+from pandas.io.excel._base import BaseExcelReader
+
+if TYPE_CHECKING:
+ from python_calamine import (
+ CalamineSheet,
+ CalamineWorkbook,
+ )
+
+ from pandas._typing import (
+ FilePath,
+ NaTType,
+ ReadBuffer,
+ Scalar,
+ StorageOptions,
+ )
+
+_CellValue = Union[int, float, str, bool, time, date, datetime, timedelta]
+
+
+class CalamineReader(BaseExcelReader["CalamineWorkbook"]):
+ @doc(storage_options=_shared_docs["storage_options"])
+ def __init__(
+ self,
+ filepath_or_buffer: FilePath | ReadBuffer[bytes],
+ storage_options: StorageOptions | None = None,
+ engine_kwargs: dict | None = None,
+ ) -> None:
+ """
+ Reader using calamine engine (xlsx/xls/xlsb/ods).
+
+ Parameters
+ ----------
+ filepath_or_buffer : str, path to be parsed or
+ an open readable stream.
+ {storage_options}
+ engine_kwargs : dict, optional
+ Arbitrary keyword arguments passed to excel engine.
+ """
+ import_optional_dependency("python_calamine")
+ super().__init__(
+ filepath_or_buffer,
+ storage_options=storage_options,
+ engine_kwargs=engine_kwargs,
+ )
+
+ @property
+ def _workbook_class(self) -> type[CalamineWorkbook]:
+ from python_calamine import CalamineWorkbook
+
+ return CalamineWorkbook
+
+ def load_workbook(
+ self, filepath_or_buffer: FilePath | ReadBuffer[bytes], engine_kwargs: Any
+ ) -> CalamineWorkbook:
+ from python_calamine import load_workbook
+
+ return load_workbook(filepath_or_buffer, **engine_kwargs)
+
+ @property
+ def sheet_names(self) -> list[str]:
+ from python_calamine import SheetTypeEnum
+
+ return [
+ sheet.name
+ for sheet in self.book.sheets_metadata
+ if sheet.typ == SheetTypeEnum.WorkSheet
+ ]
+
+ def get_sheet_by_name(self, name: str) -> CalamineSheet:
+ self.raise_if_bad_sheet_by_name(name)
+ return self.book.get_sheet_by_name(name)
+
+ def get_sheet_by_index(self, index: int) -> CalamineSheet:
+ self.raise_if_bad_sheet_by_index(index)
+ return self.book.get_sheet_by_index(index)
+
+ def get_sheet_data(
+ self, sheet: CalamineSheet, file_rows_needed: int | None = None
+ ) -> list[list[Scalar | NaTType | time]]:
+ def _convert_cell(value: _CellValue) -> Scalar | NaTType | time:
+ if isinstance(value, float):
+ val = int(value)
+ if val == value:
+ return val
+ else:
+ return value
+ elif isinstance(value, date):
+ return pd.Timestamp(value)
+ elif isinstance(value, timedelta):
+ return pd.Timedelta(value)
+ elif isinstance(value, time):
+ return value
+
+ return value
+
+ rows: list[list[_CellValue]] = sheet.to_python(
+ skip_empty_area=False, nrows=file_rows_needed
+ )
+ data = [[_convert_cell(cell) for cell in row] for row in rows]
+
+ return data
diff --git a/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/_odfreader.py b/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/_odfreader.py
new file mode 100644
index 0000000000000000000000000000000000000000..69b514da32857119f048a25f647d1002315a9889
--- /dev/null
+++ b/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/_odfreader.py
@@ -0,0 +1,253 @@
+from __future__ import annotations
+
+from typing import (
+ TYPE_CHECKING,
+ cast,
+)
+
+import numpy as np
+
+from pandas._typing import (
+ FilePath,
+ ReadBuffer,
+ Scalar,
+ StorageOptions,
+)
+from pandas.compat._optional import import_optional_dependency
+from pandas.util._decorators import doc
+
+import pandas as pd
+from pandas.core.shared_docs import _shared_docs
+
+from pandas.io.excel._base import BaseExcelReader
+
+if TYPE_CHECKING:
+ from odf.opendocument import OpenDocument
+
+ from pandas._libs.tslibs.nattype import NaTType
+
+
+@doc(storage_options=_shared_docs["storage_options"])
+class ODFReader(BaseExcelReader["OpenDocument"]):
+ def __init__(
+ self,
+ filepath_or_buffer: FilePath | ReadBuffer[bytes],
+ storage_options: StorageOptions | None = None,
+ engine_kwargs: dict | None = None,
+ ) -> None:
+ """
+ Read tables out of OpenDocument formatted files.
+
+ Parameters
+ ----------
+ filepath_or_buffer : str, path to be parsed or
+ an open readable stream.
+ {storage_options}
+ engine_kwargs : dict, optional
+ Arbitrary keyword arguments passed to excel engine.
+ """
+ import_optional_dependency("odf")
+ super().__init__(
+ filepath_or_buffer,
+ storage_options=storage_options,
+ engine_kwargs=engine_kwargs,
+ )
+
+ @property
+ def _workbook_class(self) -> type[OpenDocument]:
+ from odf.opendocument import OpenDocument
+
+ return OpenDocument
+
+ def load_workbook(
+ self, filepath_or_buffer: FilePath | ReadBuffer[bytes], engine_kwargs
+ ) -> OpenDocument:
+ from odf.opendocument import load
+
+ return load(filepath_or_buffer, **engine_kwargs)
+
+ @property
+ def empty_value(self) -> str:
+ """Property for compat with other readers."""
+ return ""
+
+ @property
+ def sheet_names(self) -> list[str]:
+ """Return a list of sheet names present in the document"""
+ from odf.table import Table
+
+ tables = self.book.getElementsByType(Table)
+ return [t.getAttribute("name") for t in tables]
+
+ def get_sheet_by_index(self, index: int):
+ from odf.table import Table
+
+ self.raise_if_bad_sheet_by_index(index)
+ tables = self.book.getElementsByType(Table)
+ return tables[index]
+
+ def get_sheet_by_name(self, name: str):
+ from odf.table import Table
+
+ self.raise_if_bad_sheet_by_name(name)
+ tables = self.book.getElementsByType(Table)
+
+ for table in tables:
+ if table.getAttribute("name") == name:
+ return table
+
+ self.close()
+ raise ValueError(f"sheet {name} not found")
+
+ def get_sheet_data(
+ self, sheet, file_rows_needed: int | None = None
+ ) -> list[list[Scalar | NaTType]]:
+ """
+ Parse an ODF Table into a list of lists
+ """
+ from odf.table import (
+ CoveredTableCell,
+ TableCell,
+ TableRow,
+ )
+
+ covered_cell_name = CoveredTableCell().qname
+ table_cell_name = TableCell().qname
+ cell_names = {covered_cell_name, table_cell_name}
+
+ sheet_rows = sheet.getElementsByType(TableRow)
+ empty_rows = 0
+ max_row_len = 0
+
+ table: list[list[Scalar | NaTType]] = []
+
+ for sheet_row in sheet_rows:
+ sheet_cells = [
+ x
+ for x in sheet_row.childNodes
+ if hasattr(x, "qname") and x.qname in cell_names
+ ]
+ empty_cells = 0
+ table_row: list[Scalar | NaTType] = []
+
+ for sheet_cell in sheet_cells:
+ if sheet_cell.qname == table_cell_name:
+ value = self._get_cell_value(sheet_cell)
+ else:
+ value = self.empty_value
+
+ column_repeat = self._get_column_repeat(sheet_cell)
+
+ # Queue up empty values, writing only if content succeeds them
+ if value == self.empty_value:
+ empty_cells += column_repeat
+ else:
+ table_row.extend([self.empty_value] * empty_cells)
+ empty_cells = 0
+ table_row.extend([value] * column_repeat)
+
+ if max_row_len < len(table_row):
+ max_row_len = len(table_row)
+
+ row_repeat = self._get_row_repeat(sheet_row)
+ if len(table_row) == 0:
+ empty_rows += row_repeat
+ else:
+ # add blank rows to our table
+ table.extend([[self.empty_value]] * empty_rows)
+ empty_rows = 0
+ table.extend(table_row for _ in range(row_repeat))
+ if file_rows_needed is not None and len(table) >= file_rows_needed:
+ break
+
+ # Make our table square
+ for row in table:
+ if len(row) < max_row_len:
+ row.extend([self.empty_value] * (max_row_len - len(row)))
+
+ return table
+
+ def _get_row_repeat(self, row) -> int:
+ """
+ Return number of times this row was repeated
+ Repeating an empty row appeared to be a common way
+ of representing sparse rows in the table.
+ """
+ from odf.namespaces import TABLENS
+
+ return int(row.attributes.get((TABLENS, "number-rows-repeated"), 1))
+
+ def _get_column_repeat(self, cell) -> int:
+ from odf.namespaces import TABLENS
+
+ return int(cell.attributes.get((TABLENS, "number-columns-repeated"), 1))
+
+ def _get_cell_value(self, cell) -> Scalar | NaTType:
+ from odf.namespaces import OFFICENS
+
+ if str(cell) == "#N/A":
+ return np.nan
+
+ cell_type = cell.attributes.get((OFFICENS, "value-type"))
+ if cell_type == "boolean":
+ if str(cell) == "TRUE":
+ return True
+ return False
+ if cell_type is None:
+ return self.empty_value
+ elif cell_type == "float":
+ # GH5394
+ cell_value = float(cell.attributes.get((OFFICENS, "value")))
+ val = int(cell_value)
+ if val == cell_value:
+ return val
+ return cell_value
+ elif cell_type == "percentage":
+ cell_value = cell.attributes.get((OFFICENS, "value"))
+ return float(cell_value)
+ elif cell_type == "string":
+ return self._get_cell_string_value(cell)
+ elif cell_type == "currency":
+ cell_value = cell.attributes.get((OFFICENS, "value"))
+ return float(cell_value)
+ elif cell_type == "date":
+ cell_value = cell.attributes.get((OFFICENS, "date-value"))
+ return pd.Timestamp(cell_value)
+ elif cell_type == "time":
+ stamp = pd.Timestamp(str(cell))
+ # cast needed here because Scalar doesn't include datetime.time
+ return cast(Scalar, stamp.time())
+ else:
+ self.close()
+ raise ValueError(f"Unrecognized type {cell_type}")
+
+ def _get_cell_string_value(self, cell) -> str:
+ """
+ Find and decode OpenDocument text:s tags that represent
+ a run length encoded sequence of space characters.
+ """
+ from odf.element import Element
+ from odf.namespaces import TEXTNS
+ from odf.office import Annotation
+ from odf.text import S
+
+ office_annotation = Annotation().qname
+ text_s = S().qname
+
+ value = []
+
+ for fragment in cell.childNodes:
+ if isinstance(fragment, Element):
+ if fragment.qname == text_s:
+ spaces = int(fragment.attributes.get((TEXTNS, "c"), 1))
+ value.append(" " * spaces)
+ elif fragment.qname == office_annotation:
+ continue
+ else:
+ # recursive impl needed in case of nested fragments
+ # with multiple spaces
+ # https://github.com/pandas-dev/pandas/pull/36175#discussion_r484639704
+ value.append(self._get_cell_string_value(fragment))
+ else:
+ value.append(str(fragment).strip("\n"))
+ return "".join(value)
diff --git a/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/_odswriter.py b/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/_odswriter.py
new file mode 100644
index 0000000000000000000000000000000000000000..bc7dca2d95b6b434279f8290fdf929e737f75459
--- /dev/null
+++ b/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/_odswriter.py
@@ -0,0 +1,357 @@
+from __future__ import annotations
+
+from collections import defaultdict
+import datetime
+import json
+from typing import (
+ TYPE_CHECKING,
+ Any,
+ DefaultDict,
+ cast,
+ overload,
+)
+
+from pandas.io.excel._base import ExcelWriter
+from pandas.io.excel._util import (
+ combine_kwargs,
+ validate_freeze_panes,
+)
+
+if TYPE_CHECKING:
+ from pandas._typing import (
+ ExcelWriterIfSheetExists,
+ FilePath,
+ StorageOptions,
+ WriteExcelBuffer,
+ )
+
+ from pandas.io.formats.excel import ExcelCell
+
+
+class ODSWriter(ExcelWriter):
+ _engine = "odf"
+ _supported_extensions = (".ods",)
+
+ def __init__(
+ self,
+ path: FilePath | WriteExcelBuffer | ExcelWriter,
+ engine: str | None = None,
+ date_format: str | None = None,
+ datetime_format=None,
+ mode: str = "w",
+ storage_options: StorageOptions | None = None,
+ if_sheet_exists: ExcelWriterIfSheetExists | None = None,
+ engine_kwargs: dict[str, Any] | None = None,
+ **kwargs,
+ ) -> None:
+ from odf.opendocument import OpenDocumentSpreadsheet
+
+ if mode == "a":
+ raise ValueError("Append mode is not supported with odf!")
+
+ engine_kwargs = combine_kwargs(engine_kwargs, kwargs)
+ self._book = OpenDocumentSpreadsheet(**engine_kwargs)
+
+ super().__init__(
+ path,
+ mode=mode,
+ storage_options=storage_options,
+ if_sheet_exists=if_sheet_exists,
+ engine_kwargs=engine_kwargs,
+ )
+
+ self._style_dict: dict[str, str] = {}
+
+ @property
+ def book(self):
+ """
+ Book instance of class odf.opendocument.OpenDocumentSpreadsheet.
+
+ This attribute can be used to access engine-specific features.
+ """
+ return self._book
+
+ @property
+ def sheets(self) -> dict[str, Any]:
+ """Mapping of sheet names to sheet objects."""
+ from odf.table import Table
+
+ result = {
+ sheet.getAttribute("name"): sheet
+ for sheet in self.book.getElementsByType(Table)
+ }
+ return result
+
+ def _save(self) -> None:
+ """
+ Save workbook to disk.
+ """
+ for sheet in self.sheets.values():
+ self.book.spreadsheet.addElement(sheet)
+ self.book.save(self._handles.handle)
+
+ def _write_cells(
+ self,
+ cells: list[ExcelCell],
+ sheet_name: str | None = None,
+ startrow: int = 0,
+ startcol: int = 0,
+ freeze_panes: tuple[int, int] | None = None,
+ ) -> None:
+ """
+ Write the frame cells using odf
+ """
+ from odf.table import (
+ Table,
+ TableCell,
+ TableRow,
+ )
+ from odf.text import P
+
+ sheet_name = self._get_sheet_name(sheet_name)
+ assert sheet_name is not None
+
+ if sheet_name in self.sheets:
+ wks = self.sheets[sheet_name]
+ else:
+ wks = Table(name=sheet_name)
+ self.book.spreadsheet.addElement(wks)
+
+ if validate_freeze_panes(freeze_panes):
+ freeze_panes = cast(tuple[int, int], freeze_panes)
+ self._create_freeze_panes(sheet_name, freeze_panes)
+
+ for _ in range(startrow):
+ wks.addElement(TableRow())
+
+ rows: DefaultDict = defaultdict(TableRow)
+ col_count: DefaultDict = defaultdict(int)
+
+ for cell in sorted(cells, key=lambda cell: (cell.row, cell.col)):
+ # only add empty cells if the row is still empty
+ if not col_count[cell.row]:
+ for _ in range(startcol):
+ rows[cell.row].addElement(TableCell())
+
+ # fill with empty cells if needed
+ for _ in range(cell.col - col_count[cell.row]):
+ rows[cell.row].addElement(TableCell())
+ col_count[cell.row] += 1
+
+ pvalue, tc = self._make_table_cell(cell)
+ rows[cell.row].addElement(tc)
+ col_count[cell.row] += 1
+ p = P(text=pvalue)
+ tc.addElement(p)
+
+ # add all rows to the sheet
+ if len(rows) > 0:
+ for row_nr in range(max(rows.keys()) + 1):
+ wks.addElement(rows[row_nr])
+
+ def _make_table_cell_attributes(self, cell) -> dict[str, int | str]:
+ """Convert cell attributes to OpenDocument attributes
+
+ Parameters
+ ----------
+ cell : ExcelCell
+ Spreadsheet cell data
+
+ Returns
+ -------
+ attributes : Dict[str, Union[int, str]]
+ Dictionary with attributes and attribute values
+ """
+ attributes: dict[str, int | str] = {}
+ style_name = self._process_style(cell.style)
+ if style_name is not None:
+ attributes["stylename"] = style_name
+ if cell.mergestart is not None and cell.mergeend is not None:
+ attributes["numberrowsspanned"] = max(1, cell.mergestart)
+ attributes["numbercolumnsspanned"] = cell.mergeend
+ return attributes
+
+ def _make_table_cell(self, cell) -> tuple[object, Any]:
+ """Convert cell data to an OpenDocument spreadsheet cell
+
+ Parameters
+ ----------
+ cell : ExcelCell
+ Spreadsheet cell data
+
+ Returns
+ -------
+ pvalue, cell : Tuple[str, TableCell]
+ Display value, Cell value
+ """
+ from odf.table import TableCell
+
+ attributes = self._make_table_cell_attributes(cell)
+ val, fmt = self._value_with_fmt(cell.val)
+ pvalue = value = val
+ if isinstance(val, bool):
+ value = str(val).lower()
+ pvalue = str(val).upper()
+ return (
+ pvalue,
+ TableCell(
+ valuetype="boolean",
+ booleanvalue=value,
+ attributes=attributes,
+ ),
+ )
+ elif isinstance(val, datetime.datetime):
+ # Fast formatting
+ value = val.isoformat()
+ # Slow but locale-dependent
+ pvalue = val.strftime("%c")
+ return (
+ pvalue,
+ TableCell(valuetype="date", datevalue=value, attributes=attributes),
+ )
+ elif isinstance(val, datetime.date):
+ # Fast formatting
+ value = f"{val.year}-{val.month:02d}-{val.day:02d}"
+ # Slow but locale-dependent
+ pvalue = val.strftime("%x")
+ return (
+ pvalue,
+ TableCell(valuetype="date", datevalue=value, attributes=attributes),
+ )
+ elif isinstance(val, str):
+ return (
+ pvalue,
+ TableCell(
+ valuetype="string",
+ stringvalue=value,
+ attributes=attributes,
+ ),
+ )
+ else:
+ return (
+ pvalue,
+ TableCell(
+ valuetype="float",
+ value=value,
+ attributes=attributes,
+ ),
+ )
+
+ @overload
+ def _process_style(self, style: dict[str, Any]) -> str:
+ ...
+
+ @overload
+ def _process_style(self, style: None) -> None:
+ ...
+
+ def _process_style(self, style: dict[str, Any] | None) -> str | None:
+ """Convert a style dictionary to a OpenDocument style sheet
+
+ Parameters
+ ----------
+ style : Dict
+ Style dictionary
+
+ Returns
+ -------
+ style_key : str
+ Unique style key for later reference in sheet
+ """
+ from odf.style import (
+ ParagraphProperties,
+ Style,
+ TableCellProperties,
+ TextProperties,
+ )
+
+ if style is None:
+ return None
+ style_key = json.dumps(style)
+ if style_key in self._style_dict:
+ return self._style_dict[style_key]
+ name = f"pd{len(self._style_dict)+1}"
+ self._style_dict[style_key] = name
+ odf_style = Style(name=name, family="table-cell")
+ if "font" in style:
+ font = style["font"]
+ if font.get("bold", False):
+ odf_style.addElement(TextProperties(fontweight="bold"))
+ if "borders" in style:
+ borders = style["borders"]
+ for side, thickness in borders.items():
+ thickness_translation = {"thin": "0.75pt solid #000000"}
+ odf_style.addElement(
+ TableCellProperties(
+ attributes={f"border{side}": thickness_translation[thickness]}
+ )
+ )
+ if "alignment" in style:
+ alignment = style["alignment"]
+ horizontal = alignment.get("horizontal")
+ if horizontal:
+ odf_style.addElement(ParagraphProperties(textalign=horizontal))
+ vertical = alignment.get("vertical")
+ if vertical:
+ odf_style.addElement(TableCellProperties(verticalalign=vertical))
+ self.book.styles.addElement(odf_style)
+ return name
+
+ def _create_freeze_panes(
+ self, sheet_name: str, freeze_panes: tuple[int, int]
+ ) -> None:
+ """
+ Create freeze panes in the sheet.
+
+ Parameters
+ ----------
+ sheet_name : str
+ Name of the spreadsheet
+ freeze_panes : tuple of (int, int)
+ Freeze pane location x and y
+ """
+ from odf.config import (
+ ConfigItem,
+ ConfigItemMapEntry,
+ ConfigItemMapIndexed,
+ ConfigItemMapNamed,
+ ConfigItemSet,
+ )
+
+ config_item_set = ConfigItemSet(name="ooo:view-settings")
+ self.book.settings.addElement(config_item_set)
+
+ config_item_map_indexed = ConfigItemMapIndexed(name="Views")
+ config_item_set.addElement(config_item_map_indexed)
+
+ config_item_map_entry = ConfigItemMapEntry()
+ config_item_map_indexed.addElement(config_item_map_entry)
+
+ config_item_map_named = ConfigItemMapNamed(name="Tables")
+ config_item_map_entry.addElement(config_item_map_named)
+
+ config_item_map_entry = ConfigItemMapEntry(name=sheet_name)
+ config_item_map_named.addElement(config_item_map_entry)
+
+ config_item_map_entry.addElement(
+ ConfigItem(name="HorizontalSplitMode", type="short", text="2")
+ )
+ config_item_map_entry.addElement(
+ ConfigItem(name="VerticalSplitMode", type="short", text="2")
+ )
+ config_item_map_entry.addElement(
+ ConfigItem(
+ name="HorizontalSplitPosition", type="int", text=str(freeze_panes[0])
+ )
+ )
+ config_item_map_entry.addElement(
+ ConfigItem(
+ name="VerticalSplitPosition", type="int", text=str(freeze_panes[1])
+ )
+ )
+ config_item_map_entry.addElement(
+ ConfigItem(name="PositionRight", type="int", text=str(freeze_panes[0]))
+ )
+ config_item_map_entry.addElement(
+ ConfigItem(name="PositionBottom", type="int", text=str(freeze_panes[1]))
+ )
diff --git a/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/_openpyxl.py b/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/_openpyxl.py
new file mode 100644
index 0000000000000000000000000000000000000000..c546443868a62aed062bf3fd41d80933e4fbc59e
--- /dev/null
+++ b/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/_openpyxl.py
@@ -0,0 +1,639 @@
+from __future__ import annotations
+
+import mmap
+from typing import (
+ TYPE_CHECKING,
+ Any,
+ cast,
+)
+
+import numpy as np
+
+from pandas.compat._optional import import_optional_dependency
+from pandas.util._decorators import doc
+
+from pandas.core.shared_docs import _shared_docs
+
+from pandas.io.excel._base import (
+ BaseExcelReader,
+ ExcelWriter,
+)
+from pandas.io.excel._util import (
+ combine_kwargs,
+ validate_freeze_panes,
+)
+
+if TYPE_CHECKING:
+ from openpyxl import Workbook
+ from openpyxl.descriptors.serialisable import Serialisable
+
+ from pandas._typing import (
+ ExcelWriterIfSheetExists,
+ FilePath,
+ ReadBuffer,
+ Scalar,
+ StorageOptions,
+ WriteExcelBuffer,
+ )
+
+
+class OpenpyxlWriter(ExcelWriter):
+ _engine = "openpyxl"
+ _supported_extensions = (".xlsx", ".xlsm")
+
+ def __init__(
+ self,
+ path: FilePath | WriteExcelBuffer | ExcelWriter,
+ engine: str | None = None,
+ date_format: str | None = None,
+ datetime_format: str | None = None,
+ mode: str = "w",
+ storage_options: StorageOptions | None = None,
+ if_sheet_exists: ExcelWriterIfSheetExists | None = None,
+ engine_kwargs: dict[str, Any] | None = None,
+ **kwargs,
+ ) -> None:
+ # Use the openpyxl module as the Excel writer.
+ from openpyxl.workbook import Workbook
+
+ engine_kwargs = combine_kwargs(engine_kwargs, kwargs)
+
+ super().__init__(
+ path,
+ mode=mode,
+ storage_options=storage_options,
+ if_sheet_exists=if_sheet_exists,
+ engine_kwargs=engine_kwargs,
+ )
+
+ # ExcelWriter replaced "a" by "r+" to allow us to first read the excel file from
+ # the file and later write to it
+ if "r+" in self._mode: # Load from existing workbook
+ from openpyxl import load_workbook
+
+ try:
+ self._book = load_workbook(self._handles.handle, **engine_kwargs)
+ except TypeError:
+ self._handles.handle.close()
+ raise
+ self._handles.handle.seek(0)
+ else:
+ # Create workbook object with default optimized_write=True.
+ try:
+ self._book = Workbook(**engine_kwargs)
+ except TypeError:
+ self._handles.handle.close()
+ raise
+
+ if self.book.worksheets:
+ self.book.remove(self.book.worksheets[0])
+
+ @property
+ def book(self) -> Workbook:
+ """
+ Book instance of class openpyxl.workbook.Workbook.
+
+ This attribute can be used to access engine-specific features.
+ """
+ return self._book
+
+ @property
+ def sheets(self) -> dict[str, Any]:
+ """Mapping of sheet names to sheet objects."""
+ result = {name: self.book[name] for name in self.book.sheetnames}
+ return result
+
+ def _save(self) -> None:
+ """
+ Save workbook to disk.
+ """
+ self.book.save(self._handles.handle)
+ if "r+" in self._mode and not isinstance(self._handles.handle, mmap.mmap):
+ # truncate file to the written content
+ self._handles.handle.truncate()
+
+ @classmethod
+ def _convert_to_style_kwargs(cls, style_dict: dict) -> dict[str, Serialisable]:
+ """
+ Convert a style_dict to a set of kwargs suitable for initializing
+ or updating-on-copy an openpyxl v2 style object.
+
+ Parameters
+ ----------
+ style_dict : dict
+ A dict with zero or more of the following keys (or their synonyms).
+ 'font'
+ 'fill'
+ 'border' ('borders')
+ 'alignment'
+ 'number_format'
+ 'protection'
+
+ Returns
+ -------
+ style_kwargs : dict
+ A dict with the same, normalized keys as ``style_dict`` but each
+ value has been replaced with a native openpyxl style object of the
+ appropriate class.
+ """
+ _style_key_map = {"borders": "border"}
+
+ style_kwargs: dict[str, Serialisable] = {}
+ for k, v in style_dict.items():
+ k = _style_key_map.get(k, k)
+ _conv_to_x = getattr(cls, f"_convert_to_{k}", lambda x: None)
+ new_v = _conv_to_x(v)
+ if new_v:
+ style_kwargs[k] = new_v
+
+ return style_kwargs
+
+ @classmethod
+ def _convert_to_color(cls, color_spec):
+ """
+ Convert ``color_spec`` to an openpyxl v2 Color object.
+
+ Parameters
+ ----------
+ color_spec : str, dict
+ A 32-bit ARGB hex string, or a dict with zero or more of the
+ following keys.
+ 'rgb'
+ 'indexed'
+ 'auto'
+ 'theme'
+ 'tint'
+ 'index'
+ 'type'
+
+ Returns
+ -------
+ color : openpyxl.styles.Color
+ """
+ from openpyxl.styles import Color
+
+ if isinstance(color_spec, str):
+ return Color(color_spec)
+ else:
+ return Color(**color_spec)
+
+ @classmethod
+ def _convert_to_font(cls, font_dict):
+ """
+ Convert ``font_dict`` to an openpyxl v2 Font object.
+
+ Parameters
+ ----------
+ font_dict : dict
+ A dict with zero or more of the following keys (or their synonyms).
+ 'name'
+ 'size' ('sz')
+ 'bold' ('b')
+ 'italic' ('i')
+ 'underline' ('u')
+ 'strikethrough' ('strike')
+ 'color'
+ 'vertAlign' ('vertalign')
+ 'charset'
+ 'scheme'
+ 'family'
+ 'outline'
+ 'shadow'
+ 'condense'
+
+ Returns
+ -------
+ font : openpyxl.styles.Font
+ """
+ from openpyxl.styles import Font
+
+ _font_key_map = {
+ "sz": "size",
+ "b": "bold",
+ "i": "italic",
+ "u": "underline",
+ "strike": "strikethrough",
+ "vertalign": "vertAlign",
+ }
+
+ font_kwargs = {}
+ for k, v in font_dict.items():
+ k = _font_key_map.get(k, k)
+ if k == "color":
+ v = cls._convert_to_color(v)
+ font_kwargs[k] = v
+
+ return Font(**font_kwargs)
+
+ @classmethod
+ def _convert_to_stop(cls, stop_seq):
+ """
+ Convert ``stop_seq`` to a list of openpyxl v2 Color objects,
+ suitable for initializing the ``GradientFill`` ``stop`` parameter.
+
+ Parameters
+ ----------
+ stop_seq : iterable
+ An iterable that yields objects suitable for consumption by
+ ``_convert_to_color``.
+
+ Returns
+ -------
+ stop : list of openpyxl.styles.Color
+ """
+ return map(cls._convert_to_color, stop_seq)
+
+ @classmethod
+ def _convert_to_fill(cls, fill_dict: dict[str, Any]):
+ """
+ Convert ``fill_dict`` to an openpyxl v2 Fill object.
+
+ Parameters
+ ----------
+ fill_dict : dict
+ A dict with one or more of the following keys (or their synonyms),
+ 'fill_type' ('patternType', 'patterntype')
+ 'start_color' ('fgColor', 'fgcolor')
+ 'end_color' ('bgColor', 'bgcolor')
+ or one or more of the following keys (or their synonyms).
+ 'type' ('fill_type')
+ 'degree'
+ 'left'
+ 'right'
+ 'top'
+ 'bottom'
+ 'stop'
+
+ Returns
+ -------
+ fill : openpyxl.styles.Fill
+ """
+ from openpyxl.styles import (
+ GradientFill,
+ PatternFill,
+ )
+
+ _pattern_fill_key_map = {
+ "patternType": "fill_type",
+ "patterntype": "fill_type",
+ "fgColor": "start_color",
+ "fgcolor": "start_color",
+ "bgColor": "end_color",
+ "bgcolor": "end_color",
+ }
+
+ _gradient_fill_key_map = {"fill_type": "type"}
+
+ pfill_kwargs = {}
+ gfill_kwargs = {}
+ for k, v in fill_dict.items():
+ pk = _pattern_fill_key_map.get(k)
+ gk = _gradient_fill_key_map.get(k)
+ if pk in ["start_color", "end_color"]:
+ v = cls._convert_to_color(v)
+ if gk == "stop":
+ v = cls._convert_to_stop(v)
+ if pk:
+ pfill_kwargs[pk] = v
+ elif gk:
+ gfill_kwargs[gk] = v
+ else:
+ pfill_kwargs[k] = v
+ gfill_kwargs[k] = v
+
+ try:
+ return PatternFill(**pfill_kwargs)
+ except TypeError:
+ return GradientFill(**gfill_kwargs)
+
+ @classmethod
+ def _convert_to_side(cls, side_spec):
+ """
+ Convert ``side_spec`` to an openpyxl v2 Side object.
+
+ Parameters
+ ----------
+ side_spec : str, dict
+ A string specifying the border style, or a dict with zero or more
+ of the following keys (or their synonyms).
+ 'style' ('border_style')
+ 'color'
+
+ Returns
+ -------
+ side : openpyxl.styles.Side
+ """
+ from openpyxl.styles import Side
+
+ _side_key_map = {"border_style": "style"}
+
+ if isinstance(side_spec, str):
+ return Side(style=side_spec)
+
+ side_kwargs = {}
+ for k, v in side_spec.items():
+ k = _side_key_map.get(k, k)
+ if k == "color":
+ v = cls._convert_to_color(v)
+ side_kwargs[k] = v
+
+ return Side(**side_kwargs)
+
+ @classmethod
+ def _convert_to_border(cls, border_dict):
+ """
+ Convert ``border_dict`` to an openpyxl v2 Border object.
+
+ Parameters
+ ----------
+ border_dict : dict
+ A dict with zero or more of the following keys (or their synonyms).
+ 'left'
+ 'right'
+ 'top'
+ 'bottom'
+ 'diagonal'
+ 'diagonal_direction'
+ 'vertical'
+ 'horizontal'
+ 'diagonalUp' ('diagonalup')
+ 'diagonalDown' ('diagonaldown')
+ 'outline'
+
+ Returns
+ -------
+ border : openpyxl.styles.Border
+ """
+ from openpyxl.styles import Border
+
+ _border_key_map = {"diagonalup": "diagonalUp", "diagonaldown": "diagonalDown"}
+
+ border_kwargs = {}
+ for k, v in border_dict.items():
+ k = _border_key_map.get(k, k)
+ if k == "color":
+ v = cls._convert_to_color(v)
+ if k in ["left", "right", "top", "bottom", "diagonal"]:
+ v = cls._convert_to_side(v)
+ border_kwargs[k] = v
+
+ return Border(**border_kwargs)
+
+ @classmethod
+ def _convert_to_alignment(cls, alignment_dict):
+ """
+ Convert ``alignment_dict`` to an openpyxl v2 Alignment object.
+
+ Parameters
+ ----------
+ alignment_dict : dict
+ A dict with zero or more of the following keys (or their synonyms).
+ 'horizontal'
+ 'vertical'
+ 'text_rotation'
+ 'wrap_text'
+ 'shrink_to_fit'
+ 'indent'
+ Returns
+ -------
+ alignment : openpyxl.styles.Alignment
+ """
+ from openpyxl.styles import Alignment
+
+ return Alignment(**alignment_dict)
+
+ @classmethod
+ def _convert_to_number_format(cls, number_format_dict):
+ """
+ Convert ``number_format_dict`` to an openpyxl v2.1.0 number format
+ initializer.
+
+ Parameters
+ ----------
+ number_format_dict : dict
+ A dict with zero or more of the following keys.
+ 'format_code' : str
+
+ Returns
+ -------
+ number_format : str
+ """
+ return number_format_dict["format_code"]
+
+ @classmethod
+ def _convert_to_protection(cls, protection_dict):
+ """
+ Convert ``protection_dict`` to an openpyxl v2 Protection object.
+
+ Parameters
+ ----------
+ protection_dict : dict
+ A dict with zero or more of the following keys.
+ 'locked'
+ 'hidden'
+
+ Returns
+ -------
+ """
+ from openpyxl.styles import Protection
+
+ return Protection(**protection_dict)
+
+ def _write_cells(
+ self,
+ cells,
+ sheet_name: str | None = None,
+ startrow: int = 0,
+ startcol: int = 0,
+ freeze_panes: tuple[int, int] | None = None,
+ ) -> None:
+ # Write the frame cells using openpyxl.
+ sheet_name = self._get_sheet_name(sheet_name)
+
+ _style_cache: dict[str, dict[str, Serialisable]] = {}
+
+ if sheet_name in self.sheets and self._if_sheet_exists != "new":
+ if "r+" in self._mode:
+ if self._if_sheet_exists == "replace":
+ old_wks = self.sheets[sheet_name]
+ target_index = self.book.index(old_wks)
+ del self.book[sheet_name]
+ wks = self.book.create_sheet(sheet_name, target_index)
+ elif self._if_sheet_exists == "error":
+ raise ValueError(
+ f"Sheet '{sheet_name}' already exists and "
+ f"if_sheet_exists is set to 'error'."
+ )
+ elif self._if_sheet_exists == "overlay":
+ wks = self.sheets[sheet_name]
+ else:
+ raise ValueError(
+ f"'{self._if_sheet_exists}' is not valid for if_sheet_exists. "
+ "Valid options are 'error', 'new', 'replace' and 'overlay'."
+ )
+ else:
+ wks = self.sheets[sheet_name]
+ else:
+ wks = self.book.create_sheet()
+ wks.title = sheet_name
+
+ if validate_freeze_panes(freeze_panes):
+ freeze_panes = cast(tuple[int, int], freeze_panes)
+ wks.freeze_panes = wks.cell(
+ row=freeze_panes[0] + 1, column=freeze_panes[1] + 1
+ )
+
+ for cell in cells:
+ xcell = wks.cell(
+ row=startrow + cell.row + 1, column=startcol + cell.col + 1
+ )
+ xcell.value, fmt = self._value_with_fmt(cell.val)
+ if fmt:
+ xcell.number_format = fmt
+
+ style_kwargs: dict[str, Serialisable] | None = {}
+ if cell.style:
+ key = str(cell.style)
+ style_kwargs = _style_cache.get(key)
+ if style_kwargs is None:
+ style_kwargs = self._convert_to_style_kwargs(cell.style)
+ _style_cache[key] = style_kwargs
+
+ if style_kwargs:
+ for k, v in style_kwargs.items():
+ setattr(xcell, k, v)
+
+ if cell.mergestart is not None and cell.mergeend is not None:
+ wks.merge_cells(
+ start_row=startrow + cell.row + 1,
+ start_column=startcol + cell.col + 1,
+ end_column=startcol + cell.mergeend + 1,
+ end_row=startrow + cell.mergestart + 1,
+ )
+
+ # When cells are merged only the top-left cell is preserved
+ # The behaviour of the other cells in a merged range is
+ # undefined
+ if style_kwargs:
+ first_row = startrow + cell.row + 1
+ last_row = startrow + cell.mergestart + 1
+ first_col = startcol + cell.col + 1
+ last_col = startcol + cell.mergeend + 1
+
+ for row in range(first_row, last_row + 1):
+ for col in range(first_col, last_col + 1):
+ if row == first_row and col == first_col:
+ # Ignore first cell. It is already handled.
+ continue
+ xcell = wks.cell(column=col, row=row)
+ for k, v in style_kwargs.items():
+ setattr(xcell, k, v)
+
+
+class OpenpyxlReader(BaseExcelReader["Workbook"]):
+ @doc(storage_options=_shared_docs["storage_options"])
+ def __init__(
+ self,
+ filepath_or_buffer: FilePath | ReadBuffer[bytes],
+ storage_options: StorageOptions | None = None,
+ engine_kwargs: dict | None = None,
+ ) -> None:
+ """
+ Reader using openpyxl engine.
+
+ Parameters
+ ----------
+ filepath_or_buffer : str, path object or Workbook
+ Object to be parsed.
+ {storage_options}
+ engine_kwargs : dict, optional
+ Arbitrary keyword arguments passed to excel engine.
+ """
+ import_optional_dependency("openpyxl")
+ super().__init__(
+ filepath_or_buffer,
+ storage_options=storage_options,
+ engine_kwargs=engine_kwargs,
+ )
+
+ @property
+ def _workbook_class(self) -> type[Workbook]:
+ from openpyxl import Workbook
+
+ return Workbook
+
+ def load_workbook(
+ self, filepath_or_buffer: FilePath | ReadBuffer[bytes], engine_kwargs
+ ) -> Workbook:
+ from openpyxl import load_workbook
+
+ default_kwargs = {"read_only": True, "data_only": True, "keep_links": False}
+
+ return load_workbook(
+ filepath_or_buffer,
+ **(default_kwargs | engine_kwargs),
+ )
+
+ @property
+ def sheet_names(self) -> list[str]:
+ return [sheet.title for sheet in self.book.worksheets]
+
+ def get_sheet_by_name(self, name: str):
+ self.raise_if_bad_sheet_by_name(name)
+ return self.book[name]
+
+ def get_sheet_by_index(self, index: int):
+ self.raise_if_bad_sheet_by_index(index)
+ return self.book.worksheets[index]
+
+ def _convert_cell(self, cell) -> Scalar:
+ from openpyxl.cell.cell import (
+ TYPE_ERROR,
+ TYPE_NUMERIC,
+ )
+
+ if cell.value is None:
+ return "" # compat with xlrd
+ elif cell.data_type == TYPE_ERROR:
+ return np.nan
+ elif cell.data_type == TYPE_NUMERIC:
+ val = int(cell.value)
+ if val == cell.value:
+ return val
+ return float(cell.value)
+
+ return cell.value
+
+ def get_sheet_data(
+ self, sheet, file_rows_needed: int | None = None
+ ) -> list[list[Scalar]]:
+ if self.book.read_only:
+ sheet.reset_dimensions()
+
+ data: list[list[Scalar]] = []
+ last_row_with_data = -1
+ for row_number, row in enumerate(sheet.rows):
+ converted_row = [self._convert_cell(cell) for cell in row]
+ while converted_row and converted_row[-1] == "":
+ # trim trailing empty elements
+ converted_row.pop()
+ if converted_row:
+ last_row_with_data = row_number
+ data.append(converted_row)
+ if file_rows_needed is not None and len(data) >= file_rows_needed:
+ break
+
+ # Trim trailing empty rows
+ data = data[: last_row_with_data + 1]
+
+ if len(data) > 0:
+ # extend rows to max width
+ max_width = max(len(data_row) for data_row in data)
+ if min(len(data_row) for data_row in data) < max_width:
+ empty_cell: list[Scalar] = [""]
+ data = [
+ data_row + (max_width - len(data_row)) * empty_cell
+ for data_row in data
+ ]
+
+ return data
diff --git a/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/_pyxlsb.py b/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/_pyxlsb.py
new file mode 100644
index 0000000000000000000000000000000000000000..a6e42616c20438fa4cab16e94b5d16a01c9c61df
--- /dev/null
+++ b/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/_pyxlsb.py
@@ -0,0 +1,127 @@
+# pyright: reportMissingImports=false
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from pandas.compat._optional import import_optional_dependency
+from pandas.util._decorators import doc
+
+from pandas.core.shared_docs import _shared_docs
+
+from pandas.io.excel._base import BaseExcelReader
+
+if TYPE_CHECKING:
+ from pyxlsb import Workbook
+
+ from pandas._typing import (
+ FilePath,
+ ReadBuffer,
+ Scalar,
+ StorageOptions,
+ )
+
+
+class PyxlsbReader(BaseExcelReader["Workbook"]):
+ @doc(storage_options=_shared_docs["storage_options"])
+ def __init__(
+ self,
+ filepath_or_buffer: FilePath | ReadBuffer[bytes],
+ storage_options: StorageOptions | None = None,
+ engine_kwargs: dict | None = None,
+ ) -> None:
+ """
+ Reader using pyxlsb engine.
+
+ Parameters
+ ----------
+ filepath_or_buffer : str, path object, or Workbook
+ Object to be parsed.
+ {storage_options}
+ engine_kwargs : dict, optional
+ Arbitrary keyword arguments passed to excel engine.
+ """
+ import_optional_dependency("pyxlsb")
+ # This will call load_workbook on the filepath or buffer
+ # And set the result to the book-attribute
+ super().__init__(
+ filepath_or_buffer,
+ storage_options=storage_options,
+ engine_kwargs=engine_kwargs,
+ )
+
+ @property
+ def _workbook_class(self) -> type[Workbook]:
+ from pyxlsb import Workbook
+
+ return Workbook
+
+ def load_workbook(
+ self, filepath_or_buffer: FilePath | ReadBuffer[bytes], engine_kwargs
+ ) -> Workbook:
+ from pyxlsb import open_workbook
+
+ # TODO: hack in buffer capability
+ # This might need some modifications to the Pyxlsb library
+ # Actual work for opening it is in xlsbpackage.py, line 20-ish
+
+ return open_workbook(filepath_or_buffer, **engine_kwargs)
+
+ @property
+ def sheet_names(self) -> list[str]:
+ return self.book.sheets
+
+ def get_sheet_by_name(self, name: str):
+ self.raise_if_bad_sheet_by_name(name)
+ return self.book.get_sheet(name)
+
+ def get_sheet_by_index(self, index: int):
+ self.raise_if_bad_sheet_by_index(index)
+ # pyxlsb sheets are indexed from 1 onwards
+ # There's a fix for this in the source, but the pypi package doesn't have it
+ return self.book.get_sheet(index + 1)
+
+ def _convert_cell(self, cell) -> Scalar:
+ # TODO: there is no way to distinguish between floats and datetimes in pyxlsb
+ # This means that there is no way to read datetime types from an xlsb file yet
+ if cell.v is None:
+ return "" # Prevents non-named columns from not showing up as Unnamed: i
+ if isinstance(cell.v, float):
+ val = int(cell.v)
+ if val == cell.v:
+ return val
+ else:
+ return float(cell.v)
+
+ return cell.v
+
+ def get_sheet_data(
+ self,
+ sheet,
+ file_rows_needed: int | None = None,
+ ) -> list[list[Scalar]]:
+ data: list[list[Scalar]] = []
+ previous_row_number = -1
+ # When sparse=True the rows can have different lengths and empty rows are
+ # not returned. The cells are namedtuples of row, col, value (r, c, v).
+ for row in sheet.rows(sparse=True):
+ row_number = row[0].r
+ converted_row = [self._convert_cell(cell) for cell in row]
+ while converted_row and converted_row[-1] == "":
+ # trim trailing empty elements
+ converted_row.pop()
+ if converted_row:
+ data.extend([[]] * (row_number - previous_row_number - 1))
+ data.append(converted_row)
+ previous_row_number = row_number
+ if file_rows_needed is not None and len(data) >= file_rows_needed:
+ break
+ if data:
+ # extend rows to max_width
+ max_width = max(len(data_row) for data_row in data)
+ if min(len(data_row) for data_row in data) < max_width:
+ empty_cell: list[Scalar] = [""]
+ data = [
+ data_row + (max_width - len(data_row)) * empty_cell
+ for data_row in data
+ ]
+ return data
diff --git a/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/_util.py b/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/_util.py
new file mode 100644
index 0000000000000000000000000000000000000000..f7a1fcb8052e391d0853be64866663f4e6de9d08
--- /dev/null
+++ b/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/_util.py
@@ -0,0 +1,334 @@
+from __future__ import annotations
+
+from collections.abc import (
+ Hashable,
+ Iterable,
+ MutableMapping,
+ Sequence,
+)
+from typing import (
+ TYPE_CHECKING,
+ Any,
+ Callable,
+ Literal,
+ TypeVar,
+ overload,
+)
+
+from pandas.compat._optional import import_optional_dependency
+
+from pandas.core.dtypes.common import (
+ is_integer,
+ is_list_like,
+)
+
+if TYPE_CHECKING:
+ from pandas.io.excel._base import ExcelWriter
+
+ ExcelWriter_t = type[ExcelWriter]
+ usecols_func = TypeVar("usecols_func", bound=Callable[[Hashable], object])
+
+_writers: MutableMapping[str, ExcelWriter_t] = {}
+
+
+def register_writer(klass: ExcelWriter_t) -> None:
+ """
+ Add engine to the excel writer registry.io.excel.
+
+ You must use this method to integrate with ``to_excel``.
+
+ Parameters
+ ----------
+ klass : ExcelWriter
+ """
+ if not callable(klass):
+ raise ValueError("Can only register callables as engines")
+ engine_name = klass._engine
+ _writers[engine_name] = klass
+
+
+def get_default_engine(ext: str, mode: Literal["reader", "writer"] = "reader") -> str:
+ """
+ Return the default reader/writer for the given extension.
+
+ Parameters
+ ----------
+ ext : str
+ The excel file extension for which to get the default engine.
+ mode : str {'reader', 'writer'}
+ Whether to get the default engine for reading or writing.
+ Either 'reader' or 'writer'
+
+ Returns
+ -------
+ str
+ The default engine for the extension.
+ """
+ _default_readers = {
+ "xlsx": "openpyxl",
+ "xlsm": "openpyxl",
+ "xlsb": "pyxlsb",
+ "xls": "xlrd",
+ "ods": "odf",
+ }
+ _default_writers = {
+ "xlsx": "openpyxl",
+ "xlsm": "openpyxl",
+ "xlsb": "pyxlsb",
+ "ods": "odf",
+ }
+ assert mode in ["reader", "writer"]
+ if mode == "writer":
+ # Prefer xlsxwriter over openpyxl if installed
+ xlsxwriter = import_optional_dependency("xlsxwriter", errors="warn")
+ if xlsxwriter:
+ _default_writers["xlsx"] = "xlsxwriter"
+ return _default_writers[ext]
+ else:
+ return _default_readers[ext]
+
+
+def get_writer(engine_name: str) -> ExcelWriter_t:
+ try:
+ return _writers[engine_name]
+ except KeyError as err:
+ raise ValueError(f"No Excel writer '{engine_name}'") from err
+
+
+def _excel2num(x: str) -> int:
+ """
+ Convert Excel column name like 'AB' to 0-based column index.
+
+ Parameters
+ ----------
+ x : str
+ The Excel column name to convert to a 0-based column index.
+
+ Returns
+ -------
+ num : int
+ The column index corresponding to the name.
+
+ Raises
+ ------
+ ValueError
+ Part of the Excel column name was invalid.
+ """
+ index = 0
+
+ for c in x.upper().strip():
+ cp = ord(c)
+
+ if cp < ord("A") or cp > ord("Z"):
+ raise ValueError(f"Invalid column name: {x}")
+
+ index = index * 26 + cp - ord("A") + 1
+
+ return index - 1
+
+
+def _range2cols(areas: str) -> list[int]:
+ """
+ Convert comma separated list of column names and ranges to indices.
+
+ Parameters
+ ----------
+ areas : str
+ A string containing a sequence of column ranges (or areas).
+
+ Returns
+ -------
+ cols : list
+ A list of 0-based column indices.
+
+ Examples
+ --------
+ >>> _range2cols('A:E')
+ [0, 1, 2, 3, 4]
+ >>> _range2cols('A,C,Z:AB')
+ [0, 2, 25, 26, 27]
+ """
+ cols: list[int] = []
+
+ for rng in areas.split(","):
+ if ":" in rng:
+ rngs = rng.split(":")
+ cols.extend(range(_excel2num(rngs[0]), _excel2num(rngs[1]) + 1))
+ else:
+ cols.append(_excel2num(rng))
+
+ return cols
+
+
+@overload
+def maybe_convert_usecols(usecols: str | list[int]) -> list[int]:
+ ...
+
+
+@overload
+def maybe_convert_usecols(usecols: list[str]) -> list[str]:
+ ...
+
+
+@overload
+def maybe_convert_usecols(usecols: usecols_func) -> usecols_func:
+ ...
+
+
+@overload
+def maybe_convert_usecols(usecols: None) -> None:
+ ...
+
+
+def maybe_convert_usecols(
+ usecols: str | list[int] | list[str] | usecols_func | None,
+) -> None | list[int] | list[str] | usecols_func:
+ """
+ Convert `usecols` into a compatible format for parsing in `parsers.py`.
+
+ Parameters
+ ----------
+ usecols : object
+ The use-columns object to potentially convert.
+
+ Returns
+ -------
+ converted : object
+ The compatible format of `usecols`.
+ """
+ if usecols is None:
+ return usecols
+
+ if is_integer(usecols):
+ raise ValueError(
+ "Passing an integer for `usecols` is no longer supported. "
+ "Please pass in a list of int from 0 to `usecols` inclusive instead."
+ )
+
+ if isinstance(usecols, str):
+ return _range2cols(usecols)
+
+ return usecols
+
+
+@overload
+def validate_freeze_panes(freeze_panes: tuple[int, int]) -> Literal[True]:
+ ...
+
+
+@overload
+def validate_freeze_panes(freeze_panes: None) -> Literal[False]:
+ ...
+
+
+def validate_freeze_panes(freeze_panes: tuple[int, int] | None) -> bool:
+ if freeze_panes is not None:
+ if len(freeze_panes) == 2 and all(
+ isinstance(item, int) for item in freeze_panes
+ ):
+ return True
+
+ raise ValueError(
+ "freeze_panes must be of form (row, column) "
+ "where row and column are integers"
+ )
+
+ # freeze_panes wasn't specified, return False so it won't be applied
+ # to output sheet
+ return False
+
+
+def fill_mi_header(
+ row: list[Hashable], control_row: list[bool]
+) -> tuple[list[Hashable], list[bool]]:
+ """
+ Forward fill blank entries in row but only inside the same parent index.
+
+ Used for creating headers in Multiindex.
+
+ Parameters
+ ----------
+ row : list
+ List of items in a single row.
+ control_row : list of bool
+ Helps to determine if particular column is in same parent index as the
+ previous value. Used to stop propagation of empty cells between
+ different indexes.
+
+ Returns
+ -------
+ Returns changed row and control_row
+ """
+ last = row[0]
+ for i in range(1, len(row)):
+ if not control_row[i]:
+ last = row[i]
+
+ if row[i] == "" or row[i] is None:
+ row[i] = last
+ else:
+ control_row[i] = False
+ last = row[i]
+
+ return row, control_row
+
+
+def pop_header_name(
+ row: list[Hashable], index_col: int | Sequence[int]
+) -> tuple[Hashable | None, list[Hashable]]:
+ """
+ Pop the header name for MultiIndex parsing.
+
+ Parameters
+ ----------
+ row : list
+ The data row to parse for the header name.
+ index_col : int, list
+ The index columns for our data. Assumed to be non-null.
+
+ Returns
+ -------
+ header_name : str
+ The extracted header name.
+ trimmed_row : list
+ The original data row with the header name removed.
+ """
+ # Pop out header name and fill w/blank.
+ if is_list_like(index_col):
+ assert isinstance(index_col, Iterable)
+ i = max(index_col)
+ else:
+ assert not isinstance(index_col, Iterable)
+ i = index_col
+
+ header_name = row[i]
+ header_name = None if header_name == "" else header_name
+
+ return header_name, row[:i] + [""] + row[i + 1 :]
+
+
+def combine_kwargs(engine_kwargs: dict[str, Any] | None, kwargs: dict) -> dict:
+ """
+ Used to combine two sources of kwargs for the backend engine.
+
+ Use of kwargs is deprecated, this function is solely for use in 1.3 and should
+ be removed in 1.4/2.0. Also _base.ExcelWriter.__new__ ensures either engine_kwargs
+ or kwargs must be None or empty respectively.
+
+ Parameters
+ ----------
+ engine_kwargs: dict
+ kwargs to be passed through to the engine.
+ kwargs: dict
+ kwargs to be psased through to the engine (deprecated)
+
+ Returns
+ -------
+ engine_kwargs combined with kwargs
+ """
+ if engine_kwargs is None:
+ result = {}
+ else:
+ result = engine_kwargs.copy()
+ result.update(kwargs)
+ return result
diff --git a/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/_xlrd.py b/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/_xlrd.py
new file mode 100644
index 0000000000000000000000000000000000000000..a444970792e6e65faf3d8947b721fff59487d994
--- /dev/null
+++ b/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/_xlrd.py
@@ -0,0 +1,143 @@
+from __future__ import annotations
+
+from datetime import time
+import math
+from typing import TYPE_CHECKING
+
+import numpy as np
+
+from pandas.compat._optional import import_optional_dependency
+from pandas.util._decorators import doc
+
+from pandas.core.shared_docs import _shared_docs
+
+from pandas.io.excel._base import BaseExcelReader
+
+if TYPE_CHECKING:
+ from xlrd import Book
+
+ from pandas._typing import (
+ Scalar,
+ StorageOptions,
+ )
+
+
+class XlrdReader(BaseExcelReader["Book"]):
+ @doc(storage_options=_shared_docs["storage_options"])
+ def __init__(
+ self,
+ filepath_or_buffer,
+ storage_options: StorageOptions | None = None,
+ engine_kwargs: dict | None = None,
+ ) -> None:
+ """
+ Reader using xlrd engine.
+
+ Parameters
+ ----------
+ filepath_or_buffer : str, path object or Workbook
+ Object to be parsed.
+ {storage_options}
+ engine_kwargs : dict, optional
+ Arbitrary keyword arguments passed to excel engine.
+ """
+ err_msg = "Install xlrd >= 2.0.1 for xls Excel support"
+ import_optional_dependency("xlrd", extra=err_msg)
+ super().__init__(
+ filepath_or_buffer,
+ storage_options=storage_options,
+ engine_kwargs=engine_kwargs,
+ )
+
+ @property
+ def _workbook_class(self) -> type[Book]:
+ from xlrd import Book
+
+ return Book
+
+ def load_workbook(self, filepath_or_buffer, engine_kwargs) -> Book:
+ from xlrd import open_workbook
+
+ if hasattr(filepath_or_buffer, "read"):
+ data = filepath_or_buffer.read()
+ return open_workbook(file_contents=data, **engine_kwargs)
+ else:
+ return open_workbook(filepath_or_buffer, **engine_kwargs)
+
+ @property
+ def sheet_names(self):
+ return self.book.sheet_names()
+
+ def get_sheet_by_name(self, name):
+ self.raise_if_bad_sheet_by_name(name)
+ return self.book.sheet_by_name(name)
+
+ def get_sheet_by_index(self, index):
+ self.raise_if_bad_sheet_by_index(index)
+ return self.book.sheet_by_index(index)
+
+ def get_sheet_data(
+ self, sheet, file_rows_needed: int | None = None
+ ) -> list[list[Scalar]]:
+ from xlrd import (
+ XL_CELL_BOOLEAN,
+ XL_CELL_DATE,
+ XL_CELL_ERROR,
+ XL_CELL_NUMBER,
+ xldate,
+ )
+
+ epoch1904 = self.book.datemode
+
+ def _parse_cell(cell_contents, cell_typ):
+ """
+ converts the contents of the cell into a pandas appropriate object
+ """
+ if cell_typ == XL_CELL_DATE:
+ # Use the newer xlrd datetime handling.
+ try:
+ cell_contents = xldate.xldate_as_datetime(cell_contents, epoch1904)
+ except OverflowError:
+ return cell_contents
+
+ # Excel doesn't distinguish between dates and time,
+ # so we treat dates on the epoch as times only.
+ # Also, Excel supports 1900 and 1904 epochs.
+ year = (cell_contents.timetuple())[0:3]
+ if (not epoch1904 and year == (1899, 12, 31)) or (
+ epoch1904 and year == (1904, 1, 1)
+ ):
+ cell_contents = time(
+ cell_contents.hour,
+ cell_contents.minute,
+ cell_contents.second,
+ cell_contents.microsecond,
+ )
+
+ elif cell_typ == XL_CELL_ERROR:
+ cell_contents = np.nan
+ elif cell_typ == XL_CELL_BOOLEAN:
+ cell_contents = bool(cell_contents)
+ elif cell_typ == XL_CELL_NUMBER:
+ # GH5394 - Excel 'numbers' are always floats
+ # it's a minimal perf hit and less surprising
+ if math.isfinite(cell_contents):
+ # GH54564 - don't attempt to convert NaN/Inf
+ val = int(cell_contents)
+ if val == cell_contents:
+ cell_contents = val
+ return cell_contents
+
+ data = []
+
+ nrows = sheet.nrows
+ if file_rows_needed is not None:
+ nrows = min(nrows, file_rows_needed)
+ for i in range(nrows):
+ row = [
+ _parse_cell(value, typ)
+ for value, typ in zip(sheet.row_values(i), sheet.row_types(i))
+ ]
+ data.append(row)
+
+ return data
diff --git a/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/_xlsxwriter.py b/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/_xlsxwriter.py
new file mode 100644
index 0000000000000000000000000000000000000000..6eacac8c064fb1f297cd46b8ab0361ceb22067b4
--- /dev/null
+++ b/mplug_owl2/lib/python3.10/site-packages/pandas/io/excel/_xlsxwriter.py
@@ -0,0 +1,284 @@
+from __future__ import annotations
+
+import json
+from typing import (
+ TYPE_CHECKING,
+ Any,
+)
+
+from pandas.io.excel._base import ExcelWriter
+from pandas.io.excel._util import (
+ combine_kwargs,
+ validate_freeze_panes,
+)
+
+if TYPE_CHECKING:
+ from pandas._typing import (
+ ExcelWriterIfSheetExists,
+ FilePath,
+ StorageOptions,
+ WriteExcelBuffer,
+ )
+
+
+class _XlsxStyler:
+ # Map from openpyxl-oriented styles to flatter xlsxwriter representation
+ # Ordering necessary for both determinism and because some are keyed by
+ # prefixes of others.
+ STYLE_MAPPING: dict[str, list[tuple[tuple[str, ...], str]]] = {
+ "font": [
+ (("name",), "font_name"),
+ (("sz",), "font_size"),
+ (("size",), "font_size"),
+ (("color", "rgb"), "font_color"),
+ (("color",), "font_color"),
+ (("b",), "bold"),
+ (("bold",), "bold"),
+ (("i",), "italic"),
+ (("italic",), "italic"),
+ (("u",), "underline"),
+ (("underline",), "underline"),
+ (("strike",), "font_strikeout"),
+ (("vertAlign",), "font_script"),
+ (("vertalign",), "font_script"),
+ ],
+ "number_format": [(("format_code",), "num_format"), ((), "num_format")],
+ "protection": [(("locked",), "locked"), (("hidden",), "hidden")],
+ "alignment": [
+ (("horizontal",), "align"),
+ (("vertical",), "valign"),
+ (("text_rotation",), "rotation"),
+ (("wrap_text",), "text_wrap"),
+ (("indent",), "indent"),
+ (("shrink_to_fit",), "shrink"),
+ ],
+ "fill": [
+ (("patternType",), "pattern"),
+ (("patterntype",), "pattern"),
+ (("fill_type",), "pattern"),
+ (("start_color", "rgb"), "fg_color"),
+ (("fgColor", "rgb"), "fg_color"),
+ (("fgcolor", "rgb"), "fg_color"),
+ (("start_color",), "fg_color"),
+ (("fgColor",), "fg_color"),
+ (("fgcolor",), "fg_color"),
+ (("end_color", "rgb"), "bg_color"),
+ (("bgColor", "rgb"), "bg_color"),
+ (("bgcolor", "rgb"), "bg_color"),
+ (("end_color",), "bg_color"),
+ (("bgColor",), "bg_color"),
+ (("bgcolor",), "bg_color"),
+ ],
+ "border": [
+ (("color", "rgb"), "border_color"),
+ (("color",), "border_color"),
+ (("style",), "border"),
+ (("top", "color", "rgb"), "top_color"),
+ (("top", "color"), "top_color"),
+ (("top", "style"), "top"),
+ (("top",), "top"),
+ (("right", "color", "rgb"), "right_color"),
+ (("right", "color"), "right_color"),
+ (("right", "style"), "right"),
+ (("right",), "right"),
+ (("bottom", "color", "rgb"), "bottom_color"),
+ (("bottom", "color"), "bottom_color"),
+ (("bottom", "style"), "bottom"),
+ (("bottom",), "bottom"),
+ (("left", "color", "rgb"), "left_color"),
+ (("left", "color"), "left_color"),
+ (("left", "style"), "left"),
+ (("left",), "left"),
+ ],
+ }
+
+ @classmethod
+ def convert(cls, style_dict, num_format_str=None):
+ """
+ converts a style_dict to an xlsxwriter format dict
+
+ Parameters
+ ----------
+ style_dict : style dictionary to convert
+ num_format_str : optional number format string
+ """
+ # Create a XlsxWriter format object.
+ props = {}
+
+ if num_format_str is not None:
+ props["num_format"] = num_format_str
+
+ if style_dict is None:
+ return props
+
+ if "borders" in style_dict:
+ style_dict = style_dict.copy()
+ style_dict["border"] = style_dict.pop("borders")
+
+ for style_group_key, style_group in style_dict.items():
+ for src, dst in cls.STYLE_MAPPING.get(style_group_key, []):
+ # src is a sequence of keys into a nested dict
+ # dst is a flat key
+ if dst in props:
+ continue
+ v = style_group
+ for k in src:
+ try:
+ v = v[k]
+ except (KeyError, TypeError):
+ break
+ else:
+ props[dst] = v
+
+ if isinstance(props.get("pattern"), str):
+ # TODO: support other fill patterns
+ props["pattern"] = 0 if props["pattern"] == "none" else 1
+
+ for k in ["border", "top", "right", "bottom", "left"]:
+ if isinstance(props.get(k), str):
+ try:
+ props[k] = [
+ "none",
+ "thin",
+ "medium",
+ "dashed",
+ "dotted",
+ "thick",
+ "double",
+ "hair",
+ "mediumDashed",
+ "dashDot",
+ "mediumDashDot",
+ "dashDotDot",
+ "mediumDashDotDot",
+ "slantDashDot",
+ ].index(props[k])
+ except ValueError:
+ props[k] = 2
+
+ if isinstance(props.get("font_script"), str):
+ props["font_script"] = ["baseline", "superscript", "subscript"].index(
+ props["font_script"]
+ )
+
+ if isinstance(props.get("underline"), str):
+ props["underline"] = {
+ "none": 0,
+ "single": 1,
+ "double": 2,
+ "singleAccounting": 33,
+ "doubleAccounting": 34,
+ }[props["underline"]]
+
+ # GH 30107 - xlsxwriter uses different name
+ if props.get("valign") == "center":
+ props["valign"] = "vcenter"
+
+ return props
+
+
+class XlsxWriter(ExcelWriter):
+ _engine = "xlsxwriter"
+ _supported_extensions = (".xlsx",)
+
+ def __init__(
+ self,
+ path: FilePath | WriteExcelBuffer | ExcelWriter,
+ engine: str | None = None,
+ date_format: str | None = None,
+ datetime_format: str | None = None,
+ mode: str = "w",
+ storage_options: StorageOptions | None = None,
+ if_sheet_exists: ExcelWriterIfSheetExists | None = None,
+ engine_kwargs: dict[str, Any] | None = None,
+ **kwargs,
+ ) -> None:
+ # Use the xlsxwriter module as the Excel writer.
+ from xlsxwriter import Workbook
+
+ engine_kwargs = combine_kwargs(engine_kwargs, kwargs)
+
+ if mode == "a":
+ raise ValueError("Append mode is not supported with xlsxwriter!")
+
+ super().__init__(
+ path,
+ engine=engine,
+ date_format=date_format,
+ datetime_format=datetime_format,
+ mode=mode,
+ storage_options=storage_options,
+ if_sheet_exists=if_sheet_exists,
+ engine_kwargs=engine_kwargs,
+ )
+
+ try:
+ self._book = Workbook(self._handles.handle, **engine_kwargs)
+ except TypeError:
+ self._handles.handle.close()
+ raise
+
+ @property
+ def book(self):
+ """
+ Book instance of class xlsxwriter.Workbook.
+
+ This attribute can be used to access engine-specific features.
+ """
+ return self._book
+
+ @property
+ def sheets(self) -> dict[str, Any]:
+ result = self.book.sheetnames
+ return result
+
+ def _save(self) -> None:
+ """
+ Save workbook to disk.
+ """
+ self.book.close()
+
+ def _write_cells(
+ self,
+ cells,
+ sheet_name: str | None = None,
+ startrow: int = 0,
+ startcol: int = 0,
+ freeze_panes: tuple[int, int] | None = None,
+ ) -> None:
+ # Write the frame cells using xlsxwriter.
+ sheet_name = self._get_sheet_name(sheet_name)
+
+ wks = self.book.get_worksheet_by_name(sheet_name)
+ if wks is None:
+ wks = self.book.add_worksheet(sheet_name)
+
+ style_dict = {"null": None}
+
+ if validate_freeze_panes(freeze_panes):
+ wks.freeze_panes(*(freeze_panes))
+
+ for cell in cells:
+ val, fmt = self._value_with_fmt(cell.val)
+
+ stylekey = json.dumps(cell.style)
+ if fmt:
+ stylekey += fmt
+
+ if stylekey in style_dict:
+ style = style_dict[stylekey]
+ else:
+ style = self.book.add_format(_XlsxStyler.convert(cell.style, fmt))
+ style_dict[stylekey] = style
+
+ if cell.mergestart is not None and cell.mergeend is not None:
+ wks.merge_range(
+ startrow + cell.row,
+ startcol + cell.col,
+ startrow + cell.mergestart,
+ startcol + cell.mergeend,
+ val,
+ style,
+ )
+ else:
+ wks.write(startrow + cell.row, startcol + cell.col, val, style)
diff --git a/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/AIX-C.cmake b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/AIX-C.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..5eae8d91aeb295fe4703b31f56c9fcccfd263302
--- /dev/null
+++ b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/AIX-C.cmake
@@ -0,0 +1,5 @@
+# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+# AIX is the default linker
+include(Platform/Linker/AIX-AIX-C)
diff --git a/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/Android-C.cmake b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/Android-C.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..d3df948fad0907378a46e3b5cbd6dd9d4328ee6c
--- /dev/null
+++ b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/Android-C.cmake
@@ -0,0 +1,5 @@
+# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+# GNU is the default linker
+include(Platform/Linker/Android-GNU-C)
diff --git a/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/Android-GNU-ASM.cmake b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/Android-GNU-ASM.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..bfef8b9f70291643d5e5e7df29fb750d5ec83443
--- /dev/null
+++ b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/Android-GNU-ASM.cmake
@@ -0,0 +1,4 @@
+# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+include(Platform/Linker/Linux-GNU-ASM)
diff --git a/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/Apple-AppleClang-ASM.cmake b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/Apple-AppleClang-ASM.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..9cf9ff2d67219fd322a7652f2efcac292c47b45c
--- /dev/null
+++ b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/Apple-AppleClang-ASM.cmake
@@ -0,0 +1,6 @@
+# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+include(Platform/Linker/Apple-AppleClang)
+
+__apple_linker_appleclang(ASM)
diff --git a/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/Apple-LLD-C.cmake b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/Apple-LLD-C.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..64d9591660163cdc26cf88a653ddf2f6a221e975
--- /dev/null
+++ b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/Apple-LLD-C.cmake
@@ -0,0 +1,6 @@
+# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+include(Platform/Linker/Apple-AppleClang-C)
+
+set(CMAKE_C_PLATFORM_LINKER_ID LLD)
diff --git a/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/Apple-LLD-CXX.cmake b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/Apple-LLD-CXX.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..deaa5588a089a8c64fb51822fd6b3e96464dfabc
--- /dev/null
+++ b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/Apple-LLD-CXX.cmake
@@ -0,0 +1,6 @@
+# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+include(Platform/Linker/Apple-AppleClang-CXX)
+
+set(CMAKE_CXX_PLATFORM_LINKER_ID LLD)
diff --git a/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/BSD-Linker-Initialize.cmake b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/BSD-Linker-Initialize.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..3de1dabb6644d2bf38223297f3046e3545f72c16
--- /dev/null
+++ b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/BSD-Linker-Initialize.cmake
@@ -0,0 +1,22 @@
+# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+block(SCOPE_FOR POLICIES)
+cmake_policy(SET CMP0054 NEW)
+
+if(NOT _CMAKE_SYSTEM_LINKER_TYPE)
+ block(SCOPE_FOR VARIABLES)
+ execute_process(COMMAND "${CMAKE_LINKER}" --version
+ RESULT_VARIABLE result
+ OUTPUT_VARIABLE output
+ ERROR_VARIABLE output)
+ if(result OR NOT output MATCHES "LLD")
+ # assume GNU as default linker
+ set(_CMAKE_SYSTEM_LINKER_TYPE GNU CACHE INTERNAL "System linker type")
+ else()
+ set(_CMAKE_SYSTEM_LINKER_TYPE LLD CACHE INTERNAL "System linker type")
+ endif()
+ endblock()
+endif()
+
+endblock()
diff --git a/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/CYGWIN-C.cmake b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/CYGWIN-C.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..703624df3237fe5f66c9d8511680e6520bc13059
--- /dev/null
+++ b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/CYGWIN-C.cmake
@@ -0,0 +1,5 @@
+# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+# GNU is the default linker
+include(Platform/Linker/CYGWIN-GNU-C)
diff --git a/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/CYGWIN-Fortran.cmake b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/CYGWIN-Fortran.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..18ce085f4537062d88f4ddcb52266a08fa858506
--- /dev/null
+++ b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/CYGWIN-Fortran.cmake
@@ -0,0 +1,5 @@
+# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+# GNU is the default linker
+include(Platform/Linker/CYGWIN-GNU-Fortran)
diff --git a/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/CYGWIN-LLD-ASM.cmake b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/CYGWIN-LLD-ASM.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..1c65875fef2f9ed7c1f83fc839170d12d4bd6e8e
--- /dev/null
+++ b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/CYGWIN-LLD-ASM.cmake
@@ -0,0 +1,6 @@
+# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+include(Platform/Linker/CYGWIN-LLD)
+
+__cygwin_linker_lld(ASM)
diff --git a/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/CYGWIN-LLD-C.cmake b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/CYGWIN-LLD-C.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..a4f3063bb9e4e63658b658fa1673fbbfc9e43cd1
--- /dev/null
+++ b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/CYGWIN-LLD-C.cmake
@@ -0,0 +1,6 @@
+# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+include(Platform/Linker/CYGWIN-LLD)
+
+__cygwin_linker_lld(C)
diff --git a/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/CYGWIN-LLD-CXX.cmake b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/CYGWIN-LLD-CXX.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..5bd50632a604106ca8599d5406ee3f3d780d95f1
--- /dev/null
+++ b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/CYGWIN-LLD-CXX.cmake
@@ -0,0 +1,6 @@
+# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+include(Platform/Linker/CYGWIN-LLD)
+
+__cygwin_linker_lld(CXX)
diff --git a/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/DragonFly-LLD-ASM.cmake b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/DragonFly-LLD-ASM.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..d4774cd2bcea85524e41ffbbcd5cd857765714bf
--- /dev/null
+++ b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/DragonFly-LLD-ASM.cmake
@@ -0,0 +1,4 @@
+# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+include(Platform/Linker/FreeBSD-LLD-ASM)
diff --git a/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/DragonFly-LLD-CXX.cmake b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/DragonFly-LLD-CXX.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..11ab59e34387792c38262eec4029382ac0337c0d
--- /dev/null
+++ b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/DragonFly-LLD-CXX.cmake
@@ -0,0 +1,4 @@
+# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+include(Platform/Linker/FreeBSD-LLD-CXX)
diff --git a/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/FreeBSD-GNU-C.cmake b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/FreeBSD-GNU-C.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..8b6f0fd464e6a330390a6cb2e517685db5c1e299
--- /dev/null
+++ b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/FreeBSD-GNU-C.cmake
@@ -0,0 +1,6 @@
+# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+include(Platform/Linker/FreeBSD-GNU)
+
+__freebsd_linker_gnu(C)
diff --git a/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/FreeBSD-LLD-C.cmake b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/FreeBSD-LLD-C.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..0120daca77d51ab5691eef1e6b697714f4eb0ac9
--- /dev/null
+++ b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/FreeBSD-LLD-C.cmake
@@ -0,0 +1,6 @@
+# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+include(Platform/Linker/FreeBSD-LLD)
+
+__freebsd_linker_lld(C)
diff --git a/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/FreeBSD-LLD.cmake b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/FreeBSD-LLD.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..19f4df59dcb633d00d1ed3db95be0e904c7a60c1
--- /dev/null
+++ b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/FreeBSD-LLD.cmake
@@ -0,0 +1,17 @@
+# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+
+# This module is shared by multiple languages; use include blocker.
+include_guard()
+
+
+include(Platform/Linker/FreeBSD-GNU)
+
+
+macro(__freebsd_linker_lld lang)
+ __freebsd_linker_gnu(${lang})
+
+ set(CMAKE_${lang}_PLATFORM_LINKER_ID LLD)
+ set(CMAKE_${lang}_LINK_LIBRARIES_PROCESSING ORDER=REVERSE DEDUPLICATION=ALL)
+endmacro()
diff --git a/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/GNU-C.cmake b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/GNU-C.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..76679409bbb1e0903478ea6a94a4c62b1b66d333
--- /dev/null
+++ b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/GNU-C.cmake
@@ -0,0 +1,5 @@
+# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+# GNU is the default linker
+include(Platform/Linker/GNU-GNU-C)
diff --git a/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/GNU-GNU-ASM.cmake b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/GNU-GNU-ASM.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..39316b9d9b9672d005fa7dacda30298457dc959a
--- /dev/null
+++ b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/GNU-GNU-ASM.cmake
@@ -0,0 +1,6 @@
+# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+include(Platform/Linker/GNU-GNU)
+
+__gnu_linker_gnu(ASM)
diff --git a/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/GNU-GNU-C.cmake b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/GNU-GNU-C.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..12a9883c81459ac8fd02aa313bacdb5578af17e2
--- /dev/null
+++ b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/GNU-GNU-C.cmake
@@ -0,0 +1,6 @@
+# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+include(Platform/Linker/GNU-GNU)
+
+__gnu_linker_gnu(C)
diff --git a/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-ASM.cmake b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-ASM.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..5812c0832031d0f5d4dd3dd62d390ff815ea6b4f
--- /dev/null
+++ b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-ASM.cmake
@@ -0,0 +1,6 @@
+# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+include(Platform/Linker/Linux-GNU)
+
+__linux_linker_gnu(ASM)
diff --git a/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-C.cmake b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-C.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..5bb322466993019012576692d3ceeb11580077f6
--- /dev/null
+++ b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-C.cmake
@@ -0,0 +1,6 @@
+# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+include(Platform/Linker/Linux-GNU)
+
+__linux_linker_gnu(C)
diff --git a/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/Linux-LLD-ASM.cmake b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/Linux-LLD-ASM.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..7196133c2d912ed922fded3611414255abb4aff6
--- /dev/null
+++ b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/Linux-LLD-ASM.cmake
@@ -0,0 +1,6 @@
+# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+include(Platform/Linker/Linux-LLD)
+
+__linux_linker_lld(ASM)
diff --git a/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/Linux-LLD-CXX.cmake b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/Linux-LLD-CXX.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..8530a3898372177276adc398ea7a302c1d22848f
--- /dev/null
+++ b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/Linux-LLD-CXX.cmake
@@ -0,0 +1,6 @@
+# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+include(Platform/Linker/Linux-LLD)
+
+__linux_linker_lld(CXX)
diff --git a/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/Linux-MOLD-Fortran.cmake b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/Linux-MOLD-Fortran.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..e26bd5db115b7833d33ae4f70482f0fdc50d1b80
--- /dev/null
+++ b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/Linux-MOLD-Fortran.cmake
@@ -0,0 +1,6 @@
+# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+include(Platform/Linker/Linux-MOLD)
+
+__linux_linker_mold(Fortran)
diff --git a/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/MirBSD-Fortran.cmake b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/MirBSD-Fortran.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..9ab9886357111cc19db4c48316e957ba2a880876
--- /dev/null
+++ b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/MirBSD-Fortran.cmake
@@ -0,0 +1,4 @@
+# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+include(Platform/Linker/OpenBSD-Fortran)
diff --git a/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/MirBSD-GNU-CXX.cmake b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/MirBSD-GNU-CXX.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..1edb8e8cf7064a451e5f887a06d8a168f8ae3468
--- /dev/null
+++ b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/MirBSD-GNU-CXX.cmake
@@ -0,0 +1,4 @@
+# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+include(Platform/Linker/OpenBSD-GNU-CXX)
diff --git a/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/NetBSD-GNU-ASM.cmake b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/NetBSD-GNU-ASM.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..533589e52c806af345457b98176a6a79aad92098
--- /dev/null
+++ b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/NetBSD-GNU-ASM.cmake
@@ -0,0 +1,6 @@
+# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+include(Platform/Linker/NetBSD-GNU)
+
+__netbsd_linker_gnu(ASM)
diff --git a/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/NetBSD-GNU-CXX.cmake b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/NetBSD-GNU-CXX.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..6e5da900afeaf49a1cf3e1afdc5106d89c6c1326
--- /dev/null
+++ b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/NetBSD-GNU-CXX.cmake
@@ -0,0 +1,6 @@
+# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+include(Platform/Linker/NetBSD-GNU)
+
+__netbsd_linker_gnu(CXX)
diff --git a/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/OpenBSD-CXX.cmake b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/OpenBSD-CXX.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..4a3d6f8017d8afdcf3aaee46f41d84174717a6eb
--- /dev/null
+++ b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/OpenBSD-CXX.cmake
@@ -0,0 +1,15 @@
+# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+include(Platform/Linker/BSD-Linker-Initialize)
+
+block(SCOPE_FOR POLICIES)
+cmake_policy(SET CMP0054 NEW)
+
+if(_CMAKE_SYSTEM_LINKER_TYPE STREQUAL "GNU")
+ include(Platform/Linker/OpenBSD-GNU-CXX)
+else()
+ include(Platform/Linker/OpenBSD-LLD-CXX)
+endif()
+
+endblock()
diff --git a/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/OpenBSD-GNU-ASM.cmake b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/OpenBSD-GNU-ASM.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..6ad992d8ab93fa22b48ef08b075c2cf75eda8ac0
--- /dev/null
+++ b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/OpenBSD-GNU-ASM.cmake
@@ -0,0 +1,6 @@
+# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+include(Platform/Linker/OpenBSD-GNU)
+
+__openbsd_linker_gnu(ASM)
diff --git a/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/OpenBSD-GNU-CXX.cmake b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/OpenBSD-GNU-CXX.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..98668e5656e1c27d8f23a527d7dbca98842b5c1b
--- /dev/null
+++ b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/OpenBSD-GNU-CXX.cmake
@@ -0,0 +1,6 @@
+# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+include(Platform/Linker/OpenBSD-GNU)
+
+__openbsd_linker_gnu(CXX)
diff --git a/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/OpenBSD-GNU-Fortran.cmake b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/OpenBSD-GNU-Fortran.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..0f2b11f9b77eb0d81281b051874012317dc427d9
--- /dev/null
+++ b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/OpenBSD-GNU-Fortran.cmake
@@ -0,0 +1,6 @@
+# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+include(Platform/Linker/OpenBSD-GNU)
+
+__openbsd_linker_gnu(Fortran)
diff --git a/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/SerenityOS-CXX.cmake b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/SerenityOS-CXX.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..34e9311ac90afc919ae1ec8f5c1216d9e8558c50
--- /dev/null
+++ b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/SerenityOS-CXX.cmake
@@ -0,0 +1,5 @@
+# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+# GNU is the default linker
+include(Platform/Linker/SerenityOS-GNU-CXX)
diff --git a/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/SerenityOS-GNU-CXX.cmake b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/SerenityOS-GNU-CXX.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..ff1f6777d6bea1dbae9566dcf3b341d89d010f5c
--- /dev/null
+++ b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/SerenityOS-GNU-CXX.cmake
@@ -0,0 +1,6 @@
+# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+include(Platform/Linker/SerenityOS-GNU)
+
+__serenityos_linker_gnu(CXX)
diff --git a/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/SerenityOS-LLD.cmake b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/SerenityOS-LLD.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..f3c0389347590b29d24e45e9105ae1aed717cf14
--- /dev/null
+++ b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/SerenityOS-LLD.cmake
@@ -0,0 +1,17 @@
+# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+
+# This module is shared by multiple languages; use include blocker.
+include_guard()
+
+
+include(Platform/Linker/SerenityOS-GNU)
+
+
+macro(__serenityos_linker_lld lang)
+ __serenityos_linker_gnu(${lang})
+
+ set(CMAKE_${lang}_PLATFORM_LINKER_ID LLD)
+ set(CMAKE_${lang}_LINK_LIBRARIES_PROCESSING ORDER=REVERSE DEDUPLICATION=ALL)
+endmacro()
diff --git a/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/SunOS-Solaris-CXX.cmake b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/SunOS-Solaris-CXX.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..f6e26451a3bef5da13aacdf0929950908bdfe96e
--- /dev/null
+++ b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/SunOS-Solaris-CXX.cmake
@@ -0,0 +1,6 @@
+# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+include(Platform/Linker/SunOS-Solaris)
+
+__sunos_linker_solaris(CXX)
diff --git a/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/Windows-Fortran.cmake b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/Windows-Fortran.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..928f6d595eff1c2e69b821a5a5000ba3d70c2fdb
--- /dev/null
+++ b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/Windows-Fortran.cmake
@@ -0,0 +1,15 @@
+# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+block(SCOPE_FOR POLICIES)
+cmake_policy(SET CMP0054 NEW)
+
+if(CMAKE_Fortran_SIMULATE_ID STREQUAL "MSVC")
+ # MSVC is the default linker
+ include(Platform/Linker/Windows-MSVC-Fortran)
+else()
+ # GNU is the default linker
+ include(Platform/Linker/Windows-GNU-Fortran)
+endif()
+
+endblock()
diff --git a/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/Windows-GNU-Fortran.cmake b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/Windows-GNU-Fortran.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..4f0c35fe5419cb470af812ab65f091276bd19879
--- /dev/null
+++ b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/Windows-GNU-Fortran.cmake
@@ -0,0 +1,6 @@
+# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+include(Platform/Linker/Windows-GNU)
+
+__windows_linker_gnu(Fortran)
diff --git a/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/Windows-LLD-ASM.cmake b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/Windows-LLD-ASM.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..fbcc55d1e6eb504b2d6b586e27fecdad231270f3
--- /dev/null
+++ b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/Windows-LLD-ASM.cmake
@@ -0,0 +1,6 @@
+# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+include(Platform/Linker/Windows-LLD)
+
+__windows_linker_lld(ASM)
diff --git a/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/WindowsKernelModeDriver-MSVC-CXX.cmake b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/WindowsKernelModeDriver-MSVC-CXX.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..7accb62cbd720742d745a371095be1cc2556434a
--- /dev/null
+++ b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/WindowsKernelModeDriver-MSVC-CXX.cmake
@@ -0,0 +1,4 @@
+# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+include(Platform/Linker/Windows-MSVC-CXX)
diff --git a/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/WindowsPhone-GNU-ASM.cmake b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/WindowsPhone-GNU-ASM.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..ec93c6b3f2c4d7364485f9e2ffe1f6a2d32216f2
--- /dev/null
+++ b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/WindowsPhone-GNU-ASM.cmake
@@ -0,0 +1,4 @@
+# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+include(Platform/Linker/Windows-GNU-ASM)
diff --git a/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/WindowsPhone-GNU-CXX.cmake b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/WindowsPhone-GNU-CXX.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..2a71ff62ca974c9719ec8c6dad02cf252da1a180
--- /dev/null
+++ b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/WindowsPhone-GNU-CXX.cmake
@@ -0,0 +1,4 @@
+# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+include(Platform/Linker/Windows-GNU-CXX)
diff --git a/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/WindowsStore-LLD-C.cmake b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/WindowsStore-LLD-C.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..8b1415f6f5aaa58472f54fffefac0d3d271112be
--- /dev/null
+++ b/openflamingo/lib/python3.10/site-packages/cmake/data/share/cmake-3.31/Modules/Platform/Linker/WindowsStore-LLD-C.cmake
@@ -0,0 +1,4 @@
+# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+include(Platform/Linker/Windows-LLD-C)