Saravanan666/pypi-org huggingface dataset:
Package: pandas-visual-analysis
StatusReleaseCodeGenerates aninteractive visual analysiswidget to analyze a pandasDataFramein Jupyter notebooks.
It can display various different types of graphs with support for linked-brushing in interactive widgets.
This allows data exploration and cognition to be simple, even with complex multivariate datasets.There is no need to create and style plots or interactivity - its all ready without any configuration.InstallationUsing pipTo install this package with pip run:pip install pandas-visual-analysisUsing condaTo install this package with conda run:conda install -c meffmadd pandas-visual-analysisFrom SourceTo install this package from source, clone into the repository or download thezip fileand run:python setup.py installUsageBasic UsageHaving aDataFrame, for example:importpandasaspdimportsslssl._create_default_https_context=ssl._create_unverified_contexturl="https://raw.githubusercontent.com/mwaskom/seaborn-data/master/mpg.csv"df=pd.read_csv(url)you can just pass it toVisualAnalysisto display the default layout:frompandas_visual_analysisimportVisualAnalysisVisualAnalysis(df)If you want to specify which columns of theDataFrameare categorical, just pass thecategorical_columnsoption:frompandas_visual_analysisimportVisualAnalysiscategorical=["name","origin","model_year","cylinders"]VisualAnalysis(df,categorical_columns=categorical)Selection TypesBy default a new selection replaces the old selection, however, it is also possible to add data points to the existing
selection by selecting theAdditiveselection type. By choosing theSubtractiveselection newly selected
data points are removed from the selection.Using DataSourceInstead of passing theDataFrameobject directly toVisualAnalysisit is possible to use aDataSourceobject.
This enables linked-brushing across multiple notebook cells if the object is used across cells.frompandas_visual_analysisimportVisualAnalysis,DataSourcedata=DataSource(df)VisualAnalysis(data)Later you can create a new analysis with the brushing still preserved
simply by using the samedataobject created earlier.VisualAnalysis(data)Using LayoutsIf you want to specify your own layout, you can do that by passing thelayoutparameter.
The parameter is a list of rows, where each row is in turn a list specifying the Widgets in that row.frompandas_visual_analysisimportVisualAnalysisVisualAnalysis(df,layout=[["Scatter","Scatter"],["ParallelCoordinates"]])Here, two scatter plots will share the first row while the second row only contains a parallel coordinates plot.
In order to see all the possible options you can call thewidgetsclass-method ofVisualAnalysis.VisualAnalysis.widgets()This outputs the following list of possible plots:['Scatter','ParallelCoordinates','BrushSummary','Histogram','ParallelCategories','BoxPlot']Any of those can be part of the layout specification.
See also:widgets Documentation.For more advanced features of theVisualAnalysisclass see:VisualAnalysis DocumentationDocumentationFor more details see theOfficial Documentation.
Package: pandas-weighting
Weight Pandas Dataframespandas-weighting enables general level weighting (similar to spss) of
dataframes. This makes it possible to calculate weighted means, frequencies
etc. statistical figures without the need to write separate functions for
applying weighting.Weighting is done by repeating rows as many times as defined in 'weight'
column. There are a few drawbacks related to weighting data this way:Absolute weighting (all weights are above one, the sum of the weighted cases
is more than sum of the unweighted cases) must be used instead of relative
weighting (some weights are below zero, the sum of the weighted cases is the
same as the sum of the unweighted cases), as it's not possible to repeat rows
fractional times.Weights are rounded to integers, which might cause inaccuracies, especially if
the weights are small.If dataframe / weights are large, weighting should be applied to individual
columns in turns, instead of the whole dataframe, as this might cause
memory issues.Usagefrompandas_weightingimportweightdf.col.pipe(weight,df.weights).describe()or by monkey patching Series/Dataframe:pd.Series.weight=weightpd.DataFrame.weight=weightdf.col.weight(df.weights).describe()Exampleimportpandasaspdfrompandas_weightingimportweightpd.Series.weight=weightpd.DataFrame.weight=weightdf=pd.DataFrame({'val':[1,2,3,4,5,6],'weights':[3,2,1,1,0,None],})# mean 3.5 =(1+2+3+4+5+6)/6df.val.mean()# weighted mean 2.0 =(3*1+2*2+1*3+1*4)/(3+2+1+1)df.val.weight(df.weights).mean()
Package: pandas-x
pandas-xGPS/position calculation accessor for pandas DataFrames.Example Usagepandas-x provides the.posDataFrame accessor:>>>importpandasaspd>>>importpandas_x>>>df=pd.DataFrame.from_dict({...'lat':[40.0,40.1,40.3],...'lon':[-105.0,-105.0,-105.0]...})>>>df['displacement']=df.pos.ds_from_xy()>>>df['displacement']00.000000111119.492664222238.985329dtype:float64>>>df.pos.s_from_ds()00.000000111119.492664233358.477993dtype:float64Dependencies and InstallationPandasandNumPyare required.The package is available onPyPiand can be installed withpip:$ pip install pandas-xLicenseThis project is licensed under the MIT License. SeeLICENSEfile for details.DocumentationThe official documentation is hosted at readthedocs:https://pandas-x.readthedocs.io/en/stable/Current ActivitiesImplement an algorithm to smooth GPS position and speed data.
Most GPS-enabled activity trackers filter their speed and distance
timeseries to remove measurement noise. I want to try and figure out
how they do it, then replicate their techniques, and compare the
smoothed position data.
Package: pandasxlframer
pandasxlframerThis is a simple wrapper of openpyxl to enable additional Excel formatting for Pandas' dataframe. The intented use is to add formatting function when saving a dataframe to Excel: font size, text alignment, coloring/merging cells, and adding header. The goal is to use method chaining to provide a quick syntax to accomplish such task.For example the default Pandas' to_excel output a file like this:A task that we often encounter is to add a header to this Excel file, merge some column cells, formatting cells, and to change background color. This can be accomplish by the following codes:int_map = {"全量": "int", "S+": "int", "S": "int", "A": "int", "B": "int", "无级别": "int"}
path = "../data/output/test.xlsx"
(
    df.excel_format.add_header(title_text="兴趣点为空统计总览")
    .set_columns_format(int_map)
    .column_color("频道", green, skip_row=2)
    .merge_column_cell("频道")
    .row_color(2, orange, skip_col=1)
    .save(path)
)It will now output a file that looks like this:Because I currently use this formatter primary for Chinese audience, the default font style is "微软雅黑". However, if you need a different font style, you can do some by changing the default_font_style in the framer.py file.The current supported functionalities are:add header;set column width;set column format (integer, float, percentage);set row alignment;merge cells in a column;change column/row color;To Doadd more cell coloring options;add more alignment options;add examples of how to write multiple dataframe and multiple sheets.
Package: pandas-xlsx-tables
pandas-xlsx-tablesEven though you might not like it, Excel isn't going anywhere. And Excel with tables isa lot better than without. Some highlights are: better performance, reference columns by name (vs defining named ranges), sticky headers (vs freeze panes), stricter typing (vs random types) and sort/filter dropdowns.Out of the box Pandas provides to and from excel functionality, but it cannot write native excel tables (the result is only formatted like one). This is where pandas-xlsx-tables comes in: convert excel tables to dataframes and vice versa, whilest mostly preserving data types. The api has been kept deliberatly  simple as to provide useful functionality out of the box.>>>frompandas_xlsx_tablesimportxlsx_table_to_df>>>df=xlsx_table_to_df("my_file.xlsx","Table1")>>>dfcol1col2Row01a12bAnd the reverse process:>>>frompandas_xlsx_tablesimportdf_to_xlsx_table>>>df_to_xlsx_table(df,"my_table",header_orientation="diagonal",index=False)Why not integretate this in Pandas directly?Due to the complexity of Pandas and the large number of users it is very difficult to significantly change the current excel implementeation. Also the abstractions available to plug different engines are not that helpful. Basically I tried andgave up(but of course I would prefer having this built into Pandas).
Package: pandas-xlwt
Re-register Xlwt WriterAs thexlwtpackage is no longer maintained, thexlwtengine of pandas was removed in pull requestDEPR: Remove xlwt#49296. And this pull request was merged since v0.2.0 .But there are some legacy APIs that still only support older MS Excel 97/2000/XP/2003 XLS files.This module contains xlwt engine copied from pandas v1.5.3 and re-register it when youimport pandas_xlwt, eventually allow pandas versions above 2.0.0 output xls format file.Due to the changes in other parts of pandas source code, xls extension will no longer recognized by pandas, You should specificengine="xlwt"when you write xls file.importpandas_xlwtdf.to_excel(path,index=False,engine="xlwt")MS Excel 97/2000/XP/2003 XLS file format is really out of date. While this code may still work today, there is no guarantee that this re-registration method will work in future versions of pandas.Please update your API to support other file formats such as.csv, .tsv or .xlsxas soon as possible.
Package: pandas-xyz
pandas-xyzGeospatial calculation accessor for pandas DataFrames.Example Usagepandas-xyz provides the.xyzDataFrame accessor:>>>importpandasaspd>>>importpandas_xyz>>>df=pd.DataFrame.from_dict({...'lat':[40.0,40.1,40.3],...'lon':[-105.0,-105.0,-105.0]...})>>>df['displacement']=df.xyz.ds_from_xy()>>>df['displacement']00.000000111119.492664222238.985329dtype:float64>>>df.xyz.s_from_ds()00.000000111119.492664233358.477993dtype:float64Dependencies and InstallationPandas,NumPy, andSciPyare required.The package is available onPyPiand can be installed withpip:$ pip install pandas-xyzLicenseThis project is licensed under the MIT License. SeeLICENSEfile for details.DocumentationThe official documentation is hosted at readthedocs:https://pandas-xyz.readthedocs.io/en/stable/The Elevation Smoothing AlgorithmThe algorithm I apply to filter elevation time series is based on a paper produced by
the National Renewable Energy Laboratory. Their algorithm is meant to smooth the elevation
time series of a moving vehicle for more reasonable estimates of road grades for energy consumption
models. This actually isn't that different from my end goal of smoothing elevation series for
more reasonable estimates of elevation gain and energy consumption by ambulating humans!
The paper is included in theresources folderProject StatusCompleteImplement an algorithm to smooth noisy elevation time series.Implement a smoothing algorithm for elevation series as a function of
distance (similar to how the completed time-smoother works.)Current ActivitiesImplement an algorithm to smooth GPS position and speed data.
Most GPS-enabled activity trackers filter their speed and distance
timeseries to remove measurement noise. I want to try and figure out
how they do it, then replicate their techniques, and compare the
smoothed position data.Develop and document a variety of elevation gain/loss algorithms.Describe the algorithms in more detail. Maybe in a wiki?Provide references to papers and other resources where I got inspiration
for each algorithm.Future WorkBenchmark algorithm performance (speed, accuracy, and consistency):Generate dummy time series of (distance, elevation) data to check
smoothing algorithm.Generate series of GPS points to obtain elevation coordinates from
various DEMs (usingelevation-querypackage)
to compare elevation datasets with and without smoothing.Create gain/loss algorithms to emulate those employed by
Strava / TrainingPeaks / Garmin.ContactReach out to me at one of the following places!Website:trailzealot.comLinkedIn:linkedin.com/in/aarondschroederTwitter:@trailzealotInstagram:@trailzealotGitHub:github.com/aaron-schroeder
Package: pandas-zmq
pandas-zmqCommunicatePandasDataFrame overZeroMQconnectionAPIsend_dataframe(socket, dataframe, secret='', alg='sha256', flags=0)recv_dataframe(socket, secret='', alg='sha256', flags=0)Serverimport pandas_zmq

# ...
pandas_zmq.send_dataframe(socket, df)Clientimport pandas_zmq

# ...
df = pandas_zmq.recv_dataframe(socket)SecurityWARNING: There are reported security issues with pickle, which is the backend serialization for this feature. A signature using a shared secret and a configurable hash algorithm has been added to mitigate this risk which will attempt to verify the data has not been altered.See pickle documentation.
Package: pandatorch
A flexible simple library that makes it easier to use the extrememly
popular pandas package with the other extremely popular framework
PyTorch.FunctionsConverts a Pandas DataFrame into a usable PyTorch dataset.Allows use of all usual Pandas functionsUsageimport pandas as pd
from pandatorch import data
df=pd.read_csv("path_to_dataset")
torch_df=data.DataFrame(X=df.drop("<Target Column>",axis=1),y=df["<Target Column>"])Note:Check out the notebooks folder for a full end-to-end training
example of a tabular dataset using PandaTorch
Package: panda-utils
Panda3D Utils v1.6Panda Utils is a set of Python scripts meant to help various projects
running on the game enginePanda3D.
It includes tools for manual use, as well as a full-fledged asset
importing pipeline. It also includes an implementation of Egg Syntax Tree,
which can be used programmatically in some scenarios.InstallationInstall Python 3.9 or abovepip install panda_utilsThis package includes a number of optional dependencies:pip install panda_utils[imagery]to enable the Downscale modulepip install panda_utils[autopath]to automatically download P3Dpip install panda_utils[runnable]to enable the CLI runnerRequires a settings file to be used that way, see:config_example.iniin this repositorypip install panda_utils[pipeline]to enable the Pipeline runnerRequires Blender to be in the system PATH to runpip install panda_utils[composer]to use the Composer tool
used for Pipeline automationRequirespipelineand has the same requirements for Blenderpip install panda_utils[everything]to include all of the aboveSome of the featuresAutomated asset pipeline, allowing to build BAM model files from input
FBX or BLEND models adding optimizations and modifying them on the flyA tool to easily rescale and palettize all images in a folderBam2Egg converter that does not suckA tool to export toon model and fix most issues arising from thatFast and flexible implementation of the Egg Syntax TreeDocumentationSee here:Documentation
Package: pandaxt
PandaXTA Python 3 "ccxt" wrapper overPandaslib.Author: Daniel J. UmpierrezLicense: UNLICENSEVersion: 0.1.10DescriptionPython ccxt multi-exchange lib mixed with pandas lib for data handling.RequirementsrequestsregexccxtpandasCythondiskcachenewtulipyUsageBasic examplefrompandaxtimportPandaXTapi=PandaXT('binance')print(api.markets)ChangelogProject changes over versions.0.1.10Update python versions support ti >=3.8Update some requirements.Added tox.ini and pyproject.toml files.0.1.9Removed unnecessary comments and code at utils.pyAdded docstring to to_lower function.0.1.8Minor fixes.0.1.7Fixed "currencies" method and recursion limit bugs.0.1.6README requirements fixedRemoved 'PandaXT._fetch_ohlcv' method.0.1.5Many features added and many errors fixed0.1.4New "model" module.Added dict2class in "utils" module.0.1.3"Binance" specific options added for time adjust and auto fit precision or orders.md.0.1.2New "create_market_order" method.New "sort_by" function in utils module.Unified cancel methods into "cancel_order".Sell and Buy methods auto-fill price and amount if not is supplied as param.0.1.1Added precision related methods to "PandaXT" class.0.1.0Initial versionTODOTODO
Package: pandazip
pandazipGo minimal, go green, go pandazip.Cut memory footprint by forth in just 2 lines of code.
Compress Pandas DataFrames without losing information or go smaller in expense of losing a bit of information.
Swift parallel execution makes pandazip very fast."A 2018 blog post from OpenAI revealed that the amount of compute required for the largest AI training runs has increased by 300,000 times since 2012. And while that post didn’t calculate the carbon emissions of such training runs, others have done so. According to a paper by Emma Strubel and colleagues, an average American is responsible for about 36,000 tons of CO2 emissions per year;training and developing one machine translation modelthat uses a technique called neural architecture search was responsible for an estimated626,000 tons of CO2.""According to the American Council for an Energy-Efficient Economy it takes 5.12 kWh of electricity per gigabyte of transferred data. And according to the Department of Energy the average US power plant expends 600 grams of carbon dioxide for every kWh generated. That means thattransferring 1GB of data produces 3kg of CO2."plus storage and processing  = Huge impact on environment without even noticing.Take action now!Installpandazip can be installed fromPyPI:pip install pandazipCompressing Pandas DataFrame using PandazipfrompandazipimportPandazipzipper=Pandazip()x_train=zipper.fit_transform(x_train)x_test=zipper.transform(x_test)
Package: pandb
PandoraPandorais a universal database proxy and SQL-Database engine, that implements
high-performance and security requirements for large-scale enterprise analytical
applications.The primary goal of Pandora is to separate data integration and data analysis
into independent tasks, by providing a unified (universal) data interface for
machine learning- and data analysis applications. To achieve this goal, Pandora
implements the two fundamental layers of a data warehouse:Theintegration layerof Pandora utilizesSQLAlchemyto allow it's connection to a variety
of SQL-Databases (e.g. IBM DB2, Oracle, SAP, MS-SQL, MS-Access, Firebird,
Sybase, MySQL, Postgresql, SQLite, etc.). Thereupon it provides native support
for flat file databases (e.g. CSV-Tables, R-Table exports), laboratory
measurements and data generators.Thestaging layerof Pandora is implemented as a native SQL-Database engine,
featuring a DB-API 2.0 interface with full SQL:2016 support, a vertical data
storage manager and real-time encryption. This allows the data analysis
application to integrate a variety of different data sources, by using a unified
data interface (and SQL dialect).Pandora is open source, based on thePythonprogramming language and actively developed as
part of theLiquid Codeframework
atFrootlab. Pandora is developed as a generic
data interface, which can be integrated into data analysis applications, to
facilitate the integration of data.Current Development StatusPandora currently is inPre-Alphadevelopment stage, which immediately follows
thePlanningstage. This means, that at least some essential requirements of
Pandora are not yet implemented. A comprehensive list of all currently supported
data back-ends is given in theonline
manual.InstallationComprehensive information and installation support is provided within theonline manual. If you already have
a Python environment configured on your computer, you can install the latest
distributed version by using pip:$ pip install pandbDocumentationThe latest Pandora documentation is available as anonline
manualand for download in the
formatsPDF,EPUBandHTML.ContributeContributors are very welcome! Feel free to report bugs and feature requests to
theissue trackerprovided by
GitHub. Currently, as the Frootlab Developers team still is growing, we do not
provide any Contribution Guide Lines to collaboration partners. However, if you
are interested to join the team, we would be glad, to receive an informalapplication.LicensePandora isopen sourceand available free
for any use under theGPLv3 license:Â© 2019 Frootlab Developers:
  Patrick Michl <patrick.michl@frootlab.org>
Â© 2018-2019 Patrick Michl
Package: pandect
Simple wrappers to load and convert common data file typesFeaturesUses file extension as heuristic to determine input formatProvides metadata using pyreadstat objects when appropriateSupports: csv, tsv, xlsx, sav, dta (unreliable), sqlite3Loads data into pandas.DataFrameProvides command line utilities: sav2dta, pandectExamplesLoad a data file into a pandas.DataFrame object:>>>importpandect>>>data,meta=pandect.load(input_file_name)Save a pandas.DataFrame object as a data file:>>>importpandas>>>importpandect>>>data=pandas.DataFrame([{'a':1,'b':2},{'a':3,'b':4}])>>>pandect.save(data=data,output='out.sav')>>>Save a pandas.DataFrame object as a data file with metadata:>>>importpandas>>>importpandect>>>importpyreadstat>>>data=pandas.DataFrame([{'a':1,'b':2},{'a':3,'b':4}])>>>meta=pyreadstat.metadata_container()>>>meta.column_names_to_labels={'a':'A Label','b':'B Label'}>>>pandect.save(data=data,output='out.sav',meta=meta)>>>Convert a data file at the command line:$pandectinput.csvoutput.dtaConvert sav data file to dta data file:$sav2dtasome_file.savDerives output file name from input file name (here:some_file.dta)This is a convenience utility for a common taskIt is basically a special case of thepandectutilityLimitationsLoading dta files is unreliable (bug in pyreadstat, might segfault)LicenseFree software: MIT licenseDocumentationhttps://pandect.readthedocs.io/CreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.
Package: pandeia.engine
The Pandeia engine is a ‘simulation-hybrid’ exposure time calculation engine that performs calculations on two-dimensional astronomical scenes created by the user. It uses a pixel-based 3D approach, modeling both the spatial and wavelength dimensions using realistic PSFs for each instrument mode, and handles saturation, correlated read noise, and inter-pixel capacitance. It supports both the James Webb Space Telescope and the Wide-field Imager mode of the Nancy Grace Roman Space Telescope.Installation and setup instructions (including a required data package) for the Pandeia engine can be found at this Space Telescope Science Institute page:https://outerspace.stsci.edu/display/PEN/Pandeia+Engine+NewsSee also this page for James Webb Space Telescope (JWST)-specific installation instructions:https://jwst-docs.stsci.edu/jwst-exposure-time-calculator-overview/jwst-etc-pandeia-engine-tutorial/installing-pandeiaA usage guide (JWST-focused) for the Pandeia engine can be found here:https://jwst-docs.stsci.edu/jwst-exposure-time-calculator-overview/jwst-etc-pandeia-engine-tutorialAny questions about the Pandeia engine should be directed to the JWST Help Desk athttps://stsci.service-now.com/jwst.