Saravanan666/pypi-org huggingface dataset:
Package: pointofview
pointofviewA Python package for determining a piece of text's point of view (first, second,
third, or unknown).Installationpointofviewis available on PyPI. Simply install it withpip:pipinstallpointofviewYou can also install it from source:$gitclonehttps://github.com/prosegrinder/python-pointofview.git
Cloninginto'python-pointofview'...
...

$cdpython-pointofview
$pythonsetup.pyinstall
...Usagepointofviewguesses a text's point of view by counting point of view pronouns.
The main functionget_text_pov()will return 'first', 'second', 'third', or
null (Python'sNoneobject):>>>importpointofview>>>text="I'm a piece of text written in first person! What are you?">>>pointofview.get_text_pov(text)'first'There are two other helper functions as well.get_word_pov()returns the point of view of a single word:>>>pointofview.get_word_pov("I")'first'>>>pointofview.get_word_pov("nope")Noneparse_pov_words()returns a dict containing all first-, second-, and
third-person point-of-view words:>>>text="""... When I try to analyze my own cravings, motives, actions and so forth, I surrender to a sort of retrospective imagination which feeds the analytic faculty with boundless alternatives and which causes each visualized route to fork and re-fork without end in the maddeningly complex prospect of my past.... """>>>pointofview.parse_pov_words(text){'first':['i','i'],'second':[],'third':[]}
Package: pointofvue
PointOfVueA simple, opinionated way to incorporate VueJS into your Django applicationsInstallationpip install PointOfVueAddpointofvueto your Django installed apps:INSTALLED_APPS=[# other apps ...'pointofvue',]Basic UsageIn your view, importpointofvueand send apointofvue.VueContextinstance to your templateimportpointofvuedefview_handler(request):vue_ctx=pointofvue.VueContext()vue_ctx.set_data('var1','My value')returnrender(request,'template.html',{"vue_ctx":vue_ctx,})In your template, write your Vue code in a#appelement and use${and}for accessing Vue data. Then load thepointofvuetemplates and call the{% vue %}tag with yourVueContextto load VueJS and create an app.<divid='app'>The value of 'var1' is<b>${ var1 }</b></div>{% load pointofvue %}
{% vue vue_ctx %}Custom JavaScriptIt is likely that you won't be able to get away with just writing HTML Vue alone, you may need to define methods and other JS native entities in custom JavaScript.Note:pointofvue encourages you to not write inline JavaScript in your Django HTML templates. Write separate JS files and serve them via staticfiles insteadDefine a Vue entry point that exports your Vue data. It may look like this:importMyCustomComponentfrom'./my-component.js';constcomponents={MyCustomComponent,};export{components,};Build that JS file (target as a library if using vue-cli-service). Then register your script with the Python VueContext in your view:vue_ctx.add_script('myscript')Now you can use your custom component in your template:<divid="app"><b>My Custom Component</b><MyCustomComponent/></div>DevelopmentReleasingI usebump2versionto manage version bumping. This will update the version number in the library, commit it, and create a version tag.bump2versionminor
gitpush--follow-tags
Package: pointpare
A simple package for paring together points.Usagefrom pointpare import PointPare
pp = PointPare()
pp.add_points([... list of point ...])
pp.pare_points()
pared_points = pp.get_pared_points()Points can be provided as a list of lists, like so:points = [[-10.4498, 31.1871, 1161.39], [-9.26793, 26.6263, 1162.51], [-8.96271, 27.5622, 1161.49], [-10.4498, 31.1871, 1161.39]]
pp.add_points(points)or as a flat list, where the list is divisible by three, like so:points = [31.1871, 1161.39, -10.7776, 29.8503, 1162.7, -9.26793, 26.6263, 1162.51, -10.7776]
pp.add_points(points)TestingTests are written with unittest and can be run like so:python -m unittest discover -s testsWhere the working directory is the base directory of the repository.To run the coverage analysis with:coverage run --source=src/ -m unittest discover -s testsWhere the working directory is the base directory of the repository.The report should show something like the following:Name                        Stmts   Miss  Cover
-----------------------------------------------
src/pointpare/__init__.py      54      0   100%
-----------------------------------------------
TOTAL                          54      0   100%from the coverage report command:coverage report
Package: pointpats
pointpats: Point Pattern Analysis in PySALStatistical analysis of planar point patterns.This package is part ofPySAL: The Python Spatial Analysis Library.IntroductionThispointpatspackage is intended
to support the statistical analysis of planar point patterns.It currently works on cartesian coordinates. Users with data in
geographic coordinates need to project their data prior to using this
module.DocumentationOnline documentation is availablehere.ExamplesBasic point pattern
structureCentrography and
visualizationMarksSimulation of point
processesDistance based
statisticsInstallationInstall pointpats by running:$ pip install pointpatsDevelopmentpointpats development is hosted ongithub.As part of the PySAL project, pointpats development follows theseguidelines.Bug reportsTo search for or report bugs, please see pointpats'issues.BibTeX Citation@software{wei_kang_2023_7706219,
  author       = {Wei Kang and
                  Levi John Wolf and
                  Sergio Rey and
                  Hu Shao and
                  Mridul Seth and
                  Martin Fleischmann and
                  Sugam Srivastava and
                  James Gaboardi and
                  Giovanni Palla and
                  Dani Arribas-Bel and
                  Qiusheng Wu},
  title        = {pysal/pointpats: pointpats 2.3.0},
  month        = mar,
  year         = 2023,
  publisher    = {Zenodo},
  version      = {v2.3.0},
  doi          = {10.5281/zenodo.7706219},
  url          = {https://doi.org/10.5281/zenodo.7706219}
}
Package: point-picker-3d
IntroductionA simple interface to pick points on a geometry file (e.g. stl, ply, obj, etc.) and to export the coordinates to a csv file.InstallationThe package can be installed with pip.$pipinstallpoint-picker-3dExample Usage>>> python main.pyMouse/keyboard operations:Rotate: left-click and dragPan: hold the wheel down and dragZoom: wheelPick a point: press P
Package: point-pypi-demo
douyin_imageAdd douyin effect to imagedouyin_image是一个给图片添加抖音效果的库示例原图转换后的代码图片使用方式usage: douyin_image [-h] [--image IMAGEFILE] [--out OUTIMAGE]

optional arguments:
  -h, --help         show this help message and exit
  --image IMAGEFILE  path of image to add effect
  --out OUTIMAGE     path of output image安装$ pip install douyin_imageLicenseMIT
Package: points2regions
Points2RegionsPoints2Regions is a Python tool designed for clustering and defining regions based on categorical marker data, commonly encountered in spatial biology. It provides methods for feature extraction, clustering, and generating various outputs like label masks, GeoJSON representations, and more.InstallationYou can install Points2Regions using the following command:pipinstallpoints2regionsUsagefrompoints2regionsimportPoints2Regionsimportpandasaspd# Example usage with a CSV filedata=pd.read_csv('https://tissuumaps.dckube.scilifelab.se/private/Points2Regions/toy_data.csv')# Create the clustering modelp2r=Points2Regions(data[['X','Y']],data['Genes'],pixel_width=1,pixel_smoothing=5)# Cluster with a specified number of clustersp2r.fit(num_clusters=15)# Get cluster label for each markercluster_per_marker=p2r.predict(output='marker')# Get a label masklabel_mask,tform=p2r.predict(output='pixel')# Get connected componentsconnected_components,num_components,label_mask,tform=p2r.predict(output='connected')ExampleSee the Jupyter Notebookexample.ipynbfor examples.LicenseThis project is licensed under the MIT License. See the LICENSE file for details.
Package: points-fl
├── points_fl                   // SDK目录
│   ├── proto                   // protobuf file
│   ├── __init__.py             // 导出类
│   ├── base.py                 // points_fl基类
│   ├── federated_learning.py   // 联邦学习
│   ├── inference.py            // 预测
│   ├── log_provider.py         // 日志
│   ├── permission.py           // 权限
│   ├── flask_api.py            // flask接口支持 Python版本：3.6+SDK使用步骤如下：pip安装包pip install points_fl使用示例from points_fl import FLServer

with FLServer(FL_SERVER_ADDRESS, FLASK_ADDRESS) as conn:
    conn.login(username=USERNAME, password=PASSWORD)

    #do some work
Package: pointstorm-dev
[![Build Status](https://travis-ci.org/dagostinelli/python-package-boilerplate.png?branch=master)](https://travis-ci.org/dagostinelli/python-package-boilerplate)
[![Requirements Status](https://requires.io/github/dagostinelli/python-package-boilerplate/requirements.svg?branch=master)](https://requires.io/github/dagostinelli/python-package-boilerplate/requirements/?branch=master)A terse boilerplate for Python packages.  Where other boilerplates contain a great many features such as a CLI, docs, code coverage and varying opinions on what a unit test should look like, this one aims to be lean and mean.  I use this on my own projects.## PackageThe package structure is:` ├── packagename │   ├── __init__.py │   ├── __main__.py │   └── somemodule.py └── tests │   ├── __init__.py │   ├── test_myclass.py │   └── test_mysecondclass.py ├── setup.py ├── .travis.yml ├── .gitignore ├── README.md ├── LICENSE └── VERSION `## RequirementsPackage requirements are handled using setup.py. They will be automatically installed on install or during unit testing## Unit TestsTesting is set up using the built in Unit Test framework in PythonRun the tests withpython setup.py testin the root directory or use the handytest.shscript in the/scriptsfolder.## Travis CIThere is a.travis.ymlfile that will execute the build and the unit tests against several versions of Python.## Quick Start` git clonehttps://github.com/dagostinelli/python-package-boilerplatecdpython-package-boilerplatevirtualenv venv source venv/bin/activate cd scripts ./build.sh ./test.sh `Then begin renaming things and keep running those unit tests as you go.## CLIThis example shows how to do a command line interface (CLI).  You can try it like this:` git clonehttps://github.com/dagostinelli/python-package-boilerplatecdpython-package-boilerplatepython-mpackagename `or like this` git clonehttps://github.com/dagostinelli/python-package-boilerplatecdpython-package-boilerplatepipsi install . packagename `## Nice to AddI enjoy filesystem monitors that look for files as I change them and then automatically execute the unit tests in the background.  I haven’t found a cross-platform way to do that yet, so it’s not in this boilerplate. For interested parties running Linux, you can do it in amakefile.  Create amake watchtarget in yourMakefile`and call `inotifywatchthere.
Package: point-tracker
Point Tracker=============The point tracker is most useful to compute and show growth and displacementfields on biological tissues. From a series of images of a biological sampleover time, the user can select material points over the various images, createcells, and compute the growth rates for each cells over time.Installation------------### From sourceYou can get the source either by cloning the repository or getting an archivethat you uncompress. The application can then be used in-place, or you caninstall it with:$ python setup.py install### Using pipFrom pip, you can simply use:$ pip install point-trackerLaunching---------### When installed on the systemThe setup script will create and install a ``point_tracker`` program on yoursystem, that you simply need to launch:$ point_tracker### From the source folderFrom the source folder, you can use one of the tracking script:$ python tracking.pyUnder Linux, you can also use the shell script:$ ./tracking.shAcknowledgements----------------If you are using this software for scientific purposes, please cite thefollowing paper:> Kuchen, E. E.; Fox, S.; Barbier de Reuille, P.; Kennaway, R.; Bensmihen, S.;> Avondo, J.; Calder, G. M.; Southam, P.; Robinson, S.; Bangham, A. & Coen, E.> **Generation of leaf shape through early patterns of growth and tissue> polarity**. *Science*. 2012, 335, 1092-1096Bibtex reference:@Article{Kuchen12,Title                    = {Generation of leaf shape through early patterns of growth and tissue polarity.},Author                   = {Kuchen, Erika E and Fox, Samantha and {Barbier de Reuille}, Pierre and Kennaway, Richard and Bensmihen, Sandra and Avondo, Jerome and Calder, Grant M and Southam, Paul and Robinson, Sarah and Bangham, Andrew and Coen, Enrico},Journal                  = {Science},Year                     = {2012},Month                    = Mar,Number                   = {6072},Pages                    = {1092--1096},Volume                   = {335},Pii                      = {335/6072/1092},Pmid                     = {22383846},}
Package: point-viz-test
IntroductionPoint_viz is a light-weight, out-of-box point cloud visualizer working in browser, it is built onThree.jsand has python API. Bounding box (bbox) visualization is supported and here is anexample.
Point_viz does not need Internet connection to work (but the installation needs, of course),
and it has been tested on Chrome and Safari with both python 2 and 3.UsageTo install point_viz, simply run:pip install point_viz, and that's all. Below is the example of its python API:# Import package.
from point_viz import PointvizConverter

# Initialize and setup output directory.
Converter = PointvizConverter(home)
# Pass data and create html files.
Converter.compile(task_name, coors, default_rgb, intensity, bbox_params, bbox_color)Variables ExplanationThe*means optional.home: The directory where to put output html files, must be given.task_name*:string, name of the output html file (can be overwritten if the name already exists; default value is "default").coors*:2-D float array, the x, y and z coordinates of each point in the point cloud.default_rgb*:2-D float/int arrayof the same length ascoors, the R, G and B colors of each point.
If not provided, the RGB will be automatically calculated based onintensity(if given) or
point coordinates (whenintensityis also missing).intensity*:1-D float arrayof the same length ascoors, the intensity of each point. It only takes effect whendefault_rgbis not given.bbox_params*:2-D list, the geometry parameters of each bbox. Attributes of each row should be arranged as follows:Attribute #Description0Length (float, dimension along x-axis)1Height (float, dimension along y-axis)2Width (float, dimension along z-axis)3X coordinate of bbox centroid  (float)4Y coordinate of bbox centroid  (float)5Z coordinate of bbox centroid  (float)6Horizontal rotation regarding the +x-axis in radians (float)7*Color of the bbox (string, optional;X11 color nameis supported, default is "Magenta")8*Label text of the bbox (string, optional)bbox_color*:boolean, default isTrue. If the color of bbox is missing while the label text is given, thenbbox_colorhas to be explicitly set toFalse.
Package: pointwise-libs
pointwise-libslibrary functions for pointwise polisci researchHow to build packageFirst, ensure that there's a.pypircin your home directory~/that looks like this:[pypi]
    username = __token__
    password = pypi-GET_API_TOKEN_FROM_PYPI_ACCOUNTThen build withpython3 -m pip install --user --upgrade setuptools wheel
python3 -m pip install --user --upgrade twine
rm -r dist
# Increment the version in `setup.py`
python3 setup.py sdist bdist_wheel
twine upload dist/*
Package: poio-api
Poio API is a free and open source Python library to access and search data from
language documentation in your linguistic analysis workflow. It converts file
formats like Elan’s EAF, Toolbox files, Typecraft XML and others into annotation
graphs as defined in ISO 24612. Those graphs, for which we use an implementation
called “Graph Annotation Framework” (GrAF), allow unified access to linguistic
data from a wide range sources.For documentation, please visithttp://media.cidles.eu/poio/poio-api/LicensePoio API source code is distributed under the Apache 2.0 License.Poio API documentation is distributed under the Creative Commons Attribution
3.0 Unported.
Package: poiolib
Poio LibraryA NLP library of common functionality within the Poio project.Install packageLocal install:$ pip install path/to/poio-libInstall from PyPI:$ pip install poio-libUsageimport poiolib
langinfo = poiolib.LangInfo()
iso_639_1 = langinfo.iso_639_1_for_3("deu")Running the tests$ python -m unittest discover
Package: pois
A python package providing the building blocks to simulate the
operation of a ground-based optical interferometer perturbed by
atmospheric seeing perturbations. It is provided as supplementary
material for the book“Practical Optical Interferometry”, and is
derived from the code which was used to provide data for many of the
figures in the book.The package includes functions to:generate simulated atmospheric turbulent wavefront perturbationscorrect these perturbations using adaptive opticscombine beams from an arbitrary number of telescopes, with or without
spatial filtering, to provide complex fringe visibility measurements.The code has been written following a functional-programming style (in
other words minimising “side-effects” in the code where possible) in order
to try and make it modular and extensible.RequirementsThe simulator runs under Python3 and requiresnumpy. Some of the
test code usesastropyfor manipulating and saving data
tables.InstallationOn unix-like systems dopip3 install poisor if that does not work because of file permission errors, thensudo pip3 install poisAlternatively download and unpack a copy of this repository and then usepython3 setup.py installThis should install the package into Python path.Basic usageAn interferometric simulation can be written as a for loop with some custom data processing, for example:frompoisimport*results=[]forphaseScreensinPhaseScreens(numTelescope=3,r0=15,pupilSize=30,screenSize=1024,numIter=1000)):pupils=AdaptiveOpticsCorrect(phaseScreens,pupilSize=30,radialOrder=5)complexPupils=ComplexPupil(pupils)fluxes,coherentFluxes=SingleModeCombine(complexPupils)# process() is a user-written data processing functionresults.append(process(fluxes,coherentFluxes))More example code using the package is in thetestsdirectory. The filetests/test_visibility.pyincludes a complete simulation for
determining visibility losses and single-mode fibre coupling losses as a
function of the diameter of the telescopes.PronunciationThe package name should be pronounced as it would be in the phrase
“petits pois”.LicencingThe code is licenced under a 2-clause BSD licence (seeLICENCE.txt).
Package: poisk
Poisk implements a thin veneer of convenience over familiar search functions.
It can be used for:regular expression searches;jq- or JMESPath-style searches in lists and dicts;XPath queries over ElementTrees.oneandmanyAt the core of Poisk is the idea that you'd rather raise an exception than
extract the wrong data. We want to check that our expectations hold. If we
expect our search to return matches, it should not return an empty list. If we
expect a single matching element, there shouldn't be two.The search functions are grouped into two modules, calledoneandmany. The
search functions underoneexpect to find a single matching value, which they
return. They raiseNotFoundif no results are found, andManyFoundif more
than one match is found.Here is an example usingone.re, which performs regular expression searches:>>>frompoiskimportone>>>one.re(r'H\w+','Hello world!')'Hello'>>>one.re(r'H\w+','Greetings, world!')Traceback(mostrecentcalllast):...poisk.exceptions.NotFound:'H\\w+'in'Greetings, world!'>>>one.re(r'H\w+','Ho Ho Ho, world!')Traceback(mostrecentcalllast):...poisk.exceptions.ManyFound:'H\\w+'in'Ho Ho Ho, world!'The corresponding functions undermanyexpect one or more results, which they
return as a list. They raiseNotFoundif no matches are found:>>>frompoiskimportmany>>>many.re(r'\w+','Hello!')['Hello']>>>many.re(r'\w+','Hello world!')['Hello','world']>>>many.re(r'\d+','Hello world!')Traceback(mostrecentcalllast):...poisk.exceptions.NotFound:'\\d+'in'Hello world!'Supported search functionsThe previous two examples useone.reandmany.reto perform regular
expression searches, using the standardremodule.Also available are functions for xpath search over ElementTrees usinglxml.etree:>>>importlxml.etreeasET>>>frompoiskimportmany,one>>>document=ET.HTML('''...     <div>...         <p id="p1">First paragraph</p>...         <p id="p2">Second paragraph</p>...     </div>... ''')>>>one.etree('p[@id="p1"]/text()',document)'First paragraph'>>>many.etree('p/text()',document)['First paragraph','Second paragraph']The sameone.etreeandmany.etreefunctions accept CSS selectors (viacssselect):>>>one.etree('p#p1',document).text'First paragraph'Theone.podsandmany.podsfunctions allow searches using Plain Old Data
Structures (dicts and lists) using a jq- or JMESPath-style query language:>>>data={..."payload":{..."total":3,..."results":[...{"id":1},...{"id":2},...{"id":3},...],...},...}>>>one.pods('payload.total',data)3>>>many.pods('payload.results[].id',data)[1,2,3]Thetest/directory contains many more examples of the sort functionality that Poisk offers.
Package: poisson-binomial
Poisson BinomialThe Poisson binomial distribution is the discrete probability distribution of a sum of independent Bernoulli trials that are not necessarily identically distributed. That is, it is the number of successes in a sequence of n independent yes/no experiments where the success probabilities vary.The package contains a single class PoissonBinomial.Parameters: p : array-like
the probabilities of success for each of the Bernouilli trialsAttributes: pmf : array-like	probability mass function
the probability of n successes where 0<=n<=len(p)
cdf			:	array-like, 	cumulative distribution function
the probability of n or less successes where 0<=n<=len(p)Methods:x_or_less(x) :	float,		probability of achieving x or less successesx_or_more(x) :	float,		probability of achieving x or more successesThe class PoissonBinomial implements a closed-form expression for the cdf of the Poisson binomial distribution,derived in "On computing the distribution function for the Poisson binomial distribution" by Yili Hong (2013).The approach is based on finding the discrete fourier transform function for the characteristic function (CF) for the Poisson binomial distribution.
Package: poisson-CNN
poisson_CNNpoisson_CNN is a convolutional neural network model whih estimates the solution of the Poisson equation with four Dirichlet boundary conditions on rectangular grids of variable sizes.Installation requires CUDA set up to work with tensorflow-gpu version 2.3 or newer. To install, please use the Dockerfile appropriate for your CPU architecture (in most cases,docker/Dockerfile-amd64)An article describing the performance of our model is available:journal|arXivIf you use this repo in your work, please cite our paper:Özbay AG, Hamzehloo A, Laizet S, Tzirakis P, Rizos G, Schuller B. Poisson CNN: Convolutional neural networks for the solution of the Poisson equation on a Cartesian mesh. Data-Centric Engineering. [Online] Cambridge University Press; 2021;2: e6. Available from: doi:10.1017/dce.2021.7
Package: poisson-disc
Poisson disc samplingPoisson disc sampling in arbitrary dimensions using Bridson's algorithm, implemented in python usingnumpyandscipy.Generates so-called "blue noise" that prevents clustering by ensuring each two points are at leastradiusapart.https://www.cs.ubc.ca/~rbridson/docs/bridson-siggraph07-poissondisk.pdfImplementation is located inpoisson_disc.py, whilepoisson_disc_sampling.ipynbcontains some examples.Available through PyPI aspoisson_disc,https://pypi.org/project/poisson-disc/