Saravanan666/pypi-org huggingface dataset:
Package: ezinputs
EzInputsEzInputs is built to get rid of the need to put while loops and try/except blocks around your type cast input() callsThe old waywhile True:

        num = input("Enter a number: ")

        try:

            num = int(num)

            break

        except ValueError:

            print("Invalid integer, try again")The EzInputs wayimport ezinputs

    num = ezinputs.int_input()Depending on how you measure it, ezinputs is about 10 times better!Docs & UseageBefore we begin, these functions are all in the ezinputs.py file that ships in this package. Therein, full documentation is given for each function.Primitive typesIn this section we will look at the 4 primitive input types ezinputs has to offer.All basic input types have two optional arguments;prompt- the input prompt shown to the user (function-specific default)error- the message displayed when an invalid value is entered (function-specific default)Integer input>>> ezinputs.int_input()

    Enter an integer: 5

    (returns)
    5Float input>>> ezinputs.float_input()

    Enter a float: 12.23

    (returns)
    12.23Boolean input>>> ezinputs.bool_input()

    Enter boolean: True

    (returns)
    TrueString inputPlease just use the builtin python input(), this str_input() function is extremely redundant!>>> ezinputs.str_input()

    Enter a string: hello world!

    (returns)
    'hello world!'Collection typesIn this section we will look at the 4 collection input types ezinputs has to offerThe collection inputs have additional optional arguments on top of the besic input arguments;astype- the datatype required for values (defaults to str)count- the number of items to retrieve (defaults to 1)List input>>> ezinputs.list_input(count=2, astype=int)

    Enter item 1: 5
    Enter item 2: 12

    (returns)
    [5, 12]Set input>>> ezinputs.set_input(count=3, astype=float)

    Enter item 1: 7.6
    Enter item 2: 2
    Enter item 3: 4

    (returns)
    {2.0, 4.0, 7.6}Tuple input>>> ezinputs.tuple_input(count=3, astype=bool)

    Enter item 1: a
    Enter item 2: 1
    Enter item 3: True

    (returns)
    (True, True, True)Dictionary input>>> ezinputs.dict_input(count=3)

    Enter key 1: sugar
    Enter str value for sugar: 150g
    Enter key 2: flour
    Enter str value for flour: 400g
    Enter key 3: insert_cake_ingredient_here
    Enter str value for insert_cake_ingredient_here: some

    (returns)
    {'sugar': '150g', 'flour': '400g', 'insert_cake_ingredient_here': 'some'}AuthorWill JohnsonDiscord: __wcj__#3111Email:277willjohnson@gmail.comWebsite:https://heyteach.co.uk/
Package: ezinterpret
ezinterpretPython library to make interpretting machine learning models easier :)Free software: GNU General Public License v3Documentation:https://ezinterpret.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2020-05-25)First release on PyPI.
Package: ezissue-br
EZIssue## Table of contents[TOC]What does it do?Theezissue cliis an application with command line interface which it's main objective is to help you
in the issue creation process in your projects.It takes a file with a markdown table with your issues, formats them and send them to your repo's API.
Therefore you will no longer spend hours creating issues manually.Why should I use this?If you find that the issue creation process is painfull and it breaks yourfull-lokomood while developing something, this is for you.But if you want to spend hours creating issues on Github or Gitlab and find it fun (I sincerely doubt it), who am I to tell you what to do!Usage and configurationCLI interfaceThis program has a CLI that you can take advantage of. Runningezissue --helpwill show you the usage and options for the CLI.$ezissue--helpUsage:ezissue[OPTIONS]FILENAME[github|gitlab]Options:--subidTEXT--numerateBOOLEAN--prefix[US|TS||BUG]--helpShowthismessageandexit.Markdown file and configurationThe EZIssue program takes a.mdfile as argument. That file must have a markdown table for it to parse to issues. That table is a common md table and can have the following headers: (Note that headers with*are mandatory)Header nameDescriptionGithub supportGitlab supportTitle*Issue’s titleYYDescriptionIssue’s body or descriptionYYTasksWill be a list of checkboxes. Items must be separated with commas.Y (goes with description)Y (goes with description)Acceptance criteriaWill be a list of checkboxes. Items must be separated with commas.Y (goes with description)Y (goes with description)AssigneeUser that is assigned to the issueY (assignee’s username)N (see next row)AssigneesList of users assigned to the issueY (array of assignee’s usernames)Y (is a array of user ids)LabelsList of labels that are to be applied to the issueY (array of strings)Y (single string, separated by commas)ConfidentialToggles the confidentiality of the issueNY (boolean value)MilestoneAdds a milestone to the issueY (number of milestone)Y (milestone id)DueSets a due date for stressing out your teamNY (datetime string in formatYYYY-MM-DD)DiscussionLinks the issue to a discussion threadNY (id of the discussion that it solves. Fills the description automatically)WeightSets the issue’s weight. Best used in XPNY (integer with the issue’s weight, must be bigger than zero)Examples:The issue output format is the following:<!-- issue-table.md -->
 | title | description | acceptance criteria |
 | ----- | ----------- | ------------------- |
 | issue title | brief description | condition a;condition b;condition c |<!--title-->
  <PREFIX><SUBID><NUMBER> issue title
  <!--body-->**Issue description:**---
  brief description**Acceptance criteria:**---- [ ]condition a- [ ]condition b- [ ]condition cUpdating your current versionIf you already have one of ourpipreleases installed in your machine and want to update to the latest version, use the command:$pip3install--upgradeezissueWant to make a contribuition? Here are some quick stuff you can work on!I want to thank you beforehand for your contribuition. Here you can find somequick fixesthat you can look into. :)
Package: ezjaxtyping
jaxtypingIMPORTANT: this relaxes the python constraint to python3.8 to be installable witheztils, but will throw a RuntimeError if you actually try to run with python3.8.Type annotationsand runtime type-checkingfor:shape and dtype ofJAXarrays;(Now also supports PyTorch, NumPy, and TensorFlow!)PyTrees.For example:fromjaxtypingimportArray,Float,PyTree# Accepts floating-point 2D arrays with matching dimensionsdefmatrix_multiply(x:Float[Array,"dim1 dim2"],y:Float[Array,"dim2 dim3"])->Float[Array,"dim1 dim3"]:...defaccepts_pytree_of_ints(x:PyTree[int]):...defaccepts_pytree_of_arrays(x:PyTree[Float[Array,"batch c1 c2"]]):...InstallationpipinstalljaxtypingRequires Python 3.9+.JAX is an optional dependency, required for a few JAX-specific types. If JAX is not installed then these will not be available, but you may still use jaxtyping to provide shape/dtype annotations for PyTorch/NumPy/TensorFlow/etc.The annotations provided by jaxtyping are compatible with runtime type-checking packages, so it is common to also install one of these. The two most popular aretypeguard(which exhaustively checks every argument) andbeartype(which checks random pieces of arguments).DocumentationAvailable athttps://docs.kidger.site/jaxtyping.FinallySee also: other libraries in the JAX ecosystemEquinox: neural networks.Optax: first-order gradient (SGD, Adam, ...) optimisers.Diffrax: numerical differential equation solvers.Lineax: linear solvers and linear least squares.Eqxvision: computer vision models.sympy2jax: SymPy<->JAX conversion; train symbolic expressions via gradient descent.Levanter: scalable+reliable training of foundation models (e.g. LLMs).DisclaimerThis is not an official Google product.
Package: ez-json-traverse
ez-json-traverseFor easier traversing and exploration of JSON structures.Provides a traversable sequenceEZJL, traversable mappingEZJDand convenience methods likeas_traversable.Starting off$ pip install ez-json-traversefollowed byfromezjtimportas_traversableDict stuffd={'a':{'name':'Jane','age':{'unit':'year','value':12}},'b':{'name':'John','age':{'unit':'year','value':14}},'c':{'name':'Jill','age':{'unit':'year','value':10}}}t=as_traversable(d,sep='.',map_char='^')# EZJD# Normal key accesst['a']# EZJD of {'name': 'Jane', 'age': {'unit': 'year', 'value': 12}}# Path key accesst['a.name']# 'Jane'# Mapping across valuest['^.age.value']# EZJD of [12, 14, 10]List stuffl=[[0,[1,2]],[1,[2,3]],[2,[3,4]]]t=as_traversable(l,sep='.',map_char='^')# EZJL# Normal key accesst[0]# EZJL of [0, [1, 2]]t['0']# EZJL of [0, [1, 2]]# Path key accesst['0.1.0']# 1# Mapping across valuest[':^.1.0']# EZJL of [1, 2, 3]t['1:-1^.1.0']# EZJL of [2]Other conveniencest=as_traversable(...,sep='.',map_char='^')# EZJLt.parent# Parent containert.root# Root containert.path# Path from root container to current traversablet.key# Final key or index of current traversable
Package: ezkey
ezKeyezkeyis a Python package that allows developers to easily manage locally stored API keys. It is designed to be used with the Command Line applicationezKeyVaultGetting StartedThis project has two partsezKeyVault - a CLI based key manager where the user can add and view their API keys. This is for local use only on a developer's machine, and is installed only once.
ezKeyVault creates a simple key/value store that writes a hidden text file in the user's home directory. ezKeyVault does not encrypt any content, it's sole purpose is to facilitate separation of the keys from the working code. Once a key is added to the ezKeyVault, it can be accessed from any project on the user's machine via theezKeypipmodule.ezKey - apipmodule that the user can add to their projects to facilitate easy access to their API keys during development.PrerequisitesYou will need Python 2 or 3 on your system to use this software. ezKeyVault and ezKey were built on OSX and should work on any *.nix machine.Be sure to install ezkeyvault as described in the repo linkedhere.InstallationInstall ezkey by running:pip install ezkeyDocumentationOnce ezKeyVault and ezKey are installed on your system, you can import ezkey into your project and use thegetkeymethod to retrieve any API keys that are stored in the ezKeyVault. You must first run ezkeyvault and store one or more API Keys in order to use them with ezkey.ezKey and ezKeyVault are not designed for production use. Do not use these modules on a production server.The ezKey and ezKeyVault modules are created solely for convenience to help beginning developers quickly and easily store their API keys in a path outside of their projects, and reduce the chance of accidentally uploading keys to a public repository. This project does not include any encryption, obfuscation, or security measures of any kind, and should only be used for local key management on a developer's machine.from ezkey import getkey

  mykey = getkey('Google')
  print("Mykey: ", mykey)
  #Use mykey wherever you need the API KeyNote - if you attempt to retrieve a key using an incorrect name, ezkey will return the string:"Error - Key not found"LicenseThis project is licensed under the Apache 2.0 License - see theLICENSE.mdfile for details
Package: ezkfg
ezkfgEasy ConfigurationInstallationpipinstallezkfgUsageBasic UsageimportezkfgasezfromezkfgimportConfigif__name__=='__main__':config=Config({"a":1,"b":{"c":2},"z.y.x":233})# or ez.load("xxx")assertconfig.a==1assertconfig.b.c==2assertconfig.z.y.x==233config.a=3assertconfig.a==3config["d.e.f"]=3assertconfig["d.e.f"]==3assertconfig.d.e.f==3config["e.f.g.h"]=4assertconfig.e.f.g.h==4assertconfig["e.f.g.h"]==4config.e["h.i.j"]=5assertconfig.e["h.i.j"]==5assertconfig.e.h.i.j==5assertconfig["e.h.i.j"]==5config["g.h.i.j"]=7assertconfig.g.h.i.j==7assertconfig["g.h.i.j"]==7config.load(["--model=resnet18","--batch-size=32","--lr=0.01"])assertconfig.model=="resnet18"assertconfig.batch_size=="32"assertconfig.lr=="0.01"config.dump('config.json')# support json, yaml, py, iniconfig.load('config.json')You can find more examples intests.Advanced UsageAcknowledgementsThis project is inspired by theaddict,CHANfiGandmmdetection.
Package: ezkl-lib
:thought_balloon:EZKLEasy Zero-Knowledge Inferenceezklis a library and command-line tool for doing inference for deep learning models and other computational graphs in a zk-snark (ZKML). It enables the following workflow:Define a computational graph, for instance a neural network (but really any arbitrary set of operations), as you would normally in pytorch or tensorflow.Export the final graph of operations as an.onnxfile and some sample inputs to a.jsonfile.Pointezklto the.onnxand.jsonfiles to generate a ZK-SNARK circuit with which you can prove statements such as:"I ran this publicly available neural network on some private data and it produced this output""I ran my private neural network on some public data and it produced this output""I correctly ran this publicly available neural network on some public data and it produced this output"In the backend we useHalo2as a proof system.If you have any questions, we'd love for you to open up a discussion topic inDiscussions. Alternatively, you can join the ✨EZKL Community Telegram Group💫.resources 📖docsthe official ezkl docs pagetutorialend-to-end tutorial using pytorch and ezklnotebookend-to-end tutorial using pytorch and ezkl in a jupyter notebookcargo doc --opencompile and open the docs in your default browserGetting Started ⚙️https://user-images.githubusercontent.com/45801863/236771676-5bbbbfd1-ba6f-418a-902e-20738ce0e9f0.mp4building the project 🔨Note that the library requires a nightly version of the rust toolchain. You can change the default toolchain by running:rustupoverridesetnightlyAfter which you may build the librarycargobuild--releaseA folder./target/releasewill be generated. Add this folder to your PATH environment variable to callezklfrom the CLI.# For UNIX like systems# in .bashrc, .bash_profile, or some other path fileexportPATH="<replace with where you cloned the repo>/ezkl/target/release:$PATH"Restart your shell or reload your shell settings# example, replace .bash_profile with the file you use to configure your shellsource~/.bash_profileYou will need a functioning installation ofsolcin order to runezklproperly.solc-selectis recommended.
Follow the instructions onsolc-selectto activatesolcin your environment.ReposThe EZKL project has several libraries and repos.RepoDescription@zkonduit/ezklthe main ezkl repo in rust@zkonduit/pyezklhelper functions in python for processing onnx files@zkonduit/ezkl-docsofficial ezkl docsContributing 🌎If you're interested in contributing and are unsure where to start, reach out to one of the maintainers:dante (alexander-camuto)jason (jasonmorton)More broadly:See currently open issues for ideas on how to contribute.For PRs we use theconventional commitsnaming convention.To report bugs or request new featurescreate a new issue within Issuesto inform the greater community.
Package: ezlab
ezlabezlab is a Python package that helps you manage files in Google Colab notebooks. It provides three functions:start_work(): This function uploads files or a zip file from your local machine (and extracts the zip file is the user wants) in the current working directory.finish_work(output_zip_file_name): This function zips all the files in the current working directory and downloads the zip file with the given name.clear_directory(): This function deletes all the files and folders in the current working directory, effectively resetting the working directory.InstallationYou can install ezlab using pip:!pip install ezlabUsageTo use ezlab, you need to import it in your notebook:import ezlab as ecThen you can call any of the functions as needed. For example, to upload and extract "my_project.zip" in your current directory, you can use:ec.start_work("my_project.zip")To zip and download all the files in your current directory as "my_project.zip", you can use:ec.finish_work("my_project.zip")To delete all the files and folders in your current directory, you can use:ec.clear_directory()LicenseThis package is licensed under the MIT License. See theLICENSE.txtfile for more details.
Package: ezlaunch
launchPrograms for managing job submission through slurm.These scripts can be used to submit jobs for a cluster running the
slurm scheduler. Some scripts are designed with neuroimaging data in
mind, for example running a single command to process data from multiple
participants in an experiment can be done usingslaunch.InstallationTo install the most recent release from PyPI, run:pipinstallezlaunchTo install the latest version on GitHub, run:pipinstallgit+https://github.com/prestonlab/launchVerify installation by runninglaunch -h.ConfigurationThe launch programs can use information about cluster configuration to
fill in blanks (e.g., the number of cores available on each node) and
to make sure you're not going over limits of the queue you're submitting
to (e.g., a maximum number of nodes).The configuration is specified using TOML files, which have a simple format.
Global settings should go under a[global]heading, while partition-specific
settings should go under a heading with the name of that partition.
For example (here, "normal" and "development" are two partitions):[global]account="myAccountName"[normal]cores=56max-nodes=1280[development]cores=56max-nodes=40This sets the default account to use when submitting jobs. It also sets the number of
cores and the maximum number of nodes per job for the
normal and development partitions. You may also set amax-coresoption to
restrict the number of total cores used by a job.The launch programs will look for a configuration file at$HOME/.launch.toml.
If you set theLAUNCH_CONFIGenvironment variable, launch will look there
instead.EZ LaunchIn contrast to launch, which is relatively low level, ezlaunch manages
command, batch script, and output files automatically.
To use ezlaunch, set the BATCHDIR environment variable to indicate the
directory in which job commands, slurm options, and output should be saved.For example, you could submit a job to a slurm cluster using something like:ezlaunch-Jmyjob'echo "hello world"'-N1-n1-r00:10:00-pnormalAfter the job runs, you would have the following files:$BATCHDIR/myjob1.sh# job commands$BATCHDIR/myjob1.slurm# slurm options (run time, number of nodes, etc.)$BATCHDIR/myjob1.out# output from all commandsIf you run another job named "myjob", that will be saved under
"myjob2.sh", etc.Running a command for multiple subjectsThe scripts slaunch and rlaunch run a given command on combinations of
subjects and runs. These scripts can optionally use the SUBJIDFORMAT
environment variable. This allows automatic conversion between subject
numbers (e.g., 5) and subject IDs (e.g., sub-05). For that example, you
would set:exportSUBJIDFORMAT='sub-%02d'Then subject number lists can be converted, for examplesubjids 1:2:3will producesub-01:sub-02:sub-03.AuthorsNeal MortonRuss Poldrack - wrote original launch script
Package: ezldap
ezldapAn object-oriented Python LDAP API and set of bundled scripts to make
common LDAP tasks easier.Although several very comprehensive LDAP API's currently exist (notablypython-ldapandldap3), neither are particularly easy to use and
generally focus more on the specifics of communicating via LDAP rather than
exposing an easy to use high-level API. This package is designed to do that.
The target audience of this package is system administrators and support
staff who are on a timeline and just need to add a user or write a quick
script in a portable manner.So how isezldapdifferent? It is a wrapper around theldap3API that gives access to easily perform a number of high-level tasks
like searching an LDAP directory, adding a user and sending them an
email, or resetting someone's password securely. This process is
streamlined by a configuration script that autodetects as many LDAP
configuration values as possible and automates future connections to the
directory server. Additionally, additions to an LDAP directory are performed
using a set of configurable LDIF templates, making it very quick to
customize the behavior of certain actions (like adding a group). Finally,
for most tasks, a command-line interface is provided, for users who just
want to get started doing stuff.Python example:importezldapwithezldap.auto_bind()ascon:con.add_user('username','groupname','password')Command-line example:# a password will be automatically generatedezldapadd_userusernamegroupnameInstallationYou'll need a copy of Python 3.4+.
No other dependencies are necessary,
thoughpandasis useful for some use cases.pip3install--usergit+https://github.com/jstaf/ezldap.git
ezldapconfigConfigure your LDAP connection details withezldap configbefore using the package.
You do not need to run this script as root.
The connection details/LDIF templates/etc. forezldapare stored in~/.ezldap.
Though you can store your bind password here for convenience,
I do not recommend doing so, as it will be stored in cleartext.
You may wish to configure the LDIF templates under~/.ezldapas well if you intend to use this package's add object functionality.Running testsTo run the tests, run the following after installation.
You will need to haveDockerinstalled -
it is used to spawn a test LDAP server to run tests against.pip3 install pytest pytest-cov pytest-docker docker-compose
pytestUsing this packageFor command-line documentation and usage info,
refer to theezldapcommand's built-in documentation
(ezldap -handezldap command -h).
Keep in mind this package is under active development and may not be appropriate for all use cases.
Functionality is constantly being added, and the API should not yet be considered stable.For further information, check out thedocumentation!