Saravanan666/pypi-org huggingface dataset:
Package: portray
Read Latest Documentation-Browse GitHub Code RepositoryThe only thing worse than documentation never written, is documentation written but never discovered.portrayis a Python3 command line tool and library that helps you create great documentation websites for your Python projects with as little effort as possible.Key Features:Zero-Config: No configuration is necessary to useportray. Just runportrayin the root of your Python project and it will find your documentation.Statically Generated:portraywebsites are easy to host on GitHub pages and other similar services as they are outputted as standard static HTML websites.Markdown Aware:portraywill automatically include your project's.mdfiles and render them into HTML. It will also find and render Markdown within__doc__strings.Fully Configurable: Whileportraydoesn't have to be configured, you still can fully configure it within the standardpyproject.tomlfile.Easily Programmable:portrayexposes a clean and simplePython API.Searchable: Out of the box,portraymakes all of your documentation, even autogenerated code references, free-text searchable.Themeable:portrayis compatible with all existingMkDocs Themes.Under the hood, portray combines theMarkdowndocumentation rendering capabilities provided byMkDocswith the automatic reference documentation generated bypdocs.Quick StartThe following guides should get you up and running with a documentation website in no time.Installation- TL;DR: Runpip3 install portraywithin your project's virtual environment.Command Line Usage- TL;DR: Runportray in_browserto test andportray on_github_pagesto deploy.API Usage- TL;DR: Everything available via the CLI is also easily available programmatically from within Python.Configuration- TL;DR: Put all configuration within a[tool.portray]section of yourpyproject.tomlfile.Why Create Portray?I create a lot of Python projects and I've always wanted a quick way to build documentation sites for them that included both manually written guides and autogenerated reference documentation.
Tools have improved over the years, but still nothing has given me this experience out of the box. Portray isn't a competitor for the 2 newer Python documentation projects (pdocs and MkDocs), rather it is melding of them
together to give me the quick to create and comprehensive documentation website generation I've always wanted.Thanks and I hope you too findportrayuseful!~Timothy Crosley
Package: portrayt
portraytThis project combines e-paper, raspberry pi's, and StableDiffusion to make a picture frame that portrays anything you ask of it.E-Ink Screen + Raspi on an easelDashboard ViewDevelopmentInstalling python dependenciespoetryinstallRunning Testspytest.Formatting Codebash.github/format.shLintingbash.github/check_lint.shRunning the ProgramInstall dockercurl-sSLhttps://get.docker.com|sh
sudogroupadddocker
sudousermod-aGdocker$USERCreate a .env file in your current directory and fill in the API key:REPLICATE_API_TOKEN=<yourtokenhere>RENDERER=inkyBuild and run the imagedockercomposeup--build-dWhen using a Raspberry pi, make sure to enable the spi interface by going toraspi-config,
interface options, and selecting enable.Running on desktopFor local development, OpenCV is used to render images to a window. The.envfile needs
to be updated to allow opencv to be installed (and used for rendering).In the.envfile, fill out the following:REPLICATE_API_TOKEN=<your token here>
RENDERER=opencv
POETRY_EXTRAS=--extras opencvThen, in terminal give docker access to the X window manager:xhost+Then build and run using the above commands.
Package: port-scanner
# Python Port ScannerA simple port scanner built with Python## How it worksThis scans a range of ports for a given URL and prepares a report showing which ports are open.## InstructionsInstall with Pip/PyPi in the command line interface:` pip installport-scanner`In your Python code, import the library:` import portscanner `Create an instance of the Target class:` my_target =portscanner.Target("example.com")`Scan your target one or more times. All the settings shown below are optional, and the example code shows what the defaults would be if nothing is specified.“min” and “max” represent the range of ports to scan“timeout” is how long in seconds the scanner will wait for an unresponsive port before moving on to the next one` my_target.scan(min = 1, max = 100, timeout = 0.01) `Generate a report of the results of your scan(s), which will be returned as a list. Set all to “True” or leave it blank if you want your report to include all of the scans for your target, or set it to “False” to see only the most recent scan.` my_target.report(all = True) `
Package: port-scanner-fokd
Simple port scanner"Scan" function type signature:def scan(target: str, start=0, stop=1023, threads=500) -> List[int]:By default you only need to enter a target IP address and it will scan the most frequently used ports/system ports, using 500 threads (be patient 🫣).Installation:>pip install port-scanner-fokd==0.1.0Usage:scanner = port-scanner-fokd.Scanner()
scanner.scan("127.0.0.1")

>> [22, 80, 443]
Package: portstat
# portstat![](https://badge.fury.io/py/portstat.svg) ![](https://travis-ci.org/imlonghao/portstat.svg) ![](https://landscape.io/github/imlonghao/portstat/master/landscape.svg?style=flat)A simple port traffic monitor## Install### Install pipFor Debian / Ubunut user```apt-get updateapt-get install python-pip```### Install portstat```pip install portstat```### System settingAdd the following line to `/etc/rc.local` to run portstat on the startup.Notice that add it before `exit 0` .```/sbin/iptables -N PORTSTAT/sbin/iptables -A INPUT -j PORTSTAT/sbin/iptables -A OUTPUT -j PORTSTAT/bin/bash /etc/portstat.rules```To upload the traffic information every minute, we should add the following line in `crontab -e````* * * * * /usr/local/bin/portstat -u```Run it every 5 minutes like the following```*/5 * * * * /usr/local/bin/portstat -u```To activate the new iptables rules, please run the `/sbin/iptables` command manually or issue a `reboot` command.After that, you have installed portstat successfully.## UpgradeEvery new version I will upload it to pypi so that you can upgrade to the latest version with the following code.```pip install -U portstat```For some unexpectable reason, I can NOT promise that you can upgrade to the latest version without change your settings.So, please come back to see what's new at every upgrade.## Usage```usage: portstat [-h] [-c CONFIG] [-v | -s | -u]A simple port traffic monitoroptional arguments:-h, --help            show this help message and exit-c CONFIG, --config CONFIGPath of the config file.-v, --version         Show portstat version.-s, --sync            Sync the portstat settings and iptables.-u, --upload          Upload the port stat with webhook.```## TutorialFirst of all, you should install portstat as I mentioned above.Create a conf in where you like, by default the path is `/etc/portstat.conf`, just remenber use `-c path` to declare the config file if you don't use the default path.The conf file should looks like that:```[imlonghao]Port=80Webhook=https://imlonghao.com/?imlonghao[shadowsocks]Port=10000-10010Webhook=https://imlonghao.com/?shadowsocks[test]Port=22,111,8080Webhook=https://imlonghao.com/?test````[name]` used to distinguish every port you want to monitor.`Port=111` used to declare the port you want to monitor, it should be a int like `111` , or a range like `10000-10010`, or `80,81,8080,8888` .`Webhook=https://imlonghao.com/` used to received the traffic information, portstat will post the information to the webhook like that![](https://cloud.githubusercontent.com/assets/4951333/8232820/24432094-1605-11e5-9534-5fc9362d1626.png)Then, save the config file.Run `portstat -s` to create new iptables rules to monitor the port you just add.Run `portstat -u` to upload to port traffic information to webhook manually.## Contribution- [Issue](https://github.com/imlonghao/portstat/issues)- [Pull Request](https://github.com/imlonghao/portstat/pulls)## LicenseLicensed under the Apache License, Version 2.0
Package: portugython
PortugythonEssa é uma biblioteca Python que facilita a interação com a linguagem para não falantes de Inglês (com foco em Brazileiros)O Brasil atulamente, 11/11/2022, é o país com o maior número de escolas de idiomas do mundo.Especialmente escolas do idioma Inglês. Contudo, um dos países que menos se fala outros idiomascomumente em sua sociedade. Pensando em uma forma de facilitar então a interatividade, o primeiro contatocom um dos idiomas mais importantes da atualidade, Idioma Das Máquinas, a In Gnave decidiu criar uma biblioteca
que traduz as funções de Python. Criando então, uma nova camada de funções/classes/modulos/pacotes padrão traduzidas.Como contribuirPara contribuir com código:Crie um fork deste repositórioCrie umabranchnova a partir da branchcoreNomeie a suabranchno seguinte formato:feature/PLB-[número do PLB]-aaaa-mm-[nome do usuário], para featuresbugfix/PLB-[número do PLB]-aaaa-mm-[nome do usuário], para bugfixFaça oscommitscomparandoacross forksSiga oplaybookpara novas contribuiçõesSempre atualize suasbranchesantes de começar a trabalhar em novas entregasObjetivoO objetivo dessa ferramenta é modificar as funções, e tudo aquilo que pertence a camadamais acessível do Python, sem modificar a gramática propriamente dita. Servindo comouma biblioteca que se comporta como tradução das funções/classes/modulos/pacotes padrão da linguagem.
Logo as palavras reservadas, também conhecidas comoKeywordspermanecem as mesmas.Installpip install portugythonCode examplefromportugythonimport*# Tradução de printimprima('Olá, Portugython!')
Package: portus
PortusPortus is an implementation of a congestion control plane (CCP).
It is a library that can be used to write new congestion control
algorithms in user-space.Congestion control algorithm implementations live in independent crates
which use this library for common functionality. Each algorithm crate
provides a binary which runs a CCP with that algorithm activated.Further documentation is available ondocs.rs.SetupInstall rust. Seehttp://rust-lang.org/for details.make. This will build and lint the portus library and bundled algorithm libraries and binaries, and run unit tests.NotesTheipc::netlinkandipc::kpmodules will only compile on Linux. If the CCP kernel module (github.mit.edu/nebula/ccp-kernel) is loaded, the test will refuse to run.RunThere are no algorithm binaries in this repository: it is just a library and runtime for CCP algorithms. You may be interested inhttps://github.com/ccp-project/generic-cong-avoid, which provides implementations of Reno and Cubic, orhttps://github.com/ccp-project/bbr, a BBR implementation.
Package: portwait
portwaitCLI Tool for waiting on ports to open.Usageusage: portwait [-h] [-t TIMEOUT] [-v] host port

positional arguments:
  host                  Host to connect to
  port                  ... its the port ok?

optional arguments:
  -h, --help            show this help message and exit
  -t TIMEOUT, --timeout TIMEOUT
                        Timeout in seconds
  -v, --verbose         Describe resultExampleWait for ssh to open up (presumably after a reboot or something):portwait 10.40.1.100 22Do a single check and don't waitportwait 10.40.1.100 22 --timeout 0
Package: pos
Chia Proof of SpaceChia's proof of space is written in C++. Includes a plotter, prover, and
verifier. It exclusively runs on 64 bit architectures. Read theProof of Space documentto
learn about what proof of space is and how it works.C++ Usage InstructionsCompile# Requires cmake 3.14+mkdir-pbuild&&cdbuild
cmake../
cmake--build.---j6Run tests./RunTestsCLI usage./ProofOfSpace-k25-f"plot.dat"-m"0x1234"create
./ProofOfSpace-k25-f"final-plot.dat"-m"0x4567"-tTMPDIR-2SECOND_TMPDIRcreate
./ProofOfSpace-f"plot.dat"prove<32bytehexchallenge>
./ProofOfSpace-k25verify<hexproof><32bytehexchallenge>
./ProofOfSpace-f"plot.dat"check<iterations>Benchmarktime./ProofOfSpace-k25createHellman Attacks usageThere is an experimental implementation which implements some of the Hellman
Attacks that can provide significant space savings for the final file../HellmanAttacks-k18-f"plot.dat"-m"0x1234"create
./HellmanAttacks-f"plot.dat"check<iterations>PythonFinally, python bindings are provided in the python-bindings directory.Installpython3-mvenv.venv
..venv/bin/activate
pip3install.Run python testsTestings uses pytest. Linting uses flake8 and mypy.py.test./tests-s-vci BuildingThe primary build process for this repository is to use GitHub Actions to
build binary wheels for MacOS, Linux (x64 and aarch64), and Windows and publish
them with a source wheel on PyPi. See.github/workflows/build.yml. CMake usesFetchContentto downloadpybind11. Building is then
managed bycibuildwheel. Further
installation is then available viapip install chiapose.g.Contributing and workflowContributions are welcome and more details are available in chia-blockchain'sCONTRIBUTING.md.The main branch is usually the currently released latest version on PyPI.
Note that at times chiapos will be ahead of the release version that
chia-blockchain requires in it's main/release version in preparation for a
new chia-blockchain release. Please branch or fork main and then create a
pull request to the main branch. Linear merging is enforced on main and
merging requires a completed review. PRs will kick off a GitHub actions ci build
and analysis of chiapos atlgtm.com. Please
make sure your build is passing and that it does not increase alerts at lgtm.
Package: pose
Pose started as a python based image gallery utilizing the Pylons framework.Since that time, Pose has evolved into a more general purpose content management system based on the Pylons framework.  It utilizes the OSBrowser module as an interface to the local filesystem being served by Pose.  OSBrowser is essentially the model in terms of MVC. In this way, Pose could be considered a web based filesytem browser.Pose should allow you to quickly organize a collection of data into a structure and see how that structure will work.  Then, as custom functionality is needed, Pylons is right there to adapt the system to your needs.Pose now includes tiny_mce, a few open source flash based audio players, and S5 rendering javascripts in the public directory.
Package: pose-annotator
Pose annotatorA simple GUI for clicking on keypoints for training pose estimation models. Currently only supports one set of
points per frame. Please consider contributing for multiple instances per frame!Installationpip install pose-annotatorUsageCustomizedefault_config.yamlthen launch usingpose_annotator usr_cfg=path/to/custom/config.yamlHotkeysCtrl+SsaveRightnext frameLeftprevious frameDownnext keypointSpacenext keypointUpprevious keypointDeletedelete keypointKnown issuesAdding or deleting images from a directory with existing annotationsannotations are matched to image files by rank-order of the filenameModuleNotFoundError: No module named 'skbuild'pleasepip install --upgrade pipTODOMake player resize image appropriately on startupcurrent behavior: changing frame resizes images to fit in view; does not expand size on image resize
Package: posebusters
PoseBusters: Plausibility checks for generated molecule poses.Paper inChemical Scienceand preprint onarXivInstallation# install with pip from PyPIpipinstallposebustersUsage# Check generated molecule pose.bustmolecule_pred.sdf
bustmolecule_a.sdfmolecule_b.sdf
bustmolecule_*.sdf# Check new ligand generated for a given protein.bustligand_pred.sdf-pmol_cond.pdb# Check re-docked ligand (a pose that should recover the ligand in a given protein-ligand crystal complex).bustligand_pred.sdf-lmol_true.sdf-pprotein.pdb# Check any of the three by providing a csv with files to check togetherbust-tfile_table.csvDocumentationDocumentation is available athttps://posebusters.readthedocs.io.For more information about the tests and for a study using PoseBusters to compare docking methods, refer to ourpaperorpreprint:@article{buttenschoen2023posebusters,
  title = {{{PoseBusters}}: {{AI-based}} Docking Methods Fail to Generate Physically Valid Poses or Generalise to Novel Sequences},
  shorttitle = {{{PoseBusters}}},
  author = {Buttenschoen, Martin and Morris, Garrett M. and Deane, Charlotte M.},
  year = "2023",
  publisher = "The Royal Society of Chemistry",
  doi = "10.1039/D3SC04185A",
  url = "http://dx.doi.org/10.1039/D3SC04185A",
}The data used for the paper is available athttps://zenodo.org/record/8278563.Feedback & ContactWe welcome all feedback. For code issues, please open an issue. For other inquiries contact us by email.ThanksThis program uses software written by other people. Notably:RDKit -https://github.com/rdkit/rdkitPandas -https://github.com/pandas-dev/pandas
Package: posecamera
PoseCameraPoseCamera is python based SDK for multi human pose estimation through RGB webcam.Installinstall posecamera package through pippipinstallposecameraIf you are having issues with the installation on Windows OS then check thispageUsageSee Google colab notebookhttps://colab.research.google.com/drive/18uoYeKmliOFV8dTdOrXocClCA7nTwRcX?usp=sharingdraw pose keypoints on imageimportposecameraimportcv2det=posecamera.pose_tracker.PoseTracker()image=cv2.imread("example.jpg")pose=det(image)forname,(y,x,score)inpose.keypoints.items():cv2.circle(image,(int(x),int(y)),4,(255,0,0),-1)cv2.imshow("PoseCamera",image)cv2.waitKey(0)output of the above exampleor get keypoints arrayfor pose in poses:
    keypoints = pose.keypointsHandtrackerimport posecamera
import cv2
det = posecamera.hand_tracker.HandTracker()

image = cv2.imread("tmp/hands.jpg")
keypoints, bbox = det(image)

for hand_keypoints in keypoints:
    for (x, y) in hand_keypoints:
        cv2.circle(image, (int(x), int(y)), 3, (255, 0, 0), -1)

cv2.imshow("PoseCamera - Hand Tracking", image)
cv2.waitKey(0)Using DockerThe official docker image is hosted onDocker Hub. The very first step is to install the dockerdockeron your system.Also note that your Nvidia driver Needs to be compatible with CUDA10.2.Doing inference on live webcam feed.xhost+;dockerrun--nameposecamera--rm--net=host--gpusall-eDISPLAY=$DISPLAY--device=/dev/video0:/dev/video0wondertree/posecamera--video=0GPU & Webcam support (if running docker) is not available on Windows Operating System.To run inference on images use the following command.dockerrun--nameposecamera--rm--net=host-eDISPLAY=$DISPLAYwondertree/posecamera--images./tmp/female_pose.jpg--cpuFor more details read ourDocsThe base of this repository is based on the following research paper.@inproceedings{osokin2018lightweight_openpose,
    author={Osokin, Daniil},
    title={Real-time 2D Multi-Person Pose Estimation on CPU: Lightweight OpenPose},
    booktitle = {arXiv preprint arXiv:1811.12004},
    year = {2018}
}Share your thoughtsJoin ourDiscussion Channel! We love to hear your ideas, suggestions or pull request
Package: poseconnect
poseconnectTools for constructing 3D pose tracks from multi-camera 2D posesInstallationTo install both the Python library and the command line interface, launch a
Python virtual environment (optional, but recommended) and then install viapip:pip install poseconnectCommand line interfaceThe command line interface consists of a single command (poseconnect) with
four subcommands:reconstructtakes a file of 2D pose data and a file of camera calibration info as inputs and outputs a file of 3D pose datatracktakes a file of 3D pose data as input and outputs a file of 3D pose data with track IDsinterpolatetakes a file of 3D pose data with track IDs as input and fills time gaps in each track with linearly interpolated posesidentifytakes a file of 3D pose data with track IDs and a file of location sensor data with person IDs and outputs a file of 3D pose data with track and person IDsoverlaytakes a file of 2D or 3D pose data and a source video for the data and outputs a video with the poses overlaidHelpOverall help is available atposeconnect --helpand help for each subcommand
(including usage and a list of options) is available atposeconnect SUBCOMMAND --help(e.g.,poseconnect reconstruct --help).Data formatsMore information about input and output data file formats is availablehere.DemoTo see the command line interface in action, download and unzip the following sample JSON data files to your current directory and run thedemo shell script:2D pose dataCamera calibration infoSensor data
Package: posedr
Project TitlePose Detection Python PackageInstallationInstall my-project with npmpipinstallpose-detectionDemofrom posedr import run_pose_detectionRun pose detection with default parametersrun_pose_detection()You can also customize the parametersrun_pose_detection(mode=True, smooth=False, detectionCon=0.7, trackCon=0.8)Parameters:mode (bool, optional): Set to True for static image mode. Default is False.smooth (bool, optional): Enable landmark smoothing. Default is True.detectionCon (float, optional): Minimum detection confidence threshold. Default is 0.5.trackCon (float, optional): Minimum tracking confidence threshold. Default is 0.5.LicenseThis project is licensed under the MIT License - see the LICENSE file for details.
Package: poseidon
Python library for managing your Digital Ocean accountThe DigitalOcean API allows you to manage Droplets and resources within the
DigitalOcean cloud in a simple, programmatic way using conventional HTTP
requests. The endpoints are intuitive and powerful, allowing you to easily make
calls to retrieve information or to execute actions.This library starts with a python wrapper for the API and aims to build tools to
make it easier to manage, provision, and deploy to Digital Ocean.HighlightsFull featured: API wrapper covering the published DigitalOcean API v2Tested: integration test coverage against most of the APISSH integration: integratesparamikolibrary so you can SSH in and issue commandsDeployment conveniences: methods likeapt,pip, andgitfor easier deploymentExampleDeploy a new Flask app from githubimportposeidonasPclient=P.connect()ssh_key_id=client.keys.list()[0]['id']droplet=client.droplets.create('example.changshe.io','sfo1','512mb','ubuntu-14-04-x64',ssh_keys=[ssh_key_id])domain=client.domains.create('example.changshe.io',droplet.ip_address)records=client.domains.records(domain['name'])records.create('A',data=droplet.ip_address)ssh=droplet.connect()ssh.apt('git python-pip')ssh.git(username='changhiskhan',repo='hello_world')ssh.chdir('hello_world')ssh.pip_r('requirements.txt')ssh.nohup('python app.py')# DNS takes a while to propagateprintssh.ps()
Package: poseidondatetime
About the classThis class implements date conversion for the fictitous sci-fi world ofPoseidonfrom the tabletop role-playing gameBlue Planetpublished byBiohazard Games.See the Blue Planet wiki for more about theColonial calendar.UsageThis is a sample session of using thePoseidonDateTimeclass.New objects are created with thefromcolonyformatorfromisoformatmethods.Pretty formatting of dates is with thecolonyformatorisoformatmethods.The attributesp_year,p_day,p_hour,p_minute, andp_secondgive the components of the Colonial datetime. Similarly, the attributesyear.day,hour,minute, andsecondgive the components of the CE datetime.You can usetimedeltaobjects changes the time;PoseidonDateTime.p_day_durationis one Poseidon day.>>> import poseidon_datetime as pdt
>>> import datetime as dt
>>> p_atlantis = pdt.PoseidonDateTime.fromisoformat('2124-08-07')
>>> p_atlantis.colonyformat()
'076.33 18:51:43'
>>> p_atlantis.colonyformat(include_time=True)
'076.33 18:51:43'
>>> p_atlantis.colonyformat(include_time=False)
'076.33'
>>> p_birthday = pdt.PoseidonDateTime.fromcolonyformat('023.99 28:15:00')
>>> p_birthday
PoseidonDateTime(2199, 1, 30, 23, 14, 22)
>>> p_birthday.isoformat()
'2199-01-30T23:14:22'
>>> p_birthday.p_day
23
>>> p_birthday.day
30
>>> p_after_birthday = p_birthday + dt.timedelta(days=1)
>>> p_after_birthday.isoformat()
'2199-01-31T23:14:22'
>>> p_after_birthday.colonyformat()
'024.99 22:14:17'
>>> p_after_birthday = p_birthday + pdt.PoseidonDateTime.p_day_duration
>>> p_after_birthday.colonyformat()
'024.99 28:15:00'
>>> p_after_birthday.isoformat()
'2199-02-01T05:15:05'