Saravanan666/pypi-org huggingface dataset:
Package: parameterpack
Parameter PackThis module provides a mechanism for writing something similar to C++17’sfold expressionsin Python. This is
achieved by co-opting Python’s mostly unusedEllipsisliteral.Supported OperatorsAddition (+)Subtraction (-)Multiplication (*)Integer division (//)Division (/)Modulus (%)Matrix Multiplication (@, Python >= 3.5 only)Bitwise And (&)Bitwise Or (|)Bitwise Xor (^)Left Shift (<<)Right Shift (>>)__call__Comparison operators (>,>=,<,<=,==,!=)ExamplesThere are two ways to “fold” an operation over a parameter pack:leftandrightfolds.fromparameterpackimportpackp=pack(1,2,3)# Left foldp-...# (1 - 2) - 3 = -4p-...-4# ((1 - 2) - 3) - 4 = -8# Right fold...-p# 1 - (2 - 3) = 2...-p-4# 4 - (1 - (2 - 3)) = -2Note that the left fold groups operations on the left, while the right fold groups them on the right. This only makes
a difference if the folded operation is not associative, such as in the case of integer subtraction.Because it is not possible to redefine theellipsistype’s operators, a right fold on the right side of a binary
operation requires parentheses.fromparameterpackimportpackp=pack(1,2,3)# This is an error because "4 - ..." is evaluated first.4-...-p# This is what you should do instead.4-(...-p)# 4 - (3 - (2 - 1)) = 2You may prefer to use parentheses in every case to keep the syntax clear and avoid this potential oversight.Conditional chains are also supported, but they work a little differently from the other folds.fromparameterpackimportpackp=pack(1,2,3)# Python evaluates "a < b < c" as "a < b and b < c", so this module does the same.p<...# 1 < 2 < 3 = True, so 3 is returned.p<...<4# 1 < 2 < 3 < 4 = Truep<...<0# 1 < 2 < 3 < 0 = Falsep=pack(3,2,1)p<...# 3 < 2 < 1 = False, so a special False-comparing object is returned....<p# 3 > 2 > 1 = TrueBecause python has no reversed-argument forms for the comparison operators, conditionals work a little differently.
If folding the comparison over the parameter pack’s elements results inFalse, in order to invalidate the entire
comparison chain, it will return a special object that will returnFalsefor any further comparisons. Otherwise, the
last element of the parameter pack is returned so that the comparison chain can continue.Running TestsTo run this module’s tests in your system’s Python interpreter, simply runpython setup.py testfrom the
repository root.To run tests in all supported interpreters, first ensure that every supported Python interpreter is installed on your
system and added to thePATHenvironment variable. Then runpip install-e.[dev]from the repository root to
install development dependencies, and then runtoxfrom the repository root to run the tests.Bugs Reports and Feature RequestsPlease use theissue trackerto submit bugs or request features.LicenseCopyright Joe Lawson, 2017.This package is distributed under the terms of theMITlicense.
Package: parameterparser
Parameter Parser (Python)Parameter Parseris a simple library used to parse intricate parameters from an array of strings.Hint:This package is available throughPython PIP.pip install parameterparserSupports Python 2.7+Documentation-Advanced Code Examples-Looking for the PHP version?FeaturesParse command line parameters.Assign aliases to parameters.Custom closures for each command line parameter.Variadic closure support for arguments taking more than one value.Customize the way the command line is parsed.Example UsageimportsysfromparameterparserimportParameter,Cluster,Parser# Initialize a new Clusterparameters=Cluster()# Add a Parameter to the Clusterparameter=Parameter("-","name",lambdaname:name)parameter.set_required(True)\.set_description("Your name.")parameters.add(parameter)# Create a new Parser using the Clusterparser=Parser(sys.argv,parameters)# Parse the parameters using the Parser.results=parser.parse()# Verify that the parameters were valid after parsing.ifnotparser.is_valid():# Since it was not valid, output usage.parameters.print_full_usage("Parameter Parser","An advanced parameter parser for Python","v1.0.0")else:# Retrieve the name from the resultsname=results['name']# Output the nameprint("Your name is "+name+os.linesep)Output~/ python test.py -name 'Nathan Fiscaletti'

   Your name is Nathan FiscalettiDevelopmentBefore commiting anything, please create a pre-commit hook with the following content.This will ensure that the pycodestyle badge is properly updated.#!/bin/bashpython3tests/style.py
Package: parameters
We consider it to be best practice to cleanly separate the parameters of a model
from the model itself. At the least, parameters should be defined in a separate
section at the start of a file. Ideally, they should be defined in a separate
file entirely. This makes version control easier, since the model code typically
changes less often than the parameters, and makes it easier to track a
simulation project, since the parameter sets can be stored in a database,
displayed in a GUI, etc.TheParameterspackage provides Python classes to make it easier to work with
parameter sets for complex models.  In particular it provides tools forworking with parameters for models that have a deep hierarchical structure;specifying that a parameter value should be drawn from a random distribution;specifying a range of values, for example for performing a sensitivity analysis;specifying the physical dimensions and range of permissible values of parameters;defining and iterating over multiple points in a parameter space;validation of parameter sets against a pre-defined schema.LicenseCopyright (C) 2008-2013  Andrew Davison, Eilif Muller, Jan AntolikParameters is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.The GNU General Public License does not permit this software to be
redistributed in proprietary programs.See source:LICENSE.txtInstallation$ pip install parametersDocumentationhttps://parameters.readthedocs.org/Reporting Bugshttps://github.com/NeuralEnsemble/parameters/issues
Package: parameter-space-2d
parameter-space-2dTools for performing 2D parameter space analysis for deterministic modelsMethodParameter space maps are built up by performing an iterative grid search, preferentially exploring parameter regimes
close to detected boundaries. Various checks are in place to ensure that any detected boundaries are fully explored.Example of a model with two states (blue and orange) and variable input parameters β and εInstallationpip install parameter-space-2dInstructionsThe repository contains a couple of notebooks with instructions for performing analysis, using the Goehring et al. (2011) PAR polarity model as an example. To run the notebooks interactively, click here:LicenseThis work is licensed under aCreative Commons Attribution 4.0 International License.
Package: parameter-store-environ
ps-environDescriptionThis is a simple wrapper around AWS SSM Parameter Store. It is designed to cache and parse variables from Parameter Store for a specific service and stage.
It is heavily inspired bydjango-environand shares a (simplified) interface.For more on Parameter Store, read theAWS documentation.InstallationInstall withpip:pipinstallparameter-store-environUsageThe wrapper assumes that variables in parameter store are in the following format:/<SERVICE>/<STAGE>/<VARIABLE_NAME>So, for example:/api/dev/DEBUG
/api/prod/DB_HOSTThe wrapper is agnostic to the variable name, but we recommend you follow the convention for environment variables and use all caps and underscores.In your settings/configuration module, import the module and create a new instance of the wrapperfromps_environimportEnvconfig=Env(service='api',stage='dev')# When called directly, the string value is returnedassertconfig('DEBUG')=='True'# Use casting methods to return the type you needassertconfig.bool('DEBUG')==TrueSchemasYou can define a schema when you instantiate the wrapper to avoid having to call the casting methodsconfig=Env(service='api',stage='dev',schema={'DEBUG':bool,'MAX_RETRIES':int,})assertconfig('DEBUG')==Trueassertconfig('MAX_RETRIES')==5Supported casting types: bool, float, int, set, list, tuple, jsonAdditional Notes:list, tuple, set: These types expect the values to be separated by commas. E.g.1,2,3json: A regular JSON string is expected. E.g.{'foo': 'bar'}Environment Variable OverrideIf the variable is also set in the environment, that value will take precedence.Default ValuesYou can set a default value by setting the default keyword.
If no default is set and the value is neither in the environment variables or in parameter store, anImproperlyConfiguredexception will be raised.assertconfig('DB_HOST',default='localhost')=='localhost'AWS Credentialsps-environusesboto3to interface with parameter store and therefore uses the same mechanism for authentication.
See theconfiguring credentialsin the Boto 3 documentation for more information.
Package: parameter-verification
Python Parameter VerificationHomepage:https://www.learningtopi.com/python-modules-applications/parameter_verification/This is a simple Python function that can be used to test variable types and values.  The intended purpose is to check the parameters of a function to ensure that appropriate types and values have been passed.The function is specifically written to support Python >=3.3 so it can be used with a wide array of applications.  There are also no dependencies that need to be installed.Usagefrom parameter_verification import verify_params, ParameterError

def test_function_1(param1, param2, param3, param4):
    ''' Sample function to show verify_params usage '''
    try:
        verify_params(param1=(param1,int), param2=(param2,str,'=abc'), param3=(param3,float, '>100.2', '<110.0'), param4=(param4,str,'len=4','=abcd'))
    except ParameterError as e:
        # some code to handle an exception if desired

    # proceed with your function!The verify_param function takes keyword arguments for each parameter to check.  The value of each parameter is passed as a tuple consisting of:The value to check (i.e. the variable)The variable type to check against(optional) an additional check to perform (i.e. '>100.2' or '=abc')(optional) more additional checks can be added, i.e. '>100.2', '<110.0'Supported ChecksThe following checks are supported (in addition to the data type which can be any Python type):'==' or '=': Both perform the same check and can be used interchangably'<', '<=', '>', '>=': Perform the typical checks'len=x', 'len>x', 'len>=x', etc: Check the length of a stringReturns and ErrorsThe function returns True if all parameters pass.  If a parameter check fails, the function raises a ParameterError exception.  If desired, this behavior can be changed by setting "no_raise=True". With no_raise set to True, False will be returned in the case of a failed parameter check rather than raising an exception.
Package: parametricGarch
ParametricGarchA Python library that uses parametric bootstrapping via the GARCH model to estimate volatility and Value-at-Risk (VaR) for financial assets.InstallationYou can install parametricGarch using pip:pip install parametricGarchDependenciesThe package dependencies are:archnumpypandasscipyUsageTo get started with parametricGarch, import the necessary modules and create an instance of theGarchclass:fromparametricGarchimportGarch# Create an instance of the Garch class to fit and forecast the modelmodel=Garch(data,vol='Garch',p=1,q=1,dist='normal',update_freq=0,disp='off',horizon=1,start=None,reindex=False)# View the summary of the fitted modelmodel.summary# View the conditional volatility of the fitted modelmodel.conditional_volatility# View the standardised residuals of the fitted modelmodel.standardised_residuals# View the forecasted conditional mean of the fitted modelmodel.forecast_mean# View the forecasted conditional variance of the fitted modelmodel.forecast_variance# View the forecasted conditional variance of the residuals of the fitted modelmodel.forecast_residual_variance# Perform parametric bootstrappingmodel.bootstrap()# View the summary of the bootstrapped modelmodel.bootstrap_summary# View the forecasted mean and volatility list from the bootstrapped modelmodel.bootstrap_samples# Estimate volatility and VaRrisk_estimates=model.estimate_risk()DocumentationPlease refer to thedocumentationfor detailed information on the available parameters, methods, and properties of the Garch class.ExamplesPlease refer toexample.ipynbfor a detailed example to help you get started quickly with parametricGarch. The examples cover various use cases and demonstrate the library's capabilities.LicenseparametricGarch is licensed under the GNU General Public License v3.0 License. See theLICENSEfile for more details.
Package: parametric-si
This package implements a more powerful and general conditional selective inference(SI) with linear regression.Key references are the following papers:Parametric Programming Approach for More Powerful and General Lasso Selective InferenceMore Powerful and General Selective Inference for Stepwise Feature Selection using the Homotopy Continuation ApproachRequirementsThis package requires the following packages:numpyscipysklearnportionInstalling parametric_siUse pip to install parametric_si package. Required packages will be also installed automatically.$pipinstallparametric_siAPI ReferenceDetailed API reference is available here
Package: parametrize-from-file
Parametrize From File is a library for reading unit test parameters from config
files.  It works with thepytestframework.  Below is the basic workflow that
this package enables:Write test cases in aJSON,YAML,TOML, orNestedTextfile:# test_camelot.ymltest_str_find:-str:sir lancelotsub:lanceloc:4-str:sir robinsub:braveloc:-1Decorate the corresponding test functions with@parametrize_from_file:# test_camelot.pyimportparametrize_from_file@parametrize_from_filedeftest_str_find(str,sub,loc):assertstr.find(sub)==locRunpytestas usual:============================= test session starts ==============================
platform linux -- Python 3.10.0, pytest-7.4.0, pluggy-1.2.0
rootdir: /home/arthur/holy_grail
collected 2 items

test_camelot.py ..                                                       [100%]

============================== 2 passed in 0.09s ===============================Refer to theonline documentationfor more information.
Package: parametrizer
parametrizerprovides a simple parametrization class for
template substitution.Twitterparametrizertweets happens here:@davidemoroChangelog0.0.3 (2019-03-19)Provide a different mechanism in parametrize: variable substitution (mapping)
and jinja context (context)0.0.2 (2019-03-14)Adopt Jinja2 as template engine. You can use$nameand${name}as usual, now
custom expressions{! name.upper() !}or any other Jinja2 constructs are supported
too0.0.1 (2019-01-16)First release
Package: paramfittorchdemo
paramfittorchdemoThis file will become your README and also the index of your
documentation.InstallpipinstallparamfittorchdemoHow to useUsing the integration routines in the library torchdiffeq we can
integrate differential equations using torch modules as the base class
for describing the systems. This allows for gradients to be computed
with respect to the model parameters. This can be combined with the
local optimization schemes used to train neural networks to give a
powerful framework for fitting differential equation models found in the
scientific literature.In this package I provide a few example systems and parameter fitting
routines for fitting the parameters.The below code demonstrates how the van der Pol oscillator system
defined as `torch.nn.module1 can be integrated against inside of
pytorch.importtorchfromtorchdiffeqimportodeint_adjointasodeintimportmatplotlib.pyplotaspltvdp_model=VDP(mu=0.5)ts=torch.linspace(0,30.0,1000)# Create a batch of initial conditionsbatch_size=30initial_conditions=torch.tensor([0.01,0.01])+0.2*torch.randn((batch_size,2))sol=odeint(vdp_model,initial_conditions,ts,method='dopri5').detach().numpy()# Check the solutionplt.plot(sol[:,:,0],sol[:,:,1],color='black',lw=0.5);plt.title("Phase plot of the VDP oscillator");plt.xlabel("x");plt.ylabel("y");The automatic batching dimensions means we can easily integrate a
collection of initial conditions at the same time using these routines
as well. The above shows the phase plane plot of the VDP oscillator for
30 random initial conditions.
Package: paramiko
Welcome to Paramiko!Paramiko is a pure-Python[1](3.6+) implementation of the SSHv2 protocol[2], providing both client and server functionality. It provides the
foundation for the high-level SSH libraryFabric,
which is what we recommend you use for common client use-cases such as running
remote shell commands or transferring files.Direct use of Paramiko itself is only intended for users who need
advanced/low-level primitives or want to run an in-Python sshd.For installation information, changelogs, FAQs and similar, please visitour
main project website; for API details, seethe
versioned docs. Additionally, the project
maintainer keeps aroadmapon his
personal site.[1]Paramiko relies oncryptographyfor crypto
functionality, which makes use of C and Rust extensions but has many
precompiled options available. Seeour installation pagefor details.[2]OpenSSH’s RFC specification page is a fantastic resource and collection of
links that we won’t bother replicating here:https://www.openssh.com/specs.htmlOpenSSH itself also happens to be our primary reference implementation:
when in doubt, we consult how they do things, unless there are good reasons
not to. There are always some gaps, but we do our best to reconcile them
when possible.
Package: paramiko-cloud
Paramiko-CloudParamiko-Cloud is an extension to Paramiko that provides ECDSA SSH keys managed by
cloud-based key management services. As well as enabling Paramiko to perform SSH
operations using cloud-managed keys, it also provides certificate signing functions,
simplifying the implementation of an SSH certificate authority.Paramiko-Cloud supports:Amazon Web Services - Key Management ServiceGoogle Cloud Platform - Cloud Key Management ServiceMicrosoft Azure - Key VaultRead the docs here:https://paramiko-cloud.readthedocs.io/en/latest/
Package: paramiko-fork
This is a library for making SSH2 connections (client or server).
Emphasis is on using SSH2 as an alternative to SSL for making secure
connections between python scripts.  All major ciphers and hash methods
are supported.  SFTP client and server mode are both supported too.To install the development version,pip install-egit+https://github.com/paramiko/paramiko/#egg=paramiko.This build is built on top ofhttps://github.com/paramiko/paramikowith some new
feature prs not merged yet. And it is most likely a temporary solution for
access these new features easily.You can reachhttps://github.com/liangxiao1/paramiko/tree/xiliangfor more details.PR#1643: Add rsa-sha2-256 and rsa-sha2-512 algorithms
Package: paramiko-ng
paramiko-ngis a fork ofparamikofor more active maintenance.For changes in releases of this fork, seehttps://github.com/ploxiln/paramiko-ng/releasesThis is a library for making SSH2 connections (client or server).
Emphasis is on using SSH2 as an alternative to SSL for making secure
connections between python scripts.  All major ciphers and hash methods
are supported.  SFTP client and server mode are both supported too.Required packages:CryptographyThe import name is still justparamiko. Make sure the originalparamikois not installed before installingparamiko-ng- otherwise pip may report
success even thoughparamiko-ngwas not correctly installed.To install the development version:pip install -e git+https://github.com/ploxiln/paramiko-ng/#egg=paramiko-ngYou can also install under the original “paramiko” pip-package-name,
in order to satisfy requirements for other packages:PARAMIKO_REPLACE=1 pip install https://github.com/ploxiln/paramiko-ng/archive/2.7.4.tar.gz#egg=paramikoReplace “2.7.4” with the desired recent version, or for latest development version do:PARAMIKO_REPLACE=1 pip install git+https://github.com/ploxiln/paramiko-ng/#egg=paramiko
Package: paramikope
This is the description file for the project.The file should use UTF-8 encoding and be written using ReStructured Text. It
will be used to generate the project webpage on PyPI, and should be written for
that purpose.Typical contents for this file would include an overview of the project, basic
usage examples, etc. Generally, including the project changelog in here is not
a good idea, although a simple “What’s New” section for the most recent version
may be appropriate.
Package: paramiko-stat
paramiko-statThis is just a wrapper for paramiko with changes included fromhttps://github.com/paramiko/paramiko/pull/1259/files.Install it from PyPIpipinstallparamiko-statUsagefromparamiko_statimportSSHClientssh=SSHClient()ssh.connect("127.0.0.1",username="user",...)sftp=ssh.open_sftp()sftp.mkdir("path",mode=700)Alternatively, a much better practice:fromparamikoimportSSHClientfromparamiko_statimportTransportssh=SSHClient()ssh.connect("127.0.0.1",username="user",...,transport_factory=Transport)
Package: param-info
A python package for parsing parametersUsage>>> from param_info import *
>>> params = ParamList()
>>> params.add( ParamInfoInt("a1",7,min=5) )
>>> params.add( ParamInfoVal("a2",['aa','bb','cc']) )
>>> params.add( ParamInfoStr("a3",' hallo ') )
>>> def doSomething(param,values):
...    if params.validate(values):
...        # Do something with values
...        for name,param in params.params.items():
...            print( '{0} ==> {1}'.format(name,param.value))
...    else:
...        # Handle errors
...        for name,param in params.errors.items():
...            print( 'Error. {0} ==> {1}'.format(name,param.errorText))
>>> doSomething(params,{'a1':3})
Error. a1 ==> a1=3 should be integer >= 5
Error. a2 ==> a2 is required
>>> doSomething(params,{'a1':8,'a2':'bb'})
a1 ==> 8
a2 ==> bb
a3 ==> hallo
>>> doSomething(params,{'a2':'zz'})
Error. a2 ==> a2=zz should be one of ['aa', 'bb', 'cc']
>>> doSomething(params,{'a2':'aa','a3':'hola'})
a1 ==> 7
a2 ==> aa
a3 ==> hola
Package: paramize
Paramize: Langchain IntegrationRequirementsWorks with Python: 3.7 onwards.InstallationIt's recommended you usevirtualenvto create isolated Python environments.pipinstallparamize-sdkAuthorsMain Contributor - Rajendra KulkarniContributingPlease go through ourCONTRIBUTING.mdfileCode of ConductReadCODE_OF_CONDUCT.mdfileLicenseApache License, Version 2.0
Copyright 2023 Wingify Software Pvt. Ltd.