Saravanan666/pypi-org huggingface dataset:
Package: scimma-client
SCiMMA Clientscimma-clientis a pub-sub client library for Multimessenger Astrophysics.QuickstartPublish a GCN to Kafka:scimma publish -b kafka://hostname:port/gcn mygcn.gcn3An example RFC 822 formatted GCN circular (example.gcn3) is provided intests/data.Clientconfigurationproperties can be passed toscimma publishvia-X property=valueor in a configuration
file specified by-F <config-file>, mimicking the behavior ofkafkacat. This can be
used to connect to a Kafka broker with SSL authentication enabled, for example.InstallationYou can install scimma-client either via pip, conda, or from source.To install with pip:pip install -U scimma-clientTo install with conda, you must use the channel from the SCiMMA Anaconda organization:conda install --channel scimma scimma-clientTo install from source:tar -xzf scimma-client-x.y.z.tar.gz
cd scimma-client-x.y.z
python setup.py installDevelopmentA Makefile is provided to ease in testing, deployment and generating documentation.A list of commands can be listed withmake help.In addition, two extras are provided when installing the scimma client that installs
the required test and documentation libraries:pip install -U scimma-client[dev,docs]To mark a new version, use Github tags to mark your commit with asemverversion:git tag v0.0.1To release a new version and upload to package repositories, push your tag after pushing your commit:git push --tags
Package: scimotf
sci-moTFsci-moTF is a very simple package to help with finding motifs that are enriched in different clusters, that are also
expressed in your dataset and make it easier to draw inferences on which TFs may be driving the observed changes.Installpip install scimotfThere are two ways to run scimotf, 1) using DoRoTHea, 2) using FIMO.Example usingDoRothEA:from scimotf import SciMotf_Doro

rcm_file = f'file output from the scircm package'
tf_file = 'dorothea_hs_ABCD.csv' # File downloaded from DoRothEA
mo = SciMotf_Doro(doro_file=tf_file, cluster_file=rcm_file, 
                 cluster_gene_id='external_gene_name', # got to match motif
                 padj_protein='column with your protein padj value',
                  logfc_protein='column with the protein logFC', 
                  padj_rna='column with the RNA padj',
                  logfc_rna='column with the RNA logFC', 
                  output_dir='')

# Run with the letters your interested in (i.e. A, B, C, D) see doro paper for deets
df = mo.run(['A'], rcm_clusters=["TMDE", "TMDS", "MDS", "MDS_TMDE", "MDE", "MDE_TMDS", "TPDE", "TPDE_TMDS", "TPDS", "TPDS_TMDE",])
df.to_csv(f'scimotif_DORO_A.csv')Plot the resultsfrom scimotf import plot_cluster_tf
plot_cluster_tf(f'scimotif_DORO_A.csv', save_fig=True, fig_dir='')Example using FIMO:The input to scimotf is: 1) the output ofFIMO, fimo.tsv, 2) a csv file with gene identifier (e.g. name), cluster, log2FC,
and p-value.Example format for fimo.tsvmotif_id        motif_alt_id    sequence_name   start   stop    strand  score   p-value q-value matched_sequence
SP5_MOUSE.H11MO.0.C             Gh      1668    1691    -       32.7879 9.78e-16        4e-09   GGGGGGGAGGGGGAGGGGGAGGGGExample format for cluster.csvgene_name,cluster,log2FC,padj
Hoxa9,hindbrain,-2.8,0.00031sci-TF will output two files, 1) scitf_detailed.csv, and 2) scitf_summary.csv.sictf_motif_merged_fp-0.05_cp-1.0.csvThis gives a detailed output of each TF that was potentially able to bind to genes in a cluster.cluster,motif,p-value,q-value,odds-ratio,count-genes-in-cluster,count-genes-bg,remainder-cluster,remainder-bg,tf-log2FC,tf-padj,tf-cluster,%-coverage,genesOverviewFilter fimo.tsv and remove any motifs that don't meet the p or qvalue thresholdFilter any motifs in fimo.tsv that don't exist in the users input data (have a 0 logFC)For each TF for each cluster, count how many genes exist and perform a FET w.r.t the backgroundadjust p-valuessummarise the identified TFsPlease post questions and issues related to sci-moTF on theIssues page_section of the GitHub repository.
Package: scimpy
Scimpy is an open-source, cross-platform loudspeaker design tool. Features include:Modeling speaker impedance, phase, SPL, and group delay from TS ParametersMeasuring speaker impedance using your sound card as a signal generator and
data acquisition systemExtract TS parameters from measured results and downloaded ZMA files.Loudspeaker cabinet design: the tool will calculate speaker performance (SPL
and group delay) for sealed and vented box designs. Will calculate “optimal”
cabinet dimensions for traditional speaker alignments (B2 closed box,
QB4-B4-C4)A complete book covering speaker design theoryScimpy is short for “Sound Card Impedance Measurements in PYthon”General Python Requirements:Python 2 or 3, scipy, numpy, pyaudio, matplotlib, pandas and either pyqt4 or pysideDebian/Ubuntu development environment & installation:sudo apt-get install python3-scipy python3-pyaudio python3-matplotlib python3-pyside python3-pandas
python3 setup.py installWindows Python Environment & Scimpy Installation:Full install (LARGE), comes with spyder IDE and many other python packagesinstall anaconda (https://www.continuum.io/downloads), open anaconda
console and then in the anaconda console run “pip install pyaudio”.If you want more control over the sound card, you can use a version of
pyaudio built with more APIs available. Download pyaudio from:http://www.lfd.uci.edu/~gohlke/pythonlibs/then open the anaconda
console and install pyaudio with “pip install
PyAudio-0.2.9-cp35-none-win_amd64.whl” replacing
PyAudio-0.2.9-cp35-none-win_amd64.whl with the name of the file you
downloaded.Minimal install:Install miniconda (32bit, even if you have 64 bit - makes things easier)
from:http://conda.pydata.org/miniconda.htmlOpen Windows PowerShell (Start Menu, search for “Windows PowerShell”)
and type the following commands:conda update conda
conda install matplotlib scipy numpy
pip install pyaudio
cd LOCATION_WHERE_SCIMPY_WAS_DOWNLOADED
python run.pyhave fun!How to build Windows binariesPyInstaller works. First install pyinstaller:pip install pywin32 pyinstaller
conda install setuptools=19.2(downgrading setuptools:https://github.com/pyinstaller/pyinstaller/issues/1781)The runpyinstaller -F run.pyto get a single executable in dist/BookLaTeX (e.g., MiKTeX)LicenseCode: GPL3Book/Documentation: CC-BY-SA 4.0
Package: scimschema
ScimSchemaValidate JSon content given a predefined set of SCIM Schemas (in JSON representation format) as specified inSCIM(supporting Python 3+).Example use caseInstall the library via pip:pipinstallscimschemaSpecify any custom schemas in json format as per the rfc requirement:https://tools.ietf.org/html/rfc7643#section-2Put the json files under a Python package as per our examples here:https://github.com/GordonSo/scimschema/tree/master/tests/extension(also checkout our __init__() file which is handy for loading the json)Import the`validate`method from scimschema and pass in json response/request content and the extension schemas to assert its validnessTo step through the above in working code, check out this test:test_scim_schema.py.fromscimschemaimportvalidatefrom.importextension# <- this is the custom schemas define by your: see https://github.com/GordonSo/scimschema/tree/master/tests/extension for example# A sample schema, like what we'd get from response.get(<scim entity url>).json()content={"schemas":["urn:ietf:params:scim:schemas:core2:2.0:Group","urn:huddle:params:scim:schemas:extension:2.0:SimpleAccount"],"id":"2819c223-7f76-453a-919d-413861904646","externalId":9,"meta":{"resourceType":"User","created":"2011-08-01T18:29:49.793Z","lastModified":"Invalid date","location":"https://example.com/v2/Users/2819c223...","version":"W\/\"f250dd84f0671c3\""}}validate(data=content,extension_schema_definitions=extension.schema)>>>E_scimschema._model.scim_exceptions.AggregatedScimMultValueAttributeValidationExceptions:Found1aggregatedexceptionsatScimresponse:>>>EScimAttributeValueNotFoundException:>>>E'Single-value attribute:ipRestrictionsEnabled'isrequiredatthefollowinglocation'['urn:huddle:params:scim:schemas:extension:2.0:Account', 'ipRestrictionsEnabled']'butfound'{}'>>>!!!!!!!!!!!!!!!!!!!Interrupted:1errorsduringcollection!!!!!!!!!!!!!!!!!!!FeaturesSupport forSCIM 2.0,Validate SCIM Schema definitionValidate Model (schema) Id, Name, description, attributesValidate Attribute (schema) Name, Type, Required, Canonical Values, Mutability, Returned, UniquenessValidate JSON Content against SCIM SchemaValidate significant value against Type (Binary, Boolean, Datetime, Decimal, Integer, Reference, String, Complex, MultiValued)Characteristics Required, Canonical Values, UniquenessUpcoming featuresValidate JSON Content for characteristics below:Mutability, ReturnedRunning the Test SuiteThe project requirespoetryThe project requirespytestto discover tests, and it complies to PEP 517 via Poetry (see pyproject.toml)
Github Actions are to run on commit as part of CI and automatic deployments.Creating new releaseUpdate scimschema/VERSION and pyproject.toml
Merge intoreleasebranchContributingThis project is powered by the QA department atHuddleThe source code is available onGitHub.Get in touch, via GitHub or otherwise, contributors are also welcome!
Package: sc-inclusive-analysis
A simple Python projectThis is a simple python project.InstallationIt is possible to install the tool withpip:pip install sc-inclusive-analysisConfigurationConfiguration files reading in this order, the first is the top most priority:production.xml in current directory,production.xml in <project_name> directory under User directory,production.xml in <project_name> directory under /var/opt/sc/ directory,default.xml in <project_name> directory under /var/opt/sc/ directory.The default configuration file looks like this:dev:
  # whether this program is running is development mode
  dev_mode: FalseLicenseThe script is released under the MIT License.  The MIT License is registered
with and approved by the Open Source Initiative[1].[1]https://opensource.org/licenses/MIT
Package: sc-inclusive-balance-detail-analysis
A simple Python projectThis is a simple python project.InstallationIt is possible to install the tool withpip:pip install sc-inclusive-balance-detail-analysisConfigurationConfiguration files reading in this order, the first is the top most priority:production.xml in current directory,production.xml in <project_name> directory under User directory,production.xml in <project_name> directory under /var/opt/sc/ directory,default.xml in <project_name> directory under /var/opt/sc/ directory.The default configuration file looks like this:dev:
  # whether this program is running is development mode
  dev_mode: FalseLicenseThe script is released under the MIT License.  The MIT License is registered
with and approved by the Open Source Initiative[1].[1]https://opensource.org/licenses/MIT
Package: scine-art
SCINE Art: Automated Reaction TemplatesIntroductionWith SCINE Art you can extract reaction templates from complex chemical reaction
networks in an automated fashion. Based on this Python framework, workflows can
be built that apply the extracted templates to new network explorations.License and Copyright InformationArt is distributed under the BSD 3-clause “New” or “Revised” License.
For more license and copyright information, see the fileLICENSE.txtin the
repository.InstallationPrerequisitesThe key requirements for Art are the Python packagesscine_utilitiesandscine_molassember. Optionally thescine_databasecan be used.
These packages are available from PyPI and can be installed usingpip.
However, these packages can also be compiled by hand. For the latter case please
visit the repositories of each of the packages and follow their guidelines.InstallationArt can be installed using pip (pip3) once the repository has been cloned:gitclone<art-repo>pipinstall./artA non super user can install the package using a virtual environment, or
the--userflag.The documentation can be found online, or it can be built using:cdartmake-CdocshtmlIt is then available at:<browsername>docs/build/html/index.htmlIn order to build the documentation, you need a few extra Python packages wich
are not installed automatically together with Art. In order to install them,
runcdartpipinstall-rrequirements-dev.txtHow to CiteWhen publishing results obtained with Art, please cite the corresponding
release as archived onZenodo(please use the DOI of the respective release).In addition, we kindly request you to cite the following article when using Art:J. P. Unsleber, “Accelerating Reaction Network Explorations with Automated Reaction
Template Extraction and Application”,J. Chem. Inf. Model.,2023,63, 3392.Support and ContactIn case you should encounter problems or bugs, please write a short message
toscine@phys.chem.ethz.ch.
Package: scine-database
IntroductionThe SCINE database module is a database wrapper for a MongoDB encoding reaction networks.License and Copyright InformationFor license and copyright information, see the fileLICENSE.txtin this
directory.Installation and UsageThe following software packages are required in order to compile the SCINE Database:A C++ compiler supporting the C++17 standard (GCC at least 7.3.0 or later)CMake (at least version 3.9.0)Eigen3 (at least version 3.3.2 or later)MongoDB C++ Driver (at least version 3.4.0)Boost (recommended: version 1.65.0 or later)Furthermore the database compilation will require the SCINE Utilities module,
and download it automatically if it is not present.The SCINE database repository includes a Git submodule; either clone the repository
recursively:git clone --recurse-submodules https://github.com/qcscine/database.gitor initialize and update the submodules after a regular clone:git clone https://github.com/qcscine/database.git scine_database
cd scine_database
git submodule update --initThe SCINE database module can be built using a standard CMake/make setup:mkdir build
cd build
cmake -DSCINE_BUILD_PYTHON_BINDINGS=ON ..
make
make test
make installNote that the tests, by default, require a MongoDB to be running on the local host.
Alternatively the-DTEST_MONGO_DB_IP=XXXflag can be set in the CMake configure
step to route the test executable to another database. For MongoDB, use at least
version 4.2.0.For minimal usage examples please see the user manual provided in this repository
or check the latest online version on theSCINE web page.How to CiteWhen publishing results obtained with the SCINE database wrapper, please cite the corresponding
release as archived onZenodo(DOI 10.5281/zenodo.6695495;
please use the DOI of the respective release).In addition, we kindly request you to cite the following article when using the SCINE database wrapper:
J. P. Unsleber, S. A. Grimmel, M. Reiher,
“Chemoton 2.0: Autonomous Exploration of Chemical Reaction Networks”,J. Chem. Theory Comput.,2022,18, 5393.Support and ContactIn case you should encounter problems or bugs, please write a short message
toscine@phys.chem.ethz.ch.Third-Party Libraries UsedSCINE Database makes use of the following third-party libraries:BoostEigenGoogle TestMongoDB C++ Driverpybind11
Package: scine-kinetx
SCINE - KiNetx Python BindingsIntroductionThis repository contains functionality which is used in SCINE to model reaction
kinetics and concentration flows in reaction networks.Installation and UsageWe currently offer only amanylinux2014build for Linux platforms. This may
be expanded in the future. If you are on a different platform, you can build
the Python bindings from source (https://github.com/qcscine/kinetx/).Support and ContactIn case you should encounter problems or bugs, please write a short message
toscine@phys.chem.ethz.ch.
Package: scine-molassembler
Molassembler libraryOverviewMolassembler is a C++ library that aims to facilitate crossings between
Cartesian and graph representations of molecules. It provides the necessary
functionality to represent a molecule as a graph, modify it in graph space, and
generate coordinates from graphs. It can capture the absolute configuration
of multidentate and haptic inorganic molecules from positional data and
generate non-superposable stereopermutations as output.
Package: scine-readuct
IntroductionSCINE ReaDuct is a command-line tool that allows you to carry outsingle point calculations,bond order calculations,Hessian calculations,structure optimizations,single-ended transition state searches,double-ended B-Spline transition state searches,intrinsic reaction coordinate (IRC) calculations,artificial force induced reaction (AFIR) calculations, andNewton trajectory scans searching for transition state guesses.For these calculations, it relies on a backend program to provide the necessary
quantum chemical properties (such as nuclear gradients). Currently, SCINE Sparrow,
XTB, CP2K, Gaussian, ORCA, Serenity, and Turbomole are supported as backend programs.License and Copyright InformationReaDuct is distributed under the BSD 3-clause “New” or “Revised” License.
For more license and copyright information, see the fileLICENSE.txtin the
repository.Installation and UsageFor instructions on how to install and use ReaDuct as well as for a detailed
documentation of the entire functionality of ReaDuct, please consult the user
manual found in themanualdirectory in in the repository.
Alternatively the manual can also be found on the official GitHub website
and on the SCINE website.How to CiteWhen publishing results obtained with ReaDuct, please cite the corresponding
release as archived onZenodo(DOI
10.5281/zenodo.3244107; please use the DOI of the respective release).In addition, we kindly request you to cite the following article when using ReaDuct:A. C. Vaucher, M. Reiher, “Minimum Energy Paths and Transition States by Curve
Optimization”,J. Chem. Theory Comput.,2018,16, 3091.Support and ContactIn case you should encounter problems or bugs, please write a short message
toscine@phys.chem.ethz.ch.Third-Party Libraries UsedSCINE ReaDuct makes use of the following third-party libraries:BoostCerealEigenIRCGoogle Testpybind11yaml-cpp
Package: scine-serenity-wrapper
IntroductionSCINE: Serenity Wrapper is a wrapper aroundSerenity; it exports the following
methods:Density Functional Theory (DFT)Hartree-Fock (HF)(Local) Coupled Cluster (CC, DLPNO-CC)into 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 Serenity 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 original Serenity source code.
For the copyright information of the Serenity code please follow the linked
git submodule to the developers repository.Installation and UsageThe wrapper can be built and installed using the following commands:git submodule update --init
mkdir build
cd build
cmake -DCMAKE_BUILD_TYPE=Release -DSCINE_BUILD_PYTHON_BINDINGS=ON -DCMAKE_INSTALL_PREFIX=<desired path> ..
make -j<number of cores to use>
make installThis will generate and install both the main Serenity code and the wrapper in
the form of the fileserenity.module.sothat can be used in SCINE.In order to make Serenity available to SCINE the following two environment
variables need to be set:export SERENITY_RESOURCES=<desired path>/share/serenity/data/
export SCINE_MODULE_PATH=$SCINE_MODULE_PATH:<desired path>/libAfterwards, SCINE programs such asReaDuctwill pick up Serenity’s existence and it will be possible to request the
implemented methods.The SCINE Serenity 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_serenity_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
manager = su.core.ModuleManager.get_instance()
calculator = manager.get('calculator', 'DFT')

# 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 Serenity wrapper, please cite the corresponding
release as archived onZenodo(DOI
10.5281/zenodo.6695038; please use the DOI of the respective release).This wrapper should also not be mistaken for the actual Serenity code it wraps.
For the latter code and its citations, we refer you to the original
Serenity repository. 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: scine-sparrow
SCINE - SparrowIntroductionSparrow is a code for fast semiempirical quantum chemical calculations. It
provides the following methods:MNDOAM1RM1PM3PM6non-SCC DFTB (DFTB0)DFTB2DFTB3Sparrow can calculate electronic energies, nuclear gradients and
Hessians for the electronic ground state, as well as electronic vertical
transition energies and the electronic transition dipoles.License and Copyright InformationSparrow is distributed under the BSD 3-clause "New" or "Revised" License.
For more license and copyright information, see the fileLICENSE.txtin the
repository.Installation and UsageFor instructions on how to install and use Sparrow as well as for a detailed
documentation of the entire functionality of Sparrow, 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 Sparrow, please cite the corresponding
release as archived onZenodo <https://zenodo.org/record/3244105>_ (DOI
10.5281/zenodo.3244105; please use the DOI of the respective release).In addition, we kindly request you to cite the following article when using Sparrow:T. Husch, A. C. Vaucher, M. Reiher, "Semiempirical molecular orbital models
based on the neglect of diatomic differential overlap approximation",Int.
J. Quantum Chem.,2018,118, e25799.Support and ContactIn case you should encounter problems or bugs, please write a short message
toscine@phys.chem.ethz.ch.Third-Party Libraries UsedSCINE Sparrow 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>_pybind11 <https://github.com/pybind/pybind11>_yaml-cpp <https://github.com/jbeder/yaml-cpp>_