Saravanan666/pypi-org huggingface dataset:
Package: partnercenterservices
Partner Center Python SDKThe Partner Center Python SDK provides an SDK to interact withMicrosoft's Partner Center service. This enables the partners to perform the Partner Center operations programmatically.Installing SDKTo install:pipinstallpartnercenterservicesSupported ScenariosTo find pointers and code snippets that show how to use the Partner Center Python SDK to manage customers, get analytics, place orders, manage billing and subscriptions, provide support, and manage accounts and profiles, please check out thesupported scenarios.Checking out the Source CodeUse the following command to clone the repositorygitclonehttps://github.com/eduardomourar/partner-center-python.gitcdpartner-center-pythonHow to Build from Command LineThis was build usingAutoRestand downloadingPartner_Center_Service_SwaggerDocumentfrom Partner Center:autorest--input-file=swagger.json--python--azure-arm=true--payload-flattening-threshold=2--namespace=microsoft.store.partnercenterservices--package-name=partnercenterservices--package-version=0.1.0Related ProjectsPartner Center Java SDKPartner Center .NET SDK Samples
Package: parton
parton – a Python package for parton distributions and parton luminositiesparton is a Python package providing parton distribution functions and parton luminosities. It uses the PDF data files provided by theLHAPDFproject. Its API is  partially compatible to LHAPDF's Python API, even though only a subset of its features are implemented.parton is written in pure Python, i.e. it runs on Linux, Mac OS, and Windows.InstallationTo install the package without administrator privileges, runpython3 -m pip install parton --userCommand-line interfaceparton provides a command-line interface that mimicks (and is partially compatible to) LHAPDF'slhapdfcommand. In particular, it can be used to install PDF grid files. It is accessed by running the package as a script,python3 -m partonFor instance, to install a specific PDF set, runpython3 -m parton update
python3 -m parton install 'CT10/0'If you already have a directory with PDF sets (e.g. from LHAPDF), that can be used as well.Python usageThe API for numerically evaluating PDFs is modeled after LHAPDF's Python API:frompartonimportmkPDFpdf=mkPDF('CT10',0)# up quark PDF at x=0.1, Q=1000 GeVpdf.xfxQ(2,0.1,1000)If the PDF sets are in a non-default location (on Linux, the default location is~/.local/share/parton/), this directory can be changed throughmkPDF'spdfdirargument.Parton luminosities are accessed similarly through thePLumiclass, but the factorization scale has to be fixed on instantiation,frompartonimportPLumi# pdf has been defined aboveplumi=PLumi(pdf,Q2=1000)# u-ubar parton luminosity at shat/s=0.1plumi.L(2,-2,0.1)Licenseparton is released under the MIT license.Contributorsparton was originally written by David M. Straub (@DavidMStraub)Other contributors:Peter Stangl (@peterstangl)Citation infoparton cannot be cited at present. Please do not forget to also acknowledge theLHAPDFproject.
Package: partpy
Parser Tools in Python (partpy, pronouncedPar-Tee-Pie), a
collection of tools for hand writing lexers and parsers in python.There are many parser generators but there isn’t much help for those
who wish to roll their own parser/lexer as counter-intuitive as that
may sound.partpyprovides a solid base for hand written parsers
and lexers through a library of common tools.By usingpartpyas the base for your own parser or lexer the hope
is to provide you with an environment where you can dive straight into
the language design, recognition and whatever else you need to do
without having to figure out how string matching should be done or
most of the error handling process.partpysupports out of the boxCythonorRPythoncompilation
for added performance.Documentation & UsageAll documentation and usage information is hosted athttp://partpy.readthedocs.orgFeedbackIf you have any suggestions or questions aboutpartpyfeel free to email me
atnekroze@eturnilnetwork.com.You can check out more of what I am doing athttp://nekroze.eturnilnetwork.commy blog.If you encounter any errors or problems withpartpy, please let me know!
Open an Issue at the GitHubhttp://github.com/Nekroze/partpymain repository.
Package: partricol
PARTRICOLmaking this pkg available on pypiinstall some tools, once for allpython3 -m pip install --user --upgrade setuptools wheel twinegenerate the package for uploadingpython3 setup.py sdist bdist_wheelchange the version number every time for new versions in thesetup.pyupload the packagetwine upload --repository-url https://upload.pypi.org/legacy/ dist/partricol-0.0.X.tar.gzReplace 'X' witht the correct version number. The 0.0.1 was deleted (I tried to remove the project), and it will never come back...You can also upload to the testpy first for checking if everything fine:twine upload --repository testpypi dist/partricol-0.0.X.tar.gzinstallationpip install --user partricolupdatepip install partricol --upgrade --userUsagecypar: reading mine-style parameter filesThe original package is athttps://pypi.org/project/cypar/from partricol import cypar
test=cypar.read('test.par')def_par_trilegal and write_par_trilegalfrom partricol import tripar
test1=tripar.def_par_trilegal()
print(test1.tri.output_kind)
   #to change the values

tripar.write_par_trilegal(test1.cmd, 'cmd.par', test1.tri, 'tri.par') #which writes 'cmd.par' and 'tri.par'run_trilegalfrom partricol import tripar
tripar.run_trilegal('S_002_phat_regions_M08.par','./main','.fits')where./mainis the trilegal executable.colibri2trilegalfrom partricol.colibri2trilegal.colibri2trilegal_cycy_noeagb import colibri2trilegal
#besides colibri2trilegal_cycy_noeagb the other options are colibri2trilegal_phil, colibri2trilegal_cycy_eagb, colibri2trilegal_cycy_noeagb_fake
from partricol.colibri2trilegal.def_par_colibri2trilegal import def_par_colibri2trilegal
from partricol.colibri2trilegal.write_par_colibri2trilegal import write_par_colibri2trilegal
s=def_par_colibri2trilegal()

   #to change the values

write_par_colibri2trilegal(s,'test.inp')
colibri2trilegal('test.inp')parcolfrom partricol import parcol
parcol.parcol(exe="../isotracks/code/revisegrid/main",parsec_dbert_dir="../isotracks/isotrack_parsec/CAF09_V1.2S_M36_S12D_NS_MAS3/dbert_comp",inpdir="./INP",indir="./S_035",outdir="isotrack_parcol/CAF09_V1.2S_M36_S12D_NS_MAS3/dbert_comp035",outfile="isotrack_parcol/CAF09_V1.2S_M36_S12D_NS_MAS3_parcol_comp035.dat")match2trilegalfrom match2trilegal import process_match_sfh, process_match_popbox
sfr_match=glob.glob(os.path.join(sfr_dir,region,'region_'+region+'.optir'+quartile+'_*.popbox'))
process_match_popbox(sfr_match, outfile=sfr_tri)
Package: partypi
Emotion detection game for parties using computer vision.DescriptionInteractive game that prompts players to show an emotion (eg, “Show surprise”), and displays the winner. Can be used on raspberry pi with piCamera module.DemoScreenshotInstallInstall OpenCV3 with python3 bindingsGet Authorization KeysMicrosoft/Oxford Emotion API ReferencePlace your subscription key in config.json: “Ocp-Apim-Subscription-Key: {subscription key}”Imgur API ReferenceGetting StartedClone repository:gitclonehttps://github.com/JustinShenk/party-pi.gitcdparty-piInstall dependencies:pipinstall-rrequirements.txtChangeconfig.json.exampletoconfig.jsonand add your Emotion_API and Imgur keys. Then start the game:pythonmain.pyAdditional (optional)  arguments:--picamfor piCamera module and--resolutionto specify resolution.Select Easy or Hard Mode (left or right arrow keys).TODOFix alignment of analyzing textRedesign mode selection boxesAdd PyQT for font and sizing supportAdd Python 2 compatibilityAdd camera detection feature to recognize if raspberry piAuthorJustin Shenk(@JustinShenk) created Party Pi.LicenseMIT
Package: partypy
partypyInstallation$pipinstall-ihttps://test.pypi.org/simple/partypyFeaturesTODODependenciesTODOUsageTODODocumentationThe official documentation is hosted on Read the Docs:https://partypy.readthedocs.io/en/latest/ContributorsWe welcome and recognize all contributions. You can see a list of current contributors in thecontributors tab.CreditsThis package was created with Cookiecutter and the UBC-MDS/cookiecutter-ubc-mds project template, modified from thepyOpenSci/cookiecutter-pyopensciproject template and theaudreyr/cookiecutter-pypackage.
Package: partysig
A command-line tool for creating and verifying distributed multi-party signatures.Installation$ virtualenv env
$ . env/bin/activate
$ pip install -e .UsageKey generationOn one machine, run:$ partysig keygen startOn the other machines, run:$ partysig keygen joinSigningOn the machine with the file to sign, run:$ partysig sign start FILEOn the other machines, run:$ partysig sign joinVerifying signaturesRun:$ partysig verify FILE SIGNATUREDesignThe current signature version (v1) implements Bitcoin-style multi-sig, where the overall
multisignature contains:The number of signatures required for the multisignature to be validThe public keys allowed to create signaturesSignatures from a subset of those keysThe first two parts together are equivalent to a Bitcoin script, and are similarly hashed
to get the “master key” for the multi-party signature group. Ed25519 is used for the
individual signatures, and BLAKE2b is used for creating the master key.Signature formatVersion    (1-byte uint)     \
Threshold  (1-byte uint)      |_ Hashed to obtain
Size       (1-byte uint)      |  the master key
Pubkeys    (32 x size bytes) /
Signatures (64 x threshold bytes)AcknowledgementsJoanna Rutkowskaaskedthe questionthat prompted the creation of this tool.Brian WarnerwroteMagic Wormhole, which is a key component to this tool’s usability.
Package: parver
parverparver allows parsing and manipulation ofPEP 440version numbers.Example>>>Version.parse('1.3').bump_dev()<Version'1.3.dev0'>>>>v=Version.parse('v1.2.alpha-3')>>>v.is_alphaTrue>>>v.pre3>>>v<Version'v1.2.alpha-3'>>>>v.normalize()<Version'1.2a3'>
Package: parviflora
parviflora is a binary exchange formatPermuatiouses a binary format called parviflora.
This is a python implementation of said format.UsageThe module exports main 2 methodswrite_msgandread_msg, as well as their safe (non-exception throwing) counterpartssafe_write_msgandsafe_read_msg.Documentation:write_msgTakes 2 argumentssfile: a BufferedWriter that can have binary values write toobj: one of the types that parviflora can represent, that will be writensafe_write_msgTakes 2 argument:filename: a filename that the file should be written to, should there not be issues with writing the valueobj: as in aboveIt also returns 1 value: EitherNoneorstrwhich is an error stringread_msgTakes 1 argument:file: a BufferedReader that can have binary values read fromIt also returns 1 value: an object that has been read from the file.safe_read_msgTakes 1 argument:filename: a filename that the file should be read fromIt also returns 1 value: an object that has been read from the file or an error.Exampleimportbinformatsafe_write_msg("hexxy",{1:b"Hello world",2:[1,2,3]})withopen("hexxy","rb")asf:print(read_msg(f))# { 1: b"Hello world", 2: [1, 2, 3] }TestingRuntests.py
Package: pascal
[![Build Status](https://travis-ci.org/qiqi/pascal.svg?branch=master)](https://travis-ci.org/qiqi/pascal?branch=master)
[![Coverage Status](https://coveralls.io/repos/github/qiqi/pascal/badge.svg?branch=master)](https://coveralls.io/github/qiqi/pascal?branch=master)
[![Dependency Status](https://dependencyci.com/github/qiqi/pascal/badge)](https://dependencyci.com/github/qiqi/pascal)
[![Documentation Status](https://readthedocs.org/projects/pascal/badge/?version=latest)](http://pascal.readthedocs.io/en/latest/?badge=latest)
[![License: GPL v3](https://img.shields.io/badge/License-GPL%20v3-blue.svg)](http://www.gnu.org/licenses/gpl-3.0)# What’s it forPascal is a tool for generating stencil computation code in C.
It decomposes a stencil update formula into atomic stages, and translates
each stage into C code, to be plugged in into a stencil-based computational
framework.# Download and use
The best way to download pascal is using pip. Pip is likely included in
your Python installation. If not, see [instruction
here](https://pip.pypa.io/en/stable/installing/). To install pascal
using pip, simply type` sudo pip install pascal `# Tutorials
Package: pascalgt
pascalgtTransform manifest file of AWS Ground Truth and Pascal VOC xml files mutually.usageinstallpip install pascalgtLink to pypi project page:https://pypi.org/project/pascalgt/Pascal VOC to AWS Ground Truth manifestfrompascalgt.transformerimportPascal2GT# transform Pascal VOC xml files into a manifest file of AWS Ground Truthpascal2gt=Pascal2GT(project_name="test-project",s3_path="s3://test-project/images")pascal2gt.run(path_target_manifest="./output.manifest",path_source_xml_dir="./xml/")AWS Ground Truth manifest to Pascal VOCfrompascalgt.transformerimportGT2Pascal# transform a manifest file of AWS Ground Truth into Pascal VOC xml filesgt2pascal=GT2Pascal()gt2pascal.run(path_source_manifest="./output.manifest",path_target_xml_dir="./xml")licenseThe source code is licensed MIT.
Package: pascal-tokenizer
PyPascalTokenizer=================Module for Python 3. It does tokenizing of Pascal code (it's planned to support full Delphi and FreePascal syntax).API===Token struct------------Token is saved as 4-tuple (text, begin, end, final):* text: string with token text* begin: position of token start, tuple (y, x), where y - 0-based line index and x - 0-based character index in line* end: position after token end, tuple (y, x)* final: bool, True if it was last tokenClass PasTokenizer------------------* __init__(lines): params: list of source code strings* get_next(): get next token and change end pos* read_next(): get next token, but don't change end pos* is_ended(): check if text endedClass PasTokenizerStack-----------------------* __init__(lines, comments=True): params: list of source code strings; "comments" allows to get also comment-tokens (otherwise tokenizer skips them)* push(s): push token to stack* pop(): pop (get and delete) token from stack* read_last(): read (get but don't delete) top token from stack* is_ended(): check if stack endedClass PasTokenizerParallelStack-------------------------------Descendant of PasTokenizerStack, which uses thread(s) for parsing entire file. Before destroying it you mast call stop().* __init__(lines, comments=True, qlong=1000): additonal param: size of internal queue bufferUtils-----Helper functions to analyze token text.* is_name(s): Check for valid identifier (can be reserved word too).* is_comment(s): Check for valid comment.* is_string(s): Check for string constant.Author=====Artem Gavrilov (@Artem3213212 at Github)
Package: pascal-tri
pascal-triangleModule for generating and printing Pascal's TriangleRequiresPython 3.9(type hints)Explicit implementation of Pascal's Triangle algorithm. Each row can be generated separately from all others. This vastly speeds up time if all you need is row 100 for example.
This module is intended to be useful for mathematics or anytime a row(s) of Pascal's triangle might be useful.InstallationPascal-trianglecan be installed directly with pip to use as a library and shell command by runningpip install pascal-triOR clone the repo and runpython -m pascalIncludes methods forgenerating a list of triangle rowspretty printing a triangle with correct spacing and alignmentThe pascal module defines the following methods, access withfrompascalimport*# To generate a explicit row 'n' of Pascal's triangle:calculate_row(n:int)->PascalRow# To generate a list of 'n' rows:pascal(n:int)->PascalTriangle# Pretty print to stdout a triangle with 'n' rows or (optionally) a supplied triangle:print_pascal(n:int,triangle:PascalTriangle=None)->NoneCan be run as a script as well.python -m pascal [-h] [-l LINES]
  If LINES not specified, runs in interactive loopLearning objectivesThis project exists as an exercise in learning these techonlogies/conceptsPython type hinting (VS code intellisense integration)Making distributable Python packages (PyPi)
Package: pascal-voc
pascalPython utility to work with PascalVoc annotation formatImage examples fromPascalVoc2007datasetCode Exampleimport json
from pathlib import Path

from PIL import Image

from pascal import annotation_from_xml
from pascal.utils import save_xml

ds_path = Path("/home/VOCtest_06-Nov-2007/VOCdevkit/VOC2007")

img_src = ds_path / "JPEGImages"
ann_src = ds_path / "Annotations"

out_labelme = ds_path / "converted_labelme"

attr_type_spec = {"truncated": bool, "difficult": bool}

label_map = {"car": 1, "dog": 0, "person": 2, "train": 3}

if __name__ == "__main__":
    for file in img_src.glob("*.jpg"):
        # Get annotation file path
        ann_file = (ann_src / file.name).with_suffix(".xml")
        # Make pascal annotation object
        ann = annotation_from_xml(ann_file, attr_type_spec)
        print(ann)
        # Save to xml file (same as ann_file)
        xml = ann.to_xml()
        out_xml_name = file.with_suffix(".xml").name
        save_xml(out_xml_name, xml)
        # Save yolo annotation
        yolo_ann = ann.to_yolo(label_map)
        out_yolo_name = file.with_suffix(".txt").name
        with open(out_yolo_name, "w") as f:
            f.write(yolo_ann)
        # Convert to labelme and save json file
        res = ann.to_labelme(file, save_img_data=False)
        with open((out_labelme / file.name).with_suffix(".json"), "w") as f:
            json.dump(res, f, indent=2)
        # Draw objects
        img = Image.open(file)
        draw_img = ann.draw_boxes(img)
        draw_img.show()Visualization example:draw_img = ann.draw_boxes(img)
draw_img.show()InstallationFrom sourcepython setup.py installUsing pippip install pascal-voc
Package: pascalvoc-to-image
pascalvoc-to-imageThis repository contains a Python script that can easily cut images from annotated PascalVOC images. It will:Read the directory containing the XMLsParse the XMLs to a readable formatCreate images for all created bounding boxes in a separate folderUsageUsing the script is pretty simple, since it only has three parameters.usage: pascalvoc-to-image [-h] pascalDirectory imageDirectory saveDirectory

positional arguments:
  pascalDirectory   A path to the directory with Pascal VOC XML files
  imageDirectory    A path to the directory with images
  saveDirectory     A path to the directory to save Pascal boundingbox images to

optional arguments:
  -h, --help  show this help message and exitInstallationPip$ pip install pascalvoc-to-imageManual$ git clone https://www.gitlab.com/jdreg95/pascalvoc-to-image.git
$ cd pascalvoc-to-image
$ sudo pip install .
Package: pascal-voc-tools
# Pascal VOC Tools[![CodeFactor](https://www.codefactor.io/repository/github/wang-tf/pascal_voc_tools/badge)](https://www.codefactor.io/repository/github/wang-tf/pascal_voc_tools)
[![Documentation Status](https://readthedocs.org/projects/pascal-voc-tools/badge/?version=latest)](https://pascal-voc-tools.readthedocs.io/en/latest/?badge=latest)
[![PyPI version](https://badge.fury.io/py/pascal-voc-tools.svg)](https://badge.fury.io/py/pascal-voc-tools)
[![codecov](https://codecov.io/gh/wang-tf/pascal_voc_tools/branch/master/graph/badge.svg)](https://codecov.io/gh/wang-tf/pascal_voc_tools)This package includes some tools about pascal voc format dataset like read xml, write xml, resize image.# Functions
- annotations file laod, edit and save;
- dataset resize;
- dataset argument(function from [link](https://github.com/Paperspace/DataAugmentationForObjectDetection));
- darknet anchors k-means;# Install`bash pip installpascal-voc-tools`
Package: pascal-voc-writer
This library can be used to create image annotation XML files in the PASCAL VOC
file format.Installpip installpascal-voc-writerUse# Writer(path, width, height)writer = Writer(‘path/to/img.jpg’, 800, 400)# ::addObject(name, xmin, ymin, xmax, ymax)writer.addObject(‘cat’, 100, 100, 200, 200)# ::save(path)writer.save(‘path/to/img.xml’)
Package: pascman
PASCMAN ᗧ ⚇Using the native Python Curses library to create a simple plain text pacman that eat every text that you want :DNo external dependencies, justpython native code:snake:Installationpip install pascmanand that's all! :snake:Usage commandsOn terminal:pascman <flags|args> (optional) # or 
python -m pascman <flags|args>Type --help and you will see all the commands descriptionspascman--helpusage:main.py[-h][--file[FILE]][--aggressive][--mask[MASK]]Eateverytextwithpycman!!:D

optionalarguments:-h,--helpshowthishelpmessageandexit--file[FILE],-f[FILE]pathtoafile--aggressive,-gjustanaliasfor--mask=*FUCK*OFF*--mask[MASK],-m[MASK]choosethetracethatpacmanwillbeleaveBasically, are three options:--file <path to a text file>--aggressive or just -g <displays *FUCK*OFF*> in pacman trace--mask <here, you set the trace, be creative>If you dont set a --file or a --mask, you will play a small example with the default options.Game commandsa -- leftd -- rightw -- ups -- downand:CTRL+C -- quitOnlyAWSDkey inputs are allowed into the game curse screen.Enjoy! :D
Package: pas.cmfextensions.update_steps
IntroductionThis package adds a new import step for GenericSetup to allow a profile to
update an existing PAS plugin registry.
It works with pas_plugins.xml file in the format of PluginRegistry xml export
file, augmented with insert-after, insert-before and remove directives.
The step allow also a acl_users directory in a profile which will be imported
with a IFileSystemImporter. This is quite useful with the use of a .preserve
file to update content of PAS.Examples of profiles using this step can be found in the
pas.plugins.external_auth package.TODOCorrect the name of package, cmfextensions is tedious because the package
doesn’t require cmf at all and could be used with PAS on empty Folder.Unit tests and more documentationFix or remove the uninstall helper for cmfquickinstallerCOPYLEFTCopyright (C) 2012 Smile Suisse
See COPYING for copyright informations and LICENSE.txt for a copy of GPLv3
license in source package “docs” directory.Changelog0.1 (beta)Initial release
Package: pascua
pascuaDescriptionPython library to perform code execution in fully isolated environments.IMPORTANT: This repository is in the early stage of development, so its not recommended to be used yet. Nevertheless, contributions are welcome!InstallationYou can install the latestpascuaversion viapip:pipinstallpascuaHow it works?pascuaallow us to perform code executions in isolated environments through containerization techniques. The main idea is thatpascuabuilds adockerimage with the given parameters defined in the corresponding implementation of theEnvironmentconstructor.When a call toexec(.)method is performed, it uses the generateddockerimage as the base in which it launches the proper interpreter or code compilation to execute the givensource_codein combination with the variables defined in thecontextdictionary.UsagePython Environmentimportpascuaaspsccontext={'size':100,}source_code=['import numpy as np','random_numbers = np.random.uniform(size=size)',]env=psc.PythonEnvironment(version='3.7.3',pip_dependencies=['numpy>=1.14.0',])result=env.exec(source_code,context)R Environmentimportpascuaaspsccontext={'size':100,}source_code=['random_numbers <- runif(n = size)',]env=psc.REnvironment(version='latest',)result=env.exec(source_code,context)C++ Environmentimportpascuaaspsccontext={'size':100,}source_code=['float r;','vector<float> random_numbers;','for (int i = 0; i < size; i++) {','  r = static_cast <float> (rand()) / static_cast <float> (RAND_MAX);','  random_numbers.push_back(r);','}',]env=psc.CCEnvironment(version='latest',includes=['vector','numeric',])result=env.exec(source_code,context)DevelopmentYou can install it simply typing:pythonsetup.pyinstallTo run the tests perform:python-munittestdiscovertestsLicenseThis project is licensed underMIT license.