Saravanan666/pypi-org huggingface dataset:
Package: seabird-growth-rate
Dummy TransformationsPara usar este repo como plantilla debemos hacer lo siguiente:Presiona el botón verde que diceUse this templateSelecciona como dueño a la organización IslasGECIAgrega el nombre del nuevo módulo de pythonPresiona el botónCreate repository from templateReemplazadummy_transformationspor el nombre del nuevo módulo en:Makefilepyproject.tomltests\test_transformations.pyRenombra el archivodummy_transformations\transformations.pyal nombre del primer archivo del
nuevo móduloCambia la descripción del archivodummy_transformations\__init__.pyRenombra el directoriodummy_transformationsal nombre del nuevo móduloCambia elcodecov_tokendel archivoMakefileLos archivos del nuevo módulo los agregarás en la carpeta que antes se llamabadummy_transformationsy las pruebas en la carpetatests.
Package: seabirdscientific
seabirdscientificThis is the repository for the Sea-Bird Scientific (SBS) Community Toolkit. It is a collection of:Python code to help in user developed processing of data collected with SBS instruments (see the repository src/sbs folder).Example SBS instrument data (see the repository documentation/example_data folder).AJupyternotebook that documents the current toolkit processing options that can be applied to data collected with SBE 37 and SBE 19plus V2 CTDs (see the repository documentation folder). This notebook also serves to document the processing options available in the SBS Fathom application.Repository Contentsseabirdscientific/
|
├── documentation/
|   ├── example_data/          [sample data files]
|   ├── ctd-processing.ipynb   [CTD Jupyter notebook]
|   ├── ctd-notebook.pdf       [static pdf notebook]
|   └── ctd-notebook.html      [static html notebook]
|
├── src/
|   └── sbs/
|       ├── process/           [processing modules]
|       └── visualize/         [visualization modules]
|
├── tests/                     [unit tests]
|
└── README.mdPackage Installation With pipThe seabirdscientific package uses Python 3.9 or greater. To install the package in a Python environment using pip send the command:On Windows:py-mpipinstallseabirdscientificOn Unix/macOS:python3-mpipinstallseabirdscientificFor additional information see thePython.org Installing Packagesreference.Example package use within python codeimportsbsfromsbs.processimportcontourimportsbs.process.conversionasconvimportsbs.process.processingasprocRequired SoftwareYou must havePythonversion 3.9 or higher installed in order to use the toolkit.CTD Jupyter NotebookThe ctd-processing.ipynb notebook in the documentation folder provides examples of the methods that can be applied to SBS CTD data within both the toolkit and the SBS Fathom application. There are a number of online references available with information on Jupyter notebook setup for different platforms and environments. For those who are not interested in an interactive notebook, there is a static version available inPDFformat.Contributions to the ToolkitIf you have code or data that you would like to contribute to the SBS community toolkit, please contactSBS customer support
Package: seaborn
seaborn: statistical data visualizationSeaborn is a Python visualization library based on matplotlib. It provides a high-level interface for drawing attractive statistical graphics.DocumentationOnline documentation is available atseaborn.pydata.org.The docs include atutorial,example gallery,API reference,FAQ, and other useful information.To build the documentation locally, please refer todoc/README.md.DependenciesSeaborn supports Python 3.8+.Installation requiresnumpy,pandas, andmatplotlib. Some advanced statistical functionality requiresscipyand/orstatsmodels.InstallationThe latest stable release (and required dependencies) can be installed from PyPI:pip install seabornIt is also possible to include optional statistical dependencies:pip install seaborn[stats]Seaborn can also be installed with conda:conda install seabornNote that the main anaconda repository lags PyPI in adding new releases, but conda-forge (-c conda-forge) typically updates quickly.CitingA paper describing seaborn has been published in theJournal of Open Source Software. The paper provides an introduction to the key features of the library, and it can be used as a citation if seaborn proves integral to a scientific publication.TestingTesting seaborn requires installing additional dependencies; they can be installed with thedevextra (e.g.,pip install .[dev]).To test the code, runmake testin the source directory. This will exercise the unit tests (usingpytest) and generate a coverage report.Code style is enforced withflake8using the settings in thesetup.cfgfile. Runmake lintto check. Alternately, you can usepre-committo automatically run lint checks on any files you are committing: just runpre-commit installto set it up, and then commit as usual going forward.DevelopmentSeaborn development takes place on Github:https://github.com/mwaskom/seabornPlease submit bugs that you encounter to theissue trackerwith a reproducible example demonstrating the problem. Questions about usage are more at home on StackOverflow, where there is aseaborn tag.
Package: seabornai
seabornaiseabornai is a Python library that leverages the OpenAI ChatGPT API to generate Seaborn graphs based on supplied data and prompts/questions.Disclaimer:Usage of this library requires an OpenAI API key and subscription, as well as the Seaborn library installed.InstallationYou can install seabornai using pip:pip install seabornaiUsagefromseabornaiimportgenerate_graph,set_openai_api_key# Set your OpenAI API keyapi_key=input("Please enter your OpenAI API key: ")set_openai_api_key(api_key)# Example usagedata={"x_column":[1,2,3],"y_column":[4,5,6]}prompt="What is the relationship between x_column and y_column?"# Generate a Seaborn graphgenerate_graph(data,prompt)FeaturesGenerate Seaborn graphs based on supplied data and prompts/questions.Customize graph style, size, labels, titles, legends, and colors.Choose from various types of plots, such as bar plots, scatter plots, line plots, or box plots.Perform statistical analysis by adding regression lines, confidence intervals, or hypothesis testing.Save the generated graph to a file in different formats (e.g., PNG, PDF, SVG).ExamplesHere are some examples of using seabornai to generate Seaborn graphs:Example 1: Scatter Plotdata={"x_column":[1,2,3,4],"y_column":[2,4,6,8]}prompt="What is the relationship between x_column and y_column?"generate_graph(data,prompt,style="darkgrid",size=(8,6))Example 2: Bar Plotdata={"category":["A","B","C"],"value":[10,20,30]}prompt="How does the value vary across different categories?"generate_graph(data,prompt,style="whitegrid",size=(6,4))LicenseThis project is licensed under theMIT License.
Package: seaborn-command
seaborn-command:ocean:seabornas a command line toolInstallationpip install seaborn-commandUsageseaborn <command> [options]Basic usagecat iris.tsv | seaborn pairplot --hue species --showInput csv filecat iris.csv | seaborn pairplot -d, --hue species --showSave image to a filecat iris.tsv | seaborn pairplot --hue species --format png > result.pngcommon options-d: delimiter (default tab)--show: show the GUI window. No output to STDOUT.--format: output format of the image (default svg)TipsSetting aliasalias sns="seaborn"Display with ImageMagickcat iris.tsv | seaborn pairplot --hue species --format png | displayNote: SVG images may not be displayed correctly.ContributingTry this command!Pull requests are welcome!LICENSEMIT
Package: seaborn-extensions
My collection of general ploting functions that I build on top of seaborn.Free software: GNU General Public License v3Documentation:https://seaborn-extensions.readthedocs.io.Featuresswarmboxenplot: Overlayed swarm- and boxen-plots with significance bars between groups.clustermap: The great clustermap but with easy annotation of rows and columns for numeric and categorical factors.volcano_plot: A volcano plot with great defaults.rankplot: A simple rank vs value plot, also known as a waterfall plot.InstallationTo install seaborn_extensions, simply use pip:pip install seaborn_extensionsCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.
Package: seaborn-image
seaborn-image: image data visualizationDescriptionSeaborn-image is a Pythonimagevisualization library based on matplotlib
and provides a high-level API todraw attractive and informative images quickly and effectively.It is heavily inspired byseaborn, a high-level visualization library
for drawing attractive statistical graphics in Python.DocumentationDetailed documentation can be foundhere.TutorialExamplesAPI ReferenceInstallationFor latest release:Usingpippipinstall-Useaborn-imageUsingcondacondainstallseaborn-image-cconda-forgeFor latest commitpipinstallgit+https://github.com/SarthakJariwala/seaborn-imageContributingPlease see thecontributing guidelines
Package: seaborn-polars
seaborn_polarsWrapper allowing to use Polars DataFrames and LazyFrames for plotting with seabornRequirementsPython 3.8+Seaborn, Polars, Pandas, Numpy, PyarrowInstallationUse regular pip install:pip install seaborn_polars pandas numpy polars seaborn pyarrowAlternatively, clone this repository.UsageThe package is a wrapper around seaborn plotting functions allowing to use Polars DataFrames and LazyFrames with the same syntax as when using Pandas DataFrames.import polars as pl
import seaborn_polars as snl

df = pl.scan_csv('data.csv')

snl.scatterplot(df, x='rating', y='responses', hue='gender')The package uses a deepcopy of original data. That way the original dataframe remains unaffected. For example, in the code snippet above, if we check the type ofdfafter plotting we'll see that it is still a Polars LazyFrame.All the plotting functions and parameters are identical to seaborn. When using data parameter, it has to be positional-only, the rest of parameters are keyword arguments.
Package: seaborn-table
# Seaborn Table
Seaborn Table acts as a dictionary and list and handles reading and writing data
to various formats seamlessly.It can do this by consuming:list of list
list of dictionary
dictionary of dictionary
dictionary of listsIt can consume these from raw python data structures, csv, text, markdown,
grid, psql, or file.
It can output to csv, text, markdown, grid, psql, rst or html tables.This is primarily as a library but can be used as a script with:
> seaborn_table source_file destination_file
Package: seabornxt
seabornxtA few handy extension plots using seaborn API.To install:You can install from PyPI as follows:pipinstallseabornxtor you can install it from the GitHub repository:git clone https://github.com/LeSasse/seabornxt.git
cd seabornxt
pip install .Use example:import seaborn as sns
from seabornxt import stripboxplot


def main():
    tips = sns.load_dataset("tips")

    plot = stripboxplot(data=tips, x="day", y="total_bill", hue="smoker")
    fig = plot.get_figure()
    fig.savefig("stripboxplot.pdf")


if __name__ == "__main__":
    main()Results in:Customise box and strip plots:You can customise the box and strip plots by passing over thestrip_kwargsandbox_kwargsdictionaries. The following
example displays data points in the same colour as the box plots:importseabornassnsfromseabornxtimportstripboxplotdefmain():tips=sns.load_dataset("tips")plot=stripboxplot(data=tips,x="day",y="total_bill",hue="smoker",strip_kwargs={"jitter":True,"alpha":0.8},box_kwargs={"boxprops":{"alpha":0.4}},)fig=plot.get_figure()fig.savefig("stripboxplot_colors.svg")if__name__=="__main__":main()The reason for this is that if nostrip_kwargsare handed over, I set the color
of the points to black for better visibility by default. But if one hands overstrip_kwargs, without explicitly specifying a color, the strip plot goes back
to the seaborn default color/hue. I prefer black as a default as this is most
useful in my use cases.Another dataset:importseabornassnsfromseabornxtimportstripboxplotdefmain():penguins=sns.load_dataset("penguins")plot=stripboxplot(data=penguins,x="sex",y="body_mass_g",hue="species",)fig=plot.get_figure()fig.savefig("stripboxplot_penguins.svg")if__name__=="__main__":main()
Package: seabreeze-opentrons
Python module forOcean OpticsspectrometersPython-seabreeze is the easy way to access your Ocean Optics spectrometers from
python. It wraps theSeaBreezelibrary provided by Ocean Optics to communicate with the spectrometer. It also
provides a pyUSB based reimplementation of SeaBreeze for easy extension.This software is not associated with Ocean Optics. Use it at your own risk.DOCUMENTATION ON RTDYou'll find the documentation and more detailed information herehttps://python-seabreeze.readthedocs.io/en/latest/ChangesThe changelog can be found hereCHANGELOG.mdInstall# via pypipipinstallseabreeze-opentrons
seabreeze_os_setupUsageThe following example shows how simple it is to acquire a spectrum with
python-seabreeze through the model independentSpectrometerclass. For a more
detailed description read thedocumentation:>>>fromseabreeze.spectrometersimportSpectrometer>>>spec=Spectrometer.from_first_available()>>>spec.integration_time_micros(20000)>>>spec.wavelengths()array([340.32581,340.70321186,341.08058305,...,1024.84940994,1025.1300678,1025.4106617])>>>spec.intensities()array([1.58187931e+01,2.66704852e+04,6.80208103e+02,...,6.53090172e+02,6.35011552e+02,6.71168793e+02])To use the pyseabreeze backend (requirespyusb) simply run this before importingseabreeze.spectrometers.>>>importseabreeze>>>seabreeze.use('pyseabreeze')>>>importseabreeze.spectrometersassbSupported DevicesSpectrometercseabreezepyseabreezeHR2000xxHR2000PLUSxxHR4000xxJAZxxMAYA2000xxMAYA2000PROxxMAYALSLxxNIRQUEST256xxNIRQUEST512xxQE65000xxQE-PROxxSTSxxTORUSxxUSB2000xxUSB2000PLUSxxUSB4000xxUSB650Issue #47SPARKxxKnown IssuesUSB2000 spectrometers causeData transfer errordue to old firmwareIssue #48USB650 not supportedIssue #47No conda packages for armv6 (RPI version 1)Issue #46Contributing GuidelinesIf you run into any problems, file an issue and be sure to include the
following in your report:Operating system (Linux distribution, Windows version, OSX version) and
archictecture (32bit, 64bit, arm)Python version and arch (i.e. Python 2.7.10 64bit)python-seabreeze versionIf you want a feature implemented, please file an issue, or create a pull
request when you implement it yourself. And if you would like to support me via
paypal, click on the paypal donate button on top of this README.LicenseFiles in this repository are released under theMIT license.Related RepositoriesIf you want me to add your project here, let me know. Happy to add it.python-seatease by @jonathanvanschenck- a software emulator of python-seabreeze. Emulates seabreeze's behavior so for testing my code without access to a spectrometer.python-seabreeze-server by @jonathanvanschenck- a TCP-based server to host the seabreeze.cseabreeze backend, allowing multiple clients (potentially offsite) to interact with a single spectrometer.SeaBreeze- Ocean Optics' SeaBreeze C library.libseabreeze- github clone of the C library.internal use only(has pre-built libraries if you know what you're doing)python-seabreeze-feedstock- anaconda feedstock for automated package deployment.internal use onlyyaqd-seabreaeze- A seabreeze interface for theyaq instrument control framework
Package: seacorenlp
SEACoreNLP: A Python NLP Toolkit for Southeast Asian LanguagesSEACoreNLP is an initiative by NLPHub ofAI Singaporethat aims to provide a one-stop solution for Natural Language Processing (NLP) in Southeast Asia.It brings together the available open-source resources (be it datasets, models or libraries) and unifies them with a single framework. We also train models on available data whenever the opportunity arises and provide them through our package on top of the third-party libraries and models.DemoPlease refer to ourdemoto see our models in action.Languages SupportedWe currently support the following languages:IndonesianThaiVietnameseCore NLP TasksThe core NLP tasks that we cover are as follows:Word TokenizationSentence SegmentationPart-of-speech Tagging (POS Tagging)Named Entity Recognition (NER)Constituency ParsingDependency ParsingInstallationpipinstallseacorenlpIf you wish to make use of models from Stanza (one of the third-party libraries that we use), ensure that you also install the relevant models after installingseacorenlp.importstanzastanza.download('id')# Download Indonesian modelsstanza.download('vi')# Download Vietnamese models# Stanza does not have models for ThaiAs there are some dependency conflicts between the latest version ofunderthesea(a package for Vietnamese NLP that SEACoreNLP depends on) and the other packages used in SEACoreNLP, we are installing an earlier version (1.2.3) that does not have conflicts. However, this version does not contain the Vietnamese dependency parser, so if you wish to make use of that, please manually upgrade the version ofundertheseato the latest version.You may consider using our natively trained Vietnamese dependency parsers if you do not wish to perform this manual upgrade:fromseacorenlp.parsingimportDependencyParser# Load best Vietnamese dependency parser trained on Universal Dependencies dataparser=DependencyParser.from_pretrained("dp-vi-ud-xlmr-best")parser.predict("Tôi muốn ăn cơm.")UsageWe provide a command-line interface for training, evaluation and prediction. We also provide classes (such asTokenizer,POSTagger,NERTaggeretc.) and models that can be used in a manner reminiscent of Huggingface Transformers.fromseacorenlp.taggingimportPOSTaggerth_text='ผมอยากกินข้าว'# Native Modelsnative_tagger=POSTagger.from_pretrained('pos-th-ud-xlmr')native_tagger.predict(th_text)# Output: [('ผม', 'PRON'), ('อยาก', 'VERB'), ('กิน', 'VERB'), ('ข้าว', 'NOUN')]# External Models# Include keyword arguments as necessary (see respective class documentation)external_tagger=POSTagger.from_library('pythainlp',corpus='orchid')external_tagger.predict(th_text)# Output: [('ผม', 'PPRS'), ('อยาก', 'XVMM'), ('กิน', 'VACT'), ('ข้าว', 'NCMN')]Please refer to ourdocumentationfor details.
Package: seadiver
"seadiver" is a Python based DeepLearning Framework which maximized its accessibility for DL beginners.You can start by creating a model in any desired structure with only 3 required arguments.
Easily train, predict and visualize your model."seadiver" supports 'export' and 'import' function in 'json' format.
pip install is available >> "pip install seadiver"Simple example for usage is like below.import seadiver#build a model
model = seadiver.model.ANN(input_shape=(1, 784), structure = (100, 100, 100, 10), output="softmax")
model.describe()  #prints how the model looks#train
model.train(y= TRAIN_BATCH, t= ANSWER_BATCH, learning_rate=0.001, iteration=1000)#predict
model.predict(x = INPUT)#export model as a 'json' file to a local directory
model.export(directory = "C:\Users....", file_name="myModel.json")#import model from a local directory
imported_model = seadiver.factory.make(file = "C:\Users.....\myModel.json")=======================================================================Updates on more types of model such as 'CNN', 'LSTM' is underway.
Thanks, and please contact the author via e-mail for any comment.
Package: seadog
seadogSeadog helps you generate statistical data visualizations directly from the command line.It aims to allow quick analyses of data, and while it is essentially a wrapper formatplotlibandseaborn, it does not intend to cover all options and capabilities.The word seadog may be slang for either a veteran sailor or seals.Supports Python 3.7+.InstallationUsingpipto installseadog:pipinstall--userseadogQuick startThis section will be updated onceseadogprovides some functionality. Features will be added as I need them.TodoData descriptionData sample (n)Data correlationData NaN detection (graph in terminal)Data NaN removalBar chart (and horizontal option)HistogramDist plot with KDELogarithmic scales for x and yAxes labelsScatter plotsPie charts?
Package: seadu
SeaduSeadu is a command-line tool used for uploading and downloading files from specific Seafile library.UsageInstallaptinstall-ypipx&&pipxinstallseaduInitialYou need to add the library API Token manually. The configuration file will be saved in~/.seadu/config.json.seaduinit-sYOUT_SERVER-tYOUR_TOKENThe-soption should be entered as a full URL containinghttp:///https://without a slash at the end, e.g.https://cloud.seafile.comDownload/UploadseadudownDIR_TO_STORE
seaduupDIR_TO_UPLOAD
Package: seaduck
seaduckA python package that interpolates data from ocean dataset from both Eulerian and Lagrangian perspective.Quick Start>>>importseaduckassdDocumentationSeaduck documentation:https://macekuailv.github.io/seaduck/Workflow for developers/contributorsFor best experience create a new conda environment (e.g. bubblebath):conda create -n bubblebath
conda activate bubblebathBefore pushing to GitHub, run the following commands:Update conda environment:make conda-env-updateInstall this package:pip install -e .Run quality assurance checks:make qaRun tests:make unit-testsRun the static type checker:make type-checkBuild the documentation:make docs-buildBuild the pdf version of the papermake jossLicenseCopyright 2023, Wenrui Jiang.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Package: seafarer
Seafarer ⛵Taxicab metric on the sphere! Install viapipinstallseafarerThis library calculates the "seafarer distance" between two points on Earth:
Travel parallel to latitude and longitude instead of "as the crow flies" –
like in the old days...UsageCalculate the distance between Schwerin and Helsinki:fromseafarerimportseafarer_metricschwerin=(53.629722,11.414722)# (lat, lon)helsinki=(60.170278,24.952222)seafarer_metric(schwerin,helsinki)# 1474.7398906623202 kilometresYou can also obtain the result in different units:seafarer_metric(schwerin,helsinki,unit="mi")# 916.3608837507956 milesseafarer_metric(schwerin,helsinki,unit="ft")# 4838385.468052049 feetSeafarer is using thehaversinelibrary
under the hood and you can use theirUnitdirectly:fromhaversineimportUnitseafarer_metric(schwerin,helsinki,unit=Unit.NAUTICAL_MILES)# 796.2958366185961 nautical milesWhat is this? Why Seafarer?On a 2-dimensional plane, the metric obtained when travelling along the axes
is known astaxicab,
Manhattan, or L1 metric. What is the equivalent on a 3-dimensional sphere?We calculate the distance when travelling along the grid of longitudinal and
latitudinal lines. When travelling from Schwerin (53°N 11°E) to Helsinki
(60°N 24°E) in the example above, there are two possiblities: travel via
53°N 24°E or 60°N 11°E. Unlike the 2D case, these two distances are
(generally) different, so we use the short one.Before navigation improved to a sufficient degree, this is how ships were
sailing: parallel to the equator until they hit the target meridian, then
North or South to their final destination. Hence seafarer metric! ⛵