Saravanan666/pypi-org huggingface dataset:
Package: psat-result-api
Project descriptionSmall and simple package to connect to the PSAT (Proofpoint Security Awareness Traning) result API.Proofpoint Result APISee theREST API full documentationfor more information.Installationpip install psat-result-apiExamplefrompsatimportResultApip=ResultApi("insert-api-token-here")# Return training assignments datatraining=p.get_training()# Return users data with some parametersusers=p.get_users(params={"user_tag_enable":"FALSE","filter[_useremailaddress]":"[user@domain.com]",})Supported endpointsCyberStrength (get_users())PhishAlarm (get_cyberstrength())Phishing (get_phishalarm())Training (get_phishing())Users (get_training())TrainingEnrollments (get_trainingenrollments())
Package: psat-server-web
psat-server-webPython 3 web interface for the Pan-STARRS and ATLAS surveys.To install:pip install psat-server-webOnce installed, don't forget to add the "data" symlinks in the:site-packages/psat_server_web/atlas/media/images
site-packages/psat_server_web/ps1/media/imagesdirectories which point to the location of the image stamps.
Package: psaudit
psauditProcess auditor for macOS. Verifies that all running processes have been signed by Apple.Installationpip install psauditUsagepsauditIf any processes fail the audit, they will be listed and the script will return a non-zero error code indicating the number of failed processes. For example:$ psaudit 
process 371 (/Applications/Utilities/Adobe Sync/CoreSync/Core Sync.app/Contents/PlugIns/ACCFinderSync.appex/Contents/MacOS/ACCFinderSync) not signed by Apple
process 14722 (/usr/local/Cellar/bash/5.0.11/bin/bash) not signed by Apple
process 75508 (/usr/local/Cellar/macvim/8.1-157/MacVim.app/Contents/MacOS/MacVim) not signed by Apple
process 75509 (/usr/local/Cellar/macvim/8.1-157/MacVim.app/Contents/MacOS/Vim) not signed by Apple
$ echo $?
4
Package: psa-utils
psa_utilsA python package for working with the ESA Planetary Science Archive. The following sub-modules are available:downloadProvides functions to help with downloading public data products using either PDAP or TAPpackagerProvides a class to package PDS4 products for delivery to the PSAgeogenProvides useful utilities for working with the geogen geometry generator packagetapA wrapper of the astropy tap class with some convenience functions and useful queriespdapA minimal wrapper of the PDAP API using the requests librarycommonCommon functions used across the packageinternalAnything contained here is designed for PSA internal use.DependenciesThe following dependencies must be met:python >=3.6matplotlibnumpyastropypandaspyyamlrequestsInstallationpippip install psa_utilsshould do the job, although creating a dedicated environment is recommended (see below).condaFirst, clone this repository. If you are using conda, the dependencies can be installed in a new environment using the provided environment file:conda env create -f environment.ymlThe newly created environment can be activated with:conda activate psa_utilsOtherwise, please make sure the dependencies are installed with your system package manager, or a tool likepip. Use of a conda environment or virtualenv is recommended!The package can then be installed with:python setup.py installURLThe URL for the PSA can be specified when instantiating the tap class. If none is given, a default URL is used, which corresponds to the default operational server.ExampleThe Jupyter notebook included with this repository shows examples of each function and module. Clickhereto access the notebook!
Package: psautohint
PSAutoHintA standalone version ofAFDKO’s
autohinter.Building and runningThis repository currently consists of a core autohinter written in C, a
Python C extension providing an interface to it, and helper Python code.To build the C extension:python setup.py buildTo install the C extension and the helper scripts globally:pip install -r requirements.txt .Alternatively to install them for the current user:pip install -r requirements.txt --user .The autohinter can be used by running:psautohintTo build just theautohintexebinary:python setup.py build_exeTestingWe have a test suite that can be run with:pytestDebuggingFor standard debugging, build with:python setup.py build --debugIt is also possible to build a debug version withAddressSanitizer("ASan") support (currentlyfor Mac OS X only)  with:python setup.py build --asan
pip install .Once it is installed, you can use theutil/launch-asan.shshell script to launch a Python process that invokes the ASan libraries needed for debugging. Attach Xcode the launched process, then execute code in the process that triggers memory usage problems and wait for ASan to do its magic.NOTE: be sure to build and installpsautohintas described above; using other techniques such aspython setup.py installwill cause a re-buildwithoutASan and debug support, which won't work.
Package: psb
Pi Status Board (psb)The Pi Status Board (psb) can be used to display text or pre-defined images on an eInk display attached to a Raspberry Pi. It is controlled via AWS IoT Core and uses mqtt.RequirementsPsb has been designed to work on a Raspberry Pi using and anInky pHAT display.InstallUse package managerpiporpipenvto install psb:pipinstallpsbUsagePsb is a command line utility. The configuration file should be stored in/etc/psb/conf.ini.  A sample config file can be found within theresources folder.For a full breakdown of all configuration options please see theconfigurationdocumentation.To run psb, run the following command without any arguments:psbPsb will connect to the mqtt broker specified in the configuration file.To trigger the changing of the display, a message needs to be sent to the configured mqtt topic. There are two types of messages that can be processed.For a text message the message sent to the topic should be:{"type":"text","data":"This is a message"}For images, the data field should contain the name of the image to display without the extension:{"type":"image","data":"meeting"}Running as a serviceIf you would like to run psb as a service, copy the example systemdservice fileto/lib/systemd/system/pi-status-board.service. You may need to change the path to the location of psb, this can be found by using thewhereiscommand:>whereispsb
psb:/etc/psb/home/pi/.local/bin/psbAfter creating the file, reload the systemd daemon:>sudosystemctldaemon-reloadYou should now be able to see the status of the service by running:>sudosystemctlstatuspi-status-boardContributingPull 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.LicenseReleased under GNU General Public License v3.0.
Package: psb2
PSB2 - Python Sampling LibraryA Python library for fetching and sampling training and test data for experimenting with the program synthesis dataset PSB2. The library will automatically download datasets to the given location, and will cache them to avoid repeated downloads.InstallationEasily installed usingpip:pip install psb2UsageThere is one constant and one function available in this library.psb2.PROBLEMSis the list of all problems in the benchmark suite as strings:>>>importpsb2>>>psb2.PROBLEMS['basement','bouncing-balls','bowling','camel-case','coin-sums','cut-vector','dice-game','find-pair','fizz-buzz','fuel-cost','gcd','indices-of-substring','leaders','luhn','mastermind','middle-character','paired-digits','shopping-list','snow-day','solve-boolean','spin-words','square-digits','substitution-cipher','twitter','vector-distance']Thefetch_examplesfunction downloads (if necessary) and samples training and test data for a specific problem in PSB2:>>>importpsb2>>>(train_data,test_data)=psb2.fetch_examples("path/to/PSB2/datasets/","fizz-buzz",200,2000)>>>train_data[{'input1':1,'output1':'1'},{'input1':2,'output1':'2'},{'input1':3,'output1':'Fizz'},{'input1':4,'output1':'4'},...{'input1':405919,'output1':'405919'},{'input1':405789,'output1':'Fizz'}]Or, if you'd like your test cases in a different format, you can supply an optionalformatargument:>>>importpsb2>>>(train_data,test_data)=psb2.fetch_examples("path/to/PSB2/datasets/","fizz-buzz",200,2000,format='lists')>>>train_data[([1],['1']),([2],['2']),([3],['Fizz']),([4],['4']),...([405919],['405919']),([405789],['Fizz'])>>>importpsb2>>>(train_data,test_data)=psb2.fetch_examples("path/to/PSB2/datasets/","fizz-buzz",200,2000,format='competitive')>>>train_data[(['1'],['1']),(['2'],['2']),(['3'],['Fizz']),(['4'],['4']),...(['405919'],['405919']),(['405789'],['Fizz'])Each example in the returnedtrain_dataandtest_datalists is a map containing one key for each input and each output.train_dataincludes all defined edge cases for a problem, as well as enough randomly generated cases to fill the training set (200 in the example above).test_datawill samplen_testcases from the randomly generated cases.CitationIf you use these datasets in a publication, please cite the paperPSB2: The Second Program Synthesis Benchmark Suiteand include a link to this repository.BibTeX entry for paper:@InProceedings{Helmuth:2021:GECCO,author="Thomas Helmuth and Peter Kelly",title="{PSB2}: The Second Program Synthesis Benchmark Suite",booktitle="2021 Genetic and Evolutionary Computation Conference",series={GECCO '21},year="2021",isbn13={978-1-4503-8350-9},address={Lille, France},size={10 pages},doi={10.1145/3449639.3459285},publisher={ACM},publisher_address={New York, NY, USA},month={10-14}#jul,doi-url={https://doi.org/10.1145/3449639.3459285},URL={https://dl.acm.org/doi/10.1145/3449639.3459285},}LicenseCopyright © 2021 Thomas HelmuthThis program and the accompanying materials are made available under the
terms of the Eclipse Public License 2.0 which is available athttp://www.eclipse.org/legal/epl-2.0.
Package: ps.basic
The ps (Production System) packages implementation started in 2013. Given a non staged production environment - hosted on different operating Systems all around the globe the implementations first goal was to consolidate the widely spread scripts and standalone Programs - started via cron - under one umbrella.
At that time it was decided to implement that umbrella using python 2.4. The ps.basic package was created.Back than the ps.basic requirements where:establish the usage of templates for shell scripts and emailsestablish a consistent way calling shell scripts and sending emailsestablish a consistent way for local logging (with automatic logfile rotation/deletion)establish a consistent way to handle configuration filesestablish a consistent way to handle staged environments (TESTING/DEVELOPMENT/INTEGRATION/PRODUCTION)In the next step it was decided to:enhance the loggingadditionally send the logging message to a network socket endpointenhance the logging message with version number, Product_id, ….implement a program/packageps_bridgebeing able to receive those logging messagesto store those logging messages in an sqlite database (as delivered with the python standard distribution)or/and route those logging messages to further destinationsimplement a web serverps_heraldto analyze the logging messages provided by the sqlite database on a nodeimplement a tool in that packageps_neelixto react onlogging messages e.g inform interested parties that something happened e.g using  email via stage_specific configuration files (easily added to versioning control)lost heartbeats of monitored services putting their logging messages in the sqlite database on a nodeadd a finite state machine environment to the ps.basic packageeasing putting structure to the implementationa graphical representation based onpygraphvizwas added - generating the image from the implementation.Those mechanisms where implemented compatible to python 2.4. Having a package major version numbers 0 e.g. 0.x.x and are used in daily production.It allows for a staged development/production environment - combined with CI/CT … allowing to easily monitor the distributed services behaviour and configuration  - as depicted in the following picture.Crucial points for the logging are:the used network connections are setup using ssh where the setup of the connection is completely owned by the “mother company”  - it is currently not in the scope of the project to further manage thisthat theVersion numberof the service (beside module name , line number …) is automatically integrated into the logging message - serving Requirements for ITIL.it is possible (and used in production) to (easily) extend existing applicacitions to use the (version based) logging mechanism.Starting with the usage of python 3 the package was released to the public using a major version number 1 e.g. 1.x.x.Documentation:https://psbasic.readthedocs.ioGit:https://bitbucket.org/drsetz/ps.basic/src/master/
Package: psbs
PSBSThe PuzzleScript Build System!PSBS combines multiple files into one puzzlescript source file and can export it to an HTML file or an online game hosted on a gist!For more information view theofficial PSBS DocumentationFeaturesCompile PuzzleScript games from many files using Jinja2 templates!Import images and spritesheets directly into your PuzzleScript game!Load existing PuzzleScript projects right from their gists!Load existing PuzzleScript projects from a source text file!Export PuzzleScript projects to html files!Export PuzzleScript projects to gists!Launch your project from play.html or the PuzzleScript editor!Supports most PuzzleScript forks!Use your favorite version control for your PuzzleScript projects!Tiledlevel editor integration!Extensible with your own custom Python extensions!InstallingIf you already have Python 3.8 or greater and pip installed simply run the following command from your terminalpip install psbsIf you don't have Python and pip installed:Download PythonIf you already have an older version of PSBS installed you can upgrade to the latest version withpip install psbs --upgradeContributingWhile I'd be grateful to receive pull requests, at this moment in time prior to doing an official 1.0.0 release what I would really like help with is testing!  Please use PSBS to its fullest and if you encounter any odd behaviors don't hesitate to raise an Issue!I would like PSBS to have friendly error handling that returns nice, brief, and useful error messages rather than a full stack trace, however it's challenging to make sure I've caught every possible exception, so if you run into a stack trace while using PSBS please raise an Issue!
Package: pschatzmann-test-001
OpenSCAD Kernel for JupyterI was missing a Jupyter Kernel forOpenSCAD. So I took up the challenge and here is the result.Any regular text in a cell is added to the overall OpenSCAD code buffer. This allows you to build up an OpenSCAD model in multiple steps using Jupyter cells and document the design along the way.PreconditionsJupyter or Jupyterlab should have been installedPlease make sure that OpenSCAD has been installed on your system (e.g. with apt install openscad) and that it can be called on the command line:openscad -vdiplays the version. E.g. 2019.12.20Installationpip install jupyter-openscad-kernelWe try to install the kernel specification automatically. If the kernel does not appear you can try to execute the following commandpython -m iopenscad setupInstallation from sourcegit clone https://github.com/pschatzmann/jupyter-openscad-kernel.git
cd openscad-kernel
pip install .Optional StepsIf you want to be able to display stl files you need to install a mime renderer for Jupyter. E.gjupyter labextension install jupyterlab-viewer-3dIf you want to have syntax highlighting for OpenSCAD:jupyter labextension install jupyterlab-openscad-syntax-highlightingNow you can launch your kernel my callingjupyter laborjupyter workspaceVersions1.0     Initial Version1.0.1   Additional syntax checking; Publish to pypiFurther InformationA quickOverview
Package: pschecker
PSCheckerpscheckerstands for Personal Server Checker. It’s a simple Python script
that audits the security state of your personal server. Through it, you
will know if your setup has the minimum security required to be online.$ pip install pschecker
$ pschecker

Welcome to Personal Server Checker!
Your personal server diagnostic is:
Distribution: debian
Root must not use password: OK
No process listens on 0.0.0.0 host: OK
You are all good!Contributors@gelnior@ldvc@nicofrand@Phyks@ZeHiro
Package: pscheduler
SetupThis pscheduler service is critical dependent upon the usage of shared filesystem across the remote machines. Setup NFS for all the remote machines.Have same login credentials for all the remote machines.Basic Linux utilities likesshandnohupshould be installed on all the remote machines.Installpscheduleris a Python 3 only module and can be easily installed using pip:pip install pschedulerConfigurationStart the service usingpscheduler service start. This will create a directory.pschedulerunder your home directory.Edit file~/.pscheduler/hosts.cfgand add all the IP addresses/domain aliases of the remote machines in each line. Save and exit. Alternately if you are in an HPC environment and LSF is already installed, then you can use the provided scriptbhostsWrapper.pyto directly populate the remote machine. You should then edit it to remove the head node machine from the list and any other required host.If you have not already setup password-less login into remote machines, then use the provided scriptbatchSetupLoginKeys.pyto set it up.UsageThere are four basic utilities:servicestart/stop the background servicehostsget information on remote machinessubsubmit jobsjobsmonitor running/pending jobSee helpfiles of individual subcommands for further detailsIt is critical that the background service is started before the submitting any jobExamples:Start service:pscheduler service startSubmit job:pscheduler sub "sleep 10"Pending and running job configuration files are stored under~/.pscheduler/jobsin PEND and RUN directory respectively. By default the finished job configuration file containing standard output(JSON format) are stored under~/.pscheduler/jobs/FINISH, but users can choose a custom location for this file by using-oflag while submitting job and providing the output location path.~/.pscheduler/DAEMON.logcontains the log of the background service. You should have a look at this file to see if any error messages have been thrown.Note that pschedulerwill notwill ignore the scheduling by other schedulers and simply launch jobs based on availability of resources (currently only number of CPU cores).Roadmap for future versionsImplementjobssubcommandJob restart in case of resource spikeImprove code for catching fatal exceptionsHISTORY0.0.1:FIRST PRE ALPHA RELEASE0.0.2:CLI CREATED using wrapper.pyBHOST wrapper script separated form phosts moduleIntroduced hosts.cfg: A user editable list of hostsBatch script made for creating login keysPSUB now saves in JSON formatDEV: Submit to PyPi using python scriptDEV: Automatic update of version in setup.py0.0.3:Addedpschedulerin scripts for command line invocation0.0.4:Deployment fix0.0.5:Import fix0.0.6:Json fix0.0.7:jobs subcommand implementedphosts doublehost check issue rectifiedsubmission process improved in daemonclass naming convention changeddefault host fixed to localhost. passwordless loging into localhost createdDEV: Travis CI now being used for testing0.1.0:pdaemon fixRolledback SSH keygenContributorsParashar Dhapola (parashar.dhapola@gmail.com)
Package: pscli
Unofficial Cisco Parstream Client with improved cli.Still in Beta, tested with Parstream 4.4.x on ubuntu and windows 10.Install it usingpip:$ pip install pscliNOTE: python 3.5 or above requiredYou can use it from cli or use its client class (PSClient) in your python code.
There is also a class (AIOPSClient) that supports async paradigm. Usebatchfunction to execute parallel statements.The execution of a statement returns 2 value:raw output string from parstream servera dict that contains timing info: start time, first packet time and final time (useful for performance test)Featurescommands history (file:$HOME/.psclient_history)autocomplete from history, sql syntax and cli commandssql syntax highlightcli commandsquery output as table instead of csv
Package: pscodeanalyzer
Static Code AnalyzerA rule-based static code analyzer with PeopleCode-specific features and an extensible plug-in architecture.AboutAlthough it was written with PeopleCode validation in mind, it should be noted that it is in fact a configurable code analysis engine that can be used to evaluate any text-based file and produce reports based on its findings.InstallationTo install the Static Code Analyzer, run the following:pipinstallpscodeanalyzerUsageRefer to thewikifor details about the design, architecture, and configuration of the Static Code Analyzer, as well as instructions on how to invoke it and extend it with custom plug-ins.AcknowledgementsThe Static Code Analyzer was written as part of the deliverables for my Master of Science dissertation at the University of Liverpool, titled "A Framework for Customizing ERP Systems to Increase Software Reuse and Reduce Rework When Challenged with Evolving Requirements." I mention this primarily in gratitude to my employer, who graciously waived their claim to intellectual property on my work as part of this academic pursuit.
Package: psconfig-client
psconfig-client is a python library to parse perfSONAR psconfig/PWA mesh configuration filesSynopsis:
import psconfig.api
import logging
import sys

log = logging.getLogger()

if __name__ == '__main__':
    log.setLevel(logging.DEBUG)
    formatter = logging.Formatter(fmt='%(message)s')
    fh = logging.StreamHandler(stream=sys.stdout)
    fh.setFormatter(formatter)
    log.addHandler(fh)

    # url supports host auto-url, particular mesh or top level mesh directory
    # for https you can pass hostcert/key and verify flag, which are all passed to the requests library call
    x = psconfig.api.PSC('url', hostcert=None, hostkey=None, verify=False)
    # get all hosts from all groups
    print(x.get_all_hosts())
    # get all hosts from the group X
    print(x.get_hosts_by_group('X'))
    # get all hosts from the groups X, Y, Z
    print(x.get_hosts_by_group('X', 'Y', 'Z'))
    # get all hosts from all groups except A
    print(x.get_hosts_by_group(exclude='A'))

    # get test types (trace, throughput, latency, etc.) per host
    for h in x.get_hosts_by_group():
        print(h, x.get_test_types(h))

    # get site name of a host
    print(x.get_site('<hostname>')

    # get all hosts from the mesh configs X, Y, Z and not Q
    print(x.get_hosts_by_config('X', 'Y', 'Z', exclude='Q'))

    # get full map of mesh -> hosts
    print(x.get_config_host_map())
Package: pscontroll
# Growtopia Private Server Controler> Module For Controle Your GTPS | Build in Python3## Creator Information- iFanPS DB:- Name : `iRfan`- Age : `17`- Come From: `Mars`- NumeX DB:- Name : `Christian`- Age : `19`- Come From : `Mars`## Installing Module```bash> pip install pscontroler```## Basic Configuration```bash> Make Sure You Already install a Python3> Install The Module```## list Worker```bash> Status (See server status)> Online (See online player)> Player (See player account total)> World (See total worlds created)> Start (Start the Server)> Stop (Stop the server)> Givepgems (Give player gems)> Giveplevel (Give player level)> Giveproles (Give player roles)> Countsize_Pwfolder (Count player and world folder size)> Maintactive and Deactive (Maintenance activator and deactive)> Pdelete (Delete player data)> Wdelete (Delete world)```## To Do list- Command:- Auto Backup