Saravanan666/pypi-org huggingface dataset:
Package: pciSeq
pciSeq: Probabilistic Cell typing by In situ SequencingA Python package that implements the cell calling algorithm as described inQian, X., et al. Nature Methods (2020)Installationpython -m pip install pciSeqRequirement: Python >= 3.8If you want to work with the source code you can download the repo and then replicate the python environment byconda env create -n pciSeq -f /path/to/environment.ymlThat will create a conda environment with the namepciSeqcontaining all the necessary packages to run the algorithm. To activate it runconda activate pciSeqor, if you open the project in your IDE, then in your project settings, switch your interpreter to the interpreter of thepciSeqenv.UsageYou need to create twopandas dataframesfor the spots and the single cell data and acoo_matrixfor the label image (which in
most cases will be the output of some image segmentation application). Then you pass them into thepciSeq.fit()method as follows:import pciSeq

res = pciSeq.fit(spots=spots_df, coo=label_image, scRNAseq=scRNA_df)See the demo below for a more detailed explanation about the arguments ofpciSeq.fit()and its return values.There is also a fourth argument (optional) to override the default hyperparameter values which are initialised
by theconfig.pymodule. To pass user-defined hyperparameter values, create adictionarywithkeysthe
hyperparameter names andvaluestheir new values. For example, to exclude all Npy and Vip spots you can do:import pciSeq

opts = { 'exclude_genes': ['Npy', 'Vip'] }
res = pciSeq.fit(spots=spots_df, coo=label_image, scRNAseq=scRNA_df, opts=opts)DemoYou can run a pciSeq demo in google colab:ViewerAn interactive viewer to explore the data runs on thisurl. Instructions about
building this viewer with your own data arehere.If you havev 0.0.49or greater you can also launch the viewer automatically by
settingopts = {'launch_viewer': True}and passing it topciSeq.fit(), seeDiagnosticsDiagnostics will help you understand whether pciSeq has been misconfigured, the algorithm has taken the
wrong path and will produce meaningless results when it finishes. You will need however to install redis (or Memurai if you are using Windows).For linux do:sudo apt-get install redis-server redis-toolsand then start the service:sudo service redis-server startYou can get the free version of memurai fromhere. Once installed, the service should start automatically but you can manually do that by:memurai.exe –service-startIf redis (or memurai) is missing from your system, the call to launch the diagnostics dashboard will be
ignored. If you are interested in this feature you may find this notebookusefulChange Log[0.0.59] - 2023-09-22Fixed a SIGSERV error under pandas '2.1.1'[0.0.56] - 2023-07-03Diagnostics dashboardBaselayers on the viewer. You can have multiple background images and switch between them.[0.0.50] - 2023-05-27Single cell data are optional, more info can be found herepciSeq.fit()takes keyword argumentsReferencesQian, X., et al. (2020). Probabilistic cell typing enables fine mapping of closely related cell types in situ. Nat
Methods 17, 101 - 106.
Package: pciw.py
pciw.pyThis module can obtainfull informationabout theCPU,RAM,GPU,Monitors,Motherboard,VideocardsandBIOS.So far, itonly works fullyon aWindowssystem.Installpip install -U pciw.pyExampleFor the example made by__main__.py:python -m pciwAuthorRoman SlabickyVkontakteGitHub
Package: pc-jamf
Pinecrest JAMF Python APIScripts and API Objects to interact with the JAMF server to manage iPadsJAMF VersionsTested with version 10.25
Uses a combination of the Classic and Pro (Beta) APIsTODOInitial Object CreationAuthentication to JAMF ServerConfiguration file for credentials and settingsList all devicesIntegration with pygsheetsJupyter Notebook AnalyticsNaming update functionSearch devices by serial numberGet Device by IDsearch devices by namesearch devices by udidadd token validation/invalidation commands
Package: pck-brendan
OverviewThe goal of this activity is to introduce you to python's packaging system calledPyPi(Python Package Index).PyPimaintains a directory service for contributed packages that is accessible bypipwhenever the tool is used to install a new package.InstructionsBegin by creating a folder for your package undersrc. Because the name of your package has to be unique, add your name as a suffix for your package name.src/pck_<your_name>Next, create the following file structure for your package.src
|__pck_<your_name>
   |__ __init__.py
   |__ mod.py
test.py
README.md
pyproject.tomlLeaveinit.pyblank.init.pyis required to import the directory as a package, and can be empty.Add the following code inmod.py, which will be the single module in your package.def add_one(number):
    return number + 1Add the following code intest.py. It will not be a proper test, just a validation that the package can be properly imported and used.from pck_<your_name> import mod

print(mod.add_one(5))After the validation, add the following inpyproject.toml, making sure to update <your_name>.[build-system]
requires = ["hatchling"]
build-backend = "hatchling.build"

[project]
name = "pck_<your_name>"
version = "0.0.1"
authors = [
  { name="Example Author", email="author@example.com" },
]
description = "A small example package"
readme = "README.md"
requires-python = ">=3.7"
classifiers = [
    "Programming Language :: Python :: 3",
    "License :: OSI Approved :: MIT License",
    "Operating System :: OS Independent",
]

[project.urls]
"Homepage" = "https://github.com/pypa/sampleproject"
"Bug Tracker" = "https://github.com/pypa/sampleproject/issues"Write something about your project inREADME.md(it cannot be left blank).This is a test project to learn something new. Added it here instead of creating a new read me.Next, try to build your project (fromsrc) using:python3 -m buildIf you get an error saying "No module named build" it means that you need to install build using pip3.After the build, adistfolder will be created.Next, it is time to publish your package so others can use. You need an account inhttps://pypi.org/. Then, go tohttps://pypi.org/manage/account/and scroll down so you can click on the "Add API token" button. Give your token a name and select "Entire account (all projects)" as the scope. Copy the token and use it to run the following:python3 -m twine upload -u __token__ -p <replace with your token> dist/*You can repeat this process multiple times if needed. For example, you may want to update your package. To do that, update the version of your package inpyproject.toml. Next, remove thedistfolder and rebuild. Finally, upload the new version.To test the installation and use of your package from PyPi, create a virtual environment and copytest.pyand see if you can run it.More InformationPyPiuser guide is availablehere.
Package: pck-BrendanD
InstructionsCompleteActivity 14: Python Packagingand have a Python package deployed on PyPi. The name of your package does not have to be "example-package" but it most end with your name. The package could do anything you like (not necessarily what is done in the tutorial). You need to push a file nameexample.pythat illustrates a possible use of your package.Grading+3 I should be able to install your package using pip.+2example.pyuses the package and runts without any error.pck_BrendanDpck_BrendanDis a simple Python package that provides a friendly greeting.InstallationInstallpck_BrendanDby running:pip install pck_BrendanDUsageTo use thegreetfunction from thepck_BrendanDpackage, follow these steps:frompck_BrendanDimportmod# Greet the worldprint(mod.greet("World"))# Greet a user by nameprint(mod.greet("Brendan"))
Package: pckit
pckitThis is a simple package for parallel computing with Python.UsageMultiprocessingIf you want to use any solver from the package you have to wrap your functions into a model.
Here the example with square of 2 and 3 are evaluated by 2 workers.MyModelis a subclass of the packageModel. The methodresultsis required.importpckitclassMyModel(pckit.Model):defresults(self,x:int)->int:# Solve here problem f(x) = x^2returnx**2if__name__=='__main__':model=MyModel()worker=pckit.MultiprocessingWorker(model)withpckit.get_solver(worker,workers_num=2)assolver:# Create tasks to solvetasks=[2,3]results=solver.solve(tasks)print(results)# >>> [4, 9]Workers number can be controlled byworkers_numargument.MPIYou can easily run scripts on the cluster withmpi4pyimplementation on MPI (Seempi4py installation docs).
Simply changeMultiprocessingWorkertoMPIWorkerin the previous example and start the script with MPImpiexec -np <n> python -m mpi4py your_script.py, where<n>is a number of workers.worker=pckit.MPIWorker(model)By default, zero rank process is also used as a worker.
It can be controlled byzero_rank_usageargument ofget_solverfunction.Single threadSingle threaded execution is also available withWorkerworker=pckit.Worker(model)ExamplesMore examplesFeaturesCacheDict based cache is available bycachingargument inget_solver().
Tasks are required to be hashable.withpckit.get_solver(worker,caching=True)assolver:tasks=[2,2]The second task's solution will be reused from the cache.You can create your own cache by implementing__contains__,__getitem__,__setitem__of theBaseCacheclass.
Seeexamplefor more details.Custom iteratorsYou can send emails or print anything during evaluation with custom iterator.tqdmis also supported.importtqdmresults=solver.solve(tasks,iterator=tqdm.tqdm)Seeexampleto create your own iterator.Logging with MPISeeexampleComsol Models, Solvers, WorkersBased onMPhpackage.TBDocumented
Package: pclean
pclean identifies and removes duplicate files within a pCloud account.By using pCloud’s API, pclean is able to determine duplicate files
without needing to download any files from the cloud, preserving your
pCloud bandwidth quota and making it pretty quick.SetupPython 3.6 is required purely due to the use of the f-strings. All
other requirements can be installed via pip withpip install .The application needs you to configure your pCloud username and
password which it will save in plain text to$HOME/.config/pclean.ini:pclean auth <username> <password>ExamplesTo report all duplicate files from the directory/copiesthat can be
found in/origyou would run:pclean -n clean /orig /copiesThe-nflag is effectively a dry run and will just report the
duplicates. By omitting-nthe duplicates will also be removed.AboutThe software is provided as is and the author accepts no
responsibility for files lost due to bugs or misuse or anything else.The source can be found here: <https://bitbucket.org/tipmethewink/pclean>
Package: pclib
PCLibPCLib is a python package with a torch-like API for building and training Predictive Coding Networks.The package includes a fully-connected layer implementation, as well as a convolutional one. Both are customisable and can be jointly, or separately used for construction neural networks.The package also includes some predesigned classification models, each with varying levels of customisability. Some models learn via simultaneously pinning inputs and targets to either end of the network, and then optimising the Free Energy. There are also models which learn a feature extractor via unsupervised learning, and then learn an mlp classifier via backpropagation; these networks have the '_us' suffix.Both models and layers are largely customiseable via their initialisation arguments. The fully connected networks are customisable in both width and depth via the initialisation arguments, however the convolutional networks are not. It is worth referring to the documentation to get a better understanding of the API.Importpip install pclibExample usageIn the examples folder you will find two different classification tasks which demonstrate the usage of this package.
Package: pclick
ClickThe main idea behind click is to enable a non-Brick controller talking to a Brick enabledAGX DynamicsSimulation in a way configurable by Brick.
The name comes from the sound two Bricks makes when connected.There are three main considerationsHow the controller can send controls and receive sensor values in a similar fashion regardless of environment, ie real or sim.How Brick adds sensors or topology on top of urdf, and how this is communicated to the controller.How to communicate controls and sensors in an effective way.The current solution is to introduce a Handshake, which enables the simulation to tell the controller what to expect in terms of how to control and what sensor data is being sent.A typical flow isClient controller connects and sends HandshakeInitServer responds with HandshakeClient receives Handshake and validates the setup.Client sends ControlsServer responds with SensorsThe loop 4-5 is repeated.Run demopython3.9-mpclick.demo.server--tracepython3-mpclick.demo.clientUseimportpclickUsage ExamplesVisit theGitHub repofor more info and usage examples.LicenseApache License 2.0
Package: pclimareq2
PClima APIPClima API - Módulo para recuperação de dados climáticos do PCBr.DESCRIPTIONA documentação do Projeto pode ser encontrada no Portal
      http://pclima.inpe.br/
As escolhas para o download de dados são definidas através 
 de um JSON que pode ser gerado utilizando do Portal API.
      http://pclima.inpe.br/analise/API

versão do Python em que foi testada: 3.6
 
exemplo de uso da API

Token: consultar a documentação para a geração do Token

Copiar o Token, no arquivo $HOME/.pclimaAPIrc (em ambiente Unix/Linux/Mac).
No Windows colocar o arquivo .pclimaAPIrc no diretório inicial do usuário (ex. C:\User\Cliente)


import pclima as pcl

Client = pcl.Client()

data = Client.getData(
{ "formato": "CSV", "conjunto": "PR0002", "modelo": "MO0003", "experimento": "EX0003", "periodo": "PE0000", "cenario": "CE0001", "variavel": "VR0001", "frequenciaURL": "Mensal", "frequencia": "FR0003", "produto": "PDT0001", "localizacao": "Ponto", "localizacao_pontos": "-23.56/-46.62", "varCDO": "tasmax" }
)

Client.save(data,"file.csv")
Package: pclines
pclinespackage for PythonThis package implements a PCLines transform for line detection in images.@INPROCEEDINGS{dubska2011pclines,author={M. {Dubská} and A. {Herout} and J. {Havel}},booktitle={CVPR 2011},title={PClines — Line detection using parallel coordinates},year={2011},}RequrementsPython 3.6+numpynumbascikit-imageInstallationThe package is onPyPI, so just run following command and install the package.>pipinstallpclinesAlternatively, you can download this repository and install manually.ExampleImport packageimportpclinesaspclData and observations
The observations are 2D weighted coordinates enclosed by a known bounding box. As an example we extract edge points from an image.image=imread("doc/test.png",as_gray=True)edges=sobel(image)r,c=np.nonzero(edges>0.5)x=np.array([c,r],"i").Tweights=edges[r,c]Accumulation in PCLines spaceh,w=image.shape[:2]bbox=(0,0,w,h)#  Bounding box of observationsd=1024# Accumulator resolutionP=PCLines(bbox,d)# Create new accumulatorP.insert(x,weights)# Insert observationsp,w=P.find_peaks(min_dist=10,prominence=1.3,t=0.1)# Find local maximaDetected linesh=P.inverse(p)# (a,b,c) parameters of linesX,Y=utils.line_segments_from_homogeneous(h,bbox)# Convert to line segments for plottingContributeIf you have a suggestion for improvement, let us know by filling an issue. Or you can fork the project and submit a pull request.
Package: pcloadletter
pcloadletterA CLI tool to generate PDF documents from HTML templates"PC LOAD LETTER" - WFT does that mean?!Installationpip install pcloadletterUsagepcloadletter lets you generate a pdf document from an HTMLJinja templategiven some context data from the command line and/or a .yml/.json file.usage: pcloadletter [-h] [-t TEMPLATE] [-o OUT] [-c CONTEXT_FILE] [extra_context ...]

Generate PDF file from a Jinja-rendered HTML template

positional arguments:
  extra_context         key=value pairs which are added to the template context (default: None)

optional arguments:
  -h, --help            show this help message and exit
  -t TEMPLATE, --template TEMPLATE
                        The invoice template to render. (default: invoice.html)
  -o OUT, --out OUT     Destination file. (default: invoice.pdf)
  -c CONTEXT_FILE, --context-file CONTEXT_FILE
                        A .yml or .json file containing context for the template. (default: None)

Examples:

    pcloadletter --template templates/invoice.html --out invoice.pdf invoice_number=2021-001 invoice_date=`date +%Y-%m-%d`

    pcloadletter --template report.html --context-file=report-data.yml addressee="Mr. M. Bolton"For example, given a template filehello.html:<!doctype html><htmllang="en"><head><linkrel="stylesheet"href="styles.css"/></head><body><h1>Hello {{ target }}!</h1></body></html>and a stylesheet:.h1{font-style:italic;}we can render the pdf like so;pcloadletter--templatehello.htmltarget="world out there"The context could have been given in a context filehello.yml;target:world out therepcloadletter--templatehello.html--context-file=hello.ymlThe above commands will generate a fileinvoice.pdfin the current directory. You can
change the destination using--out=~/Documents/report.pdf
Package: pcloud-dl
pcloud-dlpcloud-dl is a Python package that allows you to download public files from pCloud using their public link or code.InstallationYou can install pcloud-dl using pip:pip install pcloud-dlUsageTo download a file, simply run:pcloud-dl <link/code>where<link/code>is the public link or code of the file you want to download.The downloaded file will be saved in the current directory with the same name as the original file.ExampleTo download a file with the public linkhttps://u.pcloud.link/publink/show?code=XZtTpwVZnMvzSRIY2vhs6zCQgfHtI8Oya3YV, run:pcloud-dl https://u.pcloud.link/publink/show?code=XZtTpwVZnMvzSRIY2vhs6zCQgfHtI8Oya3YVThis will download the file to your current directory with the same name as the original file.Licensepcloud-dl is licensed under the MIT License. SeeLICENSEfor more information.
Package: pclpy-dependencies
pclpy dependenciesThis project contains the necessary dlls for pclpy.pclpyprovides Python bindings for the Point Cloud LibraryHistory0.2.0 (2018-06-01)VtkAdd vtk 8.1 dlls for pclpy > v0.8.00.1.0 (2018-04-23)First releaseOnly Python 3.6 is supportedPCL 1.8.1 compiled with msvc 2017
Package: pcmc
# PCMCAuthor: Daniel J. UmpierrezLicense: UNLICENSEVersion: 0.1.6## DescriptionCoinMarketCap Site Scrapper to Pandas Dataframes.## Installation
### Usingpipcommand`sh # `pip` command by supplying the github project repo URL. $ pip installgit+https://github.com/havocesp/pcmc`## Usage### CLI`sh # show accepted arguments $ pcmc--help# show 1H gainers filtered by exchanges HITBTC, BINANCE and CRYPTOPIA $ pcmc--timeframe1h--filter_bygainers hitbtc binance cryptopia `## Project dependencies.[pandas](https://pypi.org/project/pandas/)[py-term](https://pypi.org/project/py-term)## ChangelogProject history changes.### 0.1.6New CoinMarketCap class on static.pySome code tidy task accomplished and some typo fixing.### 0.1.5Added BeautifulSoap dependence for better scrapping.Removed ccxt, AppDirs, requests, begins and tabulate dependencies.Many new methods added to “CoinMarketCap” classNew ‘static.py’ module to serve as a global constants container.Fixed error on losers 7d and 24h methods.### 0.1.4New rate extraction  from html code.New “core” functionextract_ratefor html code rate extractioncryptocmpdependency removed.Some unusedCoinMarketCapmethods removed.__init__file__long_description__error fixed.### 0.1.3Newutils.pymodule containingcli.pyfunctions helpers.### 0.1.2Many function documentation added (with some “Doctests”).Added new function to handle cache data.Screen clear on every update (useful for loop mode).### 0.1.1pcmccommand added to easy run CLI interface from anywhere.Loop flag and loop interval CLI args added for auto run mode.New BTC price added (calculated from USD one at current BTC ratio)### 0.1.0“All” page data.“Gainers and Losers” page.## TODO[ ][ ] Get symbol list supported by an exchange.[ ] Show diff between refreshes.[x] Retrieve prices in BTC currency.[x] CLI interface.
Package: pcmd
AboutDuring daily development, it can be frustrating,to type long commands when you start up the terminal for the day (or when your terminal shuts down due to unknown reasons!) or,to type a set of terminal commands repeatedly to do configuration, checks, and so on.For these problems...pcmdcomes in handy :thumbsup:It's main features areIt helps to execute commands with a user-define name.It helps to execute multiple commands with just a single user-defined name.A single config file ...... and your ready to go !Trust me, it is better than bash aliases!><=> pcmdDocumentationSource Code
Package: pc-mouseparty
pc_mousepartyA package for all the base functions used in the Padilla-Coreano lab.Free software: MIT licenseDocumentation:https://padillacoreanolab.github.io/pc_mousepartyPypi:https://pypi.org/project/pc-mousepartyFeaturesHow to update a release:create a conda environment with dependencies in requirements_dev.txtactivate environment to make use of bump2versionpull latest amster branch and have it checked outrunbumpversion <major/minor/patch>(to set a specific version usebumpversion --new-version <major#.minor#.patch#> <major/minor/patch>)rungit push --tagsrungit pushto push the master branch to origin or just push the mster to origin using a git clientGo to github and use tags menu to create and publish a new releaseGH-Repo Docs
Package: pcm_player
PCM PlayerPCM Player is a Python-based commandline application for playing and testing PCM audio files that are used for creating MSU packs to be used with various emulated games and randomizers, such as A Link to the Past.InstallationPre-requisitesPython 3.8 or abovePortAudioUbuntu/Debian: apt-get install libportaudio2RHEL: dnf install portaudioArch: pacman -S portaudioInstallation Option 1: pipx (recommended)pipx is recommended it installs PCM Player into an isolated environment to avoid dependency conflicts with other Python applications, and it also creates it standalone application which can be ran directly via commandline.First, you will want to installpipx.$ pipx install pcm_player

$ pcm_player -f test.pcmInstallation Option 2: pipFirst, make sure you have pip installed and running:https://packaging.python.org/en/latest/tutorials/installing-packages/$ pip install pcm_player

$ python3 -m pcm_player -f test.pcmUsageDepending on your environment and how you installed, you may be able to run it either directly or as a Python module:# Run directly
pcm_player -f test.pcm

# Run as Python module
python3 -m pcm_player -f test.pcmThe application has two main modes:Play the full file, then loop and play around 15 secondsTest the loop by playing the last 5 seconds of the file, then loop and play 5 seconds after the loop pointYou can run them like below:# Play the full PCM file, loop, then play 15 seconds
pcm_player -f test.pcm

# Play the end of the PCM file, loop, then play 5 seconds
pcm_player -f test.pcm -l
Package: pcodec
Pcodec Python APIPcodec is a codec for numerical sequences. Example usage:>>>frompcodecimportstandalone,ChunkConfig>>>importnumpyasnp>>>>>>np.random.seed(0)>>>nums=np.random.normal(size=1000000)>>>>>># compress>>>compressed=standalone.simple_compress(nums,ChunkConfig())>>>print(f'compressed to{len(compressed)}bytes')compressedto6946316bytes>>>>>># decompress>>>recovered=standalone.simple_decompress(compressed)>>>>>>np.testing.assert_array_equal(recovered,nums)For pcodec's uses, design, and benchmarks,see the main repo.
Package: pco-image
PCO ImageSmall python package that can read PCO images and itsmetadata, especially itsimage indexandtime stamp.For reading the image, the packagepco_toolsis used.It is tested for the pco.pixelfly camera (14 bit camera) but should work for other PCO cameras, too. For
16 bit cameras you may disable 2 bit pixel shift in which caseget_timestamp(False)is called.Exampleimportmatplotlib.pyplotaspltfrompco_imageimportPCOImagepco_img=PCOImage('image.b16')# not yet loading the imageplt.imshow(pco_img.img)# only now loading the imageprint(f'image index:{pco_img.get_index()}')>>>imageindex:1print(f'image timestamp:{pco_img.get_timestamp()}')>>>imagetimestamp:2023-01-2018:21:53.096300# write to other file:pco_img.write('out.tiff')Installationpipinstallpco_image