Saravanan666/pypi-org huggingface dataset:
Package: pebblo
Pebbloenables developers to safely load data and promote their Gen AI app to deployment without worrying about the organization’s compliance and security requirements. The project identifies semantic topics and entities found in the loaded data and summarizes them on the UI or a PDF report.Pebblo has two components.Pebblo Daemon - a REST api application with topic-classifier, entity-classifier and reporting featuresPebblo Safe DataLoader - a thin wrapper to Gen-AI framework's data loadersPebblo DaemonInstallationPre-requisitesMac OSXbrewinstallpangoLinux (debian/ubuntu)sudoapt-getinstalllibpango-1.0-0libpangoft2-1.0-0Install Pebblo DaemonpipinstallpebbloRun Pebblo daemonpebbloseetroubleshootingguide for troubleshooting info.Pebblo daemon now listens tolocalhost:8000to accept Gen-AI application data snippets for inspection and reporting.Pebblo Optional Flags--config <file>: Specifies a custom configuration file in yaml format.pebblo--configconfig.yamlPebblo Safe DataLoaderLangchainPebblo Safe DataLoaderis natively supported in Langchain framework. It is available in Langchain versions>=0.1.7Enable Pebblo in Langchain ApplicationAddPebbloSafeLoaderwrapper to the existing Langchain document loader(s) used in the RAG application.PebbloSafeLoaderis interface compatible with LangchainBaseLoader. The application can continue to useload()andlazy_load()methods as it would on an Langchain document loader.Here is the snippet of Lanchain RAG application usingCSVLoaderbefore enablingPebbloSafeLoader.fromlangchain.document_loaders.csv_loaderimportCSVLoaderloader=CSVLoader(file_path)documents=loader.load()vectordb=Chroma.from_documents(documents,OpenAIEmbeddings())The Pebblo SafeLoader can be enabled with few lines of code change to the above snippet.fromlangchain.document_loaders.csv_loaderimportCSVLoaderfromlangchain_community.document_loaders.pebbloimportPebbloSafeLoaderloader=PebbloSafeLoader(CSVLoader(file_path),name="acme-corp-rag-1",# App name (Mandatory)owner="Joe Smith",# Owner (Optional)description="Support productivity RAG application",# Description (Optional))documents=loader.load()vectordb=Chroma.from_documents(documents,OpenAIEmbeddings())Seeherefor samples with Pebblo enabled RAG applications andthisdocument for more details.ContributionPebblo is a open-source community project. If you want to contribute seeContributor Guidelinesfor more details.LicensePebblo is released under the MIT License
Package: pebblo-sample
Pebbloenables developers to safely load data and promote their Gen AI app to deployment without worrying about the organization’s compliance and security requirements. The project identifies semantic topics and entities found in the loaded data and summarizes them on the UI or a PDF report.Pebblo has two components.Pebblo Daemon - a REST api application with topic-classifier, entity-classifier and reporting featuresPebblo Safe DataLoader - a thin wrapper to Gen-AI framework's data loadersPebblo DaemonInstallationPre-requisitesMac OSXbrewinstallpangoLinux (debian/ubuntu)sudoapt-getinstalllibpango-1.0-0libpangoft2-1.0-0Install Pebblo DaemonpipinstallpebbloRun Pebblo daemonpebbloseetroubleshootingguide for troubleshooting info.Pebblo daemon now listens tolocalhost:8000to accept Gen-AI application data snippets for inspection and reporting.Pebblo Optional Flags--config <file>: Specifies a custom configuration file in yaml format.pebblo--configconfig.yamlPebblo Safe DataLoaderLangchainPebblo Safe DataLoaderis natively supported in Langchain framework. It is available in Langchain versions>=0.1.7Enable Pebblo in Langchain ApplicationAddPebbloSafeLoaderwrapper to the existing Langchain document loader(s) used in the RAG application.PebbloSafeLoaderis interface compatible with LangchainBaseLoader. The application can continue to useload()andlazy_load()methods as it would on an Langchain document loader.Here is the snippet of Lanchain RAG application usingCSVLoaderbefore enablingPebbloSafeLoader.fromlangchain.document_loaders.csv_loaderimportCSVLoaderloader=CSVLoader(file_path)documents=loader.load()vectordb=Chroma.from_documents(documents,OpenAIEmbeddings())The Pebblo SafeLoader can be enabled with few lines of code change to the above snippet.fromlangchain.document_loaders.csv_loaderimportCSVLoaderfromlangchain_community.document_loaders.pebbloimportPebbloSafeLoaderloader=PebbloSafeLoader(CSVLoader(file_path),name="acme-corp-rag-1",# App name (Mandatory)owner="Joe Smith",# Owner (Optional)description="Support productivity RAG application",# Description (Optional))documents=loader.load()vectordb=Chroma.from_documents(documents,OpenAIEmbeddings())Seeherefor samples with Pebblo enabled RAG applications andthisdocument for more details.ContributionPebblo is a open-source community project. If you want to contribute seeContributor Guidelinesfor more details.LicensePebblo is released under the MIT License
Package: pebcaw
PEBCAWPEBCAW (Problem Exists Between Computer And World) monitors internet
connection security by comparing the observed IP or country with a
whitelist of VPN and Tor IPs or a whitelist of countries. It notifies if
the IP or country is not whitelisted, and optionally can notify if the
IP is in a SIGINT country, and optionally can display observed IP
details continuously.setuppipinstallpebcawusagepebcawpebcaw--help
Package: pebl
Pebl is a python library and command line application for learning the
structure of a Bayesian network given prior knowledge and observations.  Pebl
includes the following features:Can learn with observational and interventional dataHandles missing values and hidden variables using exact and heuristic
methodsProvides several learning algorithms; makes creating new ones simpleSupports hard and soft structural priorsHas facilities for transparent parallel executionCalculates edge marginals and consensus networksPresents results in a variety of formats
Package: pecan-mount
Pecan Mount===========A utility to mount Pecan applications at different points to act as one.Adding applications-------------------Pecan applications are usually mounted at `/` and they do not have an easy wayto be able to compound different apps working in unison. If you are using`pecan_mount` you need to use the tree as the actual WSGI application as itacts as WSGI middleware to properly return the apps at given mount points.You only need two things for mounting an app, an application configuration andthe mount point. The configuration can be either a path to a file ora dictionary (Pecan takes care of this loading for us). So to mount a singleapplication at `/application` with a configuration file living in`/path/to/config.py` it would look like this::import pecan_mountpecan_mount.tree.mount('/application', '/path/to/config.py')The nice things about Pecan configuration is that it will take care of findingthe right modules and everything necessary for your application. At most, theimportant decision here is the mount point.Running multiple applications----------------------------Ideally, you would want to mount all the applications you need in one place,and this place should be where the WSGI application is constructed so that itcan be consumed by a WSGI server (for example `gunicorn` or Apache with`mod_wsgi`). This is how having 4 different applications would look in a filecalled `wsgi.py`::import pecan_mountpecan_mount.tree.mount('/', '/path/to/main_config.py')pecan_mount.tree.mount('/admin', '/path/to/admin_config.py')pecan_mount.tree.mount('/registration', '/path/to/registration_config.py')pecan_mount.tree.mount('/_metrics', '/path/to/metrics_config.py')application = pecan_mount.treeNaming the mounts-----------------Optionally, when mounting, you can pass in a ``mount_name`` that will be usedadded to the WSGI app as an attribute. This is useful when debugging or whenyou need to have a better representation of what application is mounted at somepoint.If no ``mount_name`` is passed in to the ``mount`` callable, it will default toinferring the name from the ``script_name``, which in turn will use ``root``for empty strings or None and for dotted conversions for other paths.For example, a ``script_name`` that looks like: ``/foo/bar`` will be translatedto a ``mount_name`` of ``foo.bar``.Preventing overriding of mounts-------------------------------The ``tree`` object will prevent you from mounting applications in locationswhere there is already an app mounted. This is convenient when there aremultiple applications mounted and unknowingly a new app is using a locationalready taken. An ``AttributeError`` will be raised to indicate whatapplication at what mount point is being used and prevent further execution.Mounting other WSGI apps------------------------Other WSGI applications can also be mounted easily. The WSGI app will need tobe properly configured before mounting and will use a different callable::import pecan_mountimport my_appmy_wsgi_app = my_app()pecan_mount.tree.graft(my_app, '/mount_point')
Package: pecan-notario
pecan-notarioJSON validation for Pecan with Notario (http://notario.cafepais.com).In its simplest form, you need to define a schema and decorate the
controller method, like:schema = ('foo', True)

@expose()
@validate(schema)
def some_controller(self, **kw):
    return dict()The above controller method, using a Notario schema, will require afookey and aTruevalue otherwise it will (by default) set the HTTP response
to a400(invalid request) and add the validation error torequest.pecan['schema'].errors.Using a handlerIf more granular control is needed when dealing with an error condition,
a handler can be passed in to the decorator to deal with errors explicitly.@expose()
@validate(some_schema, '/some/handler')
def some_controller(self, **kw):
    return dict()In this situation ‘/some/handler’ would be a controller method that can deal
directly with the error that was slapped onto the request object (onrequest.validation_error).Notario exceptions will include areasonattribute that will contain the
specific error message that was raised if a custom validator failed with an
error message. In this case, a handler would access this Notario exception
attribute like:request.validation_error.reason
Package: pecan-swagger
some helpers to create swagger output from a pecan appexample usagegiven a file namedmyapp.pyimport pecan
from pecan_swagger import decorators as swagger


@swagger.path('profile', 'Profile', 'Root')
class ProfileController(object):

    @pecan.expose(generic=True, template='index.html')
    def index(self):
        return dict()

    @index.when(method='POST')
    def index_post(self, **kw):
        print(kw)
        pecan.redirect('/profile')


@swagger.path('/', 'Root')
class RootController(object):

    profile = ProfileController()and another file namedmyapp-doc.pyimport pprint

from pecan_swagger import utils
import myapp

pp = pprint.PrettyPrinter(indent=2)
pp.pprint(utils.swagger_build('myapp', '1.0'))the following will be produced when run$ python myapp-doc.py
{
  "swagger": "2.0",
  "info": {
    "version": "1.0",
    "title": "myapp"
  },
  "paths": {
    "/profile": {
      "POST": {},
      "GET": {}
    }
  }
}
Package: pecg
PhysioZoo ECG documentationDigital electrocardiography biomarkers to assess cardiac conduction.Based on the paper
S. Gendelman et al., "PhysioZoo ECG: Digital electrocardiography biomarkers to assess cardiac conduction," 2021 Computing in Cardiology (CinC), 2021, pp. 1-4, doi: 10.23919/CinC53138.2021.9662857.IntroductionThe electrocardiogram (ECG) is a standard tool used in medical practice for identifying cardiac pathologies. Because the necessary expertise to interpret this tracing is not readily available in all medical institutions or at all in some large areas of developing countries, there is a need to create a data-driven approach that can automatically capture the information contained in this physiological time series. The primary objective of this package is to identify and implement clinically important digital ECG biomarkers for the purpose of creating a reference toolbox and software for ECG morphological analysis.DescriptionFew steps are required to extract the morphological ECG biomarkers, those steps are implemented in the PECG toolbox:ECG Signal Preprocessing - Before computing the ECG morphological biomarkers, prefiltering of the raw ECG time series is performed to remove the baseline wander and the high frequency noise. Specifically, the toolbox includes a zero phase second-order infinite impulse response bandpass filter with the passband of 0.67Hz - 100Hz. Also, the toolbox includes an optional Notch filter that can be set to 50 or 60Hz to remove the power-line interference.ECG Fiducial Points Detection - The toolbox includes the epltd R-peaks algorithm, and the well-known wavedet algorithm for ECG fiducial points  detection.Engineering of ECG Biomarkers - Using the fiducial points ECG biomarkers are engineered for individual ECG cycles. When a biomarker cannot be engineered because some fiducial points could not be detected by wavedet, then the feature was marked as a NaN. For an ECG channel, a total of 14 features are extracted from intervals duration and 8 from waves characteristics to describe the ECG morphology.Summary Statistics - For a specified time window the six summary statistics (mean, median, min, max, IQR and std) are computed for all ECG biomarkers.InstallationAvailable on pip, with the command:
pip install pecgRequirementsPython Requirements:Python >= 3.6numpymnewfdbAll the python requirements except wfdb are installed when the toolbox is installed. To install wfbd run: pip install wfdbSystem Requirements:To run the wavdet fiducial-points detector matlab runtime (MCR) 2021a is required.https://www.mathworks.com/products/compiler/matlab-runtime.htmlTo run the epltd peak detector additional wfdb toolbox is required.https://archive.physionet.org/physiotools/wfdb-linux-quick-start.shtmlInstallation instructions:Install the "pecg" package using pip by running the command line: "pip install pecg".Install the "wfdb" package using pip by running the command line: "pip install wfdb".Follow the guidelines provided in the link:https://www.mathworks.com/products/compiler/matlab-runtime.html, and choose the version of 2021a(9.10).Documentationhttps://pecg.readthedocs.io/en/latest/pecg.html
Package: peck
peck 🐤is a command line tool that allows you to take notes across directories without cluttering your work spaces.install:pip install peckusing:peck [command] [keyword (if appropriate)]or for a quick entry:peck [entry]how everything works:notes are formatted as follows:Sat 04:48PM Sep 19 2020
-----------------------
this is a peck note 
#*#*#*#*#*#*#*#*#*#*#*#each file can contain any number of notes.all of your notes are stored in yourhomedirectory in a folder calledpck. when you run peck from a new location, a folder is created insidepeckthat references this location. for example, if your shell points toYou/Desktop, runningpeck [note]will add an entry to aYou_Desktopfolder inhome/peck. peck recognizes the directory from where you are taking notes, but leaves the location itself untouched. this allows you to take notes without the worry of cluttering your work spaces.to create a new collection file, run a command. the default file name ispeck.txt, but you can runpeck -s [new_name]to set a new default name. runningpeck -lwill print a header with useful information on the files in yourpeckfolder.config attributes allow various changes to how peck formats your notes. this file is generated withpeck -config, or whenpeck -s [new file]is run. for example, if you want a note's date header to be underlined differently, this attribute can be modified. if you want a different string to mark the end of an entry, this can be modified. it should be noted that changing things integral to how the program functions, such as an entry end marker, will outdate the path you are working in. specifications on what is safe to update in an existing path are included in the config file itself (peck.ini).suggestions for use: to-do list, dream journal, version note manager, recipe experimentation database, anything that you want to keep track of paired with the time you remembered to record itcommands:'-l': list out information about paths in use
'-n': new entry with both first and second sections'-n1': new entry with first section'-n2': new entry with second section'-nt': new entry using a textbox. ignores config file preferences'-a': new tagged entry. syntax: peck -a [tag] [entry]'-v': view entries. syntax: peck -v // peck -v [keyword]'-vf': view a difference collection in the same path. format: 'peck -vf: [collection name][opt keyword]''-ds': view entries on a specific date. format: 'peck -ds [mm/dd/yy]''-t': search for entries with a tag'-wipe': delete current default'-wipe-all': delete folder referencing this location'-b': create backup of collection'-load': load entries from backup'-config': generate config file in pwd. if config exists, defaults reset.
updating config may outdate peck'-s': specify default collection file.
does not modify existing files. modifes / creates config file.'-del': delete entry'-q': quick delete the last entry madebuild with pyinstaller:1.) pyinstaller [options]__main__.py2.) (optional) copygoogle_api_python_client-1.12.1.dist-infofolder to[project]/bin/[os]/[peck]directory to allow for google drive support (note: not implemented in current builds / source. check issue #3 for more information)
Package: peco
PECO Outage APIA library for interacting with thePECO outage mapto gain the numbers from it.Interacting with the API is simple.frompecoimportPecoOutageApiasyncdefget_data():api=PecoOutageApi()# How many customers are affected by an outage in Bucks county?print(awaitapi.get_outage_count('BUCKS').customers_out)# What is the total outage count for the entire region?print(awaitapi.get_outage_totals().outage_count)# What is the percentage of customers that are affected by an outage?print(awaitapi.get_outage_totals().percent_customers_out)importasyncioasyncio.run(get_data())Note:Thepercent_customers_outkey does not go below 5%. It will show up as4.999999instead. Make sure to take this into account when using the API.The counties that are available are:BUCKSCHESTERDELAWAREMONTGOMERYPHILADELPHIAYORKThe values you can access are:customers_outpercent_customers_outoutage_countcustomers_served
Package: pecoregex
PECOREGEXPecoregex stands for Perl-Compatible Regular Expression, better known as PCRE.
Pecoregex ispython-pcre's weird little cousin: like python-pcre, pecoregex
acts as a bridge between Python and libpcre.The key differences are:pecoregex relies on ctypes to load and leverage libpcre.so; consequently, it can be installed without compiling
anything;pecoregex only provides access to the most essential features of libpcre: compiling and executing regexes (including
retrieving captures); other features such as study(), JIT or sub() were not considered (yet?).ModulesThe pecoregex package provides multiple modules:pecoregex.pcre provides PCRE_* constants and the PCRELibrary class; this is the part that actually interacts with
libpcre.so; it can be used directly or through the other modules that build upon it;pecoregex.document defines key names for the Pecoregex document format; Pecoregex documents are a way to bundle 1 to n
PCRE patterns along with 0 to n subjects each.pecoregex.factory provides helpers to build common Pecoregex documents (e.g. "1 subject, n patterns" documents);pecoregex.util provides functions to process Pecoregex documents, i.e. compile the PCRE patterns they contain and
match their associated subject strings against them;pecoregex.cli is typically invoked through thepecoregexCLI tool; it provides a mean to compile and execute PCRE
patterns: patterns and subjects are provided either as command-line arguments or by passing a Pecoregex document on
the standard input (as JSON or YAML); supported output formats include text, JSON and YAML; therefore, it is perfectly
possible to compile and execute multiple PCRE patterns and subjects before picking up their captures usingjq.pecoregex.extproc provides simple subprocess-based wrappers that leverage pecoregex.cli to compile and execute PCRE
patterns in a separate process; this is meant for all those who consider calling C functions from Python as a threat
to the reliability of their program.LicenseThis Python package and its modules are released under the 3-clause BSD license.
Package: pecos
[![build](https://github.com/sandialabs/pecos/workflows/build/badge.svg)](https://github.com/sandialabs/pecos/actions/workflows/build_tests.yml)
[![Coverage Status](https://coveralls.io/repos/github/sandialabs/pecos/badge.svg?branch=main)](https://coveralls.io/github/sandialabs/pecos?branch=main)
[![Documentation Status](https://readthedocs.org/projects/pecos/badge/?version=latest)](https://pecos.readthedocs.io/en/stable/?badge=latest)
[![Downloads](https://pepy.tech/badge/pecos)](https://pepy.tech/project/pecos)Advances in sensor technology have rapidly increased our ability to monitor
natural and human-made physical systems. In many cases, it is critical to
process the resulting large volumes of data on a regular schedule and alert
system operators when the system has changed. Automated quality control and
performance monitoring can allow system operators to quickly detect performance
issues.Pecos is an open source Python package designed to address this need. Pecos
includes built-in functionality to monitor performance of time series data,
subject to a series of quality control tests. The Python package includes
methods to run quality control tests defined by the user and generate reports
which include performance metrics, test results, and graphics. The software was
developed specifically for solar photovoltaic system monitoring, but is
designed to be used for a wide range of applications.For more information, go tohttp://pecos.readthedocs.ioCiting PecosTo cite Pecos, use one of the following references:K.A. Klise and J.S. Stein (2016), Performance Monitoring using Pecos, Technical Report SAND2016-3583, Sandia National Laboratories.K.A. Klise and J.S. Stein (2016), Automated Performance Monitoring for PV Systems using Pecos, 43rd IEEE Photovoltaic Specialists Conference (PVSC), Portland, OR, June 5-10.LicenseRevised BSD.  See the LICENSE.txt file.OrganizationDirectoriespecos - Python packagedocumentation - User manualexamples - Examplesci - Software requirementsContactKatherine Klise, Sandia National Laboratories,kaklise@sandia.govJoshua Stein, Sandia National Laboratories,jsstein@sandia.govSandia National Laboratories is a multimission laboratory managed and operated
by National Technology and Engineering Solutions of Sandia, LLC., a wholly
owned subsidiary of Honeywell International, Inc., for the U.S. Department of
Energy’s National Nuclear Security Administration under contract DE-NA-0003525.
Package: pecpy
The pecpy library provides an implementation of the proximity effect correction (PEC) scheme proposed in [1]. Examples are bundled with the source code inpecpy/examplesIf you use this package in your research, please cite the original publication. If you use Windows, I can recommend [2] for obtaining pre-compiled versions of fftw, shapely, and opencv. Note that the latter two packages are only needed for the gds <-> image mapping.[1]https://doi.org/10.1016/j.mee.2018.07.013[2]https://www.lfd.uci.edu/~gohlke/pythonlibs/