Saravanan666/pypi-org huggingface dataset:
Package: tablexplore
IntroductionTablexplore is an application for data analysis and plotting built in Python
using the PySide2/Qt toolkit. It uses the pandas DataFrame class to store the
table data. Pandas is an open source Python library providing high-performance
data structures and data analysis tools.This application is intended primarily for educational/scientific use and allows
quick visualization of data with convenient plotting. The primary goal is to
let users explore their tables interactively without any prior programming
knowledge and make interesting plots as they do this. One advantage is the
ability to load and work with relatively large tables as compared to spreadsheets.
The focus is on data manipulation rather than data entry. Though basic cell
editing and row/column changes are supported.Documentationhttps://readthedocs.org/projects/tablexplore/Installationpip install -e git+https://github.com/dmnfarrell/tablexplore.git#egg=tablexploreWindowsA Windows standalone binary can be downloaded athttps://github.com/dmnfarrell/tablexplore/releases/latest.Use the widget in PythonCode:python
from PySide2 import QtCore
from PySide2.QtWidgets import *
from PySide2.QtGui import *
import pandas as pd
from tablexplore import data, core, plotting, interpreter

class TestApp(QMainWindow):
    def __init__(self, project_file=None, csv_file=None):

        QMainWindow.__init__(self)
        self.setAttribute(QtCore.Qt.WA_DeleteOnClose)
        self.setWindowTitle("Example")
        self.setGeometry(QtCore.QRect(200, 200, 800, 600))
        self.main = QWidget()
        self.setCentralWidget(self.main)
        layout = QVBoxLayout(self.main)
        df = data.getSampleData()
        t = core.DataFrameWidget(self.main,dataframe=df)
        layout.addWidget(t)
        #show a Python interpreter
        t.showInterpreter()
        return

if __name__ == '__main__':
    import sys
    app = QApplication(sys.argv)
    aw = TestApp()
    aw.show()
    app.exec_()Linkshttps://github.com/dmnfarrell/tablexplore/https://dmnfarrell.github.io/tablexplore/https://www.youtube.com/watch?v=nscmtsG5SKQ
Package: tablib
Tablib: format-agnostic tabular dataset library_____         ______  ___________ ______
__  /_______ ____  /_ ___  /___(_)___  /_
_  __/_  __ `/__  __ \__  / __  / __  __ \
/ /_  / /_/ / _  /_/ /_  /  _  /  _  /_/ /
\__/  \__,_/  /_.___/ /_/   /_/   /_.___/Tablib is a format-agnostic tabular dataset library, written in Python.Output formats supported:Excel (Sets + Books)JSON (Sets + Books)YAML (Sets + Books)Pandas DataFrames (Sets)HTML (Sets)Jira (Sets)TSV (Sets)ODS (Sets)CSV (Sets)DBF (Sets)Note that tablibpurposefullyexcludes XML support. It always will. (Note: This is a
joke. Pull requests are welcome.)Tablib documentation is graciously hosted onhttps://tablib.readthedocs.ioIt is also available in thedocsdirectory of the source distribution.Make sure to check outTablib on PyPI!ContributePlease see thecontributing guide.
Package: tablify
tablifyConvert data structure into html tabletablify is package used to convert python data  structures to html or clean tabular design. Thanks for checking it out.RequirementsPython 3.xExampleimport sys
from tablify.parser.parse import pyobj

dict_example = {'Total_Matches': ['200', '127', '102'],\
    'Player Name': ['M.S Dhoni', 'Virendra Sehwag', 'Shikhar Dhawan'],\
    'Sixes': ['280.', '210', '126']}

pyobj = pyobj()
htmltext = pyobj.dictToHTMLTable(dict_example)
print(htmltext)
Package: tablify-csv
tablify-csvCLI tool to convert data in a CSV file into an HTML table with basic formatting.The tool lets you:Specify column headings to be displayed on the final HTML tableAssign class names to any column (assign totdtags that fall under a given column)Save the output (prettified) HTML into a file and/or copy to clipboardRequirementsPython>= 3.8lxml>= 4.5.2prompt-toolkit>= 3.0.6pyperclip>= 1.8.0typer>= 0.3.2Please seerequirements.txtanddev-requirements.txtfor full list of dependencies.InstallationIt's recommended to create and activate a virtual environment before installing.For the latest stable release, install fromPyPI packagewithpip:$pipinstalltablify-csvTo install the latest development version, run the following:$pipinstallgit+https://github.com/ralphqq/tablify-csvUsageOnce installed,tablify-csvcan now be used without any additional configuration required. If applicable, make sure that the virtual environment where you pip installedtablify-csvis activated.Valid CSV FileThe current version oftablify-csvassumes the CSV file to be parsed has:A header row with the column names in the first line of the fileNo empty lines between the header row and the first data row (i.e., the first data row immediately follows the header row)Usage ExamplesTo convert a CSV file:$tablify-csvCSV_FILENAMEThis will save the HTML table in a file with the same name as the CSV file except the extension will be.html.To specify a filename for the output file:$tablify-csvCSV_FILENAME--output-fileOUTPUT_FILENAMETo copy the resulting HTML table to the clipboard (without saving to an output file):$tablify-csvCSV_FILENAME--clipTo copy the resulting HTML table to the clipboard and save it to an output file:$tablify-csvCSV_FILENAME--output-fileOUTPUT_FILENAME--clipDevelopment SetupClone this repo athttps://github.com/ralphqq/tablify-csvCreate and activate a virtual environmentInstall the development dependencies:$pipinstall-rdev-requirements.txtRun the test suite:$pytestNote:To ensure coding style consistency, this project uses pre-commit hooks. You may also want to initialize pre-commits into your local development clone (this is strongly recommended if you want to contribute, seeContributingsection).$pre-commitinstallContributingFork this repo athttps://github.com/ralphqq/tablify-csvClone your fork into your local machineFollow steps in Development Setup but skip step 1Initialize pre-commit hooks$pre-commitinstallCreate your feature branch:$gitcheckout-bfeature/some-new-thingCommit your changes:$gitcommit-m"Develop new thing"Push to the branch:$gitpushoriginfeature/some-new-thingCreate a pull requestLicensetablify-csvis available under theMIT License.
Package: tablign
Aligns columns in your ASCII tables.Install withpipinstalltabligntablignin.txtout.txtyou can convert your input file| A | 1.34|-214.1|
|CCCC | 55.534|   1131.1|into| A    |  1.34  | -214.1 |
| CCCC | 55.534 | 1131.1 |Column widths are unified across the table, decimal dots are aligned, and tablign tries
to be smart about column separators. Works for CSV, LaTeX, Markdown etc. By default,tablignreads from stdin and writes to stdout, so you can use pipes with tablign, too:head -n in.txt | tablignUsage from vimSimply mark the table (shift-V), and type:'<,'>:!tablignAlternativesGNU'scolumncommandis a mighty alternative:column-tSeeherefor more alternatives.
Package: tablip
tabliptablip can deal & generate multi-type of file.tablip可以处理和生成多种类型文件。功能列表Excel (Sets + Books) +auto column width!!!（智能调整列宽！！！）JSON (Sets + Books)YAML (Sets + Books)Pandas DataFrames (Sets)HTML (Sets)Jira (Sets)TSV (Sets)ODS (Sets)CSV (Sets)DBF (Sets)特点超简单使用超强大功能导出excel文件，也就是xls格式，自动优化列宽!!!!安装pip install tablip使用importtablip# 初始化表格 表名及表头data=tablip.Dataset()data.headers=['name','age']data.title='test'# 写入数据content=[['lily','18'],['lucy','20']]forrowincontent:data.append(row)# 导出excelwithopen('test.xls','wb')asf:f.write(data.export('xls'))关于author:bn.zheng
contact with email:zhengbingxian666@163.com
Package: tablipy
TablipyTablipy is a Python library for working with tabular data. It provides a simple and intuitive way to create, manipulate, and print tabular data structures.InstallationYou can install Tablipy using pip:pipinstalltablipyUsageHere's a basic example of how to use Tablipy to create a table, add data, and print it:fromtablipy.coreimportTablipy# Create an instance of Tablipytable=Tablipy(col_headers=['Name','Age','Location'])# Add data to the tabletable.add_row(['John','30','New York'])table.add_row(['Jane','25','Los Angeles'])# Print the tabletable.print()For more detailed information and examples, check thedocumentationor explore the examples in thetestsdirectory.FeaturesCreate tables with specified column headers.Add data to the table as rows.Get specific columns, rows, or cells from the table.Set values of columns, rows, or cells.Print tables in a neat tabular format.ContributingContributions are welcome! Feel free to submit issues and pull requests on theGitHub repository.LicenseThis project is licensed under the MIT License - see theLICENSEfile for details.
Package: tablo-fyi
The Tablo File Formattablois a plain text interchange format for tabular data. It is more
expressive than CSV while remaining easy for people to read and write.It adds explicit headers, datatypes, and cell formatting to address
shortcomings of delimiter-separated formats like CSV or TSV.tablosolves
delimiter collision issues by having well-defined quoting and escaping rules
that are familiar to users of formats like JSON or common programming languages
like Python or JavaScript.What's Wrong with CSV?the Microsoft version of CSV is a textbook example of hownotto design a
textual file format—Eric S. Raymond,The Art of Unix ProgrammingStated simply, there is no single CSV standard. It exists as a myriad of
informal variants whose implementation varies from vendor to vendor. Character
encodings and escape sequences vary from one application to the next, and the
ambiguities in various edge cases means that the output of one application may
not be readable by another.tablois designed to solve a number of ambiguities and shortcomings in CSV.One of the first obvious differences is that header rows are optional, but
well-defined. In other words, a document may or may not contain a header, but
determining whether the document includes a header is always unambiguous.A crucial aspect of thetabloformat is that it doesn't make assumptions
about the type of data in each cell. If a value is surrounded by quotes, it isalwaysa string. If a value is a number without quotes, it isalwaysa
number. If a value is an ISO-8601 formatted date preceded by a hash mark, it
isalwaysa datetime.InstallationInstall withpip:python -m pip install tablo-fyiUsageParsing is accomplished with theparsefunction.import tablo

data = tablo.parse('"name", "age"\n=0.1\n"Tom", 24\n"Jerry", 27\n')

name = data['A0']  # Retrieves the value in column A, row 0 => 'Tom'
age = data['B1']   # Retrieves the value in column B, row 1 => 27More InformationMore information can be found inthetablospecification, and a
set ofexample filescan be found in theproject repository.
Package: tabloo
TablooMinimalistic dashboard app for visualizing tabular data -- WIP.InstallationpipinstalltablooUsageEmbedded modeRun tabloo from within Python on an instance of a Pandas DataFrame:# given a pandas dataframe `df`importtablootabloo.show(df)CLI modeRun tabloo from the command line on a CSV file:tabloo_climy.csvBring our own backendTabloo decouples the visualization frontend from the data backend.
You could drive the frontend by arbitrary data backends, i.e.,
instead of running from DataFrames, you may implement a backend accessing other data sources like databases.
This implies that backends can be implemented in any other language.
Currently the backend API is still under development and may change.
For now, theflask backendcan serve as a reference implementation.Usage notesCurrently the "Filter" input element acceptsDataFrame.query()expressions.
It handles expressions like:# filter by specific values
SomeColumn == "some value"

# standard inequality operations are supported
SomeNumberColumn > 0

# it's possible to use advanced string conditions via `.str`
SomeStringColumn.str.len() < 10

# Combining conditions is possible with & | and or
ColumnA == 42 & SomeStringColumn.str.contains("substring")Refer to documentation ofquery()for more examples.Note: Eventually the syntax may change into a Pandas agnostic syntax to simplify implementations in non-Pandas backends.
Package: tabmaker
This program installs a script which generates song lyrics with chords above the correct words given a file in the correct format.Syntax:` tabmaker in_file[ out_file] `infile must be a plain text file with square brackets around the chords:` [c]Twinkle, twinkle [f]little [c]star, [f]How I [c]wonder [g]what you [c]are. `outfile is optional (defaults to the standard output) and prints the chords above the lyrics like so:` c                f      c Twinkle, twinkle little star, f     c      g        c How I wonder what you are. `
Package: tabnet-keras
TF2 Keras implementation of TabNetTabNet is a novel deep learning architecture fortabular data. TabNet performs reasoning in multiple decision steps and using sequential attention to select which features to use at which decision step. You can find more information about it in the originalresearch paper.Installation$pipinstalltabnet_kerasUsagefromtabnet_kerasimportTabNetRegressor,TabNetClassifiertabnet_params={"decision_dim":16,"attention_dim":16,"n_steps":3,"n_shared_glus":2,"n_dependent_glus":2,"relaxation_factor":1.3,"epsilon":1e-15,"momentum":0.98,"mask_type":"sparsemax",# can be 'sparsemax' or 'softmax'"lambda_sparse":1e-3,"virtual_batch_splits":8#number of splits for ghost batch normalization, ideally should evenly divide the batch_size}### Regressionmodel=TabNetRegressor(n_regressors=1,**tabnet_params)model.compile(loss='mean_squared_error',optimizer=tf.keras.optimizers.Adam(0.01),metrics=[tf.keras.metrics.RootMeanSquaredError()])model.fit(X,y,epochs=100,batch_size=1024)### Classificationmodel=TabNetClassifier(n_classes=10,out_activation=None,**tabnet_params)model.compile(loss='categorical_crossentropy',optimizer=tf.keras.optimizers.Adam(0.01))model.fit(X,y,epochs=100,batch_size=1024)AcknowledgmentMost of the code is taken with minor changes fromthis repository.
Package: tabnetviz
Tabnetviz - table-based network visualizerTabnetvizgenerates network visualizations from node and edge
properties provided in tables. The node and edge properties can be
mapped to visual attributes in several ways.Tabnetvizwas
inspired by the popular Cytoscape program which can also generate
similar mappings. However, Cytoscape is a resource-intensive,
interactive Java program with a complex graphical interface, and
loading networks from tables and defining mappings can be cumbersome
in it.Tabnetviz, on the other hand, is a non-interactive,
lightweight command-line tool guided by a single text-based
configuration file, thus ideal for use in scripts, Makefiles, and
reproducible workflows. Once a configuration file has been developed,
it only takes a single command to generate the network visualization
(typically an SVG file), and to quickly regenerate it whenever the
input data changes.Tabnetvizgenerates static network visualizations, and is
applicable in a wide range of fields such as bioinformatics (for gene
regulatory networks, protein interaction networks, etc.),
neuroscience, and studies of social networks, computer networks,
economic networks, etc.An example visualization generated by Tabnetviz:TheTabnetvizconfiguration file is a YAML format text file, which
is easily written manually, and easy to understand. It specifies the
node table and the edge table for the network (both can be CSV, TSV,
or Excel files), and defines how to map the node and edge properties
(provided in node and edge table columns) to visual attributes such as
colors, node sizes, shapes, line widths, etc. Node groups and edge
groups can also be defined (using Boolean expressions on the node/edge
properties), and the mappings can be applied to them.Tabnetvizis a Python program, and usesGraphvizas its network visualization
back-end, and can use anynode, edge, and graph attribute known to
Graphviz. It also uses
Graphviz for generating network layouts. Relying on the power of
Graphviz,Tabnetvizcan generate high-quality images suitable as
illustrations for science publications.As a bonus,Tabnetvizcan optionally calculate numerous graph
theoretical quantities such as degrees, centralities, clustering
coefficients, etc. These are added to the node/edge table, and can
then be mapped to visual attributes, e.g. node sizes or colors.See theTabnetviz home pagefor documentation.
Package: tab-osx
tab - Opens a new OS X Terminal window in the current directory and runsan optional command in it.If the current directory contains a file `.tabfile` this one is executedinstead (see below).Download the latest version from: https://github.com/bartTC/tabInstallation:-------------tab requires Python 3. Currently Mac OS X does not ship with Python 3, but youcan easily install it with the original package from:https://www.python.org/downloads/mac-osx/or if you're already using Homebrew, install it with it:brew install python3Install tab itseelf with pip: `pip3 install tab-osx`, or if you prefer themanual way copy the `tab` file into your `/usr/local/bin` and make itexecutable:cp tab /usr/local/binchmod +x /usr/local/bin/tabOptions:--------(no arguments) Opens a new Terminal tab and changes to the currentdirectory.-n: Window name of  the new tab-w: Open a new window instead of a tab-p: Position of the new window on screen in the format x,y (e.g 400,200)-s: Size of the new window in the format w,h (e.g. 400,200)-t: Path to a tabfile to execute.--testsuite: Opens a couple of windows to test and demonstratecapabilities.Example:--------tab                                # Opens a new tabtab vim                            # Opens vim in a new tabtab -w -s 100,100 -p 400,700 vim   # Opens vim in a new window at the# specified position and sizetab -t ~/Projects/project.tabfile  # Open the tabfileTabfile:--------You can specify multiple `tab` actions in one file, to quickly open multipletabs with commands. Tabfile is an INI file, each tab is seperated by a groupcalled either `tab:<n>` or `window:<n>`.You can specify options as 'name:', 'size:', and 'position:'. All other linesare commands which will be executed.[tab:1]                                 # Gulp Watchersource ~/myproject/bin/activategulp watch[tab:2]                                 # Django Projectsource ~/myproject/bin/activatemanage.py runserver                     # Start the server[tab:3]open http://127.0.0.1:8000/             # Open web browser for above serverclear                                   # and have a blank tab to work in[window:1]                              # Vim Editor in a separatesize: 200,400                           # window.position: 600,300vim
Package: tabplot
tabplotWORK IN PROGRESSWhen working from the terminal, I'd need to quickly (and beautifully) plot the data in csv-style text files. This meant good colors, axis labels, plot labels, adjustable axis limits, etc. I started with making a simple wrapper script around matplotlib to do this. Over time, I kept adding pre- and post-processing functionality such as scaling, normalizing, and linear regression, not to mention exposing more of matplotlib's properties and functions. Since the script kept growing, I decided to move it into its own separate package.InstallationYou can install tabplot via testpypipip install git+https://github.com/jayghoshter/tabplotCheck outSciencePlotsfor added plot beautification.ExamplesSimple line plotsAssuming text data stored in csv-style files with the following assumptions:No header labelsx,y data in columns 0,1 respectivelyEither space or comma separatedThe following code will generate basic plots. For customization options please refer to the examples section or test cases.from tabplot import Plot
plot = Plot()
plot.files = ['./file_1.csv', './file_2.csv'],
plot.linewidths = 2,
plot.labels = ['A', 'B']
plot.read()
plot.draw()
plot.show()
plot.close()orfrom tabplot import Plot
Plot(
    files = ['./file_1.csv', './file_2.csv'],
    linewidths = 2,
    labels = ['A', 'B']
).read().draw().show().close()Most used plot properties are exposed directly on thePlotobject.files,twinx, andlabelscan be specified onPlotor in theread()methodread()loads the data from the given files into.xsand.ys, which can be accessed and manipulated as wished.setup()creates a.figand.axif not already donedraw()plots the lines etc. to the figuresave('file.pdf')will write tofile.pdfshow()will display the plotted imageBar plotsfrom tabplot import BarPlot
files = ['dummy.csv']
BarPlot(bar_width = 0.5).read(files).draw().save('dummy.pdf').close()BarPlotis derived fromPlotNotes/IssuesOperator chaining is possible as seen above.Currently only uses one subplotMake sure to close the current plot with.close(). Unless garbage collected, plots may linger and calling.show()for some other object may also display a previous unclosed figure.hlines/vlines must be called after all plots/fit_lines etc are done so that no further changes to xlims, ylims are effected later.legends don't include hlinespreload-style can affect legend style even if not explicitly specified because we use setrc() in _update_params. So the default value overrides anything given in the style. While this is to be expected, the question is if this is user-friendly or not. Maybe a n otice is sufficient, that --preload-style can have this behavior.[TASK] perhaps I can separate out the setrc_defaults() and call it at another time? Or only call it if the user has specified changes to the default values
Package: tabpymigrate
TabPyMigrateShort project descriptionTabPyMigrate is a tool to migrate your Tableau Flow, Datasources, Workbooks from one server to another easily.
This is similar to TabMigrate and works with Tableay Rest API to download and deploy tableau objects. Easy to configure/Run from CLI.Table of ContentsInstallationUsageContributingLicenseInstallationPrerequisitesPython 3.6+Other dependencies# Clone the repositorygitclonehttps://github.com/codespg/TabPyMigrate.git# Navigate to the project directorycdTabPyMigrate# Install the required packagespipinstall-rrequirements.txtUsageUpdate config.py for source and target server and Tag the objects in Source Servercd tabpymigrate
python tabpymigrate.pyOption2: Provide all required information and run in cli.cd tabpymigrate
python tabpymigrate.py -action DOWNLOAD -source_server_name yourservername -source_username username -source_password password -tag_name tag_name -filesystem_path filesystem_path
Package: tabs
Tabs - Import tables in a consistent, maintainable, and readable way.Tabs is a Micro framework for defining and loading tables in a consistent way.
The goal is to make data science projects more maintainable by
improving code readability.Tabs comes with support for caching processed tables based on the current
configuration resulting in shorter loading of tables that have already been
compiled once.Link to full documentation:http://tabs.readthedocs.io/en/latest/index.html
Package: tabspy
#tabspyThis is the documentation fortabspypackageInstallation:pip install tabspyUsageSample Code:import tabspy.utils as ut
import tabspy.strategy.strategy as st

a = ut.welcome('SomeName')
b = st.Strategy('SomeName')
b.welcome()Output:Welcome SomeName : tabspy >> utils.welcome()
Welcome SomeName : tabspy >> strategy >> strategy.Strategy.welcome()
Package: tabtool
Documentation:http://tabtool.readthedocs.orgInstallpipinstalltabtoolTeststoxPrefaceUtils for tab separated files management were developed inYandex.
Core functionality was designed and implemented by Alex Akimov.
I was working as developer there and used utils.
During that period I decided to use tab separated files format inpmlllibrary to handle datasets for machine learning.
After I left Yandex, I asked team to open source package.
Guys agreed, but did not do it.
As far as I needed some functionality, I started my own implementation of simple package version.
ThenAndrey Fyodorov(developer from the team) releasedtabkitversion (very similar to one we had).
I dont know, whether tabkit code is supported or not, if supported, who is responsible for that.
I would like to continue development with Alex Akimov, if he would like to join.
As of now, there is implementation I write according to pep standards with python2 and python3 support.