Saravanan666/pypi-org huggingface dataset:
Package: papyrus_ogcproxy
papyrus_ogcproxy provides an easy and convenient method for embeding
an OGC proxy in Pyramid applications.The source code of papyrus_ogcproxy is straightforward, so if
papyrus_ogcproxy doesn’t do what you want, open its source code, get
inspiration, and write your own code.Installpapyrus_ogcproxy can be installed witheasy_install:$ easy_install papyrus_ogcproxyOften you’ll want to make papyrus_ogcproxy a dependency of your Pyramid
application, which is done by addingpapyrus_ogcproxyto theinstall_requireslist defined in the Pyramid application’ssetup.pyfile.Set upUsing papyrus_ogcproxy to set up an OGC proxy in a Pyramid application is easy.Edit the application’s main file,__init__.py, and register
papyrus_ogcproxy using theConfigurator.includemethod:def main(global_config, **settings):

    config = Configurator(settings=settings)

    import papyrus_ogcproxy
    config.include(papyrus_ogcproxy)That’s it! The OGC proxy is available at/ogcproxy.Here is a test URL:http://localhost:6543/ogcproxy?url=http%3A%2F%2Fmap1.vis.earthdata.nasa.gov/wmts-geo/wmts.cgi%3FSERVICE%3DWMTS%26REQUEST%3DGetCapabilitiesUsing a proxy for the proxyIf the requests made by the OGC proxy should be made through a proxy, the additional
packagepysocksis required. After the installation of this package, configure
the proxy:from papyrus_ogcproxy import views as ogcproxy_views
from httplib2 import ProxyInfo
import socks
ogcproxy_views.proxy_info = ProxyInfo(socks.SOCKS5, 'localhost', 1080)With this configuration the OGC proxy will make requests through the proxylocalhost:1080. For information please refer to the
documentation ofPySocksandhttplib2.Set up a development environmentTo set up a development environment with virtualenv, run the following
commands:$ virtualenv venv
$ venv/bin/python setup.py develop
$ venv/bin/pip install -r requirements-dev.txtRun the testsTo run the tests:$ venv/bin/nosetests --with-coverageOne test assumes that a proxy server is running atlocalhost:1080. To start
a proxy run:$ ssh -N -D 0.0.0.0:1080 localhost0.2Do not verify certificate from the remote server.https://github.com/elemoine/papyrus_ogcproxy/pull/4from @sbrunner.
(We may want to revisit this later.)0.1First version
Package: papyrus_tilecache
papyrus_tilecache provides an easy and convenient method for embeding
TileCache in Pyramid applications.Installpapyrus_tilecache can be installed witheasy_install:$ easy_install papyrus_tilecacheOften you’ll want to make papyrus_tilecache a dependency of your Pyramid
application, which is done by addingpapyrus_tilecacheto theinstall_requireslist defined in the Pyramid application’ssetup.pyfile.Embed TileCacheEmbeding TileCache in a Pyramid application is easy.Edit the application’sdevelopment.inifile and, in the main section
([app:]), settilecache.cfgto the location of the TileCache config
file. Example:[app:MyApp]
use = egg:MyApp
...
tilecache.cfg = %(here)s/tilecache.cfgIn this example the TileCache config file is located at the same location as
thedevelopment.inifile.You can use the following TileCache config as an example:[cache]
type=Disk
base=/tmp/tilecache
[basic]
type=WMS
url=http://vmap0.tiles.osgeo.org/wms/vmap0
extension=pngNow, edit the application’s main file,__init__.py, and register
papyrus_tilecache using theConfigurator.includemethod:def main(global_config, **settings):

    config = Configurator(settings=settings)

    import papyrus_tilecache
    config.include(papyrus_tilecache)That’s it! The Pyramid application now exposes a TileCache service at/tilecache.Test URL0.1First version
Package: papysql
PapysqlThis Library is an interface between Pandas and sqlite3. It gives the possibility to access sql databases and view the tables as pandas DataFrames.InstallationThe library can be installed through pip:pip install papysqlAlternatively you can download the scripts from here, the main functions are located in papysql/papysql.py file that you can place in the same folder and import in your workspace..After importing the library it have to read the database with the commandimport papysql as pps

db = pps.read(PathToDb)You can then access data in the db with functions list_tables and display_table e.g.pps.display_tables(db)
#It lists all the tables in the database

pps.display_table(NameOfTheTable,db)
#It returns the specific table in format of a Pandas Dataframe ObjectFinally the Function ExecuteScriptFromFile is work in progress and serves to execute a SQL script from a text fileFuture implementation will be aimed at modify and creating tables
Package: paquete-demo
Edit a file, create a new file, and clone from Bitbucket in under 2 minutesWhen you're done, you can delete the content in this README and update the file with details for others getting started with your repository.We recommend that you open this README in another tab as you perform the tasks below. You canwatch our videofor a full demo of all the steps in this tutorial. Open the video in a new tab to avoid leaving Bitbucket.Edit a fileYou’ll start by editing this README file to learn how to edit a file in Bitbucket.ClickSourceon the left side.Click the README.md link from the list of files.Click theEditbutton.Delete the following text:Delete this line to make a change to the README from Bitbucket.After making your change, clickCommitand thenCommitagain in the dialog. The commit page will open and you’ll see the change you just made.Go back to theSourcepage.Create a fileNext, you’ll add a new file to this repository.Click theNew filebutton at the top of theSourcepage.Give the file a filename ofcontributors.txt.Enter your name in the empty file space.ClickCommitand thenCommitagain in the dialog.Go back to theSourcepage.Before you move on, go ahead and explore the repository. You've already seen theSourcepage, but check out theCommits,Branches, andSettingspages.Clone a repositoryUse these steps to clone from SourceTree, our client for using the repository command-line free. Cloning allows you to work on your files locally. If you don't yet have SourceTree,download and install first. If you prefer to clone from the command line, seeClone a repository.You’ll see the clone button under theSourceheading. Click that button.Now clickCheck out in SourceTree. You may need to create a SourceTree account or log in.When you see theClone Newdialog in SourceTree, update the destination path and name if you’d like to and then clickClone.Open the directory you just created to see your repository’s files.Now that you're more familiar with your Bitbucket repository, go ahead and add a new file locally. You canpush your change back to Bitbucket with SourceTree, or you canadd, commit,andpush from the command line.
Package: paquo
PAQUO: PAthological QUpath ObsessionWelcome topaquo:wave:, a library for interacting withQuPathfromPython.paquo's goal is to provide a pythonic interface to important features of
QuPath, and to make creating and working with QuPath projects intuitive for
Python programmers.We strive to make your lives as easy as possible: Ifpaquois not pythonic,
unintuitive, slow or if its documentation is confusing, it's a bug inpaquo. Feel free to report any issues or feature requests in the issue
tracker!Developmenthappens on GitHub:octocat:DocumentationYou can findpaquo's documentation atpaquo.readthedocs.io:heart:Installationpaquo's stable releases can be installed viapip:pipinstallpaquoor viaconda:condainstall-cconda-forgepaquoGetting QuPathAfter installing, paquo requires a QuPath installation to run. To get QuPath follow theinstallation instructions.
If you choose the default installation paths paquo should autodetect your QuPath.Or you can run the following command to download a specific version of QuPath
to a location on your machine. Follow the printed instructions to configure
paquo to use that version. Currently, paquo supports every version of QuPath from0.2.0to the most recent.(We even support older0.2.0-mXversions but no guarantees).>paquoget_qupath--install-path"/some/path/on/your/machine"0.5.0# downloading: https://github.com/qupath/qupath/releases/download/v0.5.0/QuPath-0.4.3-Linux.tar.xz# progress ................... OK# extracting: [...]/QuPath-0.5.0-Linux.tar.xz# available at: /some/path/on/your/machine/QuPath-0.5.0## use via environment variable:#   $ export PAQUO_QUPATH_DIR=/some/path/on/your/machine/QuPath-0.5.0## use via .paquo.toml config file:#   qupath_dir="/some/path/on/your/machine/QuPath-0.5.0"/some/path/on/your/machine/QuPath-0.5.0Development InstallationInstall conda and gitClone paquogit clone https://github.com/bayer-science-for-a-better-life/paquo.gitRunconda env create -f environment.devenv.yamlActivate the environmentconda activate paquoNote that in this environmentpaquois already installed in development mode,
so go ahead and hack.Contributing GuidelinesPlease followpep-8 conventionsbut:We allow 120 character long lines (try anyway to keep them short)Please usenumpy docstrings.When contributing code, please try to use Pull Requests.tests go hand in hand with modules ontestspackages at the same level. We usepytest.You can set up your IDE to help you to adhere to these guidelines.(Santiis happy to help you to set up pycharm in 5 minutes)AcknowledgementsBuild with love by Andreas Poehlmann and Santi Villalba from theMachine
Learning Researchgroup at Bayer. In collaboration with thePathology Lab 2and theMechanistic and Toxicologic Pathologygroup.paquo: copyright 2020 Bayer AG, licensed underGPL-3.0
Package: par2ools
A small set of “missing” tools for par2 archives:par2ls- list the files covered by a par2 archivepar2mv- move the files (and par2 files) covered by a par2 archivepar2unrar- verify, unpack, and optionally clean up par2 & filesThese tools implement their own parsing of par2 header files, but in order to
usepar2unraryou will need thepar2command line utility and archive
utilities (likeunrar,unzip,7zr, etc).
Package: par2py
Par2PyMIT Licensed par2 parser / A Python framework for interacting with Par2 filesPar2 is a file format for using Reed-Solomon Coding to perform file recovery operations using "blocks" of recovery data.#Rationale
While working on a QR code based backup solution, I found myself wanting additional redundancy.
Which is where Par2 comes in.  Par2 is a great system with many advantages:Everything is in "packets", with extremely easy to decode headers.Packet headers are easy to find, with their "magic" values ?guaranteed? to only show up there.Any amount of padding (including random data) is allowed between packets.Provided that enough redundancy exists, a missing file can be completely reconstructed.To increase the likelihood of file recovery I found myself needing to perform byte alignment on individual packets.
There were other reasons as well, but this led to creating a par2 parser, and I decided that it would be worth it as a standalone program.References:Official SpecificationPacket & Header format"magic" & "type"/"signature" valuesNote that you can recover everything in the second link easily from any "vol...par2" file.Other (similar) projects:par2oolsby Jason Moiron
Package: para
# Para(llel) processing utilities
This library implements a simple set of parallel processing utilities that
take advantage of python’smultiprocessingmodule to distribute processing
over multiple CPUs on a single machine.  The most salient feature of this
library is themap()function that can be used to distribute CPU-intensive
processing of a collection of items over multiple cores.Installationpip install para## Basic usage>>> import para
>>> import gzip
>>>
>>> items = ["examples/big-file1.gz", "examples/big-file2.gz",
...          "examples/big-file3.gz"]
>>> def log_lines(path):
...     with gzip.open(path, 'rt') as f:
...         for lineno, line in enumerate(f):
...             if len(line) > 50:
...                 yield path, lineno, line
...
>>> for path, lineno, line in para.map(log_lines, items):
...     print(path, lineno, repr(line))
...
examples/big-file1.gz 2 'this line is going to be much longer than 80 chars -- at least I hope it will\n'
examples/big-file3.gz 0 'again with the long lines -- this is going to show up in the output, I hope\n'## Authors
* Aaron Halfaker –https://github.com/halfak
Package: parabar
parabarProgress bars fromtqdmfor multiprocessing withpathosin Python.This is similar in spirit totqdm_pathosbut more simplified.Installationpip install parabarUsageThere is a single functionparabar.map.The two required arguments are the function you want to map and the iterable(s) you want to map over:parabar.map(func, iterable).If you want to iterate over multiple arguments, you should zip them:parabar.map(func, zip(iterable1, iterable2)).It has two optional arguments:ncpus = 1: the number of processes for the pooltqdm_kwargs = {}: dictionary of extra arguments to pass totqdm.If the length of your iterable istotal, you can telltqdmby usingtqdm_kargs = {'total': total}. Otherwise,parabar.mapwill convert your iterables to a list and uselen.You can provide other fixed positional and keywords arguments to your function that you do not want to iterate over as the reminaing position and keyword arguments:parabar.map(func, iterable, arg1, arg2, kwarg1=None, ncpus=1).ExamplesFunction of a single iterable:f = lambda x: x**2
iterable = [1, 2, 3]

# Serial
y = [f(x) for x in iterable]
print(y)

# Parallel
y = parabar.map(f, iterable)
print(y)Function of a single iterable, with non-iterable args and kwargs:f = lambda x, a, b = 0: x**2 * a + b
iterable = [1, 2, 3]
a = 1
b = 0

# Serial
y = [f(x, a, b = b) for x in iterable]
print(y)

# Parallel
y = parabar.map(f, iterable, a, b = b)
print(y)Function of multiple iterables:f = lambda x, y: x * y
iterable1 = [1, 2, 3]
iterable2 = [4, 5, 6]

# Serial
z = [f(x, y) for x, y in zip(iterable1, iterable2)]
print(z)

# Parallel
z = parabar.map(f, zip(iterable1, iterable2))
print(z)Function of multiple iterables, with non-iterable args and kwargsf = lambda x, y, a, b = 0: x * y * a + b
iterable1 = [1, 2, 3]
iterable2 = [4, 5, 6]
a = 1
b = 0

# Serial
z = [f(x, y, a, b = b) for x, y in zip(iterable1, iterable2)]
print(z)

# Parallel
z = parabar.map(f, zip(iterable1, iterable2), a, b = b)
print(z)Specify number of processes and keyword arguments for progress barfrom tqdm.auto import tqdm

f = lambda x: x
iterable = [1, 2, 3]
tqdm_kwargs = dict(total = 3, desc = 'iterating')

# Serial
y = [f(x) for x in tqdm(iterable, **tqdm_kwargs)]
print(y)

# Parallel
y = parabar.map(f, iterable, ncpus=2, tqdm_kwargs=tqdm_kwargs)
print(y)
Package: para-cada
para-cadaPara Cadain Spanish meansFor Each. The tool executes your command for each file selected using glob expression(s).Why? Let's say you have multiple.tgzarchives and you would like to extract them in one shot. Some of the options available in bash are:ls*.tgz|xargs-ITtarxzvfTforTin*.tgz;dotarxzvf$T;donefind.-typef-name'*.tgz'-exectarxzvf{}\;All of them are relatively complex. This is where cada can help. Simply do:cada'tar xzvf *.tgz'Cada knows where glob expression is. It executes entire command with subsequent values corresponding to this expression. Additionally, user may transform/filter/sort those values using regular Python syntax. Take a look at thedocumentation.
Package: parac-ext-cli
Para-C CLICommand Line Interface Implementation for the Para-C programming languageFor proper documentation and info on Para-C visit the main repohere.
This also includes issues or requesting changes. These should be done on the main branch, while the issues
here will be maintainers-onlyCommandsCommands displayed are mostly only partly implementedNameDescriptionparac compileCompiles a Para-C program to C or an executable.parac runCompiles a Para-C program and runs it.parac c-initStarts the CLI for the configuration of the C-compiler, which is required for running a program.parac syntax-checkValidates the syntax of a Para-C program and logs errors if needed. (Pre-Processor ignored)parac analyseAnalyses a program and validates the syntax (Pre-Processor included - macros required)Installationpython3-mpipinstall-Uparac-ext-cliWith specific version:python3-mpipinstall-Uparac-ext-cli==versionCopyright and LicenseCopyright (C) 2021Nicolas Klatzer*.This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.You should have received a copy of the GNU General Public License
along with this program.  If not, seehttps://www.gnu.org/licenses/.See theLICENSEfor information on terms & conditions for usage.*Legal name, which does not match the preferred and commonly used name Luna Klatzer
Package: paracoord
paracoord: Plot 2-dimensional arrays in Parallel coordinatesPurposeThis package is an attempt to implement the idea ofparallel coordinatesfromSébastien TricaudandPhilippe Saadéto general purposes.Examplefrom paracoord import get_paracoord_plot


# Create 10x5 random array
values = np.random.random_sample((10, 5))
print(values)

# Plot parallel coordinates of those values
get_paracoord_plot(values)

# Set arbitrary labels for those 10 5-dimensional vectors
labels = ['aaa', 'bbb', 'aaa', 'ccc', 'bbb', 'aaa', 'aaa', 'bbb', 'aaa', 'ccc']
# Plot them in parallel coordinates with automatically chosen colors
get_paracoord_plot(values, labels=labels)
# Plot them with self defined color dict and save the resulting plot
color_dict = {'aaa': 'b', 'bbb': 'r', 'ccc': 'g'}
get_paracoord_plot(values, labels=labels, color_dict=color_dict, save_path='random_example.jpg', set_legend=True)Optionsvalues: 2-dimensional numpy arraylabels: optional, array containing labels for each row ofvaluescolor_dict: dict, optional, ignored iflabelsnot provided. {label -> color} dict.
Iflabelsis provided but notcolor_dict, the color of each label will be automatically chosensave_path: path to the file where the resulting image will be stored.
If not provided, image will not be storedset_legend: boolean, optional, ignored iflabelsnot provided. If to set a color legend for the labels or notbox: boolean. If to set a frame (x-axis, y-axis etc.) for the resulting imageylims: (ymin, ymax). If not provided, will be set to the result toget_y_min_nax(values)Installationpip install paracoordFinal noteEnjoy, do whatever you want with it as long as you don't hold me responsible for the consequences :)
Suggestions, remarks, critics, pull requests appreciated
Package: paracrine
ParacrineParacrine is a system deployment tool. It's based aroundMitogenand standard Python packages for
features (although, currently there's only the one core package). Current status is essentially,
"works for me, probably won't eat your computer", but thoughts and patches are welcomed.It's designed towards rapid idempotent deploys i.e. a zero-changes deploy should take in the order of a small number of seconds ideally, and so can be used as your application deployment option as well as for system changes, which has the design benefit of you could use it for GitOps-style deploys. Obviously, if you do more changes, it'll take longer, but that's generally less of an issue, but it should still be faster than most other tooling options. It assumes it's got a host system to run from, whichprobablycan be anything that runs Python, but the testing for that so far has been on a Debian laptop.It's named afterParacrine signaling"a type of cellular communication in which a cell produces a signal to induce changes in nearby cells" which feels pretty accurate for a deployment tool.Main documentation is athttps://palfrey.github.io/paracrine/UsageSetup Python. Tested against 3.8+pip install paracrineWrite a main file describing what you want to setup.integration_test/main.pyis a reasonable example. It must call therunfunction, which takes arguments for the inventory file, and list of modules to run.Write an inventory file for the machines this is managing. Current setup assumes they're all the same.integration_test/docker/inventory.yamlis a reasonable example file, but I suggest generating it from whatever you're using to create the servers (e.g. Terraform).Write aconfig.yaml. This has a main top-level key ofenvironmentswith keys below that for each inventory file you've got (integration_test/config.yamljust has one, but in most scenarios you'll have at least a dev and prod setup). What you do below that is up to you, but typically it'll be environment variables and secrets to feed into the main file.Runpython -m paracrine.commands.setup <inventory file>- this will install the minimum python bits so that everything else works.Run the main file (e.g.python main.py ./docker/inventory.yaml)LimitationsAll the servers are assumed to be Debian Linux boxes (although Debian-derivatives like Ubuntushouldwork)Direct SSH access is assumed possible (Mitogen supports jump boxes, but there's no setup for that yet here) with keys, not passwordsThere's no "dry run" mode yet, which would be useful for GitOps
Package: paradance
ParaDanceParaDance is a comprehensive Python toolkit tailored for large-scale data analysis. It offers functionalities for data loading, processing, evaluation metrics, sampling, and visualization. Uniquely, ParaDance features multi-objective Bayesian optimization, supporting various aggregation formulas and calculators. This flexibility in multi-objective settings positions ParaDance as a valuable tool for data scientists and researchers.InstallationYou can install ParaDance using pip:pipinstall--upgradeparadanceContributingWe welcome contributions! If you're interested in enhancing the features of ParaDance, please create a pull request.LicenseParaDance is licensed under the MIT License.AcknowledgmentsWe appreciate the community for your support and contributions. Thank you!
Package: parade
# Parade[![Build Status](https://travis-ci.org/bailaohe/parade.svg?branch=master)](https://travis-ci.org/bailaohe/parade)Paradeis a simple and out-of-box toolkit to handle data work such as ETL, data analysis, BI reports, etc, and enable fast and flexible integration mechanism with applications. It can be used for a wide range of purposes, from composing & scheduling data workflow to providing unified web-APIs of data query.## RequirementsPython 3.4+Works on Linux, Windows, Mac OSX, BSD## InstallThe quich way:`bash > pip install parade `## Basic Usage & TutorialsSee [here](http://parade.readthedocs.io/en/latest/).