Saravanan666/pypi-org huggingface dataset:
Package: veerer
Veerer is a package forSageMathto deal with
veering triangulations of surfaces and their associated flat structures. It can
in particular be used to provide representatives of pseudo-Anosov mapping
classes of surfaces. The theoretical background is based on ideas of I. Agol
and F. Guéritaud, and is developed in:M. Bell, V. Delecroix, V. Gadre, R. Gutiérrez-Romo, S. Schleimer,
“Coding Teichmüller flow using veering triangulations”,arXiv:1909.00890.ExampleAs inFlipper,
edges of a triangulation are labeled with the integers 0, 1, …, n-1.
Each edge comes with an orientation and the edge opposite toiis labelled~i(so-1,-2, etc. are respectively opposite
edges to0,1, etc.). To input a triangulation, you must provide
a list of triangles, each triangle being a triple of oriented edges,
and a list of colours:>>> from veerer import *
>>> T = VeeringTriangulation([(0, 1, 2), (-1, -2, -3)], [RED, RED, BLUE])
>>> T.is_core()
TrueSince the above example is a core triangulation, it admits a flat realization.
One can be computed by taking the middle of the barycenter of the vertices of
the polytope parametrizing the flat structures:>>> F = T.flat_structure_middle()If you use Veerer inside SageMath, the flat structure can be displayed with:>>> F.plot(vertical_train_track=True)
>>> F.plot(horizontal_train_track=True)TestingTo run the SageMath doctests, install the package with pip, typically:$ sage -pip install -e .and then run:$ sage -t --force-lib veerer/Or:$ sage -t --force-lib veerer/my_file.pyBuilding the documentationGo to thedocsdirectory and then do:$ sage -sh
$ make htmlThe documentation should be available underdocs/build/as HTML pages.Typically you might want to useveerer_demo.rstas a Jupyter notebook.
In order to convertveerer_demo.rstintoveerer_demo.ipynbyou need
to have available on your computerrst2latex python-docutilspdflatexpandocthe Python package rst2ipynbthe Python package nbconvertThen do:$ export FILE_PREFIX="veerer_demo"
$ rst2ipynb --kernel=sagemath veerer_demo.rst veerer_demo.ipynbIf you installed rst2ipynb using the--useroption of pip, the executables
might be installed in$HOME/.local/bin, in which case you should first make
the system aware of this via:$ PATH=$PATH:$HOME/.local/binAuthorsMark BellVincent DelecroixSaul Schleimer
Package: veetility
Getting StartedA library to help create python pipelines for processing Tracer DataFull Online DocumentationThis is primarily for working with Social Media Organic and Paid Advertisement Data but also contains
generic functions for writing to postgreSQL and snowflake databases, creating notifications in Slack
Channels and writing to Google SheetsLibrary Installationpip install veetilityTo upgrade the library after an updatepip install veetility --upgradeInitialisation of the UtilityFunctions classAn instance of the "UtilityFunctions" class can be initiated with the ability to read/write with
google sheets and also to read/write to tables in a postgreSQL database. However none of these
are mandatory.Google Sheets AuthenticationIn order to use the functions that read/write from google sheets then a dictionary
needs to be passed to the "gspread_auth_dict" argument.
This dictionary can be obtained from a google API credentials JSON file.The instructions for creating this JSON file can be found from thegspread documentationThen copy the JSON information in curly brackets as a python dictionary into the gspread.service_account_from_dict() authentication method. The "client_email" parameter in the JSON material is the email address of the google sheet
client we have created.This email address must be given read or write access to any google sheet you want to
interact with.PostgreSQL connection parametersThe following correction parameters need to be passed in during initialisation of the class instancedb_name e.g. "vayner_external_XXXXXXXXXXX"db_host e.g. "dashboard-vayner-XXXXXXXXXXXXXXXXXXXX.rds.amazonaws.com"db_port e.g. "5432" (this is the default for postgreSQL)db_user e.g. "tom.jones"db_password e.g. "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"Setup in codeIt is advisable to put the parameters into a config.py file (cf) which can then be imported into
the main scriptimport config as cf
from veetility import utility_functions

util = utility_functions.UtilityFunctions(cf.google_sheet_auth_dict,cf.db_user, 
                                          cf.db_password,cf.db_host,
                                          cf.db_port, cf.db_name)Usage in codeOnce an instance of the class UtilityFunctions has been created, e.g. "util" then functions (methods)
of the class can be used e.g. "write_to_gsheet()".This can write a pandas.DataFrame to any google sheet the "client_email" has been given "editor" access to.
First pass in the name of the Google Sheet workbook, then the tab of the workbook, then the pandas.DataFrameutil.write_to_gsheet("Indeed Data Error Tracking","PaidNoBoostedMatch", 
                        paid_no_boosted_match)
Package: vegafusion
VegaFusionThis package is part of the VegaFusion project:https://vegafusion.io.In particular, thevegafusionpackage provides a pure Python interface to a VegaFusion Runtime. Initially, the only runtime available is provided by thevegafusion-python-embedpackage. Eventually, the VegaFusion runtime will be available as a standalone gRPC server and this package will be updated to support communication with a VegaFusion Runtime over gRPC as an alternative to the Runtime provided byvegafusion-python-embed.
Package: vegafusion-jupyter
VegaFusion JupyterThis directory contains thevegafusion-jupyterpackage. For documentation on using this package to display Altair visualizations powered by VegaFusion in Jupyter contexts, seehttps://vegafusion.io.The content below was autogenerated by Jupyter Widget cookiecuttervegafusion-jupyterAltair Jupyter Widget library that relies on VegaFusion for serverside calculationsInstallationYou can install usingpip:pipinstallvegafusion_jupyterIf you are using Jupyter Notebook 5.2 or earlier, you may also need to enable
the nbextension:jupyternbextensionenable--py[--sys-prefix|--user|--system]vegafusion_jupyterDevelopment InstallationCreate a dev environment:condacreate-nvegafusion_jupyter-dev-cconda-forgenodejsyarnpythonjupyterlab
condaactivatevegafusion_jupyter-devInstall the python. This will also build the TS package.pipinstall-e".[test, examples]"When developing your extensions, you need to manually enable your extensions with the
notebook / lab frontend. For lab, this is done by the command:jupyter labextension develop --overwrite .
yarn run buildFor classic notebook, you need to run:jupyter nbextension install --sys-prefix --symlink --overwrite --py vegafusion_jupyter
jupyter nbextension enable --sys-prefix --py vegafusion_jupyterNote that the--symlinkflag doesn't work on Windows, so you will here have to run
theinstallcommand every time that you rebuild your extension. For certain installations
you might also need another flag instead of--sys-prefix, but we won't cover the meaning
of those flags here.How to see your changesTypescript:If you use JupyterLab to develop then you can watch the source directory and run JupyterLab at the same time in different
terminals to watch for changes in the extension's source and automatically rebuild the widget.# Watch the source directory in one terminal, automatically rebuilding when neededyarnrunwatch# Run JupyterLab in another terminaljupyterlabAfter a change wait for the build to finish and then refresh your browser and the changes should take effect.Python:If you make a change to the python code then you will need to restart the notebook kernel to have it take effect.
Package: vega-lite-linter
vega-lite-linterFixing your visualization design written in Vega-Lite based on the Answer Set Programming.SetupStep 1: installClingoFirst, you need to install Clingo.For MacOSbrew install clingoUsing Condaconda install -c potassco clingoFor other system, please look up tohttps://potassco.org/clingo/Step 2: install vega-lite-linterpip install vega-lite-linterUsagefromvega_lite_linterimportLintvega_json={"data":{"url":"data/cars.json"},"mark":"bar","encoding":{"x":{"field":"Horsepower","type":"quantitative"},"y":{"field":"Miles_per_Gallon","type":"quantitative"},"size":{"field":"Cylinders","type":"ordinal"}}}# initializelint=Lint(vega_json)# show rules that the input vega-lite json violatedviolate_rules=lint.lint()# show fixing recommendation by vega-lite-linterfix=lint.fix()LicenseThe software is available under theMIT License.ContactIf you have any question, feel free toopen an issue.
Package: vegas
Thevegaspackage is for evaluating multidimensional integrals using
an improved version of the adaptive Monte Carlo vegas algorithm
(G. P. Lepage, J. Comput. Phys. 27(1978) 192).
A tutorial on its use can be found in the documentation:
seedoc/html/index.htmlor <https://vegas.readthedocs.io>.Thevegasalgorithm has been widely used for decades to evaluate
integrals of 2 or more dimensions numerically. It is particularly
well suited to higher dimensions (e.g., 9 or 10 for Feynman diagram
evaluation). The algorithm in this package is significantly
improved over the originalvegasimplementation. In particular
a second adaptive strategy has been added. It also supports
multi-processor evaluation of integrands.The new algorithm (vegas+) is described in G. P. Lepage,
<https://arxiv.org/abs/2009.05112>
(J. Comput. Phys. 439 (2021) 110386).See theINSTALLATIONfile for installation directions.
Testvegasusingmake tests. Some simple examples are
in theexamples/subdirectory.vegasversion numbers have the formmajor.minor.patchwhere
incompatible changes are signaled by incrementing themajorversion
number, theminornumber signals new features, and thepatchnumber signals bug fixes.Created by G. Peter Lepage (Cornell University) 2013Copyright (c) 2013-2023 G. Peter Lepage
Package: vegasflow
VegasFlowVegasFlow is a Monte Carlo integration library written in Python and based on theTensorFlowframework. It is developed with a focus on speed and efficiency, enabling researchers to perform very expensive calculation as quick and easy as possible.Some of the key features of VegasFlow are:Integrates efficiently high dimensional functions on single (multi-threading) and multi CPU, single and multi GPU, many GPUs or clusters.Compatible with Python, C, C++ or Fortran.Implementation of different Monte Carlo algorithms.DocumentationThe documentation for VegasFlow is available atvegasflow.readthedocs.io.InstallationThe package can be installed with pip:python3-mpipinstallvegasflowas well asconda, from theconda-forgechannel:condainstallvegasflow-cconda-forgeIf you prefer a manual installation you can clone the repository and run:gitclonehttps://github.com/N3PDF/vegasflow.gitcdvegasflow
pythonsetup.pyinstallor if you are planning to extend or develop the code just use:pythonsetup.pydevelopExamplesA number of examples (basic integration, cuda, external tools integration) can be found in theexamples folder. A more detailed description can be found in thedocumention.Below you can find a minimal workflow for using the examples provided with VegasFlow:Firstly, one can install any extra dependencies required by the examples using:pipinstall.[examples]Minimal Working Examplefromvegasflowimportvegas_wrapperimporttensorflowastfdefintegrand(x,**kwargs):""" Function:x_{1} * x_{2} ... * x_{n}x: array of dimension (events, n)"""returntf.reduce_prod(x,axis=1)dimensions=8iterations=5events_per_iteration=int(1e5)vegas_wrapper(integrand,dimensions,iterations,events_per_iteration,compilable=True)Please feel free toopen an issueif you would like
some specific example or find any problems at all with the code or the documentation.Citation policyIf you use the package please cite the following paper and zenodo references:https://doi.org/10.5281/zenodo.3691926https://arxiv.org/abs/2002.12921@article{Carrazza:2020rdn,author="Carrazza, Stefano and Cruz-Martinez, Juan M.",title="{VegasFlow: accelerating Monte Carlo simulation across multiple hardware platforms}",eprint="2002.12921",archivePrefix="arXiv",primaryClass="physics.comp-ph",reportNumber="TIF-UNIMI-2020-8",doi="10.1016/j.cpc.2020.107376",journal="Comput. Phys. Commun.",volume="254",pages="107376",year="2020"}@software{vegasflow_package,author={Juan Cruz-Martinez andStefano Carrazza},title={N3PDF/vegasflow: vegasflow v1.0},month=feb,year=2020,publisher={Zenodo},version={v1.0},doi={10.5281/zenodo.3691926},url={https://doi.org/10.5281/zenodo.3691926}}
Package: vegas-lattice
vegas-latticeA lattice generator part of thevegassoftware initiative, it provides the
esential routines to generate regular graph lattices in linear time, as well as
some cuts of those lattices for nano particles and randomly depleted lattices.InstalationThevegas-latticeprogram has been tested in python 3.4 and 3.5 to work
properly, you can install the package from the python package index using the
following command:pipinstallvegas-lattice# this might require sudoAfter that thevegas-latticecommand should be available to your command
prompt.Feel free to use the descriptor files provided in thedocsdirectory to do
some tests, and also to runvegas-lattice--helpto get some instructions in how to use the program.FeaturesThevegas-latticepackage currently features three main routines:bulkcreates a cubic lattice with the specified periodic boundary
conditions.nanoparticlecreates a spherical nanoparticle of the given diameter.depletedcreates a bulk lattice with random site depletion.describebootstraps a descriptor file using a simple site list.
Package: vega-solver
Copyright (c) 2020 Tomori Nao (@K_atc)Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the “Software”), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.Description: vega is theorem solver to find all satisfiable Values.Please seedocs/README.mdfor more informationPlatform: UNKNOWN
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.6
Classifier: License :: OSI Approved :: MIT License
Description-Content-Type: text/x-rst
Package: vehicle-lang
VehicleVehicle is a system for embedding logical specifications into neural networks.
At its heart is the Vehicle specification language, a high-level, functional language for writing mathematically-precise specifications for your networks. For example, the following simple
specification says that a network's output should be monotonically increasing with respect to
its third input.These specifications can then automatically be compiled down to loss functions to be
used when training your network.
After training, the same specification can be compiled down to low-level neural network verifiers such as Marabou which either prove that the specification holds or produce a counter-example. Such a proof is far better than simply testing, as you can prove that
the specification holds forallinputs.
Verified specifications can also be exported to interactive theorem provers (ITPs)
such as Agda.
This in turn allows for the formal verification of larger software systems
that use neural networks as subcomponents.
The generated ITP code is tightly linked to the actual deployed network, so changes
to the network will result in errors when checking the larger proof.DocumentationUser manualTutorialExamplesEach of the following examples comes with an explanatory README file:ACAS Xu- The complete specification of the ACAS Xu collision avoidance system from theReluplex paperin a single file.Car controller- A neural network controller that is formally proven to always keep a simple model of a car on the road in the face of noisy sensor data and an unpredictable cross-wind.MNIST robustness- A classifier for the MNIST dataset that is proven to be robust around the images in the dataset.In addition to the above, further examples of specifications can be found in thetest suiteand the corresponding output of the Vehicle compiler can be foundhere.SupportIf you are interested in adding support for a particular format/verifier/ITP
then open an issue on theIssue Trackerto discuss it with us.Neural network formatsONNXDataset formatsIDXVerifier backendsMarabouInteractive Theorem Prover backendsAgdaRelated papersVehicle tool paperVehicle's type checker (in CPP'23)Vehicle's compilation to verifier queries
Package: vehicle-makes
NOTICE: If you’re reading this on GitHub.com please be aware this is a mirror of the primary remote located athttps://code.richard.do/richardARPANET/vehicle-makes.
Please direct issues and pull requests there.vehicle-makesPython library to provide up-to-date vehicle make and model data. Currently returning cars only. The data source is AutoTrader.InstallationTo install, simply:pipinstallvehicle-makesHow to usefromvehicle_makesimportget_makes_and_modelsmakes_and_models=get_makes_and_models()get_makes_and_models()returns a dict in the following structure:{'AC':('212','302','Cobra'),'Abarth':('124 Spider','500','500C','595',),}Requirements1. Python 3.6+
2. See requirements.txtRunning the testspipinstall-rrequirements-dev.txtpytestsrc/tests/tests.pyRelease History0.1.0 (2019-08-13)Initial release
Package: vehiclemapperscript
InstallationInstall python3 using the following articleInstall pythonRun these commands after installing python3python3.7-mpipinstallvehiclemapperscript
python3-mvehiclemapperscriptInputsEnter base sheet name-  Name of the first sheet eg: DigitEnter Comparing sheet name- Name of the sheet to be compared with the base sheet Eg: HDFCEnter sheet full path- Full path of the excel sheet located in your systemEnter base sheet index-  Index of the base sheet. If sheet is the first one, index will be 0, and 1 for second sheetEnter index of sheet to be compared- Index of the sheet to be compared with the base sheetEnter base sheet make- Make column name of the base sheetEnter base sheet model- Model column name of the base sheetEnter base sheet variant- Variant column name of the base sheetEnter base sheet fuel type- Fuel type column nae of the base sheetEnter base sheet vehicle code- Vehicle code column name of the base sheetEnter comparing sheet make- Make column name of the comparing sheetEnter comparing sheet model- Model column name of the comparing sheetEnter comparing sheet variant- Variant column name of the comparing sheetEnter comparing sheet fuel type- Fuel type column name of the comparing sheetEnter comparing sheet vehile code- Vehicle code column name of the comparing sheet
Package: vehicular
VehicularI like to ride motorcycles (Dualsports, to be specific) and it's well known that the
best place to look for a good deal on used bikes is craigslist.  In order to jump on
a deal, you've got to constantly troll craigslist for new posts.However, I like to automate things when I can, so I wrote this little CLI app to
search for me.  It usesfeedparserto
sort through craigslist rss feeds and sends you an email notification when it finds
new matches.UsageVehicular runs in a custom shell that manages all the various search parameters.
There are a lot of possible search parameters, inside the shell runhelpto view
all the commands. andhelp <command>to view help info for<command>.  Tab
autocomplete works for commands that have specific options.  Using it is encouraged as
incorrectly typed parameters will fail as invalid.Of all the parameters, only a few are required:city,seller_type,vehicle_typeandmake_model.cityRuncity helpto view all available cities in which to search.Tab autocomplete is your friend with this one.seller_typeDefaults to search for results from both dealers and ownersRunseller_type dealerorseller_type ownerto change it to your desired
optionvehicle_typeCraigslist splits vehicle listings up into motorcycles and cars/trucksrunvehicle_type motorcyleorvehicle_type cars/trucksto select
which search you want to run.make_modelSelects the make / model you're looking for.  Pretty obvious once you think
about it.All the other parameters are optional.After having selected the parameters, runadd_search, which compiles the selected options into
an RSS URL, which is stored in the database.  After having added the search, runningrun_searchwill parse the searches and send an email notification if matches are found.InstallationInstall viapip install vehicularLicenseGPLv3, see LICENSE.txt
Package: veides-agent-sdk
Veides Agent SDK for PythonThis repository contains Python module for Veides Agent SDK. It allows Python developers to easily connect agents and interact with Veides platform.Jump to:InstallationSamplesFeaturesInstallationUsing pippip3installveides-agent-sdkFrom sourcegitclonehttps://github.com/Veides/veides-agent-sdk-python.git
python3-mpipinstall./veides-agent-sdk-pythonSamplesSamples READMEFeaturesSSL/TLS: By default, this library uses encrypted connectionAuto Reconnection: Client support automatic reconnect to Veides in case of a network issue
Package: veides-sdk
Veides SDK for PythonThis repository contains Python modules for Veides SDK. It allows Python developers to easily connect and interact with Veides platform.Jump to:InstallationSamplesFeaturesInstallationUsing pippip3installveides-sdkFrom sourcegitclonehttps://github.com/Veides/veides-sdk-python.git
python3-mpipinstall./veides-sdk-pythonSamplesSamples READMEFeaturesVeides Stream Hub ClientSSL/TLS: By default, this library uses encrypted connectionAuto Reconnection: Client support automatic reconnect to Veides Stream Hub in case of a network issueVeides API ClientMethods operations: Use your application to invoke methods on agent