diff options
Diffstat (limited to 'lib/prettytable-3.6.0.dist-info')
| -rw-r--r-- | lib/prettytable-3.6.0.dist-info/INSTALLER | 1 | ||||
| -rw-r--r-- | lib/prettytable-3.6.0.dist-info/METADATA | 702 | ||||
| -rw-r--r-- | lib/prettytable-3.6.0.dist-info/RECORD | 13 | ||||
| -rw-r--r-- | lib/prettytable-3.6.0.dist-info/REQUESTED | 0 | ||||
| -rw-r--r-- | lib/prettytable-3.6.0.dist-info/WHEEL | 4 | ||||
| -rw-r--r-- | lib/prettytable-3.6.0.dist-info/licenses/COPYING | 30 |
6 files changed, 750 insertions, 0 deletions
diff --git a/lib/prettytable-3.6.0.dist-info/INSTALLER b/lib/prettytable-3.6.0.dist-info/INSTALLER new file mode 100644 index 0000000..a1b589e --- /dev/null +++ b/lib/prettytable-3.6.0.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/lib/prettytable-3.6.0.dist-info/METADATA b/lib/prettytable-3.6.0.dist-info/METADATA new file mode 100644 index 0000000..5971cb6 --- /dev/null +++ b/lib/prettytable-3.6.0.dist-info/METADATA @@ -0,0 +1,702 @@ +Metadata-Version: 2.1 +Name: prettytable +Version: 3.6.0 +Summary: A simple Python library for easily displaying tabular data in a visually appealing ASCII table format +Project-URL: Homepage, https://github.com/jazzband/prettytable +Project-URL: Source, https://github.com/jazzband/prettytable +Author-email: Luke Maurits <luke@maurits.id.au> +Maintainer: Jazzband +License: BSD (3 clause) +License-File: COPYING +Classifier: License :: OSI Approved :: BSD License +Classifier: Programming Language :: Python +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3 :: Only +Classifier: Programming Language :: Python :: 3.7 +Classifier: Programming Language :: Python :: 3.8 +Classifier: Programming Language :: Python :: 3.9 +Classifier: Programming Language :: Python :: 3.10 +Classifier: Programming Language :: Python :: 3.11 +Classifier: Programming Language :: Python :: Implementation :: CPython +Classifier: Programming Language :: Python :: Implementation :: PyPy +Classifier: Topic :: Text Processing +Classifier: Typing :: Typed +Requires-Python: >=3.7 +Requires-Dist: importlib-metadata; python_version < '3.8' +Requires-Dist: wcwidth +Provides-Extra: tests +Requires-Dist: pytest; extra == 'tests' +Requires-Dist: pytest-cov; extra == 'tests' +Requires-Dist: pytest-lazy-fixture; extra == 'tests' +Description-Content-Type: text/markdown + +# PrettyTable + +[](https://jazzband.co/) +[](https://pypi.org/project/prettytable/) +[](https://pypi.org/project/prettytable/) +[](https://pypistats.org/packages/prettytable) +[](https://github.com/jazzband/prettytable/actions) +[](https://codecov.io/gh/jazzband/prettytable) +[](https://github.com/psf/black) + +PrettyTable lets you print tables in an attractive ASCII form: + +``` ++-----------+------+------------+-----------------+ +| City name | Area | Population | Annual Rainfall | ++-----------+------+------------+-----------------+ +| Adelaide | 1295 | 1158259 | 600.5 | +| Brisbane | 5905 | 1857594 | 1146.4 | +| Darwin | 112 | 120900 | 1714.7 | +| Hobart | 1357 | 205556 | 619.5 | +| Melbourne | 1566 | 3806092 | 646.9 | +| Perth | 5386 | 1554769 | 869.4 | +| Sydney | 2058 | 4336374 | 1214.8 | ++-----------+------+------------+-----------------+ +``` + +## Installation + +Install via pip: + + python -m pip install -U prettytable + +Install latest development version: + + python -m pip install -U git+https://github.com/jazzband/prettytable + +Or from `requirements.txt`: + + -e git://github.com/jazzband/prettytable.git#egg=prettytable + +## Tutorial on how to use the PrettyTable API + +### Getting your data into (and out of) the table + +Let's suppose you have a shiny new PrettyTable: + +```python +from prettytable import PrettyTable +x = PrettyTable() +``` + +and you want to put some data into it. You have a few options. + +#### Row by row + +You can add data one row at a time. To do this you can set the field names first using +the `field_names` attribute, and then add the rows one at a time using the `add_row` +method: + +```python +x.field_names = ["City name", "Area", "Population", "Annual Rainfall"] +x.add_row(["Adelaide", 1295, 1158259, 600.5]) +x.add_row(["Brisbane", 5905, 1857594, 1146.4]) +x.add_row(["Darwin", 112, 120900, 1714.7]) +x.add_row(["Hobart", 1357, 205556, 619.5]) +x.add_row(["Sydney", 2058, 4336374, 1214.8]) +x.add_row(["Melbourne", 1566, 3806092, 646.9]) +x.add_row(["Perth", 5386, 1554769, 869.4]) +``` + +#### All rows at once + +When you have a list of rows, you can add them in one go with `add_rows`: + +```python +x.field_names = ["City name", "Area", "Population", "Annual Rainfall"] +x.add_rows( + [ + ["Adelaide", 1295, 1158259, 600.5], + ["Brisbane", 5905, 1857594, 1146.4], + ["Darwin", 112, 120900, 1714.7], + ["Hobart", 1357, 205556, 619.5], + ["Sydney", 2058, 4336374, 1214.8], + ["Melbourne", 1566, 3806092, 646.9], + ["Perth", 5386, 1554769, 869.4], + ] +) +``` + +#### Column by column + +You can add data one column at a time as well. To do this you use the `add_column` +method, which takes two arguments - a string which is the name for the field the column +you are adding corresponds to, and a list or tuple which contains the column data: + +```python +x.add_column("City name", +["Adelaide","Brisbane","Darwin","Hobart","Sydney","Melbourne","Perth"]) +x.add_column("Area", [1295, 5905, 112, 1357, 2058, 1566, 5386]) +x.add_column("Population", [1158259, 1857594, 120900, 205556, 4336374, 3806092, +1554769]) +x.add_column("Annual Rainfall",[600.5, 1146.4, 1714.7, 619.5, 1214.8, 646.9, +869.4]) +``` + +#### Mixing and matching + +If you really want to, you can even mix and match `add_row` and `add_column` and build +some of your table in one way and some of it in the other. Tables built this way are +kind of confusing for other people to read, though, so don't do this unless you have a +good reason. + +#### Importing data from a CSV file + +If you have your table data in a comma-separated values file (.csv), you can read this +data into a PrettyTable like this: + +```python +from prettytable import from_csv +with open("myfile.csv") as fp: + mytable = from_csv(fp) +``` + +#### Importing data from a database cursor + +If you have your table data in a database which you can access using a library which +confirms to the Python DB-API (e.g. an SQLite database accessible using the `sqlite` +module), then you can build a PrettyTable using a cursor object, like this: + +```python +import sqlite3 +from prettytable import from_db_cursor + +connection = sqlite3.connect("mydb.db") +cursor = connection.cursor() +cursor.execute("SELECT field1, field2, field3 FROM my_table") +mytable = from_db_cursor(cursor) +``` + +#### Getting data out + +There are three ways to get data out of a PrettyTable, in increasing order of +completeness: + +- The `del_row` method takes an integer index of a single row to delete. +- The `del_column` method takes a field name of a single column to delete. +- The `clear_rows` method takes no arguments and deletes all the rows in the table - but + keeps the field names as they were so you that you can repopulate it with the same + kind of data. +- The `clear` method takes no arguments and deletes all rows and all field names. It's + not quite the same as creating a fresh table instance, though - style related + settings, discussed later, are maintained. + +### Displaying your table in ASCII form + +PrettyTable's main goal is to let you print tables in an attractive ASCII form, like +this: + +``` ++-----------+------+------------+-----------------+ +| City name | Area | Population | Annual Rainfall | ++-----------+------+------------+-----------------+ +| Adelaide | 1295 | 1158259 | 600.5 | +| Brisbane | 5905 | 1857594 | 1146.4 | +| Darwin | 112 | 120900 | 1714.7 | +| Hobart | 1357 | 205556 | 619.5 | +| Melbourne | 1566 | 3806092 | 646.9 | +| Perth | 5386 | 1554769 | 869.4 | +| Sydney | 2058 | 4336374 | 1214.8 | ++-----------+------+------------+-----------------+ +``` + +You can print tables like this to `stdout` or get string representations of them. + +#### Printing + +To print a table in ASCII form, you can just do this: + +```python +print(x) +``` + +The old `x.printt()` method from versions 0.5 and earlier has been removed. + +To pass options changing the look of the table, use the `get_string()` method documented +below: + +```python +print(x.get_string()) +``` + +#### Stringing + +If you don't want to actually print your table in ASCII form but just get a string +containing what _would_ be printed if you use `print(x)`, you can use the `get_string` +method: + +```python +mystring = x.get_string() +``` + +This string is guaranteed to look exactly the same as what would be printed by doing +`print(x)`. You can now do all the usual things you can do with a string, like write +your table to a file or insert it into a GUI. + +#### Controlling which data gets displayed + +If you like, you can restrict the output of `print(x)` or `x.get_string` to only the +fields or rows you like. + +The `fields` argument to these methods takes a list of field names to be printed: + +```python +print(x.get_string(fields=["City name", "Population"])) +``` + +gives: + +``` ++-----------+------------+ +| City name | Population | ++-----------+------------+ +| Adelaide | 1158259 | +| Brisbane | 1857594 | +| Darwin | 120900 | +| Hobart | 205556 | +| Melbourne | 3806092 | +| Perth | 1554769 | +| Sydney | 4336374 | ++-----------+------------+ +``` + +The `start` and `end` arguments take the index of the first and last row to print +respectively. Note that the indexing works like Python list slicing - to print the 2nd, +3rd and 4th rows of the table, set `start` to 1 (the first row is row 0, so the second +is row 1) and set `end` to 4 (the index of the 4th row, plus 1): + +```python +print(x.get_string(start=1, end=4)) +``` + +prints: + +``` ++-----------+------+------------+-----------------+ +| City name | Area | Population | Annual Rainfall | ++-----------+------+------------+-----------------+ +| Brisbane | 5905 | 1857594 | 1146.4 | +| Darwin | 112 | 120900 | 1714.7 | +| Hobart | 1357 | 205556 | 619.5 | ++-----------+------+------------+-----------------+ +``` + +#### Changing the alignment of columns + +By default, all columns in a table are centre aligned. + +##### All columns at once + +You can change the alignment of all the columns in a table at once by assigning a one +character string to the `align` attribute. The allowed strings are `"l"`, `"r"` and +`"c"` for left, right and centre alignment, respectively: + +```python +x.align = "r" +print(x) +``` + +gives: + +``` ++-----------+------+------------+-----------------+ +| City name | Area | Population | Annual Rainfall | ++-----------+------+------------+-----------------+ +| Adelaide | 1295 | 1158259 | 600.5 | +| Brisbane | 5905 | 1857594 | 1146.4 | +| Darwin | 112 | 120900 | 1714.7 | +| Hobart | 1357 | 205556 | 619.5 | +| Melbourne | 1566 | 3806092 | 646.9 | +| Perth | 5386 | 1554769 | 869.4 | +| Sydney | 2058 | 4336374 | 1214.8 | ++-----------+------+------------+-----------------+ +``` + +##### One column at a time + +You can also change the alignment of individual columns based on the corresponding field +name by treating the `align` attribute as if it were a dictionary. + +```python +x.align["City name"] = "l" +x.align["Area"] = "c" +x.align["Population"] = "r" +x.align["Annual Rainfall"] = "c" +print(x) +``` + +gives: + +``` ++-----------+------+------------+-----------------+ +| City name | Area | Population | Annual Rainfall | ++-----------+------+------------+-----------------+ +| Adelaide | 1295 | 1158259 | 600.5 | +| Brisbane | 5905 | 1857594 | 1146.4 | +| Darwin | 112 | 120900 | 1714.7 | +| Hobart | 1357 | 205556 | 619.5 | +| Melbourne | 1566 | 3806092 | 646.9 | +| Perth | 5386 | 1554769 | 869.4 | +| Sydney | 2058 | 4336374 | 1214.8 | ++-----------+------+------------+-----------------+ +``` + +##### Sorting your table by a field + +You can make sure that your ASCII tables are produced with the data sorted by one +particular field by giving `get_string` a `sortby` keyword argument, which must be a +string containing the name of one field. + +For example, to print the example table we built earlier of Australian capital city +data, so that the most populated city comes last, we can do this: + +```python +print(x.get_string(sortby="Population")) +``` + +to get: + +``` ++-----------+------+------------+-----------------+ +| City name | Area | Population | Annual Rainfall | ++-----------+------+------------+-----------------+ +| Darwin | 112 | 120900 | 1714.7 | +| Hobart | 1357 | 205556 | 619.5 | +| Adelaide | 1295 | 1158259 | 600.5 | +| Perth | 5386 | 1554769 | 869.4 | +| Brisbane | 5905 | 1857594 | 1146.4 | +| Melbourne | 1566 | 3806092 | 646.9 | +| Sydney | 2058 | 4336374 | 1214.8 | ++-----------+------+------------+-----------------+ +``` + +If we want the most populated city to come _first_, we can also give a +`reversesort=True` argument. + +If you _always_ want your tables to be sorted in a certain way, you can make the setting +long-term like this: + +```python +x.sortby = "Population" +print(x) +print(x) +print(x) +``` + +All three tables printed by this code will be sorted by population (you could do +`x.reversesort = True` as well, if you wanted). The behaviour will persist until you +turn it off: + +```python +x.sortby = None +``` + +If you want to specify a custom sorting function, you can use the `sort_key` keyword +argument. Pass this a function which accepts two lists of values and returns a negative +or positive value depending on whether the first list should appear before or after the +second one. If your table has n columns, each list will have n+1 elements. Each list +corresponds to one row of the table. The first element will be whatever data is in the +relevant row, in the column specified by the `sort_by` argument. The remaining n +elements are the data in each of the table's columns, in order, including a repeated +instance of the data in the `sort_by` column. + +### Changing the appearance of your table - the easy way + +By default, PrettyTable produces ASCII tables that look like the ones used in SQL +database shells. But it can print them in a variety of other formats as well. If the +format you want to use is common, PrettyTable makes this easy for you to do using the +`set_style` method. If you want to produce an uncommon table, you'll have to do things +slightly harder (see later). + +#### Setting a table style + +You can set the style for your table using the `set_style` method before any calls to +`print` or `get_string`. Here's how to print a table in a format which works nicely with +Microsoft Word's "Convert to table" feature: + +```python +from prettytable import MSWORD_FRIENDLY +x.set_style(MSWORD_FRIENDLY) +print(x) +``` + +In addition to `MSWORD_FRIENDLY` you can use these in-built styles for your tables: + +- `DEFAULT` - The default look, used to undo any style changes you may have made +- `PLAIN_COLUMNS` - A borderless style that works well with command line programs for + columnar data +- `MARKDOWN` - A style that follows Markdown syntax +- `ORGMODE` - A table style that fits [Org mode](https://orgmode.org/) syntax +- `SINGLE_BORDER` and `DOUBLE_BORDER` - Styles that use continuous single/double border + lines with Box drawing characters for a fancier display on terminal + +Other styles are likely to appear in future releases. + +### Changing the appearance of your table - the hard way + +If you want to display your table in a style other than one of the in-built styles +listed above, you'll have to set things up the hard way. + +Don't worry, it's not really that hard! + +#### Style options + +PrettyTable has a number of style options which control various aspects of how tables +are displayed. You have the freedom to set each of these options individually to +whatever you prefer. The `set_style` method just does this automatically for you. + +The options are these: + +- `border` - A boolean option (must be `True` or `False`). Controls whether a border is + drawn inside and around the table. +- `preserve_internal_border` - A boolean option (must be `True` or `False`). Controls + whether borders are still drawn within the table even when `border=False`. +- `header` - A boolean option (must be `True` or `False`). Controls whether the first + row of the table is a header showing the names of all the fields. +- `hrules` - Controls printing of horizontal rules after rows. Allowed values: `FRAME`, + `HEADER`, `ALL`, `NONE` - note that these are variables defined inside the + `prettytable` module so make sure you import them or use `prettytable.FRAME` etc. +- `vrules` - Controls printing of vertical rules between columns. Allowed values: + `FRAME`, `ALL`, `NONE`. +- `int_format` - A string which controls the way integer data is printed. This works + like: `print("%<int_format>d" % data)` +- `float_format` - A string which controls the way floating point data is printed. This + works like: `print("%<float_format>f" % data)` +- `custom_format` - A Dictionary of field and callable. This allows you to set any + format you want `pf.custom_format["my_col_int"] = ()lambda f, v: f"{v:,}"`. The type + of the callable if `callable[[str, Any], str]` +- `padding_width` - Number of spaces on either side of column data (only used if left + and right paddings are `None`). +- `left_padding_width` - Number of spaces on left-hand side of column data. +- `right_padding_width` - Number of spaces on right-hand side of column data. +- `vertical_char` - Single character string used to draw vertical lines. Default is `|`. +- `horizontal_char` - Single character string used to draw horizontal lines. Default is + `-`. +- `_horizontal_align_char` - single character string used to indicate column alignment + in horizontal lines. Default is `:` for Markdown, otherwise `None`. +- `junction_char` - Single character string used to draw line junctions. Default is `+`. +- `top_junction_char` - single character string used to draw top line junctions. Default + is `junction_char`. +- `bottom_junction_char` - single character string used to draw bottom line junctions. + Default is `junction_char`. +- `right_junction_char` - single character string used to draw right line junctions. + Default is `junction_char`. +- `left_junction_char` - single character string used to draw left line junctions. + Default is `junction_char`. +- `top_right_junction_char` - single character string used to draw top-right line + junctions. Default is `junction_char`. +- `top_left_junction_char` - single character string used to draw top-left line + junctions. Default is `junction_char`. +- `bottom_right_junction_char` - single character string used to draw bottom-right line + junctions. Default is `junction_char` +- `bottom_left_junction_char` - single character string used to draw bottom-left line + junctions. Default is `junction_char`. + +You can set the style options to your own settings in two ways: + +#### Setting style options for the long term + +If you want to print your table with a different style several times, you can set your +option for the long term just by changing the appropriate attributes. If you never want +your tables to have borders you can do this: + +```python +x.border = False +print(x) +print(x) +print(x) +``` + +Neither of the 3 tables printed by this will have borders, even if you do things like +add extra rows in between them. The lack of borders will last until you do: + +```python +x.border = True +``` + +to turn them on again. This sort of long-term setting is exactly how `set_style` works. +`set_style` just sets a bunch of attributes to pre-set values for you. + +Note that if you know what style options you want at the moment you are creating your +table, you can specify them using keyword arguments to the constructor. For example, the +following two code blocks are equivalent: + +```python +x = PrettyTable() +x.border = False +x.header = False +x.padding_width = 5 + +x = PrettyTable(border=False, header=False, padding_width=5) +``` + +#### Changing style options just once + +If you don't want to make long-term style changes by changing an attribute like in the +previous section, you can make changes that last for just one `get_string` by giving +those methods keyword arguments. To print two "normal" tables with one borderless table +between them, you could do this: + +```python +print(x) +print(x.get_string(border=False)) +print(x) +``` + +### Changing the appearance of your table - with _colors_! + +PrettyTable has the functionality of printing your table with ANSI color codes. This +includes support for most Windows versions through +[Colorama](https://pypi.org/project/colorama/). To get started, import the `ColorTable` +class instead of `PrettyTable`. + +```diff +-from prettytable import PrettyTable ++from prettytable.colortable import ColorTable +``` + +The `ColorTable` class can be used the same as `PrettyTable`, but it adds an extra +property. You can now specify a custom _theme_ that will format your table with colors. + +```python +from prettytable.colortable import ColorTable, Themes + +x = ColorTable(theme=Themes.OCEAN) + +print(x) +``` + +#### Creating a custom theme + +The `Theme` class allows you to customize both the characters and colors used in your +table. + +| Argument | Description | +| ---------------------------------------------------------- | --------------------------------------------------------- | +| `default_color` | The color to use as default | +| `vertical_char`, `horizontal_char`, and `junction_char` | The characters used for creating the outline of the table | +| `vertical_color`, `horizontal_color`, and `junction_color` | The colors used to style each character. | + +> **Note:** Colors are formatted with the `Theme.format_code(s: str)` function. It +> accepts a string. If the string starts with an escape code (like `\x1b`) then it will +> return the given string. If the string is just whitespace, it will return `""`. If the +> string is a number (like `"34"`), it will automatically format it into an escape code. +> I recommend you look into the source code for more information. + +### Displaying your table in JSON + +PrettyTable will also print your tables in JSON, as a list of fields and an array of +rows. Just like in ASCII form, you can actually get a string representation - just use +`get_json_string()`. + +### Displaying your table in HTML form + +PrettyTable will also print your tables in HTML form, as `<table>`s. Just like in ASCII +form, you can actually get a string representation - just use `get_html_string()`. HTML +printing supports the `fields`, `start`, `end`, `sortby` and `reversesort` arguments in +exactly the same way as ASCII printing. + +#### Styling HTML tables + +By default, PrettyTable outputs HTML for "vanilla" tables. The HTML code is quite +simple. It looks like this: + +```html +<table> + <thead> + <tr> + <th>City name</th> + <th>Area</th> + <th>Population</th> + <th>Annual Rainfall</th> + </tr> + </thead> + <tbody> + <tr> + <td>Adelaide</td> + <td>1295</td> + <td>1158259</td> + <td>600.5</td> + </tr> + <tr> + <td>Brisbane</td> + <td>5905</td> + <td>1857594</td> + <td>1146.4</td> + ... + </tr> + </tbody> +</table> +``` + +If you like, you can ask PrettyTable to do its best to mimic the style options that your +table has set using inline CSS. This is done by giving a `format=True` keyword argument +to `get_html_string` method. Note that if you _always_ want to print formatted HTML you +can do: + +```python +x.format = True +``` + +and the setting will persist until you turn it off. + +Just like with ASCII tables, if you want to change the table's style for just one +`get_html_string` you can pass those methods' keyword arguments - exactly like `print` +and `get_string`. + +#### Setting HTML attributes + +You can provide a dictionary of HTML attribute name/value pairs to the `get_html_string` +method using the `attributes` keyword argument. This lets you specify common HTML +attributes like `id` and `class` that can be used for linking to your tables or +customising their appearance using CSS. For example: + +```python +print(x.get_html_string(attributes={"id":"my_table", "class":"red_table"})) +``` + +will print: + +```html +<table id="my_table" class="red_table"> + <thead> + <tr> + <th>City name</th> + <th>Area</th> + <th>Population</th> + <th>Annual Rainfall</th> + </tr> + </thead> + <tbody> + <tr> + ... ... ... + </tr> + </tbody> +</table> +``` + +### Miscellaneous things + +#### Copying a table + +You can call the `copy` method on a PrettyTable object without arguments to return an +identical independent copy of the table. + +If you want a copy of a PrettyTable object with just a subset of the rows, you can use +list slicing notation: + +```python +new_table = old_table[0:5] +``` + +## Contributing + +After editing files, use the [Black](https://github.com/psf/black) linter to auto-format +changed lines. + +```sh +python -m pip install black +black prettytable*.py +``` diff --git a/lib/prettytable-3.6.0.dist-info/RECORD b/lib/prettytable-3.6.0.dist-info/RECORD new file mode 100644 index 0000000..8702d1e --- /dev/null +++ b/lib/prettytable-3.6.0.dist-info/RECORD @@ -0,0 +1,13 @@ +prettytable-3.6.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+prettytable-3.6.0.dist-info/METADATA,sha256=fU3BZXeOl90w8gPN-jvtUpMXwbMH54OnidclKA7hLbM,25058
+prettytable-3.6.0.dist-info/RECORD,,
+prettytable-3.6.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+prettytable-3.6.0.dist-info/WHEEL,sha256=hKi7AIIx6qfnsRbr087vpeJnrVUuDokDHZacPPMW7-Y,87
+prettytable-3.6.0.dist-info/licenses/COPYING,sha256=DIrcwgTIr2zf33iH39H5nCmQH2wdUFp4u6lu-k-yywU,1612
+prettytable/__init__.py,sha256=f4jlohGU7tzRTutkAieeDrxnxt02322kr7ayXZH7ixs,920
+prettytable/__pycache__/__init__.cpython-39.pyc,,
+prettytable/__pycache__/colortable.cpython-39.pyc,,
+prettytable/__pycache__/prettytable.cpython-39.pyc,,
+prettytable/colortable.py,sha256=DFN-wtny2c-jdBtLTgwTlmnPWLrEAp41QqrrFQ0Ve8E,2445
+prettytable/prettytable.py,sha256=XMVnRju2YGrKqkkVSm9ImOt42uvaXXqOlqrspG_mwM4,88442
+prettytable/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
diff --git a/lib/prettytable-3.6.0.dist-info/REQUESTED b/lib/prettytable-3.6.0.dist-info/REQUESTED new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/lib/prettytable-3.6.0.dist-info/REQUESTED diff --git a/lib/prettytable-3.6.0.dist-info/WHEEL b/lib/prettytable-3.6.0.dist-info/WHEEL new file mode 100644 index 0000000..8d5c0ce --- /dev/null +++ b/lib/prettytable-3.6.0.dist-info/WHEEL @@ -0,0 +1,4 @@ +Wheel-Version: 1.0 +Generator: hatchling 1.12.2 +Root-Is-Purelib: true +Tag: py3-none-any diff --git a/lib/prettytable-3.6.0.dist-info/licenses/COPYING b/lib/prettytable-3.6.0.dist-info/licenses/COPYING new file mode 100644 index 0000000..cb6fed3 --- /dev/null +++ b/lib/prettytable-3.6.0.dist-info/licenses/COPYING @@ -0,0 +1,30 @@ +# Copyright (c) 2009-2014 Luke Maurits <luke@maurits.id.au> +# All rights reserved. +# With contributions from: +# * Chris Clark +# * Klein Stephane +# * John Filleau +# * Vladimir Vrzić +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# * Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# * The name of the author may not be used to endorse or promote products +# derived from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE +# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +# POSSIBILITY OF SUCH DAMAGE. |