Saravanan666/pypi-org huggingface dataset:
Package: scientific-plots
Scientific PlotsCreate and save plots in scientific styleTable of Contents[[TOC]]OverviewThis python module includes useful methods and definitions for various python
projects.
The focus lies of on the automatic creation of a set of plots, which are
designed to be used in scientific journals, dissertations and presentations.
The most important components are the definitions of types compatible
for numpy, located intypes_.py, and the typing stubs instubs/. These
typing stubs are also distributed in this package.PlottingThe easiest way to implement the plotting features provided by this library, is
to use one of the predefined function inscientific_plots.default_plots.
Alternatively, any plotting functions can be decorated by using theapply_stylesdecorator inscientific_plots.plot_settings.For example, this could look like this:import matplotlib.pyplot as plt
from scientific_plots.plot_settings import apply_styles

@apply_styles
def plot_something() -> None:
    """Example function."""
    plt.plot(...)
    ...
    plt.savefig("subfolder/your_plot_name.pdf")The script will create a bunch of plots and place them in the given location
next to your given path. Thus, it is advisable to create a different subfolder
for new plots.For three-dimensional plots, it is recommended to set the optional argumentthree_dof the decorator to true:@apply_styles(three_d=True)
def plot_function():
    ...Alternatively, this package provides default plot settings in the submoduledefault_plots. The provided function apply a default design, which should
look good in most situations.from scientific_plots.default_plots import plot

plot(x, y, "x_label", "y_label", "subfolder/filename.pdf")Besides this simple plot, this library also provides the following default
plots:plot_fit: Plot data and a fit of this data.def fit_function(x):
    ...
    # fit some data
    ...
    return y

plot_fit(
    x, y, fit_function, "x_label", "y_label",
    "subfolder"/"filename.pdf")`two_plots: Plot two curves sharing a single y-axis.two_plots(
    x1, y1, "label1",
    x2, y2, "label2",
    "xlabel", "ylabel", "subfolder"/"filename".pdf)two_axis_plots: Plot two curves with two y-axis in a single graph.two_axis_plots(
    x1, y1, "label1",
    x2, y2, "label2",
    "xlabel", "ylabel1", "ylabel2",
    "subfolder"/"filename".pdf)All of those functions have the following command-line arguments:logscale: Plot the data double logarithmic.single_log: Plot the x-axis logarithmic.single_log_y: Plot the y-axis logarithmic.xlim: Set the limits on the x-axis manually.ylim: Set the limits on the y-axis manually.TypesAdditional Vector like types for numpy-arrays are provided inscientifc_plots.types_.  These types can be used for static type checking
using mypy.Typing StubsAddtional typing stubs for scipy, matplotlib and numba are provided and
installed by this package. These packages do not provide type hints on their
own.
Package: scientific-tools
Scientific toolsProject's descriptionscientific_toolsis the Swiss army knife of scientists, researchers, engineers and students who work with python.This document shows most important functionalities of this framework.This framework is currently in development, but most of functionnalities works without any bugs. When a functonality isn't stable or had known bugs, it was wrote in italic.MathematicsSolveThescientific_tools.mathematics.solvepackage can resolve equations with some functions using different algorithm :dichotomyfunction search the unique solution of f(x) = 0, where f is an continuous and strictly monotone function.implicit_finite_difference_solverfunction can solve a partial differential equation with the implicit finite difference method. The shape of partial differential equation must be Ctt Utt + Ctx Uxt + Cxx Uxx + Cx Ux + Ct Ut + Cu U = Cc.NB: This solver is experimental and it has been deprecated because of bugs.explicit_finite_difference_solverfunction can solve the same shape of partial differential equation but with the explicit finite difference method.NB: This solver is experimental and it has been deprecated because of bugs.PhysicsUncertaintyThescientific_tools.physics.uncertaintypackage can calculate uncertainties :calculate standard uncertainties with propagation rulescalculate relative uncertainties with propagation rulescalculate z-scores (z-core between a value and a reference value & z-score between two value)Spectral analysisThescientific_tools.physics.spectral_analysispackage can calculate some Discrete Fourier Transforms. It can calculate frequencies of spectrum, and Discrete Fourier Transforms's coefficients, amplitudes and phases.Graphics packageFunctions graphsThescientific_tools.graphics.function_graphspackage can trace 2D and 3D functions graphs.Uncertainty graphsThescientific_tools.graphics.uncertainty_graphspackage can draw :an uncertainty graph with a function, the function plus its uncertainty and the fonction minus its uncertainty.experimental values with uncertainties bar.a z-score graph : draws the points (or a function) that correspond to z-score and draws the maximum and minimum lines of z-core validity.Spectral analysis graphsThescientific_tools.graphics.spectral_analysis_graphspackage can draw :graphs with amplitudes of Discrete Fourier Transformspectral graphs with phases of Discrete Fourier TransformAbout usLicenseCreative Commons Attribution-NonCommercial-ShareAlike 4.0 International Public License (CC-BY-NC-SA)(Futher information at:https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode)©Cyprien BONTRON(c.b.e.python@gmail.com)ThanksThis framework rely on few others frameworks that are free.
The code is written in Python 3.11 and use :numpymatplotlib
Package: scientio
Roboy ScientIOAboutRoboy ScientIO (from Lat. scientia - knowledge and Input/Output) - a Knowledge Graph Engine to organise and query complex data.DependenciesTo use ScientIO, you will need to have one of it's supported back-ends installed. Currently, the only supported back-end is Neo4j, which may be run in a number of ways
(if you don't have a remote instance available). We recommend simply running it through docker - like this:dockerrun\--publish=7474:7474--publish=7687:7687\--volume=$HOME/neo4j/data:/data\--volume=$HOME/neo4j/logs:/logs\neo4j:3.0InstallationVia PIPThe easiest way to install ScientIO is through pip:pip install scientioFor developersFirst, install dependencies:pipinstall-rrequirements.txtThen, you may open the repository in any IDE, and mark thesrcfolder as a sources root.Basic ScientIO use-casesSupplying an ontology descriptionThe ontology description is a collection of named entity types, where each type may declare a specific set of properties and relationships like this:# my_ontology.yml!OTypeentity:Alien# The name of the ontology type---!OTypeentity:Vulcan# Declare a more specific Alien typemeta:[Alien]properties:# Allowed properties for every Vulcan-name-homeworld-ear_pointiness---!OTypeentity:Human# Declare a more specific Alien typemeta:[Alien]properties:# Allowed properties for every Human-name-homeworldrelationships:[captain_of]# Allowed relationships for every HumanCreating some nodesfromscientio.ontology.ontologyimportOntologyfromscientio.sessionimportSessionfromscientio.ontology.nodeimportNode# Load the ontology from a yaml fileonto=Ontology(path_to_yaml="my_ontology.yml")# Create a session (with default Neo4j backend)sess=Session(ontology=onto,neo4j_address="bolt://localhost:7687",neo4j_username="neo4j",neo4j_password="test")# Get human/vulcan types from ontologyhuman_type=onto.get_type("Human")vulcan_type=onto.get_type("Vulcan")# Create a transient human named "Kirk"kirk=Node(metatype=human_type)kirk.set_name("Kirk")# Create a transient vulcan named "Spock"spock=Node(metatype=vulcan_type)spock.set_name("Spock")# Persist kirk and spocksess.create(kirk)sess.create(spock)Add a relationship between your nodesfromscientio.ontology.ontologyimportOntologyfromscientio.sessionimportSessionfromscientio.ontology.nodeimportNode# Load the ontology from a yaml fileonto=Ontology(path_to_yaml="my_ontology.yml")# Create a session (with default Neo4j backend)sess=Session(ontology=onto,neo4j_address="bolt://localhost:7687",neo4j_username="neo4j",neo4j_password="test")# Get human/vulcan types from ontologyhuman_type=onto.get_type("Human")vulcan_type=onto.get_type("Vulcan")# Create query templates to get the actual kirk/spockkirk=Node(metatype=human_type)spock=Node(metatype=vulcan_type)# Query Kirk and Spock from the database, using# the query nodes we created previously. We're just# gonna assume that the first human is Kirk, and the first# vulcan is Spock.kirk=sess.retrieve(request=kirk)[0]spock=sess.retrieve(request=spock)[0]# Add a relationship between Kirk and Spockkirk.add_relationships({"captain_of":{spock.get_id()}})# Make sure that the new relationship is persistedsess.update(kirk)
Package: scientisst-sense
scientisst-sense-api-pythonThe ScientISST SENSE Python API.Learn how to use it, check examples, and much morehere!DependenciesPySerialInstall it usingpip:pipinstallpyserialInstalling# Getting this repositorygitclonehttps://github.com/scientisst/scientisst-sense-api-python.gitRunningAutomaticPair your deviceRun:pythonsense.pySelect the device from the list displayed:ScientISST devices:
[1] ScientISST-ab-de - 08:3A:F2:49:AB:DE
[2] ScientISST-ac-be - 08:3A:F2:49:AC:BE
Connect to:HitCTRL-Cwhen you wish to stop.Help$ python sense.py -h

usage: sense.py [args] address

description: The program connects to the ScientISST Sense device and starts an acquisition, providing the option to store the received data in a .csv file.

positional arguments:  address               Linux: bluetooth MAC address, Mac: serial port address, Windows: bluetooth serial COM port

optional arguments:
  -h, --help            show this help message and exit
  -f FS, --frequency FS
                        sampling frequency, default: 1000
  -c CHANNELS, --channels CHANNELS
                        analog channels, default: 1,2,3,4,5,6
  -d DURATION, --duration DURATION
                        duration in seconds, default: unlimited
  -o OUTPUT, --output OUTPUT
                        write report to output file, default: None
  -s, --lsl             stream data using Lab Streaming Layer protocol
  -q, --quiet           don't print ScientISST frames
  -v, --verbose         log sent/received bytesManualLinuxPair and trust the ScientISST Sense board:bluetoothctl
scanon
pairXX:XX:XX:XX:XX
trustXX:XX:XX:XX:XXYou can now run thesense.pyscript:pythonsense.pyXX:XX:XX:XX:XXMacFirst, you need to pair the ScientISST sense device in the Bluetooth Settings section.
Then, you'll need to find the serial port address using the Terminal:ls/dev/tty.ScientISST*Copy theStringlike:/dev/tty.ScientISST-XX-XX-SPP_SE.You can now run thesense.pyscript:pythonsense.py/dev/tty.ScientISST-XX-XX-SPP_SEWindowsTurn the ScientISST Sense board on.Now, go to Control Panel > Hardware and Sound > Devices and Printers. Select "Add a device". Select the ScientISST Sense board, hit "next" until its set up.While connected to the board, search "Bluetooth settings" on the Control Panel, then go to the "COM ports" tab and check the port name for theoutgoingentry. Copy theStringlike:COMXYou can now run thesense.pyscript:pythonsense.pyCOMXExampleExample usage to acquire AI1 at 10Hz sample rate (Linux):python3 sense.py -f 10 -c 1 -o output.csv 08:3A:F2:49:AC:D2PlotDependencies:pandasnumpymatplotlibpythonplot_output.pyDisclaimerThis is not a medical device certified for diagnosis or treatment. It is provided to you as is only for research and educational purposes.AcknowledgmentsThis work was partially supported by Fundação para a Ciência e Tecnologia (FCT) under the projects’ UIDB/50008/2020 and DSAIPA/AI/0122/2020 (AIMHealth) through IT—Instituto de Telecomunicações, which is gratefully acknowledged.
Package: scientistmetrics
scientistmetricsAbout scientistmetricsscientistmetricsis aPythonpackage for calculating correlation amongst categorical variables.Why scientistmetrics?The function provides the option for computing one of six measures of association between two nominal variables from the data given in a 2d contingency table:Pearson's chi-squared test :https://en.wikipedia.org/wiki/Pearson%27s_chi-squared_testPhi coefficient :https://en.wikipedia.org/wiki/Phi_coefficientG-test:https://en.wikipedia.org/wiki/G-testCramer's V :https://en.wikipedia.org/wiki/Cramer's_VTschuprow's T :https://en.wikipedia.org/wiki/Tschuprow's_TPearson contingency coefficient :https://www.statisticshowto.com/contingency-coefficient/Notebook is availabled.InstallationDependenciesscientistmetrics requires :Python >=3.10
Numpy >=1.23.5
Pandas >=1.5.3
Plotnine >=0.10.1
Scipy >=1.10.1User installationYou can install scientistmetrics usingpip:pip install scientistmetricsAuthorDuvérier DJIFACK ZEBAZE
Package: scientistshiny
scientistshiny : Python library for multidimensional analysisAbout scientistshinyscientistshinyis aPythonpackage to easily improve multivariate Exploratory Data Analysis graphs.InstallationDependenciesscientistshiny requiresscientisttools>=0.1.3
numpy>=1.26.2
matplotlib>=3.5.3
scikit-learn>=1.2.2
pandas>=1.5.3
mapply>=0.1.21
plotnine>=0.10.1
plydata>=0.4.3
pingouin>=0.5.3
scientistmetrics>=0.0.3
ggcorrplot>=0.0.2User installationYou can install scientisttools usingpip:pip install scientistshinyAuthorDuvérier DJIFACK ZEBAZE (duverierdjifack@gmail.com)
Package: scientisttools
scientisttools : Python library for multidimensional analysisAbout scientisttoolsscientisttoolsis aPythonpackage dedicated to multivariate Exploratory Data Analysis, clustering analysis and discriminant analysis.Why use scientisttools?It performsclassical principal component methods:Principal Components Analysis (PCA)Principal Components Analysis with partial correlation matrix (PPCA)Weighted Principal Components Analysis (WPCA)Expectation-Maximization Principal Components Analysis (EMPCA)Exploratory Factor Analysis (EFA)Classical Multidimensional Scaling (CMDSCALE)Metric and Non - Metric Multidimensional Scaling (MDS)Correspondence Analysis (CA)Multiple Correspondence Analysis (MCA)Factor Analysis of Mixed Data (FAMD)Multiple Factor Analysis (MFA)In some methods, it allowed toadd supplementary informationssuch as supplementary individuals and/or variables.It provides a geometrical point of view, a lot of graphical outputs.It provides efficient implementations, using a scikit-learn API.Those statistical methods can be used in two ways :as descriptive methods ("datamining approach")as reduction methods in scikit-learn pipelines ("machine learning approach")scientisttoolsalso performs some algorithms such asclustering analysisanddiscriminant analysis.Clustering analysis:Hierarchical Clustering on Principal Components (HCPC)Variables Hierarchical Clustering Analysis (VARHCA)Variables Hierarchical Clustering Analysis on Principal Components (VARHCPC)Categorical Variables Hierarchical Clustering Analysis (CATVARHCA)Discriminant AnalysisCanonical Discriminant Analysis (CANDISC)Linear Discriminant Analysis (LDA)Discriminant with qualitatives variables (DISQUAL)Discriminant Correspondence Analysis (DISCA)Discriminant with mixed data (DISMIX)Stepwise Discriminant Analysis (STEPDISC) (onlybackwardelimination is available).Notebooks are availabled.InstallationDependenciesscientisttools requiresnumpy>=1.26.2
matplotlib>=3.5.3
scikit-learn>=1.2.2
pandas>=1.5.3
mapply>=0.1.21
plotnine>=0.10.1
plydata>=0.4.3
pingouin>=0.5.3
scientistmetrics>=0.0.3
ggcorrplot>=0.0.2User installationYou can install scientisttools usingpip:pip install scientisttoolsTutorial are availablehttps://github.com/enfantbenidedieu/scientisttools/blob/master/ca_example2.ipynb
https://github.com/enfantbenidedieu/scientisttools/blob/master/classic_mds.ipynb
https://github.com/enfantbenidedieu/scientisttools/blob/master/efa_example.ipynb
https://github.com/enfantbenidedieu/scientisttools/blob/master/famd_example.ipynb
https://github.com/enfantbenidedieu/scientisttools/blob/master/ggcorrplot.ipynb
https://github.com/enfantbenidedieu/scientisttools/blob/master/mca_example.ipynb
https://github.com/enfantbenidedieu/scientisttools/blob/master/mds_example.ipynb
https://github.com/enfantbenidedieu/scientisttools/blob/master/partial_pca.ipynb
https://github.com/enfantbenidedieu/scientisttools/blob/master/pca_example.ipynbAuthorDuvérier DJIFACK ZEBAZE (duverierdjifack@gmail.com)
Package: scientpyfic
Get the latest news from ScienceDaily.Installation>>> pip install scientpyficDocumentationCan be seenhereExample usage>>> from scientpyfic.client import ScientPyClient
>>>
>>>
>>> client = ScientPyClient()
>>>
>>> all = client.all.all()
>>>
>>> for news in all:
>>>   # news.title
>>>   # news.description
>>>   # news.pub_date
>>>
>>>
>>> top = client.top.top(body=True, journals=True)
>>>
>>> for news in top:
>>>   # news.title
>>>   # news.description
>>>   # news.pub_date
>>>   # news.body
>>>   # news.journalsLicenceMIT
Package: scierror
SciErrorLaboratory report tools in Python.Lab reports just got a whole lot easier.A package for automatic measurement error propagation and linear regressions. Stores measurements and their corresponding uncertainties in a Measurement class which can be propagated using the defined methods. CSV files can be read using the DataFile class and sets of data can be linearly regressed using the LinearRegression class. The latex table function is also useful for quickly transferring data into a preformatted latex table which can be copied into a report.
Package: sciexp2
SciExp² (akaSciExp squareor simplySciExp2) stands forScientific
Experiment Exploration, which provides a framework for easing the workflow of
creating, executing and evaluating experiments.The driving idea of SciExp² is that of quick and effortlessdesign-space
exploration. It is divided into the following main pieces:Launchgen: Aids in defining experiments as a permutation of different
parameters in the design space. It creates the necessary files to run these
experiments (configuration files, scripts, etc.), which you define as
templates that get substituted with the specific parameter values of each
experiment.Launcher: Takes the files of launchgen and runs these experiments on different
execution platforms like regular local scripts or cluster jobs. It takes care
of tracking their correct execution, and allows selecting which experiments to
run (e.g., those with specific parameter values, or those that were not
successfully run yet).Data: Aids in the process of collecting and analyzing the results of the
experiments. Results are automatically collected into a data structure that
maintains the relationship between each result and the parameters of the
experiment that produced it. With this you can effortlessly perform complex
tasks such as inspecting the results or calculating statistics of experiment
sub-sets, based on their parameter values.
Package: sciexp2-expdata
SciExp²-ExpData provides helper functions for easing the workflow of analyzing
the many data output files produced by experiments. The helper functions simply
aggregate the many per-experiment files into a single data structure that
contains all the experiment results with appropriate metadata to identify each
of the experiment results (e.g., using a pandas data frame).It works best in combination with SciExp²-ExpDef, which can be used to define
many experiments based on parameter permutations.You can find the documentation in:https://sciexp2-expdata.readthedocs.io
Package: sciexp2-expdef
SciExp²-ExpDef (akaScientific Experiment Exploration - Experiment Definition)
provides a framework for defining experiments, creating all the files needed for
them and, finally, executing the experiments.SciExp²-ExpDef puts a special emphasis in simplifying experiment design space
exploration, using a declarative interface for defining permutations of the
different parameters of your experiments, and templated files for the scripts
and configuration files for your experiments. SciExp²-ExpDef supports various
execution platforms like regular local scripts and cluster jobs. It takes care
of tracking their correct execution, and allows selecting which experiments to
run (e.g., those with specific parameter values, or those that were not
successfully run yet).You can find the documentation in:https://sciexp2-expdef.readthedocs.io
Package: scif
Scientific Filesystem (SCI-F)The The Scientific Filesystem is an organizational format for scientific software and metadata.
Our goals are centered aroundconsistency,transparency,programmatic accessibility,
andmodularity.Read aboutthe format and
pleasecontribute.CitationVanessa Sochat; The Scientific Filesystem, GigaScience, Volume 7, Issue 5, 1 May 2018, giy023,https://doi.org/10.1093/gigascience/giy023What is this?This module will provide tools for generating and interacting with scientific
filesystems, optimized for use on a host or inside a container.LicenseThis code is licensed under the Mozilla, version 2.0 or laterLICENSE.
Package: sci-fab
Fab - A Build System for Tomorrow!The "Fab" build system aims to provide a quick and easy build process tailored towards a
specific subset of scientific software developers. Quick should be in both use and
operation. Easy should mean the simple things are simple and the complicated things
possible.The tool is not intended for general use outside its intended domain although you are,
of course, welcome to use it there. Just don't expect high priority to be given to
features which do not target scientific software development.LicenceThe software is made available under a 3-clause BSD licence.InstallationYou may simply usepip install sci-fab.UsageAlthough Fab is in its initial development phases right now and much of the
functionality is yet to be added, the command line interface to the tool is
in place and can be run using the commandfab
Package: scifig
scifigscifig is a build tool for scientific figures but it could probably be used for non-scientific figures too.This code basically defines rules to convert sources to final formats such as pdf, eps, svg, etc.
Some rules are defined for gnuplot or tikz figures for examples, but other rules can be defined, it should be easy to do so.In few words, the idea is to drop your sources in a directory, the tool builds them in various formats and export the ready-to-use files in a directory. Each time you drop a new figure or you make edits, scifig works only on what needs to be rebuild.It should provide:less file manipulations (formats, name…)more reproducibilitysource versioningautomatic translationsThis code is a rewritten version of a previous code named SciFigWorkflow. This tool was based on waf. The idea was to use a solid codebase, but it was difficult to maintain and to provide new evolutions to the workflow.DocumentationTo learn more, readhttps://scifig.readthedocs.io
Package: scifit
SciFitComprehensive fits for scientistsWelcome to SciFit project the Python package for comprehensive fits for scientists
designed to ease fitting procedure and automatically perform the quality assessment.The SciFit project aims to support your work by:Providing a clean, stable and compliant interface for each solver;Perform ad hoc transformations, processing and tests on each stage of a solver procedure;Render high quality figures summarizing solver solution and the quality assessment.InstallationYou can install the SciFit package by issuing:python -m pip install --upgrade scifitWhich update you to the latest version of the package.Quick startLet's fit some data:fromscifit.solvers.scientificimport*# Select a specific solver:solver=HillEquationFitSolver()# Create some synthetic dataset:data=solver.synthetic_dataset(xmin=0.0,xmax=5.0,resolution=50,parameters=[3.75,0.21],sigma=0.1,scale_mode="auto",seed=1234,)# Perform regression:solution=solver.fit(data)# Render results:axe=solver.plot_fit()We have a nice adjustments for such noisy data:Or even better a full fit report to check each key points at once:solver.report("hill_report")Which produces a PDF file calledhill_report.pdf.ResourcesDocumentationsRepository