Saravanan666/pypi-org huggingface dataset:
Package: varfxi
VaR-Rule for FX InterventionsLink to the Python notebook:https://github.com/romainlafarguette/VaR-FX-Interventions/blob/master/notebooks/VaR-FX%20Interventions.ipynbThe Python notebook replicates the tables and the charts of the IMF WP on
"Foreign Exchange Interventions Rules for Central Banks: A Risk-Based Framework"IMPORTANT: BECAUSE OF AN UPDATE OF THE ARCH PACKAGE AFTER 4.19, and in particular the
random number generator, the way the random seed is managed has changed. Some
results are therefore slightly different (e.g. the pdf plot) by a few pips as
in the IMF WP, but are qualitatively similar. The journal version will reflect
the new versionThe paper uses  a Python package  that I have  written, DistGARCH, also  available in
this  Github folder,  with  the public  FX intervention  data  from the  Banco
Mexico. DistGARCH is based on the ARCH package of Kevin Sheppard.You can use the code for non-commercial applications, providing that you cite the IMF Working Paper
Lafarguette, R. and Veyrune, R. (2020) "Foreign Exchange Interventions Rules for Central Banks: A Risk-Based Framework", IMF Working PaperThe folder is organized as follows:mxn_estimation.py is the pure Python file with the core estimation and
robustness analysisVaR-FX Interventions.ipynb is a Jupyter notebook, which illustrates the approachmodules/ contains the modules for this project, in particular distGARCH which infers a conditional distribution from a GARCH modeldata/ contains public data files, with FX rate and FX interventions from Banco Mexico websiteimg/ contains some images to illustrate the Jupyter NotebookReuse of this  tool and  IMF data  does not  imply any  endorsement of  the research  and/or product.  Any research  presented should  not be  reported as
representing  the   views  of  the   IMF,  its  Executive  Board,   or  member
governments.Note that the Github repo contains only publicly available data.Author: Romain Lafarguette, August 2020If you have any question, please contact me via Github or rlafarguette "at" imf "dot" org
Package: varhash
VARhashDescriptionThis is an implementation of VAR Hash in PythonInstallationpip install varhashAs usual with Pip, you might need to usesudoor the--userflag
with the command above, depending on how you installed Python on your
system.UsageImportingimport varhashHashinghashed_data = varhash.hash(data)Change Log0.0.3 (04/11/2022)-Updated hash function0.0.2 (04/11/2022)-Updated hash function0.0.1 (04/11/2022)-First Release
Package: vari
Color representations and representation conversions in Python. _Väri_ means
‘color’ in Finnish.installpip install vari. Done.useCreate aVariinstance with one of many color representations:Vari(rgb=(255, 0, 0))
Vari(‘#ff0000’)
Vari(‘red’)Ask the instance for other representations:c = Vari(‘#f00’)
c.rgb  # (255, 0, 0)
c.hex  # ‘#ff0000’
c.x256  # 196futurehsl repr
Package: variable
variable.method_selectforward(y,X)back (y,X)This package executes the forward and backward selection procedures to aid in selecting variables for inclusion in an OLS regression model.The forward selection procedure starts with an equation containing no predictor varaibles, only a constant that must be added by the user.  To identify the first variable to include in the equation, the independent variable with the highest simple correlation to the response variable is selected and included in an OLS regression.  If An evaluation of the independent variable's p-value is completed, and if the variable proves significantly different from zero, it is retained in the equation and a review for a second variable is initiated.  To identify a second variable, a correlation with the remaining variables is completed against the residuals from the previous OLS regression.  The independent variable with the highest correlation to the residuals is selected as the second variable, which is included in a subsequent OLS regression.  If the p-value of this second variable proves significant from zero, this second variable is retained and the search for a third variable is initiated.  This process continues for all available variables.The backward selection procedure starts with all variables including a constant that must be added by the user, and systematically removes the variable with the smallest t-value in each iteration.To initiate the function, the user must specify the target variable (y) and the independent variable(s) (X).The output of this package is a table showing the order in which the variables were evaluated, as well as validation factors used for evaluating variables for inclusion in a model.  The user should review the table and make determinations based on their preferences.This variable selection package was developed based on the procedure as described in Chatterjee, Samprit and Hadi, Ali S (2012).Regression Analysis by Example (5th ed.). Hoboken, New Jersey: John Wiley & Sons, Inc.
Package: variable-base-factoradic
Variable-base Factoradic numbersImplementation ofhttps://xkcd.com/2835/Installationhttps://pypi.org/project/variable-base-factoradic/pipinstallvariable-base-factoradicUsagefromvariable_base_factoradicimportfrom_factoradic,to_factoradic# Convert from decimal to factoradicto_factoradic(5038)# Out: "654320"# Convert from factoradic to decimalfrom_factoradic("654320")# Out: 5038
Package: variableDatabase
How to ImportImport this way:from variableDatabase import databaseUsageThis is used to store global variables in a database.
You can retrieve the variables from unique variableIDs.FunctionscreateVar(auth, name, value)Creates a new variable and returns the Variable ID, which you can use to retrieve the value using the getValueFromID() Function.Example Script:moneyID = createVar("myUniqueAuth", "money", "$1,291")
  value = getValueFromID(moneyID)    
  print(value)Example Response:>>> $1, 291getValueFromID(ID)Retrieve the value from the Variable ID.Example Script:moneyID = createVar("myUniqueAuth", "money", "$1,291")
  value = getValueFromID(moneyID)    
  print(value)Example Response:>>>  $1, 291getJSONFromID(ID)Retrieve the JSON from the Variable ID.Does not work for userGen() Variable IDs, use getUserJSON() instead...Example Script:moneyID = createVar("myUniqueAuth", "money", "$1,291")
  json = getJSONFromID(moneyID)    
  print(json)Example Response:>>> {'_id': '633cbfd65057d14f0004d011', 'name': 'Hi', 'auth': 'John', 'value': 15}userGen(amount_of_users, statusUpdate)Generate completely random users with phone numbers, usernames, passwords, adresses, emails, and more.Params:amount_of_users: int -> How many users to generate. Must be an int such as 1, 219, or 173. | Generates a maximum of 999 users.statusUpdate: bool -> Print updates on the user generation status. If True -> Will print update for each user created. If False -> Will not print update.BETA MODE DO NOT RECOMEND!Example Script:ranUser = userGen(5, True)
print(ranUser[0])
print("\n"+ranUser[1]["name"])
print("\n"+str(ranUser[2]["age"]))Example Response:User #1 Created!
User #2 Created!
User #3 Created!
User #4 Created!
User #5 Created!
{'_id': '633c78f45057d14f0004c7d4', 'pass': '9Clifford57', 
'name': 'Bobbie Towne', 'email': 
'Hortense.Mayert@yahoo.com', 'user': 'Carolina_Ruecker', 
'age': 89, 'phone': '040-533-6820', 'address': '6724 
Rodriguez Turnpike\nLake Edgardo, UT 84745', '_mock': True}
   
Chelsey Gusikowski

96_id and _mock are debug elements, ignore themsetVar(ID, new_value)Updates an already existing variable and returns the Variable ID, which you can use to retrieve the value using the getValueFromID() Function.Example Script:moneyID = createVar("myUniqueAuth", "money", "$1,291")
  value = getValueFromID(moneyID)    
  print(value)
  updatedMoney = setVar(moneyID, "$1,801")
  updated_value = getValueFromID(moneyID)    
  print(updated_value)Example Response:>> $1, 291
>> $1, 801removeVar(ID)Deletes an already created variable.Example Script:moneyID = createVar("myUniqueAuth", "money", "$1,291")
  value = getValueFromID(moneyID)    
  print(value)
  removeVar(moneyID)
  print(getJSONFromID(moneyID))
  print(getValueFromID(moneyID))Example Response:>> $1, 291
 >> []
 >> Traceback (most recent call last):
 File "main.py", line 262, in <module>
   print(getValueFromID(moneyID))
 File "main.py", line 58, in getValueFromID
   value = response.json()["value"]
TypeError: list indices must be integers or slices, not str
Package: variable_generator
Variable_Generatorvariable_generator is a small module to support automationof generating valid python variable names from external data.It is designed as a service to be used by other programsthat would parse through data and need to translate that data to usable python code.InstallingInstall and update using pip:pip install -U variable_generatorA Simple Examplefrom variable_generator.name_generator import generate_valid_variable_nameraw_data = "123_ $%^ ששthis_is_var1   "var1 = generate_valid_variable_name(self.testing_data['string1'])> num123_dollar_percent_circumflex_15131513this_is_var1
Package: variable-protocols
Variable ProtocolsA way to specify common variables of data inputs in the field of data science and machine learning.Installationpip install variale_protocolsSpecifications:PrinciplesOnly one representation for each variable typeSeevariable_protocols/variable_protocols.pyGuidelineUse functions invariables.pyto create variables'VariableGroup' groups different type of Variables'VariableTensor' groups same type of VariablesExamplesseetest/examples.pyGoalsspecify common variables of data inputs in the field of data science and machine learning.structural typing, only sum types and product types (In the general sense, not ML family ADT)there should be one way to type one variable groupgood error messageserror (messages) oriented programmingserialization in the future (probably in Dhall)NonGoalscompatability with any current stuffeasy to optimize with current computer architectureseasy to comprehend (simple is not easy)support nominal typing(only labels)
Package: variadic
variadicis a Python (2.7+ and 3.4+)function decoratorto write variadic functions accepting a mix of arguments and iterables of those arguments.
Oh, and they keep theirargspec,
so tools doing introspection (Sphinx doc, IDEs, etc.) will work well.
No uglyf(*args,**kwds)in your doc!Note thatPEP 448makesvariadicobsolete:if you’re using Python 3.5+, you should keep plain variadic functions and call them with several argument unpackings.It’s licensed under theMIT license.
It’s available on thePython package index,
itsdocumentationand itssource codeare on GitHub.Questions? Remarks? Bugs? Want to contribute?Open an issue!Quick startInstall from PyPI:$ pip install variadicImport:>>> from variadic import variadicDefine a function:>>> @variadic(int)
... def f(*args):
...   return args
>>> f(1, 2, [3, 4], xrange(5, 8))
(1, 2, 3, 4, 5, 6, 7)
Package: varianteval
variantevalis a Python library to facilitate the comparison of one or more VCFs against each other and/or truth datasets.Installationpipis recommended forvariantevalinstallation.pip install variantevalTo install from Github source for development, the following commands can be run.git clone https://github.com/broadinstitute/varianteval.git
pip install -e varianteval/Getting StartedDon’t! This API is currently in pre-pre-alpha form. Unless you’re helping to develop this library, don’t use it for anything!Getting helpThevarianteval documentation pageprovides detailed descriptions of API usage and algorithmic details. If you encounter bugs or have questions/comments/concerns, please file an issue on ourGithub page.Developers’ guideFor information on contributing tovariantevaldevelopment, visit ourdeveloper documentation.
Package: variantmap
VariantMap - Interactive heatmap for multi-sample structural variant analysisVariantMap is a genomic structural variant (SV) visualization technique that displays variants across multiple samples in
an interactive heatmap. It is a browser-based app implemented throughDashby Plotly. Each row of
the heatmap represents an input sample and each column represents an SV breakend found in the sample cohort. The colors
indicate the class of an SV present in a sample. More details of each variant can be displayed by simply hovering over them
. The heatmap can be customized to suit your analysis by changing various components in the "Customize" tab.VariantMap requires a dataframe object (HDF5 file) that can be generated byVariantBreakwhich in turn requires VCF files generated byNanoVarwhich calls SVs using third
-generation long-read sequencing data. Future upgrades will enable VariantBreak to use VCF files produced by other tools.Basic capabilitiesVisualize the prevalence of variants and their classes across sample cohortUser-friendly interface to analyze and customize your data without the use of programming languageObtain the variant size, score, read coverage, and genotype by simply hovering over themEasy filtering of variants by gene name, gene type, gene feature, repetitive elements, or other annotations, depending on input
annotation filesCapture snapshots of heatmap by just one clickConvenient uploading of datasets directly from the app interfaceGetting StartedLaunch the app and upload your HDF5 (.h5) dataset# This Python script is installed in your PATH, execute it from anywhere
variantmap_app.pyOperating system:Linux (x86_64 architecture, tested in Ubuntu 16.04)Installation:There are three ways to install VariantMap:Option 1: Conda# Installing from bioconda
conda install -c bioconda variantmapOption 2: Pip# Installing from PyPI
pip install variantmapOption 3: GitHub# Installing from GitHub
git clone https://github.com/cytham/variantmap.git 
cd variantmap
pip install .Installation of dependenciesThese should be automatically installed, or else, you have to install them manually:pandas >=1.1.4dash >=1.17.0tables >=3.6.11.pandaspip install pandasor
Please visitherefor instructions to install.2.dashpip install dashor
Please visitherefor instructions to install.3.tablespip install tablesorconda install -c conda-forge pytablesDocumentationSeewikifor more information.VersioningSeeCHANGELOGCitationNot availableAuthorTham Cheng Yong-cythamLicenseVariantMap is licensed under GNU General Public License - seeLICENSE.txtfor details.LimitationsVariantMap is only compatible with HDF5 datasets produced by VariantBreakVariantMap may not be able to handle large HDF5 files (>32M) in Google Chrome. Do try with Mozilla Firefox for these larger
files.
Package: variant-normalizer
Variant NormalizationServices and guidelines for normalizing variant termsBackend ServicesVariant Normalization relies on some local data caches which you will need to set up. It uses pipenv to manage its environment, which you will also need to install.InstallationVariant Normalization relies onseqrepo, which you must download yourself.From thevariantdirectory of the repository:pipenv sync
pip install seqrepo
mkdir -p data/seqrepo
seqrepo -r data/seqrepo pull -i 2021-01-29
sudo chmod -R u+w data/seqrepo
cd data/seqrepo
seqrepo_date_dir=$(ls -d */)
sudo mv $seqrepo_date_dir latestVariant Normalizer also usesuta.To install:uta_v=uta_20180821
docker pull biocommons/uta:$uta_v
export UTA_DB_URL=postgresql://anonymous@localhost:5432/uta/uta_20180821
docker-compose -f docker-compose.yml upDataVariant Normalization usesEnsembl BioMartto retrievevariant/data/transcript_mappings.tsv. We currently useHuman Genes (GRCh38.p13)for the dataset and the following attributes we use are: Gene stable ID, Gene stable ID version, Transcript stable ID, Transcript stable ID version, Protein stable ID, Protein stable ID version, RefSeq match transcript (MANE Select), Gene name.Setting up Gene NormalizerVariant Normalizationnormalizeendpoint relies on data from Gene Normalization. To install:pipinstallgene-normalizerTo setup, follow the instructions from theGene Normalization README.You must have the Gene Normalizer DynamoDB running for the variantnormalizeendpoint to work.Init coding style testsCode style is managed byflake8and checked prior to commit.We usepre-committo run conformance tests.This ensures:Check code styleCheck for added large filesDetect AWS CredentialsDetect Private KeyBefore first commit run:pre-commit installTestingFrom therootdirectory of the repository:pytest tests/Starting the Variant Normalization Servicegene-normalizers dynamodb must be running and run the following:docker-compose -f docker-compose.yml upFrom therootdirectory of the repository:uvicorn variant.main:app --reloadNext, view the OpenAPI docs on your local machine:http://127.0.0.1:8000/variant
Package: variant-tools
Variant ToolsA command line tool for the manipulation, annotation, and analysis of genetic variants
from next-generation sequencing studies.InstallationIf you are using a conda environment, you can install variant tools with commandconda install variant_tools -c bioconda -c conda-forgeOption-c conda-forgeis required to enforce the use ofconda-forgeversion of dependencies (e.g.boost-cpp) over their counterpoarts in the base channel.Otherwise, you can try to install it throughpippip install variant_toolsYou will need to installlibboostgslnumpyCythonhdf5bloscA C++ compiler such asgccwhich, in a conda environment, could be installed with commandconda install -c conda-forge boost-cpp gsl numpy cython blosc hdf5This method can be used if you download or clone the latest version
of variant tools from this repository.DocumentationPlease refer toVariant Tools documentationfor details.
Package: variational
Variational SDK for PythonDocumentationhttps://docs.variational.io/for-developers/apiQuickstart1. Create API credentialsNavigate to the API section athttps://testnet.variational.io/app/settingsCreate your key and make sure to save the secret part as it's only displayed once.2. Install Python SDKpip install variational3. Make some calls!fromvariationalimportClient,TESTNET,paginateclient=Client(API_KEY,API_SECRET,base_url=TESTNET)# if you have a lot of trades in the account, this might make multiple requests to fetch all of themtrades=list(paginate(client.get_portfolio_trades))4. ExploreVisitEndpoint Referenceto learn which API calls are supported.Read about thePaginationmechanism used by Variational API.Learn howRate LimitsandAuthenticationare applied to your calls.
Package: variationalsparsebayes
VariationalSparseBayesA PyTorch library for stochastic variational inference with sparsity inducing priors.A comparison plot for sparse Bayesian regression with a half-cauchy prior (L),
support vector regression (C), and the relevance vector machine (R). We see the
half-cauchy prior provides a more sparse solution and better error bars.What is VariationalSparseBayes?This package provides an implementation of the algorithm described inLouizos et. al. (2017)for use on a
broad class of machine learning problems.InstallationpipinstallvariationalsparsebayesUsageThe library provides a high-level interface with some prebuilt sparse Bayesian
models and a low-level interface for building custom sparse Bayesian models.High-level interfaceThe library provides a few sparse Bayesian models:sparse polynomial regressionsparse Bayesian neural networks.sparse learning withprecomputed featuresTo implement your own linear model, you can inherit from theSparseFeaturesLibraryclass.
Note that I haven't implemented the "group" sparsity idea presented inLouizos et. al. (2017).
Sparsification is performed at the parameter level (meaning far less computational savings).Low-level interfaceThe most important class provided by the library is theSVIHalfCauchyPrior.
The class inherits fromnn.Module.
The user is responsible for (i) transforming a batch of weights from the variational
posterior into a batch of predictions and (ii) adding the KL-divergence provided
by the prior onto the negative ELBO.fromtorchimportnnfromvariationalsparsebayesimportSVIHalfCauchyPriorclassMyModel(nn.Module):def__init__(self,num_params:int):super().__init__()# we initialize the prior with tau=1e-5 (see https://arxiv.org/pdf/1705.08665.pdf)self.prior=SVIHalfCauchyPrior(num_params,1e-5)...defforward(self,x,num_reparam_samples):w_samples=self.prior.get_reparam_weights(num_reparam_samples)sparse_index=self.prior.sparse_index# user transforms weights and inputs into predictions...defelbo(self,x,y):returnlog_like(x,y)-self.prior.kl_divergence()model=MyModel(num_params)...When it comes time to sparsify the approximate posterior run:model.prior.update_sparse_index()# get the index of all weights which remain after sparsificationmodel.prior.sparse_index
Package: variation-number
Variation NumberA package for calculating the variation number of nucleotide/protein sequence using sequence orthologs.Characteristic Attribute Organization System (CAOS) discovers rules associated with a given phylogenetic tree. A pure (Pu) rule or character attribute (CA) is a state that exists in all elements of a clade but not the alternate clade; a private (Pr) CA is present in some members of a clade but absent in the alternate clade. A variation number (VN) is defined as the number of occurrences of a position as a CA in all the tree clades.The method is described in the publication:Lai, J., & Sarkar, I. N. (2021). A Phylogenetic Approach to Analyze the Conservativeness of BRCA1 and BRCA2 Mutations. AMIA ... Annual Symposium proceedings. AMIA Symposium, 2020, 677–686.https://www.ncbi.nlm.nih.gov/pmc/articles/PMC8075528/FeaturesDownload orthologsBuild phylogenetic treesGenerate variation numbersRequired python packagesPython packages (most of which can be installed using pip) needed to run LYRUS include:skbio(0.5.6):http://scikit-bio.orgnumpy(1.22.3):https://numpy.org/install/Bio(1.79):https://biopython.org/wiki/DownloadBeautifulSoup(4.10.0):https://www.crummy.com/software/BeautifulSoup/bs4/doc/#installing-beautiful-soupRequired external packagesIn order to runvn.py, please installcommand lineversion for:Clustal Omega:http://www.clustal.org/omega/Mafft:https://mafft.cbrc.jp/alignment/software/PAUP:http://phylosolutions.com/paup-test/FastTree:http://www.microbesonline.org/fasttree/Running instructions for installation using pipvariation_number(0.2.5) is published onPyPI. Use the following command to install variation_number using pip:$pipinstallvariation-numberUsageimport variation_number as vn
import os
gene = 'BRCA1'
seqtype =' protein'
outputDir = '{}/output'.format(os.getcwd())

# Download orthologs from NCBI orthologs database (optional; can use user provided sequence file)
acc = vn.getFasta(gene, outputDir,seqtype,refseqID=None)

# Calculate variation number using clustal omega
vn.processVN(file='{}/{}'.format(outputDir, gene), outputDir, reindex=False, accession_full=acc, seqType=seqtype, aligned=False, alignTool='clustal', treeTool='paup')