Saravanan666/pypi-org huggingface dataset:
Package: scine-swoose
SCINE - Swoose.. image:: resources/swoose_landscape_low_res.png
:alt: SCINE Swoose.. inclusion-marker-do-not-removeIntroductionThis repository contains the Swoose module of
the SCINE open-source quantum chemistry software.
It provides functionalities for treating large molecular
systems with self-parametrizing system-focused atomistic models.
This includes the automated parametrization of such models and
applying them in single point calculations as well as structure
optimizations or molecular dynamics simulations. Furthermore, this
module also provides QM/MM hybrid models.License and Copyright InformationThis code is licensed under the 3-clause BSD license.
Copyright ETH Zurich, Laboratory of Physical Chemistry, Reiher Group.
See LICENSE.txt for details.Installation and UsageFor instructions on how to install and use Swoose as well as for a detailed
documentation of the entire functionality of Swoose, please consult the user
manual found in themanualdirectory in the repository.
Alternatively the manual can also be found on the official GitHub website,
SCINE website and in the hosted documentation.How to CiteWhen publishing results obtained with Swoose, please cite the corresponding
release as archived on Zenodo.In addition, we kindly request you to cite the following articles when using Swoose:C. Brunken, M. Reiher, "Self-Parametrizing System-Focused Atomistic Models",J. Chem. Theory Comput.,2020,16, 1646-1665.C. Brunken, M. Reiher, "Automated Construction of Quantum-Classical Hybrid Models",J. Chem. Theory Comput.,2021,17, 3797-3813.Support and ContactIn case you should encounter problems or bugs, please write a short message
toscine@phys.chem.ethz.ch.Third-Party Libraries UsedSCINE Swoose makes use of the following third-party libraries:Boost <https://www.boost.org/>_Cereal <https://uscilab.github.io/cereal/>_Eigen <http://eigen.tuxfamily.org>_Google Test <https://github.com/google/googletest>_MongoDB C++ Driver <http://mongocxx.org/>_pybind11 <https://github.com/pybind/pybind11>_yaml-cpp <https://github.com/jbeder/yaml-cpp>
Package: sc-inetbox-adapter
sc_inetbox_adapterAPI adapter for Swisscom Internet BoxInstallation$pipinstallsc_inetbox_adapterUsageTODOContributingInterested in contributing? Check out the contributing guidelines. Please note that this project is released with a Code of Conduct. By contributing to this project, you agree to abide by its terms.Licensesc_inetbox_adapterwas created by Matthias Weis. It is licensed under the terms of the GNU General Public License v3.0 license.DevelopIn the root dir:$python-mvenv.
$source./bin/activate
$poetryinstallTestPlace a file named '''.password''' containing the admin password in the root folder and run the tests:$python-mpytesttestsPublishpoetryconfigpypi-token.test-pypi*TOKEN*
poetrypublish-rtest-pypiCreditssc_inetbox_adapterwas created withcookiecutterand thepy-pkgs-cookiecuttertemplate.
Package: scinet-JoshGoA
SCINETGraph theory abstract data type.scinet.Graphis designed upon thegraph (abstract data type)definition and functions as a bare bones skeletal graph data mapping, containing abstract vertices and edges.Includes DiGraph and MultiGraph support, with HyperGraph capabilities.InstallationInstallPython >= 3.8Installscinet$pipinstallscinetUsageImportscinetimportscinetassnCreate graphG=sn.Graph()Manipulate dataadd_vertexG.add_vertex(vertex:="foo")add_edgeEdges must be assigned using hashable keys so that no name conflicts exist between source_vertex and target_vertex edgeskey=G.add_edge(source_vertex:="foo",target_vertex:="bar"[,edge:="foobar"])remove_vertexG.remove_vertex(vertex:="foo")remove_edgeG.remove_edge(source_vertex:="foo",target_vertex:="bar"[,edge:="foobar"])")adjacent(target_vertex:="bar")inG[(source_vertex:="foo")]>>>Trueneighborsset(G[(vertex:="foo")])>>>{"neighbor_1","neighbor_2",...}Seedocsfor further details.ContributorsJoshGoA-Main contributor-GitHubTODOGraph visualizationCreate "matplotlib.pyplot" supported API
Package: scinet-josugoar
Graph theory abstract data type.scinet.Graphis designed upon thegraph (abstract data type)definition and functions as a bare bones skeletal graph data mapping, containing abstract vertices and edges.Includes DiGraph and MultiGraph support, with HyperGraph capabilities.InstallationInstallPython >= 3.8Installscinet$pipinstallscinet-josugoarUsageImportscinetimportscinetassnCreate graphG=sn.Graph()Manipulate dataadd_vertexG.add_vertex(vertex:="foo")add_edgeEdges must be assigned using hashable keys so that no name conflicts exist between source_vertex and target_vertex edgeskey=G.add_edge(source_vertex:="foo",target_vertex:="bar"[,edge:="foobar"])remove_vertexG.remove_vertex(vertex:="foo")remove_edgeG.remove_edge(source_vertex:="foo",target_vertex:="bar"[,edge:="foobar"])")adjacent(target_vertex:="bar")inG[(source_vertex:="foo")]>>>Trueneighborsset(G[(vertex:="foo")])>>>{"neighbor_1","neighbor_2",...}Seedocsfor further details.Contributorsjosugoar-Main contributor-GitHub
Package: scine-utilities
IntroductionThis repository contains functionality which is used in most SCINE modules.
It is vital for the correct functioning of all SCINE modules, but it does not
directly provide any functionality for end users. Therefore, only developers
of SCINE need to directly interact with this repository.License and Copyright InformationFor license and copyright information, see the fileLICENSE.txtin this
directory.Installation and UsageAs a user of one of the SCINE modules (such as Sparrow), you do not need
to set up SCINE Utilities yourself. Instead, this is done as part of the
installation process of the respective SCINE module. Therefore, the following
instructions are only necessary for developers of SCINE, or those interfacing
this library directly.DependenciesRequired software, minimum required versions in brackets, for this SCINE project are:A C++ compiler supporting the C++17 standardCMake (3.9)Boost (1.65.0)Eigen3 (3.3.2)InstallationIn order to compile this as a SCINE developer, execute the following
commands:git submodule init
git submodule update
mkdir build
cd build
cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=../inst -DSCINE_BUILD_PYTHON_BINDINGS=ON ..
make -j 4
make UtilsOSDocumentation
make test
make installKnown IssuesDue to abugin boost
version 1.69.0, linkage against this version will result in a leakage
of file handles if the ORCA and Gaussian Calculators are called repeatedly.Support and ContactIn case you should encounter problems or bugs, please write a short message
toscine@phys.chem.ethz.ch.Third-Party Libraries UsedSCINE Utilities makes use of the following third-party libraries:BoostEigenGoogle TestIRCLBFGSBpybind11Spglibyaml-cpp
Package: scine-xtb-wrapper
IntroductionSCINE XTB Wrapper is a wrapper aroundxtb, it
exports:GFN0-xTBGFN1-xTB (formerly GFN-xTB)GFN2-xTBGFN-FFinto the SCINE tool chain.
Each method is represented by its ownCalculatorand the entire wrapper
constitutes a SCINE module that can be loaded dynamically at runtime.
For more information on these concepts see theScine::Corerepository.License and Copyright InformationThe SCINE XTB wrapper is distributed under the BSD 3-clause “New” or “Revised”
License. For more license and copyright information, see the fileLICENSE.txtin the repository.Note: this license does not cover the originalxtbsource code.
For the copyright information of thextbcode please follow the linked git
submodule to the developers’ repository.Installation and UsageThe wrapper can be built and installed using the following commands:export INSTALL_PATH=<desired path>
git submodule init
git submodule update
mkdir build
cd build
cmake -DCMAKE_BUILD_TYPE=Release -DSCINE_BUILD_PYTHON_BINDINGS=ON -DCMAKE_INSTALL_PREFIX=$INSTALL_PATH ..
make -j<number of cores to use>
make installThis will generate and install both the mainxtbcode and the wrapper in the
form of the filextb.module.sothat can be used in SCINE.In order to make XTB available to SCINE the following two environment variables
need to be set:export XTBPATH=$INSTALL_PATH/share/xtb
export SCINE_MODULE_PATH=$SCINE_MODULE_PATH:$INSTALL_PATH/libAfterwards, SCINE programs such asReaDuctwill pick up XTB’s existence and it will be possible to request the implemented
methods.The SCINE XTB wrapper is also available via Python.
The underlying SCINE module can be loaded and its implemented calculators
accessed using the standardscine_utilitiesPython bindings.
A minimal workflow could look like this:import scine_utilities as su
import scine_xtb_wrapper

# Generate Structure
structure = su.AtomCollection()
structure.elements = [su.ElementType.H, su.ElementType.H]
structure.positions = [[-0.7, 0, 0], [0.7, 0, 0]]

# Get calculator
calculator = su.core.get_calculator('GFN2', 'xtb')

# Configure calculator
calculator.structure = structure
calculator.set_required_properties([su.Property.Energy, su.Property.Gradients])

# Calculate
results = calculator.calculate()
print(results.energy)
print(results.gradients)How to CiteWhen publishing results obtained with the SCINE XTB wrapper, please cite the corresponding
release as archived onZenodo(DOI
10.5281/zenodo.5782861; please use the DOI of the respective release).This wrapper should also not be mistaken for the actualxtbcode it wraps.
For the latter code and its citations, we refer you to the originalxtbrepository. There you will find the references of the actual methods used.
They are listed in theREADME.md.Support and ContactIn case you should encounter problems or bugs with the wrapper, please write a
short message toscine@phys.chem.ethz.ch.
Package: scing
SCING: Single-Cell pIpeliNe GardenPronounced as "sing" /siŋ/Unified framework for building and running single-cell computational pipelines______     ______     __     __   __     ______
/\  ___\   /\  ___\   /\ \   /\ "-.\ \   /\  ___\
\ \___  \  \ \ \____  \ \ \  \ \ \-.  \  \ \ \__ \
 \/\_____\  \ \_____\  \ \_\  \ \_\\"\_\  \ \_____\
  \/_____/   \/_____/   \/_/   \/_/ \/_/   \/_____/PipelineDescriptionVersionSEQCSingle-cell & Single-nucleus RNA-seq 3' Preprocessor0.2.11SEQC AdaSEQC AutomateD Analysis0.0.4Sharp (♯)Demultiplexing Hashtag, CITE-seq, CellPlex, and ASAP-seq0.1.1VelopipeRNA Velocity for SEQC0.0.9FastQCA high throughput sequence QC analysis tool0.11.9TransgenesCreating a reference package with transgenes0.0.8Cell Ranger GEXSingle-cell gene expression (3' and 5')6.1.2Cell Ranger V(D)JSingle-cell immune profiling (TCR/BCR)6.1.2Cell Ranger ATACSingle-cell chromatin accessbility (ATAC)2.1.0Cell Ranger ARCSingle-cell multiome ATAC + Gene Expression2.0.0Space RangerSingle-cell spatial gene expression1.3.1CellPlexCell multiplexing6.1.2mkrefCreating a human+mouse hybrid genome0.0.6ArchRProcessing and analyzing single-cell ATAC-seq data0.1.0Coming SoonPipelineDescriptionMito TracingLineage tracing using mitochondrial mutationsPrerequisitesTo use SCING, you need:Cromwell: a workflow management system for scientific workflows developed by the Broad InstituteAmazon Web Services, Google Cloud Platform, Microsoft Azure, or HPC (with LSF, Slurm, ...)If you need information about how to install Cromwell on Cloud/HPC, please follow the instructions below:Amazon Web ServicesAmazon Genomics Workflow:https://github.com/hisplan/cromwell-gwf-setupAmazon Genomics CLI (AGC): TBDGoogle Cloud Platform: TBDMicrosoft Azure: TBDHPC with LSF: TBDInstall CLI (Command-Line Interface)condacreate-nscingpython=3.8pip
condaactivatescing
gitclonehttps://github.com/hisplan/scing.gitcdscing
pipinstall.If you are a developer of SCING, additionally install either JRE or JDK. Here are some options for installing JRE or JDK:JRE (Java 8 packaged by Cyclus):condainstall-ccyclusjava-jreJDK (Zulu OpenJDK v11):condainstall-cconda-forgeopenjdkOn HPC:moduleaddjava/11.0.12Build ContainersAll the required docker containers are pre-built and publicly available/accessible viaquay.io/hisplan, thus building the containers are optional. If you want to build the docker containers on your own and push them to your own docker registry, please follow the instructionshere. Otherwise, skip to the Install section.Install PipelinesRun the following command to install all the pipelines:scinginstall--config=config.yaml--home$HOME/scing/binGo to$HOME/scing/binand extract everything:cd$HOME/scing/bin
ls-1*.tar.gz|xargs-I{}bash-c"tar xvzf {} && rm -rf {}"
Package: scinode
SciNodeA platform for designing node-based workflows for science and engineering.Featureseasy to design computational workflow and reusable components.execute the workflow on the local or remote computer.easy to control the nodetree: reset, pause, play and cancel nodes.suitable for both programmers and non-programmers.easy to share ready-to-use components and workflow templates.support high throughput calculation.Different from other node-base workflowsNodetree data is stored in the database. A nodetree can be fully reconstructed from the database.For long-running jobs, thus the execution does not provide instant feedback.Demo siteTry it here:https://scinode-app.herokuapp.com/Installationpip install --upgrade --user scinodeDocumentationCheck thedocsand learn about the features.ExamplesA simple math calculationfromscinode.nodetreeimportNodeTreent=NodeTree(name="example")float1=nt.nodes.new("Float",value=2.0)float2=nt.nodes.new("Float",value=3.0)add1=nt.nodes.new("Operator",operator="+")nt.links.new(float1.outputs[0],add1.inputs[0])nt.links.new(float2.outputs[0],add1.inputs[1])nt.launch()LicenseMIT
Package: scinot
This package expresses numbers in scientific notation, in formatted
strings. Its intended use is to make computational results easier to read,
especially when using a REPL like IPython. If using IPython, output is color-coded,
to visually diferentiate the base and power.Installation:pipinstallscinotPython 2 is unsupported, due to unicode handling.Use: Run scinot.start() to format REPL output and printing as scientific notation.341283875012.238>> 341283875012.238importscinotscinot.start()341283875012.238>> 3.413 x 1011Call scinot.end() to return to remove parsing:scinot.end()341283875012.238>> 341283875012.238You can specify the number of significant figures to display with start,
and how long the number must be to invoke scientific notation. It defaults
to 4 significant figures, and order-of-magnitude 4:scinot.start(sigfigs=2,thresh=3)15>> 15152>> 1.5 x 102Call scinot.format() to return a string in scientific notation:scinot.format(341283875012.238)>> ‘3.413 x 1011’You can also specify the number of significant figures to display; it
defaults to 3.scinot.format(-.00000409348,2)>> ‘-4.1 x 10-6’Call scinot.sciprint() instead of scinot.format() to print the result
directly, rather than returning a string. format and sciprint both take two
arguments: The number, and optionally, the amount of significant figures.If you’re running Python in a Windows terminal and see squares instead of
exponents, try a different font, like Source Code Pro. Scinot’s start() behavior
will not work if sympy.init_printing() is activated.I’ve built this module with my own use-case in mind, and have likely overlooked
features that would extend and improve functionality. If you have an idea,
please contact me, or submit a pull request.Note: Color, and the proper times symbol are used in the package, but are not
displayed in this readme due to RST limitations.
Package: scintillant
Scintillant Bot FrameworkA framework for instantly creating chat bots based on other popular tools.
At the moment, the framework supports the development of skills for the popular chatbot Lilia.Installationpip install scintillant==0.0.7UsingTo quickly create a skill template, use the command:>> snlt bottleQuick StartCreate a directory in which you will work>> mkdir my_test_skillCreate a virtual environment in which you will install the necessary dependencies for work, including the Scintillant framework:>>py-mvenvenv
>>sourceenv/Scripts/activateInstall the Scintillant framework. It is also included in the list of dependencies for each skill template.(env)>>pipinstallscintillantAfter successful installation, you need to get the latest version of the skill template.
Run the command(env) >> snlt bottleand follow the instructions.When choosing a working directory, select the current directory (.) Or leave the field blank to create the template in a subfolder with the skill name.Install the remaining dependencies and run the skill.(env)>>pipinstall-rrequirements.txt(env)>>pymanage.pyProject setupIn the .env file, you can find the starting configurations of the project.Most addictions are easy to change and not viral. At the moment, the core of the skill is the Bottle framework, but you can easily replace it with AioHTTP or FastAPI.In the future, it will be possible to receive versions of templates based on other popular web frameworks, as well as on pure WSGI (werkzeug).
Package: sciogovterminal
Introduction:https://mp.weixin.qq.com/s/aMskzjGkb0PQBHD0Z0O0_gSciogovterminalSciogovterminal: Browse "The State Council Information Office of the People's Republic of China" in the terminal.
You can star this repository to keep track of the project if it's helpful for you, thank you for your support.InstallPip installrun "pip install sciogovterminal"Source code install(1)Offline
Step1:gitclonehttps://github.com/CharlesPikachu/sciogovterminal.git
Step2:cdsciogovterminal->run"python setup.py install"(2)Online
run"pip install git+https://github.com/CharlesPikachu/sciogovterminal.git@master"Quick StartAfter installing sciogovterminal, you can execute the command in the terminal like:sciogov -i http://www.scio.gov.cn/m/37234/Document/1720965/1720965.htmThen, you can browse《2021年美国侵犯人权报告》in the terminal as follows:Projects in Charles_pikachuGames: Create interesting games by pure python.DecryptLogin: APIs for loginning some websites by using requests.Musicdl: A lightweight music downloader written by pure python.Videodl: A lightweight video downloader written by pure python.Pytools: Some useful tools written by pure python.PikachuWeChat: Play WeChat with itchat-uos.Pydrawing: Beautify your image or video.ImageCompressor: Image compressors written by pure python.FreeProxy: Collecting free proxies from internet.Paperdl: Search and download paper from specific websites.Sciogovterminal: Browse "The State Council Information Office of the People's Republic of China" in the terminal.CodeFree: Make no code a reality.DeepLearningToys: Some deep learning toys implemented in pytorch.DataAnalysis: Some data analysis projects in charles_pikachu.Imagedl: Search and download images from specific websites.MoreWeChat Official AccountsCharles_pikachu
Package: sciope
READMEScalable inference, optimization and parameter exploration (sciope)
is a Python 3 package for performing machine learning-assisted inference and model
exploration by large-scale parameter sweeps. Please see thedocumentationfor examples.What can the sciope toolbox do?Surrogate Modeling:train fast metamodels of computationally expensive problemsperform surrogate-assisted model reduction for large-scale models/simulators (e.g., biochemical reaction networks)Inference:perform likelihood-free parameter inference using parallel ABCtrain surrogate models (ANNs) as expressive summary statistics for likelihood-free inferenceperform efficient parameter sweeps based on statistical designs and sampling techniquesOptimization:optimize a specified objective function or surrogate model using a variety of approachesModel exploration:perform large distributed parameter sweep applications for any black-box model/simulator which output time series datagenerates time series features/summary statistics on simulation output and visualize parameter points in feature spaceinteractive labeling of paramater points in feature space according to the users preferences over the diversity of model behaviorssupports semi-supervised learning and downstream classifiersVersion 0.4How do I get set up?Please see thedocumentationfor instructions to install and examples. The easiest way to start using Sciope is through the StochSS online platform (https://app.stochss.org).Steps to a successful contributionFork Sciope (https://help.github.com/articles/fork-a-repo/)Make the changes to the source code in your fork.Check your code with PEP8 or pylint. Please limit text to 80 columns wide.Each feature or bugfix commit should consist of the corresponding code, tests, and documentation.Create a pull request to the develop branch in Sciope.Please feel free to use the comments section to communicate with us, and raise issues as appropriate.The pull request gets accepted and your new feature will soon be integrated into Sciope!Who do I talk to?Prashant Singh (prashant.singh@it.uu.se)Fredrik Wrede (fredrik.wrede@it.uu.se)Andreas Hellander (andreas.hellander@it.uu.se)Citing SciopeTo cite Sciope, please reference theBioinformatics application note. Sample Bibtex is given below:@article{sciope,
    author = {Singh, Prashant and Wrede, Fredrik and Hellander, Andreas},
    title = "{Scalable machine learning-assisted model exploration and inference using Sciope}",
    journal = {Bioinformatics},
    year = {2020},
    month = {07},
    issn = {1367-4803},
    doi = {10.1093/bioinformatics/btaa673},
    url = {https://doi.org/10.1093/bioinformatics/btaa673},
    note = {btaa673},
    eprint = {https://academic.oup.com/bioinformatics/advance-article-pdf/doi/10.1093/bioinformatics/btaa673/33529616/btaa673.pdf},
}
Package: sciopy
This package offers the serial interface for communication with an EIT device from ScioSpec. Commands can be written serially and the system response can be read out. With the current version, it is possible to start and stop measurements with defined burst counts and to read out the measurement data. In addition, the measurement data is packed into a data class for better further processing.Install RequirementsAll requirements are provided inside therequirements.txt. To install them navigate inside the sciopy directory and type:pip3 install -r requirements.txt # Linux, macOS, Windows
pip install -r requirements.txt  # WindowsRun Example ScriptFor a single measurement, you can simply run one of theexamplescripts using the command:python custom_measurement.pyTo find the right port you can use:from sciopy import available_serial_ports
available_serial_ports()This script establishes a serial connection to the ScioSpec device, sends the measurement configuration, and starts a
measurement. For a successful measurement with 16 electrodes, you have to plug in the 16 electrodes to the port "channel 1-16" at the ScioSpec device. For saving the data, setsave = Trueand insert a valids_pathto thescio_spec_measurement_configat the beginning of the script. If you don't change the path the files will be saved to the current directory.The example scriptprep_data_for_ml.pycan be used for the conversion of a finished measurement.
This script creates a new folder with the ending_preparedand puts together the potential values and object positions for all measurements. This could be useful for later application of machine learning.Explanation of stored files (.npz)potential matrix(e.g. variable P) is a 16x16 matrix (n_el=16). If you visualize it usingfrom sciopy import plot_potential_matrixyou can recognize the used excitation pattern or if an electrode is a defect.p_with_excis the matrix P with the excitation electrodesp_without_excis the matrix P without the excitation electrodesabs_p_norm_without_extis the matrix, normalized between (I think) 0-1 without the excitation electrodes.v_with_extis the computed voltage from the potential values containing the excitation electrodesv_without_extis the computed voltage from the potential values without the excitation electrodesabs_v_norm_without_extis the voltage data, normalized between 0-1 without the excitation electrodes.configcontains some information regarding the measurement procedure.ContactIf you have ideas or other advice don't hesitate to contact me!Email:jacob.thoenes@uni-rostock.de