Saravanan666/pypi-org huggingface dataset:
Package: pargeo
ParGeoOverview|Installation|Basic Usage|Getting Started|Documentation|CiteGenerate complex two-dimensional geometries for simulations based on mesh discretizations.OverviewWith ParGeo you can create complexdomains, where a domain is a two-dimensional geometry which is described by a collection of shapelyPolygonsandMultiPolygonscalledsubdomains.This domain could then be used for mesh generation, to further perform 2D mesh based simulations, like the Finite Element Methods (FEM). We provide mesh generating functionalities based onGmsh.To generate the desired domain you will use thepargeo.domain.Domainclass and sequentially add subdomains. Each subdomain is associated with a visibility level. The visibility level is an integer, and subdomains with a higher visibility level will cover those with a lower one and be merged with those having the same one.Following features support you with the domain-generating process:Create Geometries(pargeo.geometry):Create common geometries that can easly be transformed into shapely Polygons.Following geometries are provided:BoxCircle & EllipseStellarNStarRaindropTransform Geometries(pargeo.transform)Pass transforms to your domain while adding new sub-domains. The sub-domain will then be first accordingly transformed before being added to the domain.Following transforms are provided:RepeatPeriodicDiffeomorphismImpose Constraints(pargeo.constraint)Pass constraints to the domain while adding new sub-domains. The new sub-domain is only added, if the constraints are met.Following constraints are provided:DistanceConstraintCheck out thedocumentationfor more information.InstallationInstall the latest version of ParGeo from PyPI using pip:pipinstallpargeoBasic UsageHere's a simple example of how to use ParGeo.frompargeoimportwrite_meshfrompargeo.domainimportDomainfrompargeo.geometryimportBox,Circle,Stellar# Create a domainbackground=Box((0,0),(1,1)).to_polygon()domain=Domain(background)# Add some subdomainssubdomain=Circle((0.3,0.5),0.3).to_polygon(refs=50)domain.add_subdomain(subdomain=subdomain,level=1)subdomain=Circle((0.7,0.5),0.3).to_polygon(refs=50)domain.add_subdomain(subdomain=subdomain,level=1)subdomain=Stellar((0.5,0.3),0.2).to_polygon(refs=50)domain.add_subdomain(subdomain=subdomain,level=2)# Plot the domaindomain.plot()# Mesh the domain using Gmsh and write the .MSH filewrite_mesh(domain,"basic_usage")CiteIf you use ParGeo in your research, please cite it. You can use the following BibTeX entry:@software{Schafer_ParGeo_2024,author={Schäfer, Till and Gruhlke, Robert},month=feb,title={{ParGeo}},url={https://github.com/Priusds/ParGeo},version={0.3.2},year={2024}}
Package: parglare
A pure Python scannerless LR/GLR parser.For more information seethe docs.Quick introThis is just a small example to get the general idea. This example shows how to
parse and evaluate expressions with 5 operations with different priority and
associativity. Evaluation is done using semantic/reduction actions.The whole expression evaluator is done in under 30 lines of code!fromparglareimportParser,Grammargrammar=r"""
E: E '+' E  {left, 1}
 | E '-' E  {left, 1}
 | E '*' E  {left, 2}
 | E '/' E  {left, 2}
 | E '^' E  {right, 3}
 | '(' E ')'
 | number;

terminals
number: /\d+(\.\d+)?/;
"""actions={"E":[lambda_,n:n[0]+n[2],lambda_,n:n[0]-n[2],lambda_,n:n[0]*n[2],lambda_,n:n[0]/n[2],lambda_,n:n[0]**n[2],lambda_,n:n[1],lambda_,n:n[0]],"number":lambda_,value:float(value),}g=Grammar.from_string(grammar)parser=Parser(g,debug=True,actions=actions)result=parser.parse("34 + 4.6 / 2 * 4^2^2 + 78")print("Result = ",result)# Output# -- Debugging/tracing output with detailed info about grammar, productions,# -- terminals and nonterminals, DFA states, parsing progress,# -- and at the end of the output:# Result = 700.8InstallationStable version:$pipinstallparglareDevelopment version:$gitclonegit@github.com:igordejanovic/parglare.git$pipinstall-eparglareCiting parglareIf you use parglare in your research please cite this paper:Igor Dejanović, Parglare: A LR/GLR parser for Python,
Science of Computer Programming, issn:0167-6423, p.102734,
DOI:10.1016/j.scico.2021.102734, 2021.

@article{dejanovic2021b,
    author = {Igor Dejanović},
    title = {Parglare: A LR/GLR parser for Python},
    doi = {10.1016/j.scico.2021.102734},
    issn = {0167-6423},
    journal = {Science of Computer Programming},
    keywords = {parsing, LR, GLR, Python, visualization},
    pages = {102734},
    url = {https://www.sciencedirect.com/science/article/pii/S0167642321001271},
    year = {2021}
}LicenseMITPython versionsTested with 3.6-3.11CreditsInitial layout/content of this package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.
Package: parguments
A simple cli args parser for Python.Useful for creating command-line scripts.Example"""
catsup v1.0

Usage:
    catsup init [<path>]
    catsup build
    catsup deploy
    catsup -h | --help
    catsup --version

Options:
    -h --help             Show this screen and exit.
    -s --settings=<file>  path to config file. [default: config.json]
"""
from parguments import Parguments

parguments = Parguments(__doc__, version='1.0')

@parguments.command
def init(path):
  """
  Usage:
    catsup init [<path>]

  Options:
    -h --help             Show this screen and exit.
    -s --settings=<file>  path to setting file. [default: config.json]
  """
  pass

@parguments.command
def build(settings):
  """
  Usage:
    catsup build [-s <file>|--settings=<file>]

  Options:
    -h --help             Show this screen and exit.
    -s --settings=<file>  path to setting file. [default: config.json]
  """
  pass

@parguments.command
def deploy(settings):
  """
  Usage:
    catsup deploy [-s <file>|--settings=<file>]

  Options:
    -h --help             Show this screen and exit.
    -s --settings=<file>  path to setting file. [default: config.json]
  """
  pass

if __name__ == '__main__':
  parguments.run()Documents athttp://parguments.rtfd.org/
Package: pargv
pargvParse command line arguments into a list of args and a dict of kwargs.InstallationpipinstallpargvUsageBy default,pargv.parse_args()usessys.argvas command line arguments.
It can be used in the following way.frompargvimportparse_argsargs,kwargs=parse_args()The arguments to be parsed can also be specified manually:frompargvimportparse_argsargs,kwargs=parse_args(argv=['pargv.py','--name=pargv'])Specificationparse_argsparses arguments in the following way, assuming the following command line arguments (sys.argv):['/pargv/pargv.py', 'command', 'positional', '--flag', '--optional=value', 'test', '--output-file', 'filename', '-ab=one', 'two']By callingargs, kwargs = parse_args(), this would return the following list and dict:args=['/pargv/pargv.py','command','positional']kwargs={'flag':True,'optional':['value','test'],'output_file':'filename','a':True,'b':['one','two'],}Basic behaviourAll arguments before the first option (starting with a hyphen) are considered positional arguments (args)All other arguments are considered optional keyword arguments (kwargs)Optional arguments without leading hyphens are considered as values to preceding keyword argumentsOne value of an option is stored as a string, multiple values are stored as a listFlags are stored with the valueTruein the dictUp to 2 leading hyphens are stripped from options, all other hyphens are converted into underscores (---test-this-would become the key_test_this_in the dict)For multiple short options such as-vao=file.extor-vao file.ext, the last option (o) is set to the specified value, while other options (vanda) are set toTrue.
Package: pari-jupyter
AJupyterkernel forPARI/GP.InstallationInstall the dependencies listed below and runpip install pari-jupyterSyntax highlightingOn Jupyter notebook versions older than 5.3, syntax highlighting must be
explicitly enabled by runningjupyter nbextension enable --sys-prefix gp-mode/mainReplace--sys-prefixby--userfor a user installation.DependenciesPython(tested with version 2.7.14 and 3.6.1)Jupyter4PARIversion 2.13 or laterReadline(any version which works with PARI)Optional:Cythonversion 0.25 or laterRunning testsThere is a standalone python script in test/ that depends onjupyter_kernel_test(see the file
test/environment.yml for the precise dependency list that are run in the github
action using conda).
Package: parish
📿 ParishMinimal Reinforcement Learning FrameworkContributionsare welcome!Table Of ContentsOverviewRoadmapOverviewMinimal reinforcement learning framework.Get started withparishby installing it with $pip install parishor cloning this repository.RoadmapThis project is being built while I learn about reinforcement
learning, the roadmap for the project includes:Common RL Algorithms (Easily Comparable)Common RL Performance Tricks (Separate from Algorithms)Common RL ModelsFlexible/Modular ComponentsMultiprocessingDistributed Computing
Package: pari-utils
A Python library to parse PARI/GP configuration and header files. This
is mainly used in the code generation ofhttps://github.com/sagemath/cypari2andhttps://github.com/sagemath/pari-jupyter.This library supports only Python 3.InstallationUsing pipRequirements:PARI/GP >= 2.9.4 (header files and library)Python >= 3.7setuptools >= 40.6.0, wheelInstall pari-utils via the Python Package Index (PyPI) via$ pip install pari-utils [--user](the optional option–userallows to install pari-utils for a single user
and avoids using pip with administrator rights). Depending on your operating
system the pip command might also be called pip2 or pip3.If you want to try the development version use$ pip install git+https://github.com/sagemath/pari-utils.git [--user]ContributingSubmit pull request or get in touch with the SageMath developers.
Package: park
Park is a persistent key-value API for Python with ordered traversal
of keys. Both keys and values are binary safe. It’s similar in use to
LevelDB, but has no dependencies outside the Python standard library.It is meant to be extremely easy to use and can scale to a few
gigabytes of data. It allows you to be lazy until it doesn’t meet your
needs. Use it until then.It supports simple getting and setting of byte data:>>> kv = park.SQLiteStore("numbers.park")
>>> kv.put("1", "one")
>>> kv.put("2", "two")
>>> kv.put("3", "three")
>>> kv.put("4", "four")

>>> kv.get("2")
'two'Batched setting of data from an iterable:>>> kv.put_many([("1", "one"), ("2", "two"), ("3", "three")])

>>> kv.get("3")
'three'Lexically ordered traversal of keys and items, with start and end
sentinels (inclusive):>>> kv.put("1", "one")
>>> kv.put("2", "two")
>>> kv.put("3", "three")
>>> kv.put("11", "eleven")
>>> kv.put("12", "twelve")

>>> list(kv.keys())
['1', '11', '12', '2', '3']

>>> list(kv.keys(key_from="12"))
['12', '2', '3']

>>> list(kv.keys(key_from="12", key_to="2"))
['12', '2']

>>> list(kv.items(key_from="12"))
[('12', 'twelve'), ('2', 'two'), ('3', 'three')]Iteration over all keys or items with a given prefix:>>> kv.put("pet/dog", "Canis lupus familiaris")
>>> kv.put("pet/cat", "Felis catus")
>>> kv.put("pet/wolf", "Canis lupus")

>>> list(kv.prefix_keys("pet/"))
['pet/cat', 'pet/dog', 'pet/wolf']

>>> list(kv.prefix_keys("pet/", strip_prefix=True))
['cat', 'dog', 'wolf']

>>> list(kv.prefix_items("pet/", strip_prefix=True))
[('cat', 'Felis catus'),
 ('dog', 'Canis lupus familiaris'),
 ('wolf', 'Canis lupus')]It plays well with generators, so you can e.g. park all the counting
numbers (this will take a while):def numbers():
    for num in itertools.count(1):
        key = value = str(num)
        yield key, value

kv.put_many(numbers())Or recursively park a directory’s contents (keyed by relative paths)
from the local filesystem:def file_item(filename):
    with open(filename, "r") as fd:
        return filename, fd.read()

kv.put_many(file_item(os.path.join(root, name))
            for root, dirs, files in os.walk(directory)
            for name in files)
Package: parking-app
# Parking management app
requires
- python >= 3.6 installed on desktop
- pipInstall or upgradepip install parking-app –upgradeAuthenticateBefore first run, you must authenticate.
From command linempipes auth authenticate –micropipes_url https://devel3.parking.oid.digital –set_defaultand follow instructions.
You can issue this command multiple times if you wish to work with multiple users
(type different user credentials in web browser).
With this feature you can then work/switch multiple authentications in parking-app.Runparking-appRun with debug informationsparking-app-debug
Package: parking-env
parking-envParking-env is a gymnasium-based environment for reinforcement learning, written in a single Python file and accelerated by Numba. The environment is designed to simulate the task of parking a vehicle in a parking lot, where the agent controls the steering angle and the speed to park the vehicle successfully.PPO agent with discrete actionsPPO agent with multidiscrete actionsPPO agent with continuous actionsInstallationTo install the stable version,pipinstallparking-envTo install the current version with additional scripts in editable mode,gitclonehttps://github.com/KexianShen/parking-env.gitcdparking-env
pipinstall-e.UsagePre-trained models are uploaded toHugging Face Hubwith detailed notes.To use parking-env, you can code as follows:importgymnasiumasgymenv=gym.make("Parking-v0",render_mode="human",observation_type="vector",action_type="discrete")env.reset()terminated=Falsetruncated=Falsewhilenotterminatedandnottruncated:action=2obs,reward,terminated,truncated,info=env.step(action)CreditsParking-env is heavily inspired by theHighwayEnvenvironment, and some of its code was adapted for use in parking-env.Additionally, parking-env uses the algorithms provided inCleanRL, a collection of clean implementations of popular RL algorithms.LicenseThis project is licensed under the MIT License - see the LICENSE file for details.
Package: parking-lot
This repository gives an overview of how we can design a basic parking lot in Python. It creates parking lot with given number of slots. The cars follow Greedy approach while being parked in the slots.index.py = Main File(The file which you have to Run)
classes.py = The file where I declare and define my class and it's member function.
Function.py = The file where I declare and define non member function.
input.txt = The file which contains input.You can change according to your requirment.index.py script defines the following functions -create_parking_lot n - Given n number of slots, create a parking lotpark car_regno car_color - Parks a vehicle with given registration number and color in the nearest empty slot possible. If there are no more empty slots available, it shows a message "Sorry, parking lot is full".status - Prints the slot number, registration number and color of the parked vehicles.leave x - Removes vehicle from slot number xThere are few query functions to retrieve slot number from registration number of car, get registration numbers of cars with particular color etc.index.py can be run through shell or through file containing test cases. I did with file handling, In file input.txt all the test cases are there.You just need to run index.py,the desired output will be display in your screen.Additional Functionality :I have added a feature by which you can extend the number of parking slot if you required at any instance of program.To perform this you will have to add a command in input file.(modify 10).This will add 10 more new slot.I have added a feature by which You can check the available slot.To perform this you will have to add a command in input file.(display_avaiable_slot).This will show all free slot.
Package: parkinson-detector
Parkinson detectorAn Ensemble of CNN Models for Parkinson’s Disease DetectionMedical support tool for fast preliminary diagnosis can be used by any medical personnel.  Parkinson detector is written in Python and runs in a normal Windows and Linux environment. The user interface was implemented using the Qt library.Our application can work directly with Dicom files (.dcm) from a digital CRT machine or with any image files (jpg, png, etc.). We make a simple user interface with drag-and-drop support.Note:prediction from the application cannot be used as a medical diagnosis.Application requirements:Operational system:Windows 7 or laterUbuntu 16.04 or laterMac OS 10.12.6 (Sierra) or later (64-bit) (no GPU support)Python 3.6 or laterHard Drive: 4Gb of free space,Processor: Intel Core i3,Memory (RAM): 3Gb or above free.Internet connection: wideband connection for first use (for neural network model downloading)Admin privileges are not a requirementRun without instalationRequirements instalationgit clone https://gitlab.com/digiratory/biomedimaging/parkinson-detector.git
cd parkinson-detector
pip install -r requirements.txtApplication startingcd parkinson-detector
python run.pywInstalation over pippip install parkinson-detectorFor starting application run the follow command:parkinson-detector-appCitationIf you find this project useful, please cite Kurmi A, Biswas S, Sen S, Sinitca A, Kaplun D, Sarkar R. An Ensemble of CNN Models for Parkinson’s Disease Detection Using DaTscan Images. Diagnostics. 2022; 12(5):1173.https://doi.org/10.3390/diagnostics12051173:@Article{diagnostics12051173,AUTHOR={Kurmi, Ankit and Biswas, Shreya and Sen, Shibaprasad and Sinitca, Aleksandr and Kaplun, Dmitrii and Sarkar, Ram},TITLE={An Ensemble of CNN Models for Parkinson&rsquo;s Disease Detection Using DaTscan Images},JOURNAL={Diagnostics},VOLUME={12},YEAR={2022},NUMBER={5},ARTICLE-NUMBER={1173},URL={https://www.mdpi.com/2075-4418/12/5/1173},ISSN={2075-4418},DOI={10.3390/diagnostics12051173}}
Package: park-nyc
# park-nyc
[ParkNYC](https://parknyc.parkmobile.us/parknyc/) API Python wrapper[![Build Status](https://travis-ci.org/alecxe/park-nyc.svg)](https://travis-ci.org/alecxe/park-nyc)
[![Coverage Status](https://coveralls.io/repos/github/alecxe/park-nyc/badge.svg?branch=master)](https://coveralls.io/github/alecxe/park-nyc?branch=master)
[![Code Climate](https://codeclimate.com/github/alecxe/park-nyc/badges/gpa.svg)](https://codeclimate.com/github/alecxe/park-nyc)
Package: parkour
[![Build Status](https://github.com/pcarolan/parkour/workflows/Tests/badge.svg)](https://github.com/pcarolan/parkour/actions?query=workflow%3ATests)#  ParkourData replication utility## Roadmap[X] Connect to a Postgres database[ ] Connect to a MySQL database[X] Stream Data to a generator[ ] Reflect schema from database[ ] Load data and schema to apache arrow format[ ] Save table as Parquet File on disk[ ] Save table as Parquet File on s3
Package: parkproxies
Proxies UtilThis package can be used to cycle through a list of free proxies as a way to easily obfuscate one's IP.Create a ProxyService object like this:service = ProxyService(ProxyClient())To populate the ProxyService with a list of proxies -service.getProxies()After populating the ProxyService with proxies, filter through them by providing a dictionary of options to .filterProxies() -filters={"anonymity":"anonymous",#"anonymous" or "elite proxy""code":"US",# country code"google":True,# google compatible"https"True,# https compatible}# pass True to save filltered proxies into the ProxyService.filtered_proxies attributefiltered_proxies=service.filterProxies(filters,True)
Package: parkr
ParkrA light weight neural network libraryParkr was created for my second year AI methods module at university.It is very basic to get a neural network up and running and getting results quickly.Installationpip install parkrExamplesCreating the networkTo create a network you just need to specify how many input nodes, how many output nodes, a vector that contains the amount of nodes in each hidden layer, and the activation function you want to use.from parkr import Network, ActivationMethods
my_network = Network(6, [4,4], 1, ActivationMethods.TANH)This will create a network with 6 input nodes, 2 hidden layers, both with 4 nodes each and 2 output nodes and it will use the tanh activation function.Training the networkTo train the network you must pass a tuple where the first element is the training data and the second is the expected values for that training data.Then when calling the train method the network will updates its bias' and weights on those values.import numpy as np
training_data = np.array([
    [0.77,0.21,0.34,0.2,0.12,0.54],
    [0.43,0.12,0.65,0.12,0.76,0.34]
    ])

expected_data = np.array([
    [1],
    [0]
    ])

epochs = 10
my_network.train(epochs, (training_data, expected_data))Performing a forward pass on the networkTo perform a forward pass on the network you simply pass it a vector with each element as an input vaule.my_result = my_network.forward_pass([0.54,0.32,0.12,0.46,0.68,0.43])Saving and opening networksParkr supports saving networks to disk and loading them back in so that you do not have to retrain your network everytime it leaves memory.SaveThis will save the networks structure as a .json filemy_network.save("my_network_on_disk")LoadThis will load the network from the .json filemy_loaded_network = Network.open("my_network_on_disk")PrintThis will output the structure of the network along with the weights and bias' to the console.my_network = Network(4,[6,2],2, ActivationMethods.SIGMOID)
my_network.print()Would output the followingA(0) B(0) C(0) D(0) 

E(0.30882) F(-0.27833) G(0.74767) H(-0.20595) I(-0.54466) J(0.32999)

K(-1.64158) L(0.17655)

M(-0.02446) N(-0.23844)

A->E: 1.65803
A->F: 0.88988
A->G: -0.20031
A->H: 0.0684
A->I: 0.50825
A->J: 0.69463
B->E: 0.11407
B->F: 0.30879
B->G: -0.06734
B->H: 0.45021
Package: parktoma-vscconan
Conan Utility For Visual Studio CodeOverviewThis package provides a helper method for aConanproject's conanfile.py to update the Visual Studio Code C++ Tools plugin after installing dependencies, so that Intellisense finds the installed pathsHow to useUse aconanfile.pyinstead of conanfile.txt to define your project dependencies.Then, in your class, add an event handler forimports:#...fromparktoma.vscconanimportupdate_cpp_toolsclassMyProject(ConanFile):#...defimports(self):update_cpp_tools(self,conanfile_path=__file__)
Package: parledata
# Parledata V0.5Ã©crit par Emmanuel Sandorfi
parleweb.frparleweb@gmail.comAvignon, FranceLicense : GNU GENERAL PUBLIC LICENSE## l’efficacitÃ© par le dÃ©veloppementMVC (concept) + Python (langage)## la simplicitÃ© du contenu = le savoir faire de l’entreprisearborescenceclassementfichiers bureautiquesrÃ©pertoires disque local, partagÃ© ou cloud## la maÃ®trise du site web = rÃ©duction des coÃ»tsautomatisation des tÃ¢chessingularitÃ© du contenu gÃ©nÃ©rÃ© par modÃ¨lesindÃ©pendance des sites et pages gÃ©nÃ©rÃ©s## l’accessibilitÃ© des rÃ©alisations webrapiditÃ©rÃ©fÃ©rencementmaquette ou productionexpÃ©rience utilisateur
Package: parler
Parler Python APIParler Social Media Python APIInstall$pipinstallparlerAuthenticationAfter you login to Parler.com you can get theMSTandJSTtokens:Open DevTools -> Storage -> CookiesUsagefromparlerimportParlermst='XXX'# see authentication sectionjst='YYY'client=Parler(mst,jst)print(client.getFeed());Methods$python
Python3.7.3(default,May312019,XX:XX:XX)[GCC5.4.02016XXXX]onlinux
Type"help","copyright","credits"or"license"formoreinformation.
>>>importparler
>>>help(parler)