Saravanan666/pypi-org huggingface dataset:
Package: prostate-nomograms
Prostate NomogramsA simple implementation of prostate cancer nomograms.Prostate cancer nomograms are prediction tools designed to help patients and their physicians understand the nature of their prostate cancer, assess risk based on specific characteristics of a patient and his disease, and predict the likely outcomes of treatment.1InstallationLatest stable version :pip install prostate-nomogramsLatest (possibly unstable) version :pip install git+https://github.com/MaxenceLarose/prostate-cancer-nomogramsQuick usage previewimportpandasaspdfromprostate_nomogramsimportMskccPreRadicalProstatectomyNomogram,ClassificationOutcomemskcc_nomogram=MskccPreRadicalProstatectomyNomogram(outcome=ClassificationOutcome.LYMPH_NODE_INVOLVEMENT)dataframe=pd.read_csv("data.csv")probability=mskcc_nomogram.predict_proba(dataframe)MotivationNomograms are typically implemented as web-based applications in which a physician must fill in certain boxes using a patient's medical information. Once all the boxes are filled in, the prediction tool can either calculate the probability of several clinical outcomes or calculate a risk score associated with the patient's health status, depending on the type of nomogram. Thepurposeof this application is to speed up the process for a very large number of patients. Indeed, the statistical models of the nomograms are reproduced in Python which allows to calculate in a few seconds the probabilities and the scores of thousands of patients. The coefficients of the models are read from the web sites, then used for the calculations.Which nomograms are currently implemented?Currently, the nomograms of two major centers are implemented, namely :Memorial Sloan Kettering Cancer Center (MSKCC)Pre-Radical ProstatectomyUCSF - CAPRACAPRA ScoreThe MSKCC nomogram directly gives the probability and risk of different outcomes. The UCSF one gives a CAPRA score, which is then converted to probability using logistic regression or cox regression on patient data.Note that a custom nomogram is also implemented, i.e. a simple logistic regression or cox regression using arbitrary variables.Getting startedYou can find exampleshere.LicenseThis code is provided under theApache License 2.0.Citation@misc{prostate-nomograms,
  title={prostate-nomograms: Prediction tools based on existing prostate cancer nomograms},
  author={Maxence Larose},
  year={2022},
  publisher={Université Laval},
  url={https://github.com/MaxenceLarose/prostate-nomograms},
}ContactMaxence Larose, B. Ing.,maxence.larose.1@ulaval.ca
Package: prostlab
Prost LabProst Lab is a Python package for performing experiments with theProst
planner. It is based on theLab toolkit, so most of theLab
documentationis also relevant for Prost Lab.Setting up Prost LabTo set up the virtual environment for Prost Lab in the directory/path/to/prostlab-venv, perform the following steps:cd /path/to/prostlab-venv(switch to directory)python3 -m venv prostlab-venv(create virtual environment)source prostlab-venv/bin/activate(activate the virtual environment)pip install -U pip(upgrade pip)pip install prostlab(install prostlab)If you want to install the latest development version and/or need to
change Prost Lab itself, you can clone the Prost Lab repository and
install it in the virtual environment:git clone https://github.com/prost-planner/prostlab.git(clone the repo)cd prostlab(switch into prostlab directory)pip install --editable ./(install prostlab)In both cases, you need to define two environment variables to perform
experiments with Prost Lab:PROST_BENCHMARKS points to the testbed/benchmarks directory of your prost cloneRDDLSIM_ROOT points to the root directory of rddlsimPerforming an experimentSeethe Prost
wikifor
information on how to perform an experiment with Prost using Prost Lab.
Package: prosuite
Dira ProSuite Python ClientFunctionalityThe Dira ProSuite Python Client is the Python API for the ProSuite Quality Verification Server. ProSuite is a suite of high-end productivity tools for ArcGIS for data production, quality assurance, and cartographic refinement.The ProSuite Python Client API is a lightweight package that provides access to the ProSuite QA functionality. It has been specifically designed as an easy-to-use programming interface that supports intellisense and comes with a documentation and samples.
Quality specifications containing QA tests for geodata can be fully defined in Python and executed on a ProSuite server which runs either locally or on a remote machine. Alternatively, an existing XML specification can be executed with just a few lines of code.Find out more about ProSuite atDira GeoSystems.Installationpip install prosuiteDocumentationSeeProSuite Python.
Package: proSVD
Procrustean SVD (proSVD)Tools for streaming dimension reduction analyses of neural data.Seedemos/for usage.To build:$ git clone https://github.com/pearsonlab/proSVD
$ cd proSVD
$ pip install .To import:from proSVD import proSVDUnder active development! Please contactpranjal.gupta@duke.edufor any inquiries.
Package: prot
Prot - Pro Tools for Python 3Note: this readme is not updated and does not reflect the latest applied patches. A huge update is under the way!Modulesclassesfunctionsconverterssettingsclasses ModuleDatabaseOptionsDatabaseProgressProgressBar(fromProgressandBarWidget)LockedDictStrTextListFileWidgetTimeWidgetBarWidgetTaskWidgetCallWidgetValueWidgetLoadingWidgetfunctions ModuleverifyColorinsertColorgetRandomPasswordtestSpeedgetVarFromFilecheckMethodscallMethodscallMethodsWithArgcheckFileSamesplitStrrunAsMainprintMsgprintErrprintWarnconverters Modulerst2htmldict2matrixstr2listlist2strmatrix2strPackagescolorpipprogresspromptwcwidthpip Packagethis is a Advanced pip Tool, this Package has a List of all pip Packages that you can Search, Download and Install them and you can Update this List anytime you wantFeaturesit has built in Packages Listyou can do an Offline Searchcan Create Offline Repositirycan do Batch Install or Download with built in List or use Custom Listand more...
Package: protarrow
ProtarrowProtarrowis a python library for converting from protobuf to arrow and back.It is used atTradewell Technologies,
to share data between transactional and analytical applications,
with little boilerplate code and zero data loss.InstallationpipinstallprotarrowUsageTaking a simple protobuf:messageMyProto{stringname=1;int32id=2;repeatedint32values=3;}It can be converted to apyarrow.Table:importprotarrowmy_protos=[MyProto(name="foo",id=1,values=[1,2,4]),MyProto(name="bar",id=2,values=[3,4,5]),]table=protarrow.messages_to_table(my_protos,MyProto)nameidvaluesfoo1[1 2 4]bar2[3 4 5]And the table can be converted back to proto:protos_from_table=protarrow.table_to_messages(table,MyProto)See thedocumentation
Package: protclus
protclus - Minimal Python 3 library for Protein Complex Discovery in PPI NetworksThis is a Python 3 library containing clustering algorithms chiefly used for protein complex discovery in protein-protein interaction (PPI) networks.It is inspired by the collection of Python 2 scripts inhttps://github.com/trueprice/python-graph-clustering(which is unfortunately due to deprecate in 2021) --- but updated for Python 3 and rewritten to as a set of classes and methods. As a result it is significantly easier to import and integrate into projects. Additionally it benefits from some additional flexibility in the output and some improvements on the speed of the algorithms.It benefits from extremely simple usage that is shared between all of the methods# Example using MCODEfilename="data/unweighted_example_network.txt"c=MCODE(filename)c.cluster()print(c.clusters())c.save_clusters("mcode_example_clusters.txt")MethodsCurrently IncludedMCODEby Gary D. Bader and Christopher W. V. Hogue "An automated method for finding molecular complexes in large protein interaction networks."DPCLUSby Md Altaf-Ul-Amin et al. "Development and implementation of an algorithm for detection of protein complexes in large interaction networks."IPCAby Min Li, Jian-er Chen, Jian-xin Wang, Bin Hu, and Gang Chen. Modifying the dpclus algorithm for identifying protein complexes based on new topological structures.COACHby by Min Wu, Xiaoli Li, Chee-Keong Kwoh, and See-Kiong Ng. "A core-attachment based method to detect protein complexes in ppi networks."Coming SoonGraph Entropyby E. C. Kenley and Y. Cho "Entropy-Based Graph Clustering: Application to Biological and Social Networks"InstallationInstallation from PyPIpipinstallprotclusInstallation from source from the project root folder wheresetup.pycan be done viapipinstall-e.Testingpythonsetup.pytestCitationIf this work was of use to you please cite the original authors of each of the algorithms and the previous Python2 script authors.Additionally please consider citing the following paper, as this library was developed as part of@misc{protclus,
      title={Incorporating network based protein complex discovery into automated model construction}, 
      author={Paul Scherer and Maja Trȩbacz and Nikola Simidjievski and Zohreh Shams and Helena Andres Terre and Pietro Liò and Mateja Jamnik},
      year={2020},
      eprint={2010.00387},
      archivePrefix={arXiv},
      primaryClass={q-bio.MN}
}
Package: protcur
#+TITLE: protcur#+AUTHOR: Tom Gillespie#+HTML: <a href="https://pypi.org/project/protcur/"><img alt="PyPI version" src="https://badge.fury.io/py/protcur.svg"></a># #+HTML: <a href="https://travis-ci.org/tgbugs/protc"><img alt="Build Status" src="https://travis-ci.org/tgbugs/protc.svg?branch=master"></a># #+HTML: <a href="https://coveralls.io/github/tgbugs/protc?branch=master"><img alt="Coverage Status" src="https://coveralls.io/repos/github/tgbugs/protc/badge.svg?branch=master"></a>A dashboard for web annotation workflows for protocol curation.* Setup** Python=pip install protcur=** GentooAs root.#+BEGIN_SRC bashlayman -a tgbugs-overlayemerge -p protcurvim /etc/portage/package.accept_keywordsemerge protcurvim /etc/conf.d/protcurrc-config add protcur default/etc/init.d/protcur start#+END_SRC
Package: protean-elasticsearch
Protean Elasticsearch ExtensionFree software: BSD 3-Clause LicenseInstallationpip install protean-elasticsearchDocumentationhttps://protean-elasticsearch.readthedocs.io/Developmentpyenv virtualenv -p python3.6 3.6.5 protean-es-devTo run the all tests run:toxNote, to combine the coverage data from all the tox environments run:Windowsset PYTEST_ADDOPTS=--cov-append
toxOtherPYTEST_ADDOPTS=--cov-append toxChangelog0.0.1 (2018-07-20)First release on PyPI.
Package: protean-flask
Protean Flask ExtensionFree software: BSD 3-Clause LicenseInstallationpip install protean-flaskDocumentationhttps://protean-flask.readthedocs.io/Developmentpyenv virtualenv -p python3.7 3.7.2 protean-flask-devTo run the all tests run:toxNote, to combine the coverage data from all the tox environments run:Windowsset PYTEST_ADDOPTS=--cov-append
toxOtherPYTEST_ADDOPTS=--cov-append toxChangelog0.0.1 (2018-07-20)First release on PyPI.0.0.6 (2018-12-28)Base version of the library.0.0.9 (2019-03-11)Sync with protean 0.0.9.
Package: protean-sqlalchemy
Protean Sqlalchemy ExtensionFree software: BSD 3-Clause LicenseInstallationpip install protean-sqlalchemyDocumentationhttps://protean-sqlalchemy.readthedocs.io/Developmentpyenv virtualenv -p python3.6 3.6.5 protean-es-devTo run the all tests run:toxNote, to combine the coverage data from all the tox environments run:Windowsset PYTEST_ADDOPTS=--cov-append
toxOtherPYTEST_ADDOPTS=--cov-append toxChangelog0.0.10 (2019-04-09)Match functionality with version 0.0.10 of proteanSupport for chained update and delete methods on QuerySetSupport for update_all method for mass updates on objectsSupport for delete_all method for mass deletion of objectsRename databases configuration key in Config file from REPOSITORIES to DATABASESSplit Adapter class into Provider and RepositorySubclass from BaseLookup instead of LookupCentralize model registrations for the test suiteUse Pytest fixtures instead of setup and teardown methods0.0.9 (2019-03-11)Match with version 0.0.9 of protean0.0.7 (2019-03-04)Match with version 0.0.7 of protean0.0.6 (2018-12-28)Match with version 0.0.6 of protean0.0.1 (2018-07-20)First release on PyPI.
Package: proteas-lib
GSOC 2019 - A DIY robot kit for educatorsThe proteas library is a python robotics library for
Raspberry Pi. This library created for the "GSOC 2019 - A DIY robot kit for educators"
by Christos Chronis. This library mainly designed to work along the Jupyter Notebook
but works fine direct from any python script. You can easly control all the electronics
parts of a robot with minimun requirement the GPIO pin number. In the library you can also find
some applications of computer vision with OpenCV, such as face detection, arruco artifact detection
e.t.c.. More informations onhttps://github.com/eellak/gsoc2019-diyrobot.
Package: protec
ProtecFeaturesTODORequirementsTODOInstallationYou can installProtecviapipfromPyPI:$pipinstallprotecUsagePlease see theCommand-line Referencefor details.ContributingContributions are very welcome.
To learn more, see theContributor Guide.LicenseDistributed under the terms of theApache 2.0 license,Protecis free and open source software.IssuesIf you encounter any problems,
pleasefile an issuealong with a detailed description.CreditsThis project was generated from@cjolowicz'sHypermodern Python Cookiecuttertemplate.
Package: protecc
proteccAccess modifiers for python.SetupPIP installpipinstallproteccFrom the sourcegitclonehttps://github.com/avinashshenoy97/protecccdprotecc
pythonsetup.pyinstallUsageOld-Style ClassesInherit from/extend theproteccclass.fromproteccimportproteccclassregulatedClass(protecc):def__init__(self):self.publicVariable='public value'self._privateVariable='private value'defpublicMethod(self):returnTruedef__privateMethod(self):returnTruedefgetPrivateVariable(self):returnself._privateVariabledefprivateMethodProxy(self):returnself.__privateMethod()New-Style Classes (type)If you prefer metaclass (for better readability/what not), usemetaProtecc.classmetaRegulatedClass(metaclass=metaProtecc):def__init__(self):self.publicVariable='public value'self._privateVariable='private value'defpublicMethod(self):returnTruedef__privateMethod(self):returnTruedefgetPrivateVariable(self):returnself._privateVariabledefprivateMethodProxy(self):returnself.__privateMethod()When accessing "private" methods (i.e, methods that begin with either a single or two underscores), this exception is raised>>>r=regulatedClass()>>>r.__privateMethod()Traceback(mostrecentcalllast):File"<stdin>",line1,in<module>File"/Users/avinashshenoy/STUFF/projects/protecc/protecc.py",line23,in__protecced_getattribute__raiseAccessException('Cannot access '+varType+' member '+name)fromNoneprotecc.AccessException:Cannotaccessprivatemember__privateMethodPrivate methods can still be accessed from within other class methods, as is expected:>>>r=regulatedClass()>>>r.privateMethodProxy()TrueNoteThis is, by no means, fool-proof access protection."Private members" are those members whose names are mangled by Python, as per PEP 8 conventions, i.e, starting with 2 underscores and having not more than one trailing underscore.Additionally, "protected members" are those members whose names are preceded by a single underscores. These members cannot be accessed from outside the class as well, as is expected.Primary ContributorsAvinash ShenoyLicenseThis project is released under theMIT License.
Package: protected
pyzopfli======"Protected" data types to hide secrets in Django config files.Running a Django server in debug mode risks exposing secrets like APIkeys and passwords to the world.  While Django will "filter out"certain values, it still makes available the contents of localvariables which might also contain hidden keys.Protected works by breaking the object's __repr__ method to prevent casual display.from protected import ProtectedString>>> print ProtectedString('abc')abc>>> print repr(ProtectedString('abc')<Protected String 'abc'>
Package: protectedblob
# protectedblob[![Build Status](https://travis-ci.org/lukhnos/protectedblob-py.svg?branch=master)](https://travis-ci.org/lukhnos/protectedblob-py)protectedblob is a library and a utility that can create apassphrase-protected blob from a plaintext as well as decrypt it.This is still a work in progress. I am working on[a mobile password manager](https://github.com/lukhnos/PocketPasswords)that depends on it. This project is also an exercise in creating a librarythat supports both Python 2.7 and 3.4, among many other library developmentdrills.Also please be warned that this code has not been through any securityreview. Use this at your own risk.## Supported PlatformsThis is currently tested only on OS X, but it should work on general *NIX.There's currently no Windows support.The code can be used with Python 2.6.9, 2.7, and 3.4.## UsageTo install:python setup.py installIt's very likely that you'll need `sudo`:sudo python setup.py installThis library depends on [PyCrypto](https://www.dlitz.net/software/pycrypto/),which in turn requires a C compiler to build. For OS X users, this means youhave to have Xcode or Xcode Command Line Tools installed (so that you have theClang C/C++ compiler). On Linux, you'll need gcc, and, on a lot ofdistributions, a corresponding Python development package, such as`python-devel` on CentOS or `python-dev` on Debian or Ubuntu.Alternatively, install the code in development mode:python setup.py developTo encrypt a file:protectedblob encrypt --input <input file> --output <output file>You'll be prompted for the passphrase twice. There's also an optional`--rounds` argument to override the default number of rounds.To decrypt:protectedblob decrypt --input <input file> --output <output file>## High-Level DescriptionA passphrased-protected blob has two types of data: An encrypted key, and theactual ciphertext. Before encrypting the plaintext, we generate a random key.This makes it possible to change passphrase later.The random key is encrypted with another key derived from the suppliedpassphrase. A key-derivation function (KDF) is used. To increase the strengthof the derived key, many rounds are used.The key derivation function is PBKDF2 with the underlying PDF being SHA-256. Arandom salt is also generated. The default number of rounds is 65536, althoughmore should be used on fast computers.The real encryption key is encrypted using AES-256 (128-bit block, 256-bitkey) in ECB mode. We actually don't use the encryption key directly. Rather,we derive two more keys from it: One for the AES-256 cipher, another for theHMAC function. The two keys are derived by using an AES-256 in ECB mode toencrypt 32 bytes of 0x00's and 32 bytes of 0x01's, respectively. The plaintextis then encrypted using AES-256 in CBC mode with a 128-bit IV (initializationvector).The library implements authenticated encryption. The HMAC function is SHA-256,and the HMAC is created from the ciphertext (so encrypt-then-mac).
Package: protected-classification
Protected  classificationThis library contains the Python implementation of Protected probabilistic classification. The method is way of protecting probabilistic prediction models against changes in the data distribution, concentrating on the case of classification. This is important in applications of machine learning, where the quality of a trained prediction algorithm may drop significantly in the process of its exploitation under the presence of various forms of dataset shift.Installationpip install protected-classificationThe algorithm can be applied on top of an underlying scikit-learn algorithm for binary and multiclass classification problems.Usagefrom protected_classification import ProtectedClassification
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import log_loss
from sklearn.datasets import make_classification
import numpy as np

np.random.seed(1)

X, y = make_classification(n_samples=1000, n_classes=2, n_informative=10, random_state=1)
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=1)
clf = RandomForestClassifier()
clf.fit(X_train, y_train)
p_test = clf.predict_proba(X_test)

# Initialise Protected classification
pc = ProtectedClassification(estimator=clf)

# Calibrate test output probabilities
pc.fit(X_train, y_train)
p_prime = pc.predict_proba(X_test)

# Compare log loss of underlying RF algorithm and Protected classification
print('Underlying classifier log_loss (no dataset shift) ' + f'{log_loss(y_test, p_test):.3f}')
print('Protected classification log loss (no dataset shift) ' + f'{log_loss(y_test, p_prime):.3f}')

#  Assume a dataset shift where a random portion of the class labels is set to a single class
y_test[:100] = 0
ind = np.random.permutation(len(y_test))
X_test = X_test[ind]
y_test = y_test[ind]    

p_test = clf.predict_proba(X_test)

# Generate protected output probabilities  (assuming that test examples arrive sequentially)
pc = ProtectedClassification(estimator=clf)
p_prime = pc.predict_proba(X_test, y_test)

# Compare log loss of underlying RF algorithm and Protected classification
print('Underlying classifier log_loss (dataset shift) ' + f'{log_loss(y_test, p_test):.3f}')
print('Protected classification log loss (dataset shift) ' + f'{log_loss(y_test, p_prime):.3f}')ExamplesFurther examples can be found in the github repositoryhttps://github.com/ip200/protected-calibrationin theexamplesfolder:simple_classification.ipynbfor an example of the method appplied to calibrate the outputs of the underlying algorithmprotected_classification.ipynbfor an example of the method used to protect the underlying algorithm under various forms of dataset shiftCitationIf you find this library useful please consider citing:Vovk, Vladimir, Ivan Petej, and Alex Gammerman. "Protected probabilistic classification." In Conformal and Probabilistic Prediction and Applications, pp. 297-299. PMLR, 2021. (arxiv versionhttps://arxiv.org/pdf/2107.01726.pdf)
Package: protectonce
python-agentAgent to callagent_coreusingagent_interfaceMinimum requirements (Linux)install python3Install pippython3 -m pip install --user --upgrade pipinstall virtualenvpython3 -m pip install --user virtualenvinstall nodejsPython PackagingPackaging minimum requirementsPython3sudo apt-get install python3.xBuild python package./packaging/packaging.shBuild and publish python package to pypip./packaging/packaging.sh -pTestsRun./tests/test.sh
Package: protectonce-native
agent_interfaceInterface to call agent_core from different run times other than nodejsCompilationBuild Minimum requirements (Linux)Install cmakeapt-get install -y cmakeCompilationRun script./build.shPython PackagingPackaging minimum requirementsPython3sudo apt-get install python3.xnvm needs to be installed
How to install nvm? refer this linkhttps://www.digitalocean.com/community/tutorials/how-to-install-node-js-on-ubuntu-20-04Build python package./packaging/packaging.shBuild and publish python package to pypip./packaging/packaging.sh -pTestingUnit tests and Component testsBuild Minimum requirement for Unit and Component testsInstall docker,install nodejsCompilation and ExecutionRun both tests./tests/test.shUnit TestsTestingagent_interfacewith mockedagent_coreCompilation and ExecutionRun./tests/test.sh -uWhere is test report?HTML test report is generated on path/tests/unit/out/reports/Unit_test_report.htmlRun Unit tests on list of raw docker imagesRun./tests/unit/docker_test.shComponent testsTestingagent_interfaceandagent_corewith mockedpo_backend_mockCompilation and ExecutionRun./tests/test.sh -cWhere are test reports?HTML test report is generated on path/tests/component/out/reports/Component_test_report.html
Package: protectremote
ProtectRemotenext-gen security solution for remote workersInstallpip install protectremoteUsageFLASKProtect all routesfromflaskimportFlaskfromprotectremoteimportProtechRemoteMiddlewareapp=Flask(__name__)app.wsgi_app=ProtechRemoteMiddleware(app.wsgi_app)@app.route('/')defpublic():return'Hello'@app.route('/secured')defsecured():return'secured'if__name__=='__main__':app.run()Protect specific route onlyfromflaskimportFlaskfromprotectremoteimportpr_accessapp=Flask(__name__)@app.route('/')defpublic():return'Hello'@app.route('/secured')@pr_access()defsecured():return'secured'if__name__=='__main__':app.run()### DJANGO