Saravanan666/pypi-org huggingface dataset:
Package: pisces-db
PiscesPisces is a Python library that connects your geophysical analysis
environment to a SQL database that uses the Center for Seismic Studies
(CSS) 3.0 or NNSA KB Core table schema.Documentation:http://jkmacc-lanl.github.io/piscesRepository:https://github.com/jkmacc-LANL/piscesFeaturesImport/export waveforms directly to/from your database.Build database queries using Python objects and methods
(SQLAlchemy), not by concatenating SQL
strings.Integration withObsPy.Geographic filtering of results.InstallationRequires:ObsPySQLAlchemyClickC compilerInstall fromPyPI:pip install pisces-dbInstall current master from GitHub:pip install git+https://github.com/jkmacc-LANL/piscesRecent History(full change log)0.2.2Changespisces.util.get_tables,pisces.util.make_tables, andpisces.util.get_or_create_tablesare deprecated and will raise a
warning.pisces.request.get_waveformsnow has atolkeyword that will
raise an exception if any returned waveform is not withintolseconds from the requested starttime/endtime.Added--bbfkflag topisces sac2db, which uses the broadband
f-k (BBFK) convention of reading x, y array offset distances in the
USER 7, 8 SAC header variables and storing them Site.dnorth and
Site.deast.Windows support! Thanks to @mitchburnett! e1 and convert C libraries
now build (using MSVC).Automated testing on Mac OSX, Linux, and Windows 7, for Python 2.7
and 3.4, thanks to Travis CI and Appveyor.Require ObsPy > 1.0Bug fixesFixed sac2db wfdisc.foff (issue #12) and wfdisc.dir (issue #11)
handling.
Package: pisco
PiscoPisco is a keyboard-only controller for Sonos speakers.
While Pisco's graphical interface displays the album art of the track currently playing,
you can control playback using your keyboard.Pisco has been tested on Linux and macOS.
It is especially well suited for use with
small displays (e.g.Pimoroni HyperPixel 4.0 Square) and
media remote controls (e.g.Satechi Bluetooth Multi-Media Remote).SetupTo set up Pisco on a regular Linux or macOS machine, follow these steps:Make sure you are using Python 3.9 or higher.Create a virtual environment if you do not want to clutter up your default environment.Install Pisco:pip3installpiscoFor a clean and minimalist deployment
on aRaspberry Pi Zero,
please seethe directorydeployment.UsageWhen starting Pisco,
you need to specify the name of the Sonos device (i.e. Sonos room) you want to control:piscoLeseecke# Replace 'Leseecke' with the name of your Sonos device.You can use the option--helpto find additional options:$ pisco --help
Usage: pisco [OPTIONS] SONOS_DEVICE_NAME

  Control your Sonos device with your keyboard

Options:
  -b, --backlight DIRECTORY    sysfs directory of the backlight that should be
                               deactivated when the device is not playing
  -w, --width INTEGER RANGE    width of the Pisco window  [default: 320; x>=0]
  -h, --height INTEGER RANGE   height of the Pisco window  [default: 320;
                               x>=0]
  -r, --refresh INTEGER RANGE  time in milliseconds after which playback
                               information is updated  [default: 40; x>=1]
  --help                       Show this message and exit.Once Pisco is running, you can use the following keys to control playback:⏯ (or return) to pause or resume playback⏹ to stop playback⏮ and ⏭ (or left and right arrow) to play the previous or next track0️⃣ to 9️⃣ to play the top 10 tracks (or radio stations) of your Sonos favorites➕ and ➖ (or up and down arrow) to increase or decrease volume🔇 to mute or unmute
Package: piscola
PISCOLA: Python for Intelligent Supernova-COsmology Light-curve AnalysisSupernova light-curve fitting code in pythonAlthough the main purpose of PISCOLA is to fit type Ia supernovae, it can be used to fit other types of supernovae or even other transients.Read the full documentation at:piscola.readthedocs.io. See below for a summary.InstallationPISCOLA can be installed in the usual ways, via pip:pip install piscolaor from source:git clone https://github.com/temuller/piscola.git
cd piscola
pip install .RequirementsPISCOLA has the following requirements:numpy
pandas
matplotlib
peakutils
requests
sfdmap
extinction
astropy
scipy
george
pickle5
pytest  (optional: for testing the code)TestsTo run the tests, go to the parent directory and run the following command:pytest -vUsing PISCOLAPISCOLA can fit the supernova light curves and correct them in a few lines of code:sn=piscola.call_sn(<sn_file>)sn.fit()The light-curve parameters are saved in a dictionary and can be accessed directly:sn.lc_parameters# dictionarysn.dm15You can find an example of input file in thedatadirectory.Citing PISCOLAIf you make use of PISCOLA in your projects, please citeMüller-Bravo et al. (2022). See below for the bibtex format:@ARTICLE{2022MNRAS.512.3266M,
       author = {{M{\"u}ller-Bravo}, Tom{\'a}s E. and {Sullivan}, Mark and {Smith}, Mathew and {Frohmaier}, Chris and {Guti{\'e}rrez}, Claudia P. and {Wiseman}, Philip and {Zontou}, Zoe},
        title = "{PISCOLA: a data-driven transient light-curve fitter}",
      journal = {\mnras},
     keywords = {supernovae: general, cosmology: observations, distance scale, Astrophysics - High Energy Astrophysical Phenomena, Astrophysics - Cosmology and Nongalactic Astrophysics, Astrophysics - Instrumentation and Methods for Astrophysics, Astrophysics - Solar and Stellar Astrophysics},
         year = 2022,
        month = may,
       volume = {512},
       number = {3},
        pages = {3266-3283},
          doi = {10.1093/mnras/stab3065},
archivePrefix = {arXiv},
       eprint = {2110.11340},
 primaryClass = {astro-ph.HE},
       adsurl = {https://ui.adsabs.harvard.edu/abs/2022MNRAS.512.3266M},
      adsnote = {Provided by the SAO/NASA Astrophysics Data System}
}Contributing and raising an issueThe recommended way is to use theissuespage or send a pull request. Otherwise, you can contact me directly.
Package: piScope
πScopeπScope is a python based workbench for data analysis and modeling.
(S Shiraiwa, T Fredian, J Hillairet, J Stillerman, "πScope: Python based scientific workbench with MDSplus data visualization tool", Fusion Engineering and Design 112, 835 (2016)https://doi.org/10.1016/j.fusengdes.2016.06.050)Goal of piScope includesData browsing (scope) application for MDSplus data system (www.mdsplus.org)Lego blocks for gluing up large simulation codes using pythonUser frontend platform for Petra-M (MFEM based finite element simulation).and for the above purposes, πScope is equipped witha data analysis environment (= python shell, editor, data structure browser, and matplotlib figure)various GUI componetns to work with matplotlib based figures which allows tosave/load a figure as a figure file.edit artists using GUI palette for plot, contour, image, triplots and so on.change panel layout via an interactive layout editorcut/paste of plot, axes, or an entire page.export data from plot to python shell by one clickinteractively annotate figure using text, arrow, lines,,,draw 3D (OpenGL) in matplotlib canvas.πScope is also used for Petra-M finiete element analysis platform built on MFEM (https://piscope.psfc.mit.edu/index.php/Petra-M)RequirementsPython >3.6wxPython 4.2matplotlib 3.6.2PyOpenGL... and others.Typical pip command list...pip install attrdict
 pip install wxPython
 pip install piScopeWiki page :http://piscope.psfc.mit.edu/Directories:../python/ifigure             core program../python/ifigure/example              examples../bin/                        scripts to run πScope../example/                   example data to look in πScope
Package: piscord
PiscordPiscord is a python framework to communicate with the Discord api.In particular, it simplifies the creation of a bot that interacts with a Web server.
It thus allows to do much more easily various things like bot control panels.DocumentationPiscord DocumentationTutorialPiscord Tutorial(Only in French for the moment)How to use itYou can install it with pip : pip install piscordUsed Modules :aiohttpwebsocketsAuthor : AstremyDiscord :PiscordThis project is licensed under the terms of the MIT license :LicenseAlthough it is common to have a v1.x.x stable, piscord is still in beta, we are trying to stabilise the API during the v1.x.x phase and avoid breaking backward compatibility but please keep in mind this is still a provisional API
Package: pi-screencontrol-webthing
pi_screencontrol_webthingA web connected screen control of Raspberry PiThe screen control package exposes a http webthing endpoint which supports activating the screen. E.g.# webthing has been started on host 192.168.0.23

curl http://192.168.0.23:9122/properties 

{
"activated": true,
"log": "[2022-02-25T14:40:18]  XAUTHORITY=~pi/.Xauthority DISPLAY=:0 xset s 180\n
        [2022-02-25T14:40:18]  XAUTHORITY=~pi/.Xauthority DISPLAY=:0 xset dpms 180 180  180\n
        [2022-02-25T14:40:18]  XAUTHORITY=~pi/.Xauthority DISPLAY=:0 xset s 180\n
        [2022-02-25T14:40:18]  XAUTHORITY=~pi/.Xauthority DISPLAY=:0 xset dpms 180 180  180"
}To install this software you may usePIPpackage manager such as shown belowsudo pip install pi_screencontrol_webthingAfter this installation you may start the webthing http endpoint inside your python code or via command line usingsudo screen --command listen --port 9832Here, the webthing API will be bind to the local port 9832Alternatively to thelistencommand, you can use theregistercommand to register and start the webthing service as systemd unit.
By doing this the webthing service will be started automatically on boot. Starting the server manually using thelistencommand is no longer necessary.sudo screen --command register --port 9832
Package: pisense
This package is an alternative interface to the Raspberry Pi Sense HAT.  The
major difference to theofficial APIis that the various components of the
Sense HAT (the screen, the joystick, the environment sensors, etc.) are each
represented by separate classes which can be used individually or by the main
class which composes them together.The screen has a few more tricks including support for any fonts thatPILsupports, representation as anumpyarray (which makes scrolling by
assigning slices of a larger image very simple), and bunch of rudimentary
animation functions. The joystick, and all sensors, have an iterable interface
too.LinksThe code is licensed under theBSD licenseThesource codecan be obtained from GitHub, which also hosts thebug
trackerThedocumentation(which includes installation, quick-start examples, and
lots of code recipes) can be read on ReadTheDocsPackages can be downloaded fromPyPI, but reading the installation
instructions is more likely to be useful
Package: piservopantilt
piservopantiltInitial code to control Raspberry Pi with camera setup on 2-axis servo controlled arm.UsagefrompiservopantiltimportServoControls=ServoControl(pan_limits=(650,2500),tilt_limits=(650,2250))# Move to 0,0s.min()# Move to 180,180s.max()# Move to specific coordinatess.move_to(180,0)TestingRun unit tests with command:python3-munittestdiscover-spiservopantilt/tst/Get test coverage with commands:coveragerun-munittestdiscover-spiservopantilt/tst/
coveragereport-m
Package: pish
pish: Manual--------------Licensepish is written by pino under the terms of the GPLv3.Please read the LICENSE file from the package and the Dependencies section for included third-party stuff.Up-to-date?Are you currently reading from another source than the homepage? Are you in doubt if that place is up-to-date? If yes, you should visit the homepage and check that. You are currently reading the manual for version0.5.DependenciesThere are no dependencies.
Package: pishock
PiShock for PythonThebestestPython PiShock API wrapper and CLI!If you have no idea whatPiShockis: I'm left wondering how you found this, but it's an ecosystem around using dog shock collars on humans (clearly the better way to use them!).Pythonic,easy-to-use API.Beautifulcommand-line interfacetosend shocks/vibrates/beeps,manage share codes, keep someone on their toes withrandom shocks, interfacing with the PiShockoverUSB/serial,upgrading firmware, and more!Ticks the boxes: Support formini-shocks, gettingshocker info, and various other undocumented API features. If it's possible to do, this project probably supports it.Local shocking: Drop-in support for theUSB serial APIinstead of HTTP.Battle-tested: I accidentally shocked my balls while developing so you don't have to (Iwishthis was a joke).High-quality, moderncodebase: Type annotations inMypy strict mode, Linting/Formatting viaRuff, Automated tests withpytest.Made with love: Decent test coverage,CI,nice documentation, …. — I love zappies and I love going the extra mile!Almost official: While this is not an official pishock.com product, I'm the same person who developed the code running on your PiShock that's sending out the shocks.Runs anywhere: Tested on CPython 3.8 to 3.12, on Windows, macOS and Linux. Possibly CircuitPython soon?Using the CLI to send a vibrate (or a shock, if you dare):$pipinstallpishock[...]$pishockinit👤 PiShock username (your own username): Zerario🔑 PiShock API key (https://pishock.com/#/account): 964f1513-c76a-48cc-82d4-41e757d4eb04✅ Credentials saved.$pishockcodeaddmy-shockerABCDEF12345✅  my-shocker    ABCDEF12345$pishockvibratemy-shocker--duration1--intensity20📳Or via the Python API:frompishockimportPiShockAPIusername="..."# from pishock.comapi_key="..."# https://pishock.com/#/accountsharecode="..."# https://pishock.com/#/control (share button)api=PiShockAPI(username,api_key)shocker=api.shocker(sharecode)shocker.vibrate(duration=1,intensity=10)For serial USB usage:frompishockimportSerialAPIshocker_id=1234# https://pishock.com/#/control (cogwheel button)api=SerialAPI()shocker=api.shocker(shocker_id)shocker.vibrate(duration=1,intensity=10)For more, see thedocumentation.
Package: pishockpy
pishockpyComfortably use thePiShockAPI in Python.This requires at leastPython 3UsageImport the package:frompishockpyimportPishockAPIDeclare a new shocker instance:pishock=PishockAPI("YOUR_API_KEY","YOUR_USERNAME","SHARECODE","YOUR_APP_NAME")Run actions on a shocker:# Send a shock - intensity (float between 0 and 1) and duration in seconds (integer between 1 and 15)pishock.shock(INTENSITY,DURATION)# Send a mini shock - intensity (float between 0 and 1)pishock.minishock(INTENSITY)# Send a vibration - intensity (float between 0 and 1) and duration in seconds (integer between 1 and 15)pishock.vibrate(INTENSITY,DURATION)# Send a sound - duration in secondspishock.beep(DURATION)Check if an action was successful:if(pishock.shock(INTENSITY,DURATION)):print("Shock was successful")else:print("Shock was not successful")DisclaimerI'm not affiliated with PiShock in any way. I am also not responsible for any damage caused by this library.
Package: pi-si7021
pi_si7021Library for playing around with si7021 relative humidity and temperature sensor with Raspberry Pi. Based onpigpio example.Usagefrompi_si7021importSi7021RHTEMP=Si7021()print("Temperature: "+str(round(RHTEMP.temperature,2))+u"\u00B0C")print("Relative humidity: "+str(round(RHTEMP.relative_humidity,2))+" %")RHTEMP.close()TestingRun unit tests with commands:cdpi_si7021

python3-munittestdiscover-stst/Get test coverage with commands:cdpi_si7021

coveragerun-munittestdiscover-stst/
coveragereport-m
Package: pisim
Author: Luca Casone (csnluca@gmail.com)URL:https://pypi.org/project/pisim/Description (in English)Program to simulate the development of a supplementary pension plan.
Tired of so many online simulators which are somehow opaque in the hypotheses
they take and rigid in the small set of parameters they provide to be
freely changed by the user, I decided to write one by my own. I wanted
to be able to set almost everything that may impact on plan performance
and compare different scenarios. This program is the result of the effort.Being explicitly thought and tailored for Italian rules, the whole interface
is written in Italian as well as guidelines to use it.Descrizione (in Italiano)Tutti i simulatori online di pensione integrativa sono poco configurabili
e spesso le ipotesi su cui si basano per i loro calcoli non sono
completamente specificate.Questo simulatore, invece, permette di configurare tutti i parametri che
influenzano lo sviluppo di un fondo pensione integrativa e di confrontare
differenti scenari che si possono verificare a parità di condizioni.Le indicazioni sull’uso programma sono incluse nel programma stesso.Installazione ed usoPiSim si scarica ed installa analogamente ad altri package Python:pip install pisimUna volta installato, PiSim può essere eseguito da linea di comando digitando:pisim
Package: piskg
piskg: Python IPFS Swarm Key GeneratorThis program generates swarm.key file for IPFS Private Network feature.Installing$ pip install piskgUsage$ piskg > ~/.ipfs/swarm.keyChange~/.ipfs/to different directory if you use customIPFS_PATH. To
join a private network, save the key value to your~/.ipfs/swarm.key.When using this feature, you will not be able to connect to the default
bootstrap nodes since they are not part of your private network, so you
will need to set up your own bootstrap nodes.To prevent your node from even trying to connect to the default
bootstrap nodes, run:$ ipfs bootstrap rm --allTo be extra cautious, you can also set the LIBP2P_FORCE_PNET
environment variable to 1 to force the usage of private networks. If no
private network is configured, the daemon will fail to start.CreditsDirect port ofhttps://github.com/Kubuxu/go-ipfs-swarm-key-gen/. Setup
information derived fromhttps://github.com/ipfs/go-ipfs/issues/3397#issuecomment-284341649.Logo derived from work byEagle Eye(CC BY 3.0) andSergey Demushkin(CC BY 3.0) and itself licensedCC BY-SA 4.0.LicenseMIT
Package: piskle
PisklePiskleallows you to selectively serialize python objects to save on memory and load times.It has special support for exportingscikit-learn's  models in an optimized way,
exporting exactly what's needed to make predictions.via GIPHYExample:To usepiskle, you first need a model to export. You can use this as an example:fromsklearnimportdatasetsfromsklearn.neural_networkimportMLPClassifierdata=datasets.load_iris()model=MLPClassifier().fit(data.data,data.target)Exporting the model is then as easy as the following:importpisklepiskle.dump(model,'model.pskl')Loading it is even easier:model=piskle.load('model.pskl')If you want even faster serialization, you can disable theoptimizefeature.
Note that this feature reduces the size of the exported file even further and improves loading time.piskle.dump(model,'model.pskl',optimize=False)Future ImprovementsThis is still an early working version of piskle, there are still a few improvements planned:More thorough testingVersion Management: Support for more versions of scikit-learn (earlier versions)Support for more Estimators (Feel free to contact us for a specific request)Support for "Nested" Estimators (Pipelines, RandomForests, etc...)Support for other serialization methods (such as joblib, shelve or json...)ContributeAs this is still a work in progress, while using piskle, you might encounter some bugs.
It would be a great help to us, if you couldreport them in the github repo.Feel free, to share with us any potential improvements you'd like to see in piskle.If you like the project and want to support us, you can buy us a coffee here:Currently Supported ModelsPredictors ( Classifiers, Regressors, ...)EstimatorReferenceLinearSVCsklearn.svmLinearRegressionsklearn.linear_modelLogisticRegressionsklearn.linear_modelLassosklearn.linear_modelRidgesklearn.linear_modelPerceptronsklearn.linear_modelGaussianNBsklearn.naive_bayesKNeighborsRegressorsklearn.neighborsKNeighborsClassifiersklearn.neighborsMLPClassifiersklearn.neural_networkMLPRegressorsklearn.neural_networkDecisionTreeClassifiersklearn.treeDecisionTreeRegressorsklearn.treeKMeanssklearn.clusterGaussianMixturesklearn.mixtureTransformersEstimatorReferencePCAsklearn.decompositionFastICAsklearn.decompositionCountVectorizersklearn.feature_extraction.textTfidfVectorizersklearn.feature_extraction.textSimpleImputersklearn.imputeStandardScalersklearn.preprocessingLabelEncodersklearn.preprocessingOneHotEncodersklearn.preprocessing
Package: pi-smart-camper
pi-smart-camperThe goal is to use a Raspberry Pi to provide some modern-era amenities, monitoring, and "smart-home" niceties to a vintage camper trailer.The camper in question is a 1972 Eco fiberglass egg,
which is a clone of theBoler.I'll keep the code and necessary docs here, but put more general how-to, details and a running progress log onhttps://www.smartercamper.com.Here's what's at least tentatively planned:Plex, with a decent-size SSD drive to store moviesTemperature, motion and other sensors to monitor the trailerWIFI boosting and cleaning (VPN)A cellular modem to send messages if something is out of whackAn external power button, since the Pi will be hard-wired into the trailer.A simple web server so I can monitor things with my phone.The cellular modemThis is a giant pain, and I still don't know if I can actually get it to work or not.The USB modem I purchasedtook six weeks to arrive and came with almost no instructions. It took awhile to even figure out where to put the SIM card. Definitely not recommended. But it's what I have, and itshouldwork. I've copied the Linux instructions found on the modem itself here, but so far I don't trust them. We'll see.The instructions are hard to find because by default the modem doesn't want to mount on the Pi, and it doesn't appear as a USB drive, either. So that's fun.MonitoringExternal temperature:to comeMotion detection:to comeSmoke detection:to comeInternal temperature monitoringGiven a lack of ventilation, I have some concerns about CPU temp. Theinternal-temp.pyscript will allow me to monitor it and if I see it get high, I can easily add a fan for extra cooling when the temp climbs.To-Do: have it run automatically in the background.
Package: pism-palseries
A small script to prepare scalar modifier temperature and precipitation time
series for the Parallel Ice Sheet Model (PISM) based on online-available
palaeo-climate records or simple mathematical functions.RequiresNetCDF4andNumpy.Installation:pip install pism-palseriesExample usage:pism_palseries.py ramp 0 1000 0 -10 --output ramp.nc
pism_palseries.py --help