Saravanan666/pypi-org huggingface dataset:
Package: expressgpt
expressGPTexpressGPT is a handy utility that allows you to run ChatGPT prompts in any window or application just by typing a simple keyword sequence. It provides a quick and convenient way to get assistance from ChatGPT, whether you're drafting an email, writing code, or even coming up with a flirty message for your partner.FeaturesUniversal ChatGPT access: Use ChatGPT in any window or application by typinggpt:followed by your query and ending the query with:gpt.Versatile use cases: Get help with various tasks, such as drafting emails in your mail app, writing code in a code editor, generating jokes, and more.SetupYou need to add your openAI API key and the modelname to the evironment variable:Setting Environment VariablesTo use expressGPT, you need to set up the following environment variables:API_KEY_OPENAI: Your OpenAI API keyCHATGPT_MODEL: The ChatGPT model name for themodelyou want to use (e.g.,gpt-3.5-turbo)It is recommended to set the variables permanently for ease of use instead of setting them temporary.You can followthistutorial to setup the environment variable in Windows.
Followthistutorial for setting the environment variable in Linux.
For Mac OS usethis.InstallationYou can install expressGPT using pip:pipinstallexpressgptUsageOpen a terminal and type:expressgptThe program will run and to use ChatGPT in any window or application, simply typegpt:followed by your query and end the query with:gpt. expressGPT will replace your query with ChatGPT's response.
For example, if you're in a text editor and you type:gpt: Who was the winner of the first IPL season :gptexpressGPT will replace the query with ChatGPT's response, like:Rajasthan Royal won the first IPL season.SupportIf you find expressGPT helpful and want to show your appreciation, consider buying me a cup of coffee:Your support is greatly appreciated!Thanks,Digant Patelwww.digantpatel.com
Package: express-integrations-monday
mondayA python client for the monday.com GraphQL APIFor the Monday API docs,click here.RequirementsPython >= 3.6Getting startedpip install mondaymondaysample usage:frommondayimportMondayClientmonday=MondayClient('your token')monday.items.create_item(board_id='12345678',group_id='today',item_name='Do a thing')
Package: expressionable
# expressionable Python ModuleThe official repository for the expressionable Python module, which allows for:* Transforming tabular data sets from one format to another.* Querying large data sets to filter out useful data.* Selecting additional columns/features to include in the resulting data set.* Merging data sets of various formats into a single file.* Gzipping resulting data sets, as well as the ability to read gzipped files.Click for information on the [ExpressionAble command-line tool](https://github.com/srp33/ShapeShifter-CLI), which combinesthe features of ExpressionAble with the ease and speed of the command-line!Basic use is described below, but see the full documentation on [Read the Docs](https://shapeshifter.readthedocs.io/en/latest/).## Install`pip install expressionable`## Basic UseAfter installing, import the ExpressionAble class with `from expressionable import ExpressionAble`. An ExpressionAble objectrepresents the file to be transformed. It is then transformed using the `export_filter_results` method. Here is a simpleexample of file called `input_file.tsv` being transformed into an HDF5 file called `output_file.h5`, while filteringthe data on sex and age:```pythonfrom expressionable import ExpressionAblemy_expressionable = ExpressionAble("input_file.tsv")my_expressionable.export_filter_results("output_file.h5", filters="Sex == 'M' and Age > 40")```Note that the type of file being read and exported to were not stated explicitly but inferred by ExpressionAble based onthe file extensions provided. If necessary, `input_file_type` and `output_file_type` can be named explicitly.## ContributingWe welcome contributions that help expand ExpressionAble to be compatible with additional file formats. If you areinterested in contributing, please follow the instructions [here](https://github.com/srp33/ExpressionAble/wiki/Adding-Support-for-Additional-File-Types-in-ExpressionAble).## Currently Supported Formats#### Input Formats:* CSV* TSV* JSON* Excel* HDF5* Parquet* MsgPack* Stata* Pickle* SQLite* ARFF* GCT* GCTX* PDF* Kallisto* GEO* StarReads#### Output Formats:* CSV* TSV* JSON* Excel* HDF5* Parquet* MsgPack* Stata* Pickle* SQLite* ARFF* GCT* RMarkdown* JupyterNotebook## Future Formats to SupportWe are working hard to expand ExpressionAble to work with even more file formats! Expect the following formats to beincluded in future releases:* Fixed-width files (fwf)* Genomic Data Commons clinical XML
Package: expressive-regex
Expressive RegexThis project was made with inspiration fromSuper Expressive for JavaScript.Expressive Regex allow you to build regular expressions in almost natural language and without external dependency.DocumentationExampleto match a telephone number that can be in the format 555-555-555, 555 555 555 or 555555555.ExpressiveRegex()\.exactly(2).group\.oneOrMore.digit\.optional.setOfLiterals\.char('-')\.whitespaceChar\.end()\.end()\.oneOrMore.digit\.toRegexString()"(?:\d+[\-\s]?){2}\d+"
Package: express-server
Express-ServerExpress-Server is a lightweight and fast web server for Python, inspired by the simplicity  of Express.js.Simple Syntaxfromexpress_serverimportexpressapp=express()defhome(req,res,next):returnres.send("Hello World")app.get("/",home)app.listen(3000)InstallationThis is aPythonlibrary available through the pip registry.Before installing, download and installpython. Python 3.1 or higher is required.Installation is done using the pip command:$pipinstallexpress-server🛠️This project is currently in development! Use For FunWe are actively working on improving and expanding this project. While many features are functional, there may be bugs or incomplete functionality. If you encounter any issues or have suggestions, feel free to open an issue or contribute to the development.Security Notice🔒This project is not intended for production use, and it may not be secure.As a work in progress, security considerations have not been fully addressed. Avoid using this project in a production environment or with sensitive data.LinksPyPI Releases:https://pypi.org/project/express-server/Github Code:https://github.com/avinashtare/express-server-python
Package: expr.py
expr.pyA safe and simple math evaluator for Python, built with rply.View on PyPIExpr.py is a simple but safe math expression evaluator made for Python.It can evaluate pretty advanced math concepts without crashing your computer.Made usingrplyFeaturesFully object orientedCompletely typed for intellisenseProtection against DoS attacksCustomizable and extendableFollows order of operationsFloating point precisionGetting startedYou should install expr.py usingpip:$pipinstall-Uexpr.pyHere is a simple program to get started:importexprif__name__=='__main__':expression='6 + 5 * 2'print(expr.evaluate(expression))# 16What does expr.py support?Basic operationsThe following operations are supported by expr.py:+(addition)-(subtraction)*(multiplication)/(division)//(floor division)%(modulo)^(exponentation)!(factorial)VariablesThe most basic way of defining variables is by
passing in thevariableskwarg into the evaluator.expr.evaluate('2x',variables={'x':2})# 4You can also let the input define variables:expr.evaluate('x = 5')expr.evaluate('6 + x')# 11There are by default, 2 predefined constants. (piande)Functions [WIP]You can define functions through thebuiltinskwarg:deff(x):returnx+1expr.evaluate('f(5)',builtins={'f':f})# 6You can also define functions via input:expr.evaluate('f(x) = 2x')expr.evaluate('f(3)')# 6There are a few builtin functions:sqrtcbrtloglog10lnradsincostanasinacosatanGroupingThis concept is pretty simple, anything in parentheses will be evaluated
before anything outside of them.expr.evaluate('5 * 6 + 2')# 32expr.evaluate('5 * (6 + 2)')# 40StatesYou can create different states so that each can store their
own variables and functions independently from others.To do this, useexpr.create_state:state=expr.create_state()print(state.evaluate('0.1 + 0.2'))# 0.3Note: All parameters belong increate_staterather than inevaluatefor states.Again, variables and functions are independent from each other:state1=expr.create_state()state1.evaluate('x = 1')state2=expr.create_state()state2.evaluate('x')# error (x is not defined)state1.evaluate('x')# 1Changelogv0.2This update mainly brings bug fixes from v0.1.What's new?You can now pass in custom classes intoParser.evaluateConstants are now precise to around 30 places.New constants (phi,tau)More precise builtin functionsv0.2 changes the way some builtin functions are processed
for boosts on both performance and precision.sqrtnow usesDecimal.sqrtlog10now usesDecimal.log10lnnow usesDecimal.lncbrtnow usesinput ** expr.one_thirdsinnow usesexpr.sincosnow usesexpr.cosBug fixesFixed unary minus interfering with implicit multiplication.in v0.1:5-3=-15in v0.2:5-3=2MiscellaneousMany functions now have positional-only arguments for slight performance boostsThis drops support for Python 3.7Messages retrieved fromParsingError.friendlyare now much more descriptive.v0.3What's new?Unary plus is now supported (E.g.+5)Scientific notation is now supported (E.g.4E-2)To reduce conflics, 'E'mustbe captialized.This means that2e9would evaluate to2 * e * 9, for example.Theclskwarg is now supported inexpr.evaluateBug fixesCatchOverflowErrorin theexpr.Overflowparsing error.Fix invalid typings withCallable
Package: expsuite
Python Experiment SuitePyExperimentSuiteis an open source software tool written in Python, that supports scientists, engineers and others to conduct automated software experiments on a large scale with numerous different parameters.It reads parameters (or ranges of parameters) from a configuration file, runs the experiments using multiple cores if desired and logs the results in files. Parameter combinations can be evaluated as a grid (each combination of parameters) or in a list (try several defined parameter combinations in row).PyExperimentSuitealso supports continuing any experiments where left off when the execution was interrupted (e.g. power failure, process was killed, etc.). The experiment results can be obtained in different ways by a built-in Python interface.For more information, see thedocumentationfor instructions.InstallationInstall theexpsuitepackage via pip:pipinstallexpsuiteBasic Usage ExampleCreate a new Python file (e.g.suite.py) and define a class that inherits fromPyExperimentSuite. Within the class, implement the two methodsreset()anditerate(). Also add the main script execution code at the bottom (last 3 lines below).fromexpsuiteimportPyExperimentSuiteclassMySuite(PyExperimentSuite):defreset(self,params,rep):"""for this basic example, nothing needs to be loaded or initialized."""passdefiterate(self,params,rep,n):"""this function does nothing but access the two parameters alpha andbeta from the config file experiments.cfg and returns them for thelog files, together with the current repetition and iteration number."""# access the two config file parameters alpha and betaalpha=params["alpha"]beta=params["beta"]# return current repetition and iteration number and the 2 parametersret={"rep":rep,"iter":n,"alpha":alpha,"beta":beta}returnretif__name__=="__main__":mysuite=MySuite()mysuite.start()You also need an experiment config file. Create a second fileexperiments.cfgand add the following content:[DEFAULT]
repetitions = 5
iterations = 10
path = results

[myexperiment]
alpha = 1
beta = 0.1Now call the script withpython suite.py.It will have generated a local./resultsdirectory with one subdirectorymyexperiment(the only experiment we defined in the config file). In this directory, you find 5 log files (#.logwhere#goes from 0 to 4) and anotherexperiments.cfgfile specific to this experiment.For more examples, see theexamplesfolder.
Package: expsweep
expsweep - Numerical Experiment SweeperRuns Monte Carlo experiments on a function with swept-parameters and collects results into a table.Featuresautomatically parallelizes experiment and displays a progress barresults are returned as a Pandas table which can be easily plotted in seabornQuickstartpip install expsweepBasic Example - two simultaneous experiments with a single variable sweepimportexpsweep# Function to run Monte Carlo experiment on.# Should return a dictionary containing experiment results.defexp(x):return{'experiment1':np.random.normal(loc=x,scale=x),'experiment2':np.random.normal(loc=3*x,scale=x)}# Run Monte Carlo experiment on exp() function.# Sweep parameter x (with 20 repetitions for each x) and collect results.mc=expsweep.experiment(exp,repeat=20,x=range(10),)""">>> mcx  experiment1  experiment20    0     0.000000     0.0000001    0     0.000000     0.0000002    0     0.000000     0.000000..  ..          ...          ...197  9    14.120838    27.557313198  9    11.443396    21.961869199  9    14.120838    27.557313"""Plotting with Seaborn# Seaborn expects data from both experiments to be in one column.# Use `merge=True` to merge experiment columns together for Seaborn.mc=expsweep.experiment(exp,repeat=20,x=range(10),merge=True)""">>> mcx   experiment     result0    0  experiment1   0.0000001    0  experiment1   0.0000002    0  experiment1   0.000000..  ..          ...        ...397  9  experiment2  17.528782398  9  experiment2  17.528782399  9  experiment2  27.557313"""importseabornassnssns.lineplot(data=mc,x='x',y='result',hue='experiment',style='experiment',)Multiple Parameters and Fixed ParametersMore parameters can be swept combinatorially by simply providing more arguments:defexp(x,y,z):...return{'experiment1':...}# sweep 2 variables (and 1 fixed) with a single repetition at each pointmc=expsweep.experiment(exp,x=range(10),y=range(10),z=1)>>>mcxyzexperiment100010.00000011010.00000022010.000000........9779117.5287829889117.5287829999127.557313"""Other Argumentsdef experiment(...)func(function) - function to run Monte Carlo simulation ondisable_print(boolean) - whether to show progress bars. (default False)repeat(int) - number of repetitions for each parameter combination. (default 1)merge(bool) - merge all experiment results into single data column ("results") and create new categorical column ("experiment").  (default False)cpu_count(int) - number of jobs to create.  If None, use all available cpus.  (default None)backend(str) - use pqdms "processes" backend or "threads" backend (more info). (default "processes")pqdm_kwargs(dict) - arguments to pass to pqdm (default None)TroubleshootingAttributeError: Can't pickle local object ...Define the variable in question as a global or switch the backend to 'threads'.
Package: expt
exptExperiment. Plot. Tabulate.exptis a small Python library that helps you draw time-series plots from a tabular data.
Typical use cases are drawing learning curves for machine learning experiments.exptaim to provide a minimal API for doing most of common plotting needs with sensible defaults and useful batteries included.Features:Parsing of CSV or TensorBoard eventfiles, in parallelEasy plotting of individual runs, hypotheses, or experiments.UsageSeea demo ipython notebook, until an user guide and API documentation arrive.Installation:pip install expt
pip install git+https://github.com/wookayin/expt@master        # Latest development versionLicenseMIT License (c) 2019-2022 Jongwook Choi
Package: exptools
Note to the author: Please add something informative to this READMEbeforereleasing your software, asa little documentation goes a long way.  Both
README.rst (this file) and NEWS.txt (release notes) will be included in your
package metadata which gets displayed in the PyPI page for your project.You can take a look at the README.txt of other projects, such as repoze.bfg
(http://bfg.repoze.org/trac/browser/trunk/README.txt) for some ideas.CreditsDistributeBuildoutmodern-package-template
Package: expurgator
expurgatorCensor sensitive string data in Python.QuickstartInstall with:pipinstallexpurgatorUsageLike so:fromexpurgatorimportshallow_dict_expurgatororig_dict={'user':'johnsmith','pass':'supersecret'}censored_dict=shallow_dict_expurgator(orig_dict)# censored_dict is now:# {'user': 'johnsmith', 'pass': '<SensitiveString>'}BuildingTo build this library as a wheel:pythonsetup.pybdist_wheel--universalTestingFirst, make sure you have pytest installed:pipinstallpytestTo run all tests, simply do:py.testLegalCopyright 2018IRESS Ltd.License: Apache License 2.0.
Package: exputils
Exputils: Experiment Utilities for ExpediencyA toolkit of convenient scripts and functions that are commonly used in my (Derek Prijatelj's) code for running experiments, specifically machine learning experiments.
This project is intended to expedite the research coding process by serving as a toolkit.
Though if a tool is developed enough, it may be split up into its own package.The main components are:io: nest namespaces in argparse, default arg parser, ease of saving JSONs, logging, and eventually profiling helpers (e.g. runtime at least)docstrand soon to betyping-to-configargparseas well, provide the argparse tools now and further development is done through them.data: kfold cv wrapper and abstract data classvisuals: Visualization scripts for common plots via pyplotDesign PrinciplesWrite oncereduce redundant code and the need for rewriting code for the same functionality.Keep it simpleand functionalModularityKeep as modular as possible such that each unit may be removed, replaced, or taken and plugged into a different system.Efficiencyefficient coding and executionFeaturesexputils.dataConfusion matrix: streamlines obtaining, modifying, combining, deriving summary measures, saving/loading, and visualizing of confusion matrices.Ordered Confusion Tensor, really ordered confusion matrices to get top-k measures, such as top-5 accuracy, as well as get the original confusion matrix.
Essentially, storing the order of class predictions over all samples.exputils.data.handlersexputils.iobasic conveniences for input and output, mostly for creating a filepath and making a new unique name if it already exists by appending datetime to it.exputils.mljust generic class structure, mostly for reference.[-TODO-]exputils.profileexputils.rayexputils.visualsTODOAdd general configuration file handling and connect to the default initial argparser.support yaml and JSONImprove the NestedNamespace creation process so it is simpler and streamlined.make it so the user does not need to specify dest, as it is duplicativethe nested namespaces have args mutually exclusive only to their current namespace (node in the namespace tree), allowing separate namespaces to use the same argument name as another.This requires the command line interface to provide the argparse namespace identifier when the user supplies arguments. (i.e. long arg format)
e.g. path from top level namespace to the node of the nested namespace whose args are being modified.Perhaps here is not best, but being able to turn any table (csv, tsv) into a LaTeX table would be wonderful for expediency of putting it into a paper.Consider a confusion tensor when addressing multiple random variables, e.g. a tensor with n+1 dimensions: actual/ground truth, predictor 1, predictor 2, ... predictor n.VerisoningExputils usesSemantic Versioning 2.0.0.
Exputils's version will remain < 1.0.0 until adequate unit test coverage exists.LicenseThe exputils project is licensed under the MIT license.
The license is provided in LICENSE.txt
Package: exputils-test
Experiment UtilsConvenient scripts and functions that are commonly used in code for running experiments, specifically machine learning experiments.The main components are:io: nest namespaces in argparse, ease of saving JSONs, default arg parser, logging, and eventually profiling helpers (e.g. runtime at least)data: kfold cv wrapper and abstract data classvisuals: Visualization scripts for common plots via pyplotTODOAdd general configuration file handling and connect to the default initial argparser.support yaml and JSONImprove the NestedNamespace creation process so it is simpler and streamlined.the user does not need to specify destthe nested namespaces have args mutually exclusive only to their current namespace (node in the namespace tree), allowing separate namespaces to use the same argument name as another.This requires the command line interface to provide the argparse namespace identifier when the user supplies arguments.
e.g. path from top level namespace to the node of the nested namespace whose args are being modified.
Package: expviz
Experiments Visualization Toolkit (ExpViz)Welcome to the Experiments Visualization Toolkit (ExpViz), a Python-based solution designed to facilitate the handling and visualization of experiment results, particularly those stored in JSON format. Whether your results are stored in files or represented as JSON-like dictionaries, ExpViz is here to streamline your data visualization process.FeaturesRead Results: Directly input JSON-like dictionaries or read experiment results from JSON files in a specified directory.Convert to DataFrame: Elegantly transform nested dictionaries into customizable Pandas DataFrames.Table Rendering: Convert DataFrames to LaTeX and Markdown tables for seamless integration into documents and web pages.Jupyter Display: Render and showcase DataFrames interactively within Jupyter notebooks.Installation# Clone the repositorygitclonehttps://github.com/fuzihaofzh/expviz.git# Navigate to the cloned repositorycdexpviz# (Optional) Install any dependencies listed in requirements.txtpipinstall-rrequirements.txtUsage1. Reading Results# Directly using a JSON-like dictionarydata_dict={"exp1":{"Score1":10.1,"Score2":20},"exp2":{"Score1":30,"Score2":None}}results=read_results(data_dict=data_dict)# Alternatively, using the base URL and experiment namesbaseurl="path/to/experiment/results"expnames=["experiment1","experiment2"]# or {"exp1": "experiment1", "exp2": "experiment2"}results=read_results(baseurl,expnames,filename="eval.json")2. Converting to DataFrame# Format and convert the results to a DataFramedf=dict_to_dataframe(results,fmt='{:,.3g}',transpose=False)print(df)3. Rendering as LaTeX or Markdown# Convert the DataFrame to a LaTeX tablelatex_table=to_latex(results,fmt='{:,.3g}',transpose=False)print(latex_table)# Convert the DataFrame to a Markdown tablemarkdown_table=to_markdown(results,fmt='{:,.3g}',transpose=False)print(markdown_table)4. Displaying in Jupyter# Visualize the DataFrame in a Jupyter notebookshow(results,fmt='{:,.3g}',transpose=False)ExamplesUsing JSON-like Dictionarydata_dict={"exp1":{"Score1":10.1,"Score2":20},"exp2":{"Score1":30,"Score2":None}}results=read_results(data_dict=data_dict)Using a List of Experimentsresults=read_results("path/to/results",["experiment1","experiment2"])Using a Dictionary of Experimentsresults=read_results("path/to/results",{"exp1":"experiment1","exp2":"experiment2"})Visualizing in Jupyter Notebookshow(results)Rendering as Markdownmd_table=to_markdown(results)print(md_table)ContributingContributions are warmly welcomed! For information on how to contribute, please refer to ourcontributing guidelines.LicenseExpViz is under the MIT License. For more details, check out theLICENSE.mdfile in our GitHub repository.