Saravanan666/pypi-org huggingface dataset:
Package: param-medic
Param-Medic breathes new life into MS/MS database searches by optimizing
search parameter settings for your data.Usage:param-medic [–options] <spectra file>+Description:In shotgun proteomics analysis, search engines compare tandem mass
spectrometry spectra with theoretical spectra to make peptide-spectrum
matches (PSMs). Proper selection of various parameters is critical to
achieving good search performance. In particular,precursor mass tolerance defines the peptide candidates considered
for each spectrum, andfragment mass tolerance (or bin size) determines how close observed
and theoretical fragments must be in order to be considered a match.For each of these parameters, too large a setting yields randomly
high-scoring false PSMs, while too small excludes true PSMs.Param-Medic finds pairs of spectra that are likely to have been
generated by the same peptide and uses these pairs to infer optimal
parameters for search with Comet, Tide and other search engines. If
multiple input files are provided, then they will be processed together.Param-Medic may fail if too few paired spectra are discovered, or if the
observed precursor m/z values appear to have been artificially
manipulated.With permission, Param-Medic makes use of code repurposed from Jacob
Schreiber’sPomegranatemixture-modeling software.Input<spectra file>+: The path to one or more files from which to parse
fragmentation spectra, in .mzML or .ms2 format.OutputThe program prints to standard output the estimated parameter values for
precursor mass tolerance (in ppm) and fragment bin size (in Th), as well
as the standard deviations of the estimated error distributions for
precursor and fragment masses.Options–min-precursor-mz : Minimum precursor m/z value to consider.–max-precursor-mz : Maximum precursor m/z value to consider.–min-frag-mz : Minimum fragment m/z value to consider.–max-frag-mz : Maximum fragment m/z value to consider.–min-scan-frag-peaks : Minimum fragment peaks an MS/MS scan must
contain to be considered.–max-precursor-delta-ppm : Maximum ppm distance between precursor
m/z values to consider two scans potentially generated by the same
peptide.–charge : Precursor charge state to consider MS/MS spectra from.
Ideally, this should be the most frequently occurring charge state in
the given data.–top-n-frag-peaks : Number of most-intense fragment peaks to
consider, per MS/MS spectrum.–pair-top-n-frag-peaks : Number of fragment peaks per spectrum pair
to be used in fragment error estimation.–min-common-frag-peaks : Number of the most-intense peaks that two
spectra must share in order to be potentially generated by the same
peptide.–max-scan-separation : Maximum number of scans two spectra can be
separated by in order to be considered potentially generated by the
same peptide.–min-peak-pairs : Minimum number of peak pairs (for precursor or
fragment) that must be successfully paired in order to attempt to
estimate error distribution.–debug : If this flag is set, verbose debug logging will be enabled.
Package: paramnb
ParamNBAutomatically generate ipywidgets fromParameterizedobjects in a Jupyter
notebook.Demo notebooksThe following links go to static versions of the notebooks, so after
looking at them it's best to try them out yourself interactively!Introduction:examples/user_guide/index.ipynbAdditional Features:examples/user_guide/AdditionalFeatures.ipynbSetting parameters via JSON:examples/user_guide/JSONInit.ipynbInstallationYou can easily install paramnb using conda:conda install -c pyviz paramnbor pip:pip install paramnb
Package: paramnet
paramnetprovides a convenience mixin,Parametrized, for creating subclasses of
NetworkX’sGraph(DiGraph) that have numeric parameters associated with nodes and
edges (for example, a dynamical system on a network). It provides the following key features:Simplified reads/writes for the parameter value for a specific node/edge, without navigating NetworkX’s nested dict structureEnforcing a well-defined node order on the graph, which in turn allows…Extraction of all values of a given node (edge) parameter as a 1D (2D)numpyarrayExamplesA parametrized network class can be created by subclassing fromGraphorDiGraphusing theParametrizedmixin. The names of any node/edge parameters can be specified
in the class definition:>>>classMyGraph(Parametrized,Graph,node_params=['x'],edge_params=['y']):...passG=MyGraph()Note: As with all mixins,Parametrizedshould be inherited fromfirstas above.paramnetautomatically adds named fields for each declared parameter, supporting clean random
access (both read and write) by node or edge>>>G.add_edge('a','b',y=3)>>>G.x['a']100>>>G.x['a']=4>>>G.y['a','b']3>>>G.y['a','b']=50Contrast this with the more cumbersome random access in base NetworkX (which can be used interchangeably if you wish):>>>G.nodes['a']['x']100>>>G.nodes['a']['x']=4>>>G.edges['a','b']['y']3>>>G.edges['a','b']['y']=50What’s more,paramnetmaintains the order in which nodes were added, allowing index lookup:>>>G.index('a')0>>>G.index('b')1>>>G.add_node('c')>>>G.index('c')2But that’s not all. Because the nodes are ordered, we can get a well-defined representation ofallvalues of a given node (edge) parameter at once as a vector (matrix). This is accomplished withinparamnetby accessing the associated parameter attribute without square brackets:>>>G.xarray([100,100])>>>G.yarray([[0.,3.],[3.,0.]])>>>G.Aarray([[0.,1.],[1.,0.]])Note the special case for the weighted network adjacency matrix, which is automatically defined
for every graph through the fieldA(instead ofweight), regardless of whetherweightis
supplied inedge_params.Under the hood, the parameter fields return View objects that wrap mostnumpyfunctionality,
allowing vector arithmetic and other array operations>>>G=MyGraph()>>>G.add_nodes_from([(node,{'x':5*node+1})fornodeinrange(5)])>>>G.add_cycle(range(5),y=1)# number of paths of length two between node pairs>>>np.dot(G.A,G.A)array([[0.,3.,1.,1.,3.],[3.,0.,3.,1.,1.],[1.,3.,0.,3.,1.],[1.,1.,3.,0.,3.],[3.,1.,1.,3.,0.]])>>>G.x+1array([2,7,12,17,22])DependenciesNetworkX (>= 2.0)numpyLicenseparamnetis released under the MIT license. See LICENSE for details.
Package: param-parser
param-parserparam-parseris a parser library for a param string expression. Those expressions are arbitrary strings  with
placeholders in it, where a placeholder consists of a name, an optional type and a list of options.InstallationWith acorrectly configuredpipenvtoolchain:pipenvinstallparam-parserYou may also use classicpipto install the package:pipinstallparam-parserGetting startedExamples of param string expressions look as follows:this-is-a-{param:string:option1,option2,option3}-expression
this-is-a-{param:string}-expression
this-is-a-{param}-expressionAs you see, a param is introduced by an opening curly bracket, followed by the name of the param, a colon, the type of
the param, another colon and a comma separated list of options. The param configuration gets terminated by a closing
curly bracket. Note that the type and option configuration are optional, but the name is mandatory.To parse an expression shown above, use the Python code as follows:importparam_parserresult=param_parser.parse(r"this-is-a-{param:string:option1,option2,option3}-expression")result[0]# Gets a `param_parser.node.SequenceNode` instanceresult[0].sequence_value# Gets `"this-is-a-"` as a stringresult[1]# Gets a `param_parser.node.ParamNode` instanceresult[1].param_name# Gets `"param"` as a stringresult[1].param_type# Gets `"string"` as a stringresult[1].param_options# Gets `["option1", "option2", "option3"]` as a list of stringsresult[2]# Gets a `param_parser.node.SequenceNode` instanceresult[2].sequence_value# Gets `"-expression"` as a stringIt is also possible to escape opening curly brackets, closing curly brackets, colons and commas as follows:importparam_parserresult=param_parser.parse(r"this-is-a-\{param:string:option1,option2,option3\}-expression")result[0]# Gets a `param_parser.node.SequenceNode` instanceresult[0].sequence_value# Gets `"this-is-a-{param:string:option1,option2,option3}-expression"` as a stringSupported versionsSupportedPython 3.7✓Python 3.8✓Python 3.9✓Python 3.10✓Python 3.11✓List of developersAndreas StockerAStocker@anexia-it.com, Lead Developer
Package: param-persist
Param PersistThis library will be used to persist param instance to databases, files or other persistent stores.The current supported persist methods are:sqlalchemy databaseThis library so far requires the dev version of param. That can be installed by running the following:python-mpipinstallgit+https://github.com/holoviz/param.gitAn jupyter notebook example of how to use the library can be found in theexamplesfolder.
Package: params
# Params[![travis](https://api.travis-ci.org/reorx/params.svg?branch=master)](https://travis-ci.org/reorx/params)
[![codecov](https://img.shields.io/codecov/c/github/reorx/params.svg?style=flat-square&label=coverage)](https://codecov.io/gh/reorx/params)A Python package that does better in request parameters validation than django.forms, wtforms, web_args or so.
Package: params-aws
params-awsLoad and Save typed Parameters in AWS DatastoreInstallpip install params-awsUsing the libraryEnsure thataws_access_key_idandaws_secret_access_keyis properly set in ~/.aws/credentials.
Or any place where boto3 would recognize -https://boto3.amazonaws.com/v1/documentation/api/latest/guide/configuration.htmlImportfrom params_aws import params_aws
from params_aws import modelList parameters>>> params_aws.get_parameter_names()
['test']Get parameter with typeThis will be cached for 12 hour>>> params_aws.get_parameter('test', model.DBConfig, cached=True)
DBConfig(host='host', user='username', password='password', port=5432, ssl=False)Put parameterWe should use the cli (see below)>>> params_aws.put_parameter('test', model.DBConfig, 'value')CLI>>> params_aws_cli names
test
test2

>>> params_aws_cli types
DBConfig
GGAPIConfig

>>> params_aws_cli get-value test
{
  "host": "host",
  "user": "username",
  "password": "password",
  "port": 5432,
  "ssl": false
}

>>> params_aws_cli get test DBConfig
host='host' user='username' password='password' port=5432 ssl=False

>>> params_aws_clit put test DBConfig
(launches an editor which saves and validate on exit)
Package: paramspace
Theparamspacepackage is an open-source project and Python package that
makes it possible to conveniently define dictionary-based, multi-dimensional
parameter spaces and iterate over them.Why?In Python, dictionaries provide a powerful tool to control program behaviour.
Frequently, these configuration structures take the shape of highly nested
dictionaries, where each hierarchical level holds the information required at
that point of the program.However, it is frequently desired to instantiate some program not with asingleset of parameters but with a set of parameters.
Especially for scientific purposes, e.g. numerical simulations, it is often
required to perform many instantiations of the same program with different
parameters, so-called parameter sweeps.
For simple configuration structures, this can be easily achieved by basic
control flow tools; however, this becomes increasingly difficult the more
parameters are desired to be sweeped over or the further nested they are in the
configuration hierarchy.This is where the paramspace package comes in.How?At its core, the paramspace package supplies theParamSpaceclass, which
accepts a dictionary-like object. To define parameter dimensions, individual
entries within that dictionary can be replaced by aParamDimobject,
regardless of the position and nestedness within the dictionary.
The parameter space is then the cartesian product of all parameter dimensions,
each parameter opening a new dimension of the parameter space.When iterating over the space, each returned value is a dictionary with one
combination of parameters, ready to be passed on to run the desired program.
This allows retaining a hierarchical configuration structure while at the same
time being able to conveniently perform sweeps over parameters, e.g. to spawn
simulations with.Furthermore, the paramspace package integrates tightly with YAML, making it
very simple to define multidimensional parameter spaces directly in a
configuration file.Learn MoreFor more information, visit the project page and have a look at the README:https://gitlab.com/blsqr/paramspaceFor use of paramspace, seeutopyaor theUtopia Project.
Package: param-store
param-store works with parameter stores (e.g. EC2 Parameter Store) to resolve specific parameters.
It is designed to be pluggable so that stores can be created for e.g. Vault or Azure Key Vault.A use-case is to store secrets in the EC2 parameter store and resolve them automatically.Installationpipinstallparam-storeUsageAs a standalone packagefromparam_storeimportEC2ParameterStorefromparam_storeimportinterpolate_dictdata={'key':'my-secret-{{ parameter-1 }}'}store=EC2ParameterStore()result=interpolate_dict(data,store)assertresult[key]=='my-secret-password'In combination with django-environfromenvironimportEnvfromparam_storeimportEC2ParameterStorefromparam_store.contribimportresolve_django_environenv=Env()store=EC2ParameterStore()resolve_django_environ(env,store)
Package: paramsurvey-tooling
paramsurvey-toolingInstallpip install paramsurvey-toolingparamsurvey usage on clusters with batch queuesMake 3 batch scripts: head, driver, and child. They all have a similar header:#FOO batch header lines

. ~/setup-my-software-environment.shThe script to set up your environment should activate your Conda environment, or
load modules or whatever.Then each of these scripts gets one of the following commands:pstool start headpstool start driver ./my-script.py foo bar bazpstool start childFinally, submit the head job, then the driver, and finally a bunch of children.Instead of using a driver batch script, you can also run the driver on a head
node:pstool submit ./my-script.py foo bar baz  # NOT YET WORKINGContainers and paramsurveyMany compute clusters do not support Docker containers, for security reasons.
These clusters often do support Singularity containers, and it's not hard to
turn an arbitrary Docker container into a Singularity container. Build
the Docker container on a machine that does have docker installed, and
then export it to a file:docker save IMAGE_ID | gzip > my_docker_image.tar.gzTransfer that file to a host withparamsurvey-toolingandsingularityinstalled, and do:pstool build my_docker_image.tar.gzIf you find a bugThis tool attempts to support many systems that the author can not
directly test. If you find a bug in your environment, run this:pstool debug > DEBUGand attach this fileDEBUGto your bug report.DocumentationInstalling code in an environment:CondaOS packagesmodulesContainerized environments:DockerSingularityExecution environment:Laptop or a single serverCluster with batch queue:PhilosophyDetailsslurm -- Harvard clusterPBSPro -- ASIAA clusterGrid Engine -- Smithsonian Hydra clusterTearing downCloud-native:PhilosophyOpen Science Gridhttps://bhpire.arizona.edu/2022/09/12/new-webinar-performing-large-scale-parameter-surveys-with-osg-services/Ray Cluster on AWS or GCERay Cluster over Kubernetes
Package: param-sweeps
Param-sweepsA Parameter sweeper for applications driven by ui.json filesThis package contains two main modules.  One is for generating sweep
files, and the other is to run a sweep over some number of parameters
in a driver application.Basic UsageTo generate a sweep file from a ui.json file for an existing
application, use the following command:python-mparam_sweeps.generatesome_file.ui.jsonThis will create a newsome_file_sweep.ui.jsonfile that may be run
with:python-mparam_sweeps.driversome_file_sweep.ui.jsonBy default, this would execute a single run of the original parameters.
To design a sweep, simply drag thesome_file_sweep.ui.jsonfile into
theGeoscience ANALYST Prosession that produced the original file and select start, end, and number
of samples values for parameters that you would like to sweep.To organize the output, param-sweeps uses aUUIDfile naming scheme, with
alookup.jsonfile to map individual parameter sets back to their respective
files.
Package: paramtk
ParamTk is an optional Tkinter interface to Param, allowing easy
construction of GUIs from existing code.Please seehttp://ioam.github.com/paramtk/for documentation and
examples.InstallationParamTk depends on Tkinter (usually included as standard with Python),
PIL (or Pillow) with its Tk interface (http://www.pythonware.com/products/pil/orhttp://python-pillow.github.io/),
and Param (http://ioam.github.com/param/).Official releases of ParamTk are available athttp://pypi.python.org/pypi/paramtk, and can be installed along with
depedencies viapip install paramtkoreasy_install paramtk.Alternatively, after seperately installing the dependencies, ParamTk
can be installed viapython setup.py install.
Package: paranoid-deobfuscator
[!WARNING]Currently not working on Windows. Please use WSL or a Linux VM. See#14.Paranoid/LSParanoid deobfuscator[!NOTE]Only compatible with Paranoid v0.3.0+ (released in 25 Jan 2020)A script to deobfuscate apps obfuscated withParanoid/LSParanoidto help you with static analysis.BeforeAfterInstallationUsing pippip install paranoid-deobfuscatorManualgit clone https://github.com/giacomoferretti/paranoid-deobfuscatorcd paranoid-deobfuscatorpip install .UsageAPK file (usingApktool)Decode.apkfile:apktool d app.apkRun deobfuscator:python -m paranoid_deobfuscator appBuild:apktool b appEnjoy your deobfuscated apk!DEX file (usingsmali)Disassemble.dexfile:baksmali d classes.dexRun deobfuscator:python -m paranoid_deobfuscator outAssemble:smali a outEnjoy your deobfuscated dex!
Package: paranoid-openvpn
Paranoid OpenVPNParanoid OpenVPN hardens OpenVPN profiles and provides additional optional
provider-specific fixes (e.g. Private Internet Access).UsageWhen installed, Paranoid OpenVPN provides theparanoid_openvpnexecutable
which comes with built-in help.  These are the common options:$pipinstallparanoid-openvpn$# usage: paranoid_openvpn [--min-tls {1.0,1.1,1.2,1.3}] [--pia] source dest$# Process a remote zip file of OpenVPN profiles and apply PIA fixes$paranoid_openvpn--piahttps://www.privateinternetaccess.com/openvpn/openvpn-strong.zip/path/to/output_dir$# Process one profile and allow TLS 1.2 (default is 1.3)$paranoid_openvpn--min-tls1.2/path/to/input/profile.ovpn/path/to/output/hardened.ovpnsourceabove can be a remote zip, remote single profile, local zip, local
single file, or local directory.Hardening OpenVPNMost OpenVPN users are aware of thecipherandhashsettings but that is
usually the extent of security options that people modify. OpenVPN, however,
has two distinct channels that each have their own security settings: the
control and data channel. Thecipherandhashsettings apply only to the
data channel but OpenVPN exposes settings for the control channel as well.
The control channel is used to exchange keys that are then used to encrypt
your traffic in the data channel.Paranoid OpenVPN tries to match the security of the data channel to the control
channel. In broad terms, OpenVPN has options for <128-bit, 128-bit, 192-bit,
and 256-bit ciphers for the data channel. Paranoid OpenVPN will configure the
control channel to match these protection levels, with an absolute minimum of
128-bits.Cryptographic ReasoningWhere cryptographic judgement calls needed to be made, these rules were followed:AEAD ciphersare always preferred over non-AEAD ciphersAt the 256-bit security level, AES-GCM was preferred over CHACHA20-POLY1305
(for no particular reason).The 192-bit security level is rounded up to 256-bit as there are no 192-bit
TLS ciphers.At the 128-bit security level, CHACHA20-POLY1305 was the preferred fallback
for AES-128-GCM instead AES-128-CBC because it is an AEAD cipher.
AES-128-CBC is then the fallback for CHACHA20-POLY1305.Provider-specific FixesMost VPN providers work fine with "normal" OpenVPN profiles but some providers
benefit from a few tweaks.Private Internet Access (PIA)PIA's provided OpenVPN profiles seemingly only support AES-128-CBC and
AES-256-CBC as thecipheroption.  However with a little coaxing, PIA will
connect using AES-256-GCM and AES-128-GCM. Use the--piaflag to allow
your client to client with these AEAD ciphers.DonationsIf you use this project and feel it's worth a donation, check outGitHub SponsorsorBuy Me a Coffee.CreditA lot of inspiration for this project was taken fromhttps://blog.securityevaluators.com/hardening-openvpn-in-2020-1672c3c4135a.
Package: paranoid-scientist
Paranoid Scientist is a Python module for verifying scientific
software which provides:Runtimeverification of entry and exit conditionswritten in
pure Python, including hyperproperties.Conditions specified using pure Pythonrefinement types,
i.e. types are defined by predicates.Automated unit testingof individual functions.To learn more, read thedocumentation,conceptual FAQs,technical FAQs, ortutorial, or see thepaper/preprintfor more technical details.If you use Paranoid Scientist in an academic work, please cite:Shinn M. (2020) Refinement Type Contracts for Verification of Scientific Investigative Software. In: Chakraborty S., Navas J. (eds) Verified Software. Theories, Tools, and Experiments. VSTTE 2019. Lecture Notes in Computer Science, vol 12031. Springer, Cham. DOI: 10.1007/978-3-030-41600-3_10System requirementsPython 3.5 or aboveOptional: Numpy (for Numpy types support)LicenseAll code is available under the MIT license.  See LICENSE.txt for more
information.  Paranoid Scientist is copyright 2018-2020 Max Shinn.
The logo is copyright 2018 Anastasia Ershova.