Saravanan666/pypi-org huggingface dataset:
Package: pkhelper
PkhelperJust something to get my work doneInstallation~$pipinstallpkhelperCan download direct link from Command Line.Usage:~$pkhelper--ddlyourdirectlinkCan download gdrive files from command line.Usage:~$pkhelper--gdriveyourlinkYou can also use it in script.frompkhelperimportgdrivedownloadfile=gdrivedownload(url)As Simple as thisfrompkhelperimportdirect_dlfile=direct_dl(url)As  simple as this.frompkhelperimportdirect_dl_asyncasddl_afile=ddl_a(url)As Simple as this.You can run bash commands in python and get outputfrompkhelperimportbashoutput=bash("ffmpeg")If you want async bash command thenfrompkhelperimportbash_asyncoutput=awaitbash_async("ffmpeg")You can generate direct download links of all branches of a public github repofrompkhelperimportrepo_ddl_link_genddl_list=repo_ddl_link_gen("repository link")To upload to gofilefrompkhelperimport*json_text,download_page=awaitgofi_uploader(file)print(download_page)
Package: pkhpc1pyr
HP C1-Pyruvate Pharmacokinetic Modeling Package for PythonPurposeThis package was meant to create a more user friendly, open source version of the MATLAB developed by the MD Anderson Magnetic Resonance Engineering Laboratory.
The original repository is available at https://github.com/mda-mrsl/HP-C1Pyr-PKThese scripts calculate the relationship between [1-13C]-pyruvate and [1-13C]-lactate, but can easily be extended to include other metabolites.There are three base models, of differing complexity, which include a different number of physical compartments:The scripts titled P2L3*.py describe signal evolution between two chemical pools and three physical compartments. The three-compartment model is the most physiologically accurate among these models, but it is also the most computationally intensive, requiring the largest number of descriptive parameters.The scripts titled P2L2*.py are for the PK model with two chemical pools and two physical compartments. Here, HP pyruvate and lactate in the extravascular/extracellular space is assumed to be very well mixed with HP pyruvate in the intracellular space - and separate from pyr/lac in the vascular supply.The scripts titled P2L1*.py represent a simple precursor-product model, which does not consider physical compartmentalization of imaging agents. Equivalently, this assumes that all compartments (vascular; extravascular/extracellular; and cellular) are well mixed.Each script is accompanied by utilities and a test function which runs a model and plots the results for given parameters.InstallationRunning requires python version 3.10 or compatibleCan be installed from Pypi repository with pippip install pkhpc1pyrThe required dependencies can be found in the file requirements.txt and installed with the commandpip install -r requirements.txtThe installation can be tested by calling the TestP2L* functions without any arguments. For example:import pkhpc1pyr as pkpk.tests.TestP2L3()ContactFor questions about code or maintenance please contact Ryan Boycerboyce@mdanderson.orgFor further questions about the original MATLAB repository please contact Dr. Jim Banksonjbankson@mdanderson.org
Package: pki-client
AboutA convenient client to interact withtunfish-ca, a slightly improveddjango-ca. Its purpose is to easily create a RSA private/public key
pair and then have the CA create a certificate.Synopsispki-client \
    --ca-url=http://127.0.0.1:8000/ --ca-name=RootCA \
    --cacert=cacert.pem --key=example.key --certificate=example.pem --profile=server --common-name-prefix=node
Package: pkiexpress
# PKI Express for PythonPackage for using PKI Express on PythonThe recommend way to installPKI Express for Pythonis through [PyPi](https://pypi.org/):$ pip install pkiexpressOr informing on your project’srequirements.txtfile:pkiexpress==1.10.0## Documentationhttps://docs.lacunasoftware.com/en-us/articles/pki-express/python## SamplesPlease visit the [PKI Express samples repository](https://github.com/LacunaSoftware/PkiExpressSamples/tree/master/Python)
for examples on how to use this library.
Package: pkipplib
pkipplib is a Python library which can prepare IPP requests with the help of a
somewhat high level API. These requests can then be sent to an IPP printer or
print server (e.g. CUPS).
This library can also parse IPP answers received, and create high level Python
objects from them.
Both of these actions can be done through an IPPRequest class and its instance
methods.
Finally, a CUPS class can be leveraged to easily deal with CUPS print servers.
All of this library being written in the Python language, there’s no need to
link the code with the CUPS’ API, which makes it independant of the CUPS version
being installed. Some command line tools which rely on pkipplib are now included.
Package: pki-tools
PKI tools exposes a high levelcryptographyAPI for e.g.:Loading certificates from PEM strings/files/cryptography object into
apydanticmodel including allx509 v3 extensionsChecking revocation of certificates usingOCSPwithCRLfallbackDocsDocumentation is available
at:https://pki-tools.fulder.devQuickstartInstallpip install pki-toolsUsageLoading certificatefrompki_toolsimportCertificatecert_pem="""-----BEGIN CERTIFICATE-----<CERT_PEM_BYTES>-----END CERTIFICATE-----"""cert=Certificate.from_pem_string(cert_pem)Loading chainfrompki_toolsimportChainissuer_cert_pem="""-----BEGIN CERTIFICATE-----<ISSUER_CERT_PEM_BYTES>-----END CERTIFICATE-----"""chain=Chain.from_pem_string(issuer_cert_pem)Checking revocation using OCSP with CRL fallbackThe following example is using thecertandchainfrom the examples abovefrompki_toolsimportis_revokedifis_revoked(cert,chain):print("Certificate Revoked!")
Package: pkiutils
This is a set ofpycryptoandpyasn1based tools to create, load and verify
public key infrastructure material like:RSA keysPKCS#10certificate signing requestsInstallationpython setup.py installDocumentationPkiutils is documented usingSphinx, you can read the documentation athttp://python-pkiutils.readthedocs.org/.LicenseThe pkiutils package is licensed under the terms of the MIT license.Copyright (c) 2014 Jan DittbernerPermission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the “Software”), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
Package: pklcache
pklcacheThe name stands for pickle cache, and it is a quick anddirtyway of caching function results on disk usingpickle.This can be helpful for example in some machine learning tasks, where you have to preprocess the data with many time-consuming steps, and you want to not recompute things every time you run your program.Examplefrom pklcache import cache

@cache("foo_result.pkl")
def foo(*args, **kwargs):
    # time consuming operations here...
    return resultIf you run the programresult = foo()  #foo executedAnd if you run it againresult = foo()  #foo not executed, load result from diskThe first timefoois called its result is saved on disk onfoo_cache.pkl. If then the function is called another time or the program is run again,foois not executed, instead its return value is loaded from disk and returned.Args@cache(fpath, enabled=True)fpath: is the cache file pathenabled: ifFalsethe store/load is disabled and the function is executed like if it wasn't decorated. Useful during development and debugging.Installpip install pklcacheIf you don't want an external dependency just copy and paste the code in__init__.py
Package: pkldo
DescriptionPickled Data Object (pkldo) is method #470 for saving Python data to a file.  It provides
functionality for create, retrieve, update, and delete operations and uses Python’s built-in
Pickle routines.  It also performs operations atomically and offers file integrity.  Its
best fit is for applications with basic data persistence needs.Development StatusTested on BSD and Linux.Windows compatibility will be next.Documentation in progress.Quick ExampleHere’s a brief example of how to use a Pickled Data Object:>>> import pkldo
>>> class Test(pkldo.Pdo):
...     pass
...
>>> a = Test()
>>> a.some_data = "howdy"
>>> a.create_pdo('/tmp/some_file')
>>> b = Test()
>>> b.load_pdo('/tmp/some_file')
>>> b.some_data
'howdy'
>>> b.some_data = "hmmmm"
>>> b.save_pdo()
>>> c = Test()
>>> c.load_pdo('/tmp/some_file')
>>> c.some_data
'hmmmm'
>>> c.delete_pdo()
>>>
Package: pklib
pklibThis project is intend to reduce the effort of working in machine learning processVersion 0.0.1
-   Test Project UploadedVersion 0.0.2
- Project Update CheckVersion 0.0.3
- Libraries update to callVersion 0.0.4
- Imported Preprocessor from pklibsVersion 0.0.5
- Unintended df bug solved in Data Encoders
Package: pklshop
pklshopA library for accessing and analyzing Pickleball data frompklmart. You can find the full
documentationhere.InstallInstall using:pipinstallpklshopHow to useThis package includes the latest pickleball data from pklmart already
convieniently loaded into a pandas dataframe. You can access this data
by importing thepklshop.datamodule using:frompklshop.dataimport*(Note that since this package is writen usingnbdevit is safe to wildcard import because
the__all__variable is automatically generated for each module.)Once that’s done, this lib provides a functionget_tab_as_dfyou can use to create and display tables within the databaseAvailable tables are:table_names['tournament',
 'match',
 'game',
 'rally',
 'shot_type_ref',
 'shot',
 'player',
 'team']match.head()<style scoped>
    .dataframe tbody tr th:only-of-type {
        vertical-align: middle;
    }.dataframe tbody tr th {
    vertical-align: top;
}

.dataframe thead th {
    text-align: right;
}</style>match_idtourn_idconsol_indteam_id_1team_id_2maint_dtmmaint_appcreate_dtmcreate_app0M1T1NT1T22022-04-09 03:19:33.840951+00:00postgres2022-04-09 03:19:33.840951+00:00postgres1M2T2NT2T32022-05-26 00:45:11.301752+00:00postgres2022-05-26 00:45:11.301752+00:00postgres2M5T5NT6T52022-06-28 00:40:22.948360+00:00postgres2022-06-28 00:40:22.948360+00:00postgres3M6T6NT5T72022-07-07 23:01:45.921540+00:00postgres2022-07-07 23:01:45.921540+00:00postgres4M7T7NT8T92022-07-11 02:40:50.597016+00:00postgres2022-07-11 02:40:50.597016+00:00postgresg=Game("G1")g.summarize_game()Anna Leigh Waters & Leigh Waters beat Jesse Irvine & Catherine Parenteau 12-10 in game G1
             Player  Error %  Winner %
       Jesse Irvine    17.46      9.52
Catherine Parenteau     1.59      0.00
  Anna Leigh Waters     1.59      3.17
       Leigh Waters     9.52      4.76g.plot_impact_flow()To see a more complete analysis in action, check out theexamples.
Also check out Connor andthisanalysis by conner-mcnicholas on timeout momentum!r = Rally(“R1020”) r.animate_rally()
Package: pkman
pkmanA python package manager inspired by npm.Demomkdirmy-demo-package&&cdmy-demo-package
pkmaninit# edit package.jsonpkxinit-pypkg# if git repo is configured, bind remote branch on remote repository bypkxgitopsinitgit@host:username/repobranch# once you finished updating your code, sync code to remote bypkxgitopsupdate"update-code"
Package: pkmap
the Pseudo Karnaugh MapIntroductionThe Pseudo Karnaugh Map (PKMap),
a coloured Weighted / Multi-valued Karnaugh Map,
an Enchanced Karnaugh Map as the project's initially named,
is an evaluation method to visualize the imbalanced class distribution
of a dataset.This project was started to guide the generating of synthesis datasets
in which a self-collected data is added into a public dataset.
Later, we found it works in dataset imbalance representation as well.Why PKMapGain instructive insight of a datset before utilizing
is currently virtually impossible.
The PKMap is expected to offer an intuitionistic and visualized recognization
of the imbalanced classes distribution of a dataset.DocumantationPKMap DocumantationPublicationsA primiarypaperabout the PKMap has been publish, more is on the way.Lu Z, Liu G, Liao R. A pseudo Karnaugh mapping approach
for datasets imbalance. In: E3S Web of Conferences. Vol 236. EDP Sciences;
2021:04006. DOI:10.1051/e3sconf/202123604006Here is the BibLaTeX code:@inproceedings{lu2021,
  title = {A Pseudo {{Karnaugh}} Mapping Approach for Datasets Imbalance},
  booktitle = {{{E3S Web}} of {{Conferences}}},
  author = {Lu, Zhijian and Liu, Gang and Liao, Rongwen},
  editor = {Anpo, M. and Song, F.},
  date = {2021},
  volume = {236},
  pages = {04006},
  publisher = {{EDP Sciences}},
  doi = {10.1051/e3sconf/202123604006},
  eventtitle = {3rd {{International Conference}} on {{Energy Resources}} and {{Sustainable Development}} ({{ICERSD2020}})}
}
Package: pkm-buildsys
About This ForkThis is a poetry-core fork with some relaxations and additional features
Please seeRelaxed Poetryfor more informationThe rest of this README left as is from the original Poetry Core READMEPoetry CoreAPEP 517build backend implementation developed forPoetry. This project is intended to be a light weight, fully compliant,
self-contained package allowing PEP 517 compatible build frontends to build Poetry managed projects.UsageIn most cases, the usage of this package is transparent to the end-user as it is either made use by Poetry itself
or a PEP 517 frontend (eg:pip).In order to enable the usepoetry-coreas your build backend, the following snippet must be present in your
project'spyproject.tomlfile.[build-system]requires=["poetry-core"]build-backend="poetry.core.masonry.api"Once this is present, a PEP 517 frontend likepipcan build and install your project from source without the need
for Poetry or any of it's dependencies.# install to current environmentpipinstall/path/to/poetry/managed/project# build a wheel packagepipwheel/path/to/poetry/managed/projectWhy is this required?Prior to the release of version1.1.0, Poetry was a build as a project management tool that included a PEP 517
build backend. This was inefficient and time consuming in majority cases a PEP 517 build was required. For example,
bothpipandtox(with isolated builds) would install Poetry and all dependencies it required. Most of these
dependencies are not required when the objective is to simply build either a source or binary distribution of your
project.In order to improve the above situation,poetry-corewas created. Shared functionality pertaining to PEP 517 build
backends, including reading lock file,pyproject.tomland building wheel/sdist, were implemented in this package.  This
makes PEP 517 builds extremely fast for Poetry managed packages.
Package: pkmodel-zxara
pkmodel-zxaraA Python package for pharmacokinetics modelling of drug delivery systems.Read the Docshere.InstallationUse the package managerpipto install.pipinstallpkmodel-zxaraUsageNavigate to the model directory.cd lib/python3.8/site-packages/pkmodel_zxara/Run themain.py file.python3 -m __main__.pyTheoryPharmacokinetics (PK) provides a quantitative basis for describing the delivery of a drug to a patient, the diffusion of that drug through the plasma/body tissue, and the subsequent clearance of the drug from the patient’s system. PK is used to ensure that there is sufficient concentration of the drug to maintain the required efficacy of the drug, while ensuring that the concentration levels remain below the toxic threshold. For an introductory theory, we recommend "Principles of Pharmacokinetics", by Ratain et. al. Available from:https://www.ncbi.nlm.nih.gov/books/NBK12815/The model presented discretises the body into several linked, homogeneous compartments through which the concentration of an administered drug is tracked. It allows the user to specify the drug administration protocol, as well as physiological parameters.DemoThe program outputs a figure and the associated data. With these users may compare models with different protocols and physiological parameters. An example is provided in the results directory, as shown in the following figure.ContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.Please make sure to update tests as appropriate.LicenseMIT
Package: pkns
Public Key Name System FrameworkThis is the Public Key Name System Framework designed as a Public Key Exchange for both centralised and peer-to-peer services. It comes pre-built with useful and powerful CLI tools.InstallationFrom sourceTo install from source use the following command, make sure you havesetuptools>=50.0.0python3seutp.pyinstallTo install from PyPIpip3installpknsUsing thePKNS_TableAPIThePKNS_TableAPI is the core for the PKNS Local Services found in thepknscorefrompkns.pknscoreimportPKNS_Tablenew_table=PKNS_Table(PATH_TO_A_TABLE_DIR)PATH_TO_A_TABLEcan be a path to an existing table directory or a new table directory, defaults to~/.pkns.
The API provides all basic table operations.Using thePKNS_ServerAPIThePKNS_ServerAPI is the core of PKNS Network Services found in thepknscore. It provides the correct server handling and configuration for a hosted PKNS Services. The PKNS service runs on the default port6300.  It is capable to handle multiple clients and process multiple requests and can be safely daemonized.frompkns.pknscoreimportPKNS_Serverserver=PKNS_Server(IP_ADDR,PORT,PATH_TO_A_TABLE_DIR)IP_ADDRis the IP Address to use for the server, defaults to0.0.0.0,PORTis the port to be used for the server, defaults to6300,PATH_TO_A_TABLEcan be a path to an existing table directory or a new table directory, defaults to~/.pkns.Query SyntaxPKNS Query is used for better integration of centralised servers. The query follows a fixed Syntaxpkns://HOST_SERVER[:PORT][/PEERGROUP][/USER]CLI ToolsCLI Tools help manage the PKNS Tables and Servers easily, they also include useful functions.Local Table ManagertabmanManaging Local Tables$pknstabman
Usage:pknstabman[OPTIONS]COMMAND[ARGS]...PKNSTableManager

Options:--helpShowthismessageandexit.

Commands:add-peergroupAdd/CreateaPeergroupadd-userAddUserstoaPeergroupdel-peergroupDelete/LeaveaPeergroupdel-userRemoveUsersfromaPeergroupget-peergroupGetInfoofaPeergroupget-userGetUsersInfofromaPeergrouprename-peergroupRenameaPeergrouprename-userRenameaUserfromaPeergroupServer ManagerserverServer Utilities$pknsserver
Usage:pknsserver[OPTIONS]COMMAND[ARGS]...PKNSServerManager

Options:-i,--hostTEXTIPAddresstobind[default:0.0.0.0]-p,--portINTEGERPorttobind[default:6300]--helpShowthismessageandexit.

Commands:restartRestartPKNSServerstartStartthePKNSServerstatusPKNSServerStatusstopStopthePKNSServerOther utilitiesPingPing a Local or Remote Server$pknsping--help
Usage:pknsping[OPTIONS][ADDRESS]PKNSPing

Options:-n,--nopINTEGERNumberofPingstosend--helpShowthismessageandexit.QueryQuery Local or Remote Server$pknsquery--help
Usage:pknsquery[OPTIONS]QUERYPKNSQuery

Options:--helpShowthismessageandexit.SyncSync to Local or Remote Server$pknssync--help
Usage:pknssync[OPTIONS][ADDRESS]PKNSSync

Options:--helpShowthismessageandexit.
Package: pknulms
부경대학교 Smart-LMS Python 클라이언트사용법importsysfrompknulmsimportLMSClientlms=LMSClient()ifnotlms.login('사용자 아이디','사용자 비밀번호'):print('로그인에 실패했습니다.')sys.exit(0)iflms.send_note('받는 사람 아이디','제목','내용'):print('쪽지 전송 성공')else:print('쪽지 전송 실패')lms.logout()
Package: pkp
😸 pkp ⚡⚡pkp(pronunciation) is a
simple CLI tool to query KeePass databases from CLI.It's built on the awesomepykeepass library.InstallationBinaryThe easiest way to start would be to check out thelatest release.NOTE: The-termuxbinaries are manually built on Termux with./build.sh termux(no CI).zinit# KeePass(){localextra_args=()ifcommand-vtermux-info>/dev/nullthenextra_args=(bpick"*termux")fizzinit\$extra_args\as"command"\from"gh-r"\sbin"pkp* -> pkp"\forpschmitt/pkp}From pypi# Recommendedpipxinstallpkp# Boring alternativepip3install--userpkpUsageJust runpkp --help. You'll get it:usage: pkp.py [-h] [-V] -f FILE [-p PASSWORD] [-F KEYFILE] [-I] [-r] [-C] [-D]
              {list,ls,l,get,g,entry,e,show,display,sh,ds,search,find,fd,se,f,s}
              ...

positional arguments:
  {list,ls,l,get,g,entry,e,show,display,sh,ds,search,find,fd,se,f,s}
                        sub-command help
    list (ls, l)        List entries (by path)
    get (g, entry, e)   Get entries
    show (display, sh, ds)
                        Show entry data
    search (find, fd, se, f, s)
                        Find entries

optional arguments:
  -h, --help            show this help message and exit
  -V, --version         show program's version number and exit
  -f FILE, --file FILE  KeePass DB file
  -p PASSWORD, --password PASSWORD
                        Password
  -F KEYFILE, --keyfile KEYFILE
                        Key file
  -I, --case-sensitive  Case sensitive matching
  -r, --raw             Disable REGEX path search
  -C, --no-color        Disable colored output
  -D, --debug           Debug mode
Package: pkpass-olcf
PKPass: Public Key Based Password ManagerRTDhttps://pkpass.readthedocs.io/en/latest/Requires >= Python 3.6OverviewThis is a basic password store and password manager for maintaining arbitrary secrets.The password management solution provides:Encryption at RestPassword distribution/organization based on definable hierarchiesPassword creation timestampsPassword history and change logsDistributed backup capabilitiesPIV/Smartcard Credential encryption/decryptionImport and export functionalityPasswords that are created are distributed to recipients by public key encryption.  The x509 certificate of the intended recipient is used to create an encrypted copy of the distributed password that is then saved in a password-specific git repository.  Multiple encrypted copies of the secret are created, one for each user.  End users then check out the git repo and are able to read passwords using their PIV/Smartcard credential to decrypt.InstallEverything:pip install pkpass-olcfMacOs:brew install olcf/tap/pkpassx509 Certificate RepositoryPKPass needs a trusted x509 certificate repository, which typically is managed using git.  Certificates in this repository should all be
signed by Certificate Authorities that can be found in the CABundle file that PKPass is configured to look at.  Since this repository should be
considered 'trusted', it is typically managed by a smaller trusted set of site administrators.  PKPass validates all encryption certificates as they are used to make sure they are signed by a trusted Certificate Authority (CA).You may also use a local x509 certificate repository that you sync with others using RSYNC, NFS, shared volumes, etc.  You can configure the directory that pkpass will use for the certificate repository either on the command line, or through the .pkpassrc file.The CABundle file to use can also be configured in the .pkpassrc file or on the command line.Additionally, certificates should be named .cert.  For example, the certificate for user 'jason' should be named 'jason.cert' inside this x509 directory.Password RepositoryPKPass also needs a directory to serve as a 'password database'.  Like the x509 certificate repository, it is also typically managed with git to provide change control, history, and tracking of changes.  Local directories can also be used and shared via rsync, NFS, shared volumes, etc if preferred.To change the default password repository, you may specify another directory on the command line or in the .pkpassrc file.