Saravanan666/pypi-org huggingface dataset:
Package: polar-bear
Polar Bear:panda_face: -> cleansing -> polar bear!! ʕ·ᴥ·　 ʔPolar-bear is a library for easily and quickly performing machine learning tasks.Example of machine learning tasks:ClassificationRegressionIn addition, it generally performs necessary preprocessing automatically.Example of preprocessing:OnehotEncodingHandling MissingValueInstallation$ pip install polar-bearGet StartedTutorial NotebookLicenseThis project is licensed under the terms of the MIT license. SeeLICENSEfor additional details.
Package: polarcbo
:snowflake: Polarized Consensus-Based Optimization and SamplingThis code produces the examples for the paper "Polarized consensus-based dynamics for optimization and sampling":https://arxiv.org/abs/2211.05238@online{bungert2022polarized,
    author = {Bungert, Leon and Roith, Tim and Wacker, Philipp},
    title = {Polarized consensus-based dynamics for optimization and sampling},
    year = {2022},
    eprint={2211.05238},
    archivePrefix={arXiv},
    primaryClass={math.OC}
}💡 What is PolarCBO/CBS?Polarized consensus-based dynamics allow to apply consensus-based optimization (CBO) and sampling (CBS) for objective functions with several global minima or distributions with many modes, respectively. Here we haveparticles ${x^{(i)}}\in\mathbb{R}^d$ which explore the space,the objective $V:\mathbb{R}^d\to\mathbb{R}$ which we want to optimize.For optimizing $V$ the position of the particles are updated via the stochastic ODE$$
\begin{align}
\boxed{%
d x^{(i)} = -(x^{(i)} - m(x^{(i)})) d t + \sigma |x^{(i)} - m(x^{(i)})| d W^{(i)}
}
\end{align}
$$where$m(x^{(i)})$ is a weighted empirical mean associated with the point $x^{(i)}$,$W^{(i)}$ are independent Brownian motions,$\sigma$ scales the influence of the noise term.For sampling from $\exp(-V)$ the position of the particles are updated via the stochastic ODE$$
\begin{align}
\boxed{%
d x^{(i)} = -(x^{(i)} - m(x^{(i)})) d t + \sqrt{2\lambda^{-1}C(x^{(i)})} d W^{(i)}
}
\end{align}
$$where $C(x^{(i)})$ is a weighted empirical covariance matrix associated with the point $x^{(i)}$.The choice of the functions $m(\dot)$ and $C(\cdot)$ are at the heart of our polarized methods. Given a similarity measure $\mathsf k(\cdot,\cdot)$ and an inverse temperature parameter $\beta>0$ we define$$
\begin{align}
m(x) &:= \frac{\sum_{i}\mathsf k(x,x^{(i)})x^{(i)}\exp(-\beta V(x^{(i)}))}{\sum_{i}\mathsf k(x,x^{(i)})\exp(-\beta V(x^{(i)}))},
\
C(x) &:= \frac{\sum_{i}\mathsf k(x,x^{(i)})(x^{(i)}-m(x))\otimes(x^{(i)}-m(x))\exp(-\beta V(x^{(i)}))}{\sum_{i}\mathsf k(x,x^{(i)})\exp(-\beta V(x^{(i)}))}.
\end{align}
$$Note that these weighted mean and covariance give more influence to particles which are close to $x$ and have a small value of $V$. If $\mathsf k(\cdot,\cdot)=1$ one recovers standard CBO and CBS.
Package: polarimetry-lc2pkpi
Aligned polarimetry field of the Λc → p π K decayThis repository a symbolic amplitude model for the decay $\Lambda^+_c \to p \pi^+ K^-$ that is aligned withDalitz-plot decompositionand computes an align polarimeter vector field $\vec\alpha$. Helicity couplings and other parameter values are taken from a recent study by the LHCb Collaboration[^1] and itssupplementary material.[^1]: Amplitude analysis of the $\Lambda^+_c \to p K^- \pi^+$ decay and $\Lambda^+_c$ baryon polarization measurement in semileptonic beauty hadron decays (2022)[link]InstallationIt's recommended to develop this code base withVSCodeand install the developer environment with Conda:condaenvcreate
condaactivatepolarimetryStyle checks are enforced withPre-commit. To activate for each commit, run:pre-commitinstall[!TIP]
For more information about the local Python developer environment, seehere.This repository also contains Julia source code and Pluto notebooks. Julia can be downloadedhere. You then have to activate and instantiated the Julia environment provided in thejuliafolder. This can be done as follows from the root directory:julia--project=./julia-e'import Pkg; Pkg.instantiate()'Documentation dependenciesTo build the documentation, you need to install LaTeX and some additional fonts. In Ubuntu, this can be done with:sudoapt-getinstall-ycm-superdvipngtexlive-latex-extraIn addition, forbuilding the documentation as a single PDF file, you need to install XeTeX:sudoapt-getinstall-yinkscapelatexmkmaketexlive-fonts-extratexlive-xetexxindyBuilding the documentationHavinginstalled the Python environment, you can build the documentation with:[^2]tox-edocnbThis will run all Jupyter notebooks and convert the output to static webpages (view the output underdocs/_build/html/index.html). Running all notebooks from scratch (without any available cache) should takearound one hour.If you have installed Julia and instantiated the Julia environment, you can embed thePluto notebooksas static pages in the documentation with:EXECUTE_PLUTO=YEStox-edocnbor, alternatively, by executingallJupyter and Pluto notebooks (ignoring any existing caches):EXECUTE_PLUTO=YEStox-edocnb-forceTheabove commandsresult in a static HTML webpage. It's also possible to render the notebook as a single PDF file. This can be done as follows:tox-epdfJust as above, cell output can be rendered by setting theEXECUTE_NBvariable to some value:EXECUTE_NB=YEStox-epdf[^2]:
It's also possible have a look at the documentationwithoutcell output (just as a check for the links). This can be done with:```shell
tox -e doc
```
Package: polario
Polars IO utility libraryHelpers to make it easier to read and write Hive partitioned parquet dataset with Polars.It is meant to be a library to deal with datasets easily, but also contains a commandline interface
which allows you to inspect parquet files and datasets more easily.DatasetExample of use ofpolario.dataset.HiveDatasetfrompolario.datasetimportHiveDatasetimportpolarsaspldf=pl.from_dicts([{"p1":1,"v":1},{"p1":2,"v":1},])ds=HiveDataset("file:///tmp/",partition_columns=["p1"])ds.write(df)forpartition_dfinds.read_partitions():print(partition_df)To model data storage, we use three layers: dataset, partition, fragment.Each dataset is a lexical ordered set of partitions
Each partition is a lexical ordered set of fragments
Each fragment is a file on disk with rows in any order
Package: polarion
Python-polarionThis package allows the user to access many Polarion items like workitems, test run, plans and documents.Feature overviewThis package can, among others, read, modify and create:WorkitemsTest runs from templatesPlansDocumentsWork with attachments in workitems and test runs.
Work with custom field in workitems and documents.Installationpip install polarionGetting startedCreating the Polarion client and getting workitems, test runs or plans:frompolarionimportpolarionclient=polarion.Polarion('http://example.com/polarion','user','password')project=client.getProject('Python')workitem=project.getWorkitem('PYTH-510')run=project.getTestRun('SWQ-0001')plan=project.getPlan('00002')Modifying workitems:workitem.setDescription('Some description..')workitem.addComment('test comment','sent from Python')workitem.addHyperlink('google.com',workitem.HyperlinkRoles.EXTERNAL_REF)Or test run results:run=project.getTestRun('SWQ-0001')run.records[0].setResult(record.Record.ResultType.PASSED,' Comment with test result')Adding workitems to a plan:plan.addToPlan(workitem)plan.removeFromPlan(workitem)More examples to be found in the quick start section of the documentation.Go to the documentationHow does it work?This project uses the SOAP API of Polarion. This API exposes most of the user interactions you can do with Polarion like creating or editing workitems, plans and test runs.
The API is divided in seven different services which you can find from your Polarion instance at the urlhttp://domain.com/polarion/ws/services.
Each of the services provides a WSDL file detailing the available functions. (Also available form you local instance athttp://domain.com/polarion/ws/services/TrackerWebService?wsdl)
For this project the TrackerWebService, PlanningWebService and TestManagementWebService are the most used ones.In general the project attempts for the objects (like workitems) to behave like Python objects which you can modify and are saved in the background.
Where the API provide operation to preform an action that API call is used, and the object is reloaded from polarion to reflect the changes locally.The API does not allow access to the project administration.DependenciesThe package uses; requests, urllib3 and zeep.It is tested for Python version 3.7 through 3.12.
Python 3.6 support has been dropped in 1.3.0.Known issues or missing featuresNo way of knowing the test run possible statuses.Deleting work items used in documents does not remove the reference from the document.
Package: polarion-docstrings
DescriptionLibrary for reading Polarion docstrings used in Insights and CFME QE. Includes a flake8 extension for validating the docstrings.InstallTo install the package to your virtualenv, runpip install polarion-docstringsor install it from cloned directorypip install -e .Package on PyPI <https://pypi.python.org/pypi/polarion-docstrings>
Package: polarishub
ReadMe for Python LibraryWritten by TPIOSThis is a p2p file transfer program via LAN.This program is implemented with Django Framework.External libraries required: MyQR for generating QR code.Update version 0.9.16 (Important)We have add console script for our library.After install our library, you can keep your console open, and continuing typingpolarishub setupto setup the environment of our library, and typepolarishub runto run our library.Make sure you first set up the environment, and then run.In short, you can just type:phub setup
phub runfor efficient use.You can also usepolarishub -h
phub -hto check the help information.
Package: polaris-lib
PolarisSo many stars in the sky, yet one is enough to guide you home.🟆 Polaris Hub|🛈 Client DocPolaris establishes a novel, industry‑certified standard to foster the development of impactful methods in AI-based drug discovery.This library is a Python client to interact with thePolaris Hub. It allows you to:Download Polaris datasets and benchmarks.Evaluate a custom method against a Polaris benchmark.Create and upload new datasets and benchmarks.[!WARNING]
The Polaris Hub is currently released as a closed, private beta. We hope to officially release it early 2024.Quick API Tourimportpolarisaspo# Load the benchmark from the Hubbenchmark=po.load_benchmark("polaris/hello_world_benchmark")# Get the train and test data-loaderstrain,test=benchmark.get_train_test_split()# Use the training data to train your model# Get the input as an array with 'train.inputs' and 'train.targets'# Or simply iterate over the train object.forx,yintrain:...# Work your magic to accurately predict the test setpredictions=[0.0forxintest]# Evaluate your predictionsresults=benchmark.evaluate(predictions)# Submit your resultsresults.upload_to_hub(owner="dummy-user")DocumentationPlease refer to thedocumentation, which contains tutorials for getting started withpolarisand detailed descriptions of the functions provided.InstallationYou can installpolarisusing conda/mamba/micromamba:condainstall-cconda-forgepolarisYou can also use pip:pipinstallpolaris-libDevelopment lifecycleSetup dev environmentcondaenvcreate-npolaris-fenv.yml
condaactivatepolaris

pipinstall--no-deps-e.TestsYou can run tests locally with:pytestLicenseUnder the Apache-2.0 license. SeeLICENSE.
Package: polaris-py
# Polaris : Hyperparamter optimization library.[![Documentation Status](https://readthedocs.org/projects/polaris/badge/?version=latest)](https://polaris.readthedocs.io/en/latest/?badge=latest)Polaris is a hyperparamter optimization library.We plan to support every state-of-art tuning method as follows.-  Random Search-  Bayesian Optimization-  Tree-structured Parzen Estimators (TPE)## DocumentationPolaris' documentation can be found at [https://polaris.readthedocs.io/](https://polaris.readthedocs.io/)## Prerequisites- Python >= 3.6- RabbitMQ (Only for parallel execution)## Installation```shell$ pip install polaris-py```## Examples### Sequential Execution```pythonfrom polaris import Polaris, STATUS_SUCCESS, Trials, Boundsdef pseudo_train(params, exp_info):lr_squared = (params['lr'] - 0.006) ** 2weight_decay_squared = (params['weight_decay'] - 0.02) ** 2loss = lr_squared + weight_decay_squaredreturn {'loss':  loss,'status': STATUS_SUCCESS,}if __name__ == '__main__':bounds = [Bounds('lr', 0.001, 0.01),Bounds('weight_decay', 0.0002, 0.04),]trials = Trials()polaris = Polaris(pseudo_train, bounds, 'bayesian_opt',trials, max_evals=100, exp_key='this_is_test')best_params = polaris.run()print(best_params)```### Parallel Execution#### Single Process1. Run `rabbitmq-server`1. Set `RABBITMQ_URL` (ampq://guest:guest@localhost//)1. Run `polaris-worker --exp-key this_is_test`1. Run codes as follows### Multiple Processes (Use MPI)1. Run `rabbitmq-server`1. Set `RABBITMQ_URL` (ampq://guest:guest@localhost//)1. Run `mpirun -n 4 polaris-worker --mpi --exp-key this_is_test`1. Run codes as follows```python...if __name__ == '__main__':bounds = [Bounds('lr', 0.001, 0.01),Bounds('weight_decay', 0.0002, 0.04),]trials = Trials()polaris = Polaris(pseudo_train, bounds, 'bayesian_opt',trials, max_evals=100, exp_key='this_is_test')best_params = polaris.run_parallel()print(best_params)```
Package: polarity-switcher
READMEPolarity SwitcherThepolarity-switcheris ...DependenciesThe packagepolarity-switcherhas the following pre-requisites:Python 3.6andpip 10.0are the minimum required versions to build and installpolarity-switcherand its dependencies. It is
recommended to install and runpolarity-switcher(and any other package, for that matter) under avirtual environment.libpq, a C library that implements connections to the PostgreSQL
backend server. It is used by the packagelab-utilsto
connect to the PostgreSQL backend, manage database structure and save new data entries.Getting StartedTODO: pip package available nowUsageTo use a thepolarity-switcherpackage, TODOAuthorsCarlos Vigo-Initial work-GitLabContributingPlease read ourcontributing policyfor details on our code of
conduct, and the process for submitting pull requests to us.VersioningWe useGitfor versioning. For the versions available, see thetags on this repository.LicenseThis project is licensed under theGNU GPLv3 LicenseBuilt WithPyCharm Professional Edition- The IDE usedSphinx- DocumentationAcknowledgmentsNobody so far
Package: polaroid
PolaroidHyper fast image processingThis is a Work in Progress. DO NOT USE in production.For all the examples, meme.png is used. Please replace that with whatever Image you useVia File SystemfrompolaroidimportImageim=Image("meme.png")im.solarize()im.save("solar.png")Using Bytes# Just an example use any library to supply bytesfrompolaroidimportImageimportrequestsbyt=requests.get("https://dagpi.xyz/dagpi.png").contentim=Image(byt)im.filter("dramatic")ret_byt=im.save_bytes()PropertiesfrompolaroidimportImageim=Image("meme.png")h=im.heightw=im.weightwi,hei=im.sizeimage_format=im.formatmode=im.modeUsing the RGB class for coloringfrompolaroidimportImage,Rgbim=Image("meme.png")# Color Rgbcolor=Rgb(78,93,148)im.color(color)# Now SaveMethodsImage Methods['add_noise_rand','adjust_contrast','alter_blue_channel','alter_channel','alter_channels','alter_green_channel','alter_red_channel','apply_gradient','b_grayscale','blend','box_blur','brighten','color','color_no_grayscale','colorize','crop','decompose_max','decompose_min','desaturate','detect_horizontal_lines','detect_vertical_lines','edge_detection','edge_one','emboss','filter','fliph','flipv','g_grayscale','gaussian_blur','gradient','grayscale','grayscale_human_corrected','grayscale_shades','hog','horizontal_strips','identity','inc_brightness','invert','laplace','liquid_rescale','monochrome','noise_reduction','offset','offset_blue','offset_green','offset_red','oil','pink_noise','prewitt_horizontal','primary','r_grayscale','remove_blue_channel','remove_green_channel','remove_red_channel','replace_backround','resize','rotate180','rotate270','rotate90','save','save_base_64','save_bytes','save_jpeg_bytes','selective_desaturate','selective_hue_rotate','selective_lighten','selective_saturate','sepia','sharpen','single_channel_grayscale','sobel_horizontal','sobel_vertical','solarize','swap_channels','threshold','thumbnail','tint','unsharpen','vertical_strips','watermark']#All available for ImageRgb MethodsSpecial Methods forImagefrompolaroidimportImageim=Image("meme.png")print(repr(im))#The `bytes` method is not implemented usebyt=im.save_bytes()# Save a jpegim.save_jpeg(quaility:int)byt=im.save_jpeg_bytes(quality:int)
Package: polaroidme
polaroidme is a simple to use command-line-tool for placing an image into a
Polaroid-like frame and optionally put a title / description on the bottom.
The default font mimics scribbled handwriting but any (ttf-)font
which suits your taste is supported. The tool offers basic features
like auto-scaling up-/downwards and/or cropping, using any (ttf-)font,
supports high-res output and gets the job just done well.
polaroidme is actively maintained & developed (2019).
To see if it fits your needs take a look at the project’s
github-repo and check out theexamplesContributions are welcome, and they are greatly appreciated!examples:https://github.com/s3h10r/polaroidme/blob/master/README.md
Package: polarpy
polarpyTools for reading and fusing live data streams from Polar OH1 (PPG) and H10 (ECG) sensors.RequirementsIf installing from the repo you needpygatttool(pip install pygatttool).Installationpip install polarpyUsageThe following code starts the raw PPG and IMU streams on a Polar OH1, fuses the blocks pf data in the two streams at 135Hz, and provides a single output stream, each record having a timestamp, the PPG signal values for each of the 3 pairs of LEDs, and the corresponding accerelometer x, y and z readings.from polarpy import OH1

OH1_ADDR = "A0:9E:1A:7D:3C:5D"
OH1_CONTROL_ATTRIBUTE_HANDLE = 0x003f
OH1_DATA_ATTRIBUTE_HANDLE = 0x0042

def callback(type: str, timestamp: float, payload: dict):
    print(f'{timestamp} {payload}')

if '__main__' == __name__:
    device = OH1(address=OH1_ADDR,
                 control_handle=OH1_CONTROL_ATTRIBUTE_HANDLE,
                 data_handle=OH1_DATA_ATTRIBUTE_HANDLE,
                 callback=callback)

    if device.start():
        while device.run():
            passThe output looks something like this:3.94 {'ppg0': 263249, 'ppg1': 351764, 'ppg2': 351928, 'ax': 0.775, 'ay': -0.42, 'az': 0.476}
3.947 {'ppg0': 263297, 'ppg1': 351964, 'ppg2': 352077, 'ax': 0.775, 'ay': -0.42, 'az': 0.476}
3.954 {'ppg0': 263319, 'ppg1': 352062, 'ppg2': 352013, 'ax': 0.778, 'ay': -0.417, 'az': 0.481}
3.962 {'ppg0': 263293, 'ppg1': 352106, 'ppg2': 352082, 'ax': 0.778, 'ay': -0.417, 'az': 0.481}
3.969 {'ppg0': 263440, 'ppg1': 352273, 'ppg2': 352199, 'ax': 0.778, 'ay': -0.417, 'az': 0.481}

...The callback is used (rather than returning data fromrun()) because the blocks of PPG, ECG and IMU data arrive with different lengths and at different speeds. The individual samples from each channel must be buffered and interleaved, timestamps interpolated, then delivered asynchronously through the callback.The address and attribute handles for your particular device can be found usinggatttoolor another BLE tool such as nRF Connect.
Package: polar-route
PolarRoutePolarRoute is a long-distance maritime polar route planning package, able to take into account complex and changing environmental conditions. It allows the construction of optimised routes through three main stages: discrete modelling of the environmental conditions using a non-uniform mesh, the construction of mesh-optimal paths, and physics informed path smoothing. In order to account for different vehicle properties we construct a series of data-driven functions that can be applied to the environmental mesh to determine the speed limitations and fuel requirements for a given vessel and mesh cell. The environmental modelling component of this functionality is provided by theMeshiPhilibrary.InstallationPolarRoute is available from PyPI and can be installed by running:pip install polar-routeAlternatively you can install PolarRoute by downloading the source code from GitHub:git clone https://github.com/Antarctica/PolarRoute
pip install -e ./PolarRouteUse of-eis optional, based on whether you want to be able to edit the installed copy of the package.NOTE: Some features of the PolarRoute package require GDAL to be installed. Please consult the documentation for further guidance.Required Data sourcesPolarRoute has been built to work with a variety of open-source atmospheric and oceanographic data sources. For testing and demonstration purposes it is also possible to generate artificial Gaussian Random Field data.A full list of supported data sources and their associated dataloaders is given in the
'Dataloader Overview' section of theMeshiPhi manualDocumentationThe documentation for the package is available to read at:https://antarctica.github.io/PolarRoute/If you make changes to the source of the documentation you will need to rebuild the corresponding html files using Sphinx.
The dependencies for this can be installed through pip:pip install sphinx sphinx_markdown_builder sphinx_rtd_theme rinohtypeWhen updating the docs, run the following command within the PolarRoute directory to recompile.sphinx-build -b html ./docs/source ./docs/htmlSometimes the cache needs to be cleared for internal links to update. If facing this problem, run this from the PolarRoute directory.rm -r docs/html/.doctrees/DevelopersJonathan Smith, Samuel Hall, George Coombs, James Byrne,  Michael Thorne, Maria Fox, Harrison Abbot, Ayat FekryCollaborationWe are currently assessing the best practice for collaboration on the codebase, until then please contactpolarroute@bas.ac.ukfor further info.LicenseThis software is licensed under a MIT license, but request users cite our publication.Jonathan D. Smith, Samuel Hall, George Coombs, James Byrne, Michael A. S. Thorne, J. Alexander Brearley, Derek Long, Michael Meredith, Maria Fox, (2022), Autonomous Passage Planning for a Polar Vessel, arXiv,https://arxiv.org/abs/2209.02389For more information please see the attachedLICENSEfile.