Saravanan666/pypi-org huggingface dataset:
Package: impartial-text-cls
Text classifier, based on the BERT and a Bayesian neural network, which
can train on small labeled texts and doubt its decision.The goal of this project is developing of simple and power text classifier
based on transfer learning and bayesian neural networks.A transfer learning (particulary, well-known BERT model) helps to generate
special contextual embeddings for text tokens, which provide a better
discrimination ability in feature space, than classical word embeddings.
Therefore we can use smaller labeled data for training of final classifier.Bayesian neural network in final classifier models uncertainty in data,
owing to this fact probabilities of recognized classes returned by this
network are more fair, and bayesian neural network is more robust to
overfitting.
Package: impauto
ImpautoMake your life easier with automated inputsInstallationpip install impautoHow to useThe Basic way to use this modulefromimpautoimportAutomated# Each argument passed will be enter as a str to the input function.Automated(154)# use your script as normaldefsyracuse(x):step=0whilex!=1:x=(3*x+1)ifx%2else(x//2)step+=1returnstepn=int(input("Enter a number: "))print(syracuse(n))You can also hide terminal input messagesfromimpautoimportAutomated# Each argument passed will be enter as a str to the input function.Automated(1,2,3,show_message=False)By default, It will raise a exception if there is more input than value given.
To make input repeats indefinitely, you can use this codefromimpautoimportAutomated# Each argument passed will be enter as a str to the input function.Automated("a","b",forever=True)Thanks for using ImpautoLicenseÂ© 2020 copyright EdhyjoxThis repository is licensed under the MIT License.
See LICENSE for details.
Package: impayident
from impayident import envenv.CPCODE = ‘’  # CP code 등등 설정…from impayident import cert, billresponse = cert(CPCODE=’’, …)  # 매뉴얼 참고response.RESULT == ‘0000’ # 매뉴얼 상의 응답 값을 가진 namedtupleresponse = bill(CPCODE=’’, …)  # 매뉴얼 참고response.RESULT == ‘0000’ # 매뉴얼 상의 응답 값을 가진 namedtuple
Package: impconverter1.0
ImpyrialA package for converting between imperial unit lengths and weights.This package was created for the [DataCamp] (https://www.datacamp.com) course "Developing Python Packages".FeaturesConvert lengths between miles, yards, feet and inches.Convert weights between hundredweight, stone, pounds and ounces.Usageimport impyrial

# Convert 500 miles to feet
impyrial.length.convert_unit(500, from_unit='yd', to_unit='ft')  # returns 1500.0

# Convert 100 ounces to pounds
impyrial.weight.convert_unit(100, from_unit='oz', to_unit='lb')  # returns 6.25
Package: impedance
impedance.pyimpedance.pyis a Python package for making electrochemical impedance spectroscopy (EIS) analysis reproducible and easy-to-use.Aiming to create a consistent,scikit-learn-like APIfor impedance analysis, impedance.py contains modules for data preprocessing, validation, model fitting, and visualization.For a little more in-depth discussion of the package background and capabilities, check out ourJournal of Open Source Software paper.If you have a feature request or find a bug, pleasefile an issueor, better yet, make the code improvements andsubmit a pull request! The goal is to build an open-source tool that the entire impedance community can improve and use!InstallationThe easiest way to install impedance.py is fromPyPIusing pip.pipinstallimpedanceSeeGetting started with impedance.pyfor instructions on getting started from scratch.Dependenciesimpedance.py requires:Python (>=3.7)SciPy (>=1.0)NumPy (>=1.14)Matplotlib (>=3.0)Altair (>=3.0)Several example notebooks are provided in thedocs/source/examples/directory. Opening these will require Jupyter notebook or Jupyter lab.Examples and DocumentationSeveral examples can be found in thedocs/source/examples/directory (theFitting impedance spectra notebookis a great place to start) and the documentation can be found atimpedancepy.readthedocs.io.Citing impedance.pyIf you use impedance.py in published work, please consider citinghttps://joss.theoj.org/papers/10.21105/joss.02349as@article{Murbach2020,doi={10.21105/joss.02349},url={https://doi.org/10.21105/joss.02349},year={2020},publisher={TheOpenJournal},volume={5},number={52},pages={2349},author={MatthewD.MurbachandBrianGerweandNealDawson-ElliandLok-kunTsui},title={impedance.py:APythonpackageforelectrochemicalimpedanceanalysis},journal={JournalofOpenSourceSoftware}}Contributors ✨This project started at the2018 Electrochemical Society (ECS) Hack Week in Seattleand has benefited from a community of users and contributors since. Thanks goes to these wonderful people (emoji key):Lok-kun Tsui💻⚠️📖Brian Gerwe💻⚠️📖👀Neal👀💻Matt Murbach📖👀⚠️💻Kenny Huynh🐛💻lawrencerenna🤔Rowin🐛💻Michael Plews🤔Chebuskin🐛environmat🐛Abdullah Sumbal🐛nobkat💻Nick🐛💻aokomorowski💻Peter Attia💻⚠️📖sdkang⚠️💻lucasfdvx🐛Marcus Karlstad🐛Mark Bouman🐛💻oslopanda🐛pililac🐛Kavin Teenakul💻📖Enrico💻This project follows theall-contributorsspecification. Contributions of any kind welcome!
Package: impedancefitter
ImpedanceFitterImpedance spectroscopy (IS) is a great tool to analyse the behaviour of an electrical circuit,
to characterise the response of a sample (e.g. biological tissue), to determine the dielectric
properties of a sample, and much more1.In IS, often (complex) non-linear least squares is used for parameter estimation
of equivalent circuit models.
ImpedanceFitter is a software that facilitates parameter estimation for arbitrary equivalent circuit models.
The equivalent circuit may comprise different standard elements or
other models that have been formulated in the context of impedance spectroscopy.
The unknown parameters are found by fitting the model to experimental impedance data.
The underlying fitting software is LMFIT2,
which offers an interface to different optimization and curve-fitting
methods going beyond standard least-squares.ImpedanceFitter allows one to build a custom equivalent circuit, fit an arbitrary amount of data sets and
perform statistical analysis of the results using OpenTurns3.DocumentationThe documentation is available atRead the Docs.If you want to compile it locally:
The documentation is in thedocdirectory and requiresSphinxto be compiled.
A requirements file can be found in thedocdirectory.InstallationImpedanceFitter works with Python >= 3.6.ImpedanceFitter can be installed using pippip install impedancefitterIf you want to install the code from source,
clone into a local directory.cdinto this directory and runpip install -e . --userin this directory.
It will install all requirements automatically.
Moreover, you can edit the source code and
run the edited version without reinstalling.TestingThe tests usepytest.
Simply runpytestinside the repository main directory.Use ImpedanceFitterCheck out theexamplesdirectory and the documentation to see how
ImpedanceFitter is supposed to work.ContributeIf you find bugs or missing functionality,
feel free to raise an issue here on github
or create a pull request!References1: Barsoukov, E., & Macdonald, J. R. (Eds.). (2018). Impedance Spectroscopy: Theory, Experiment, and Applications. (3rd ed.). Hoboken, NJ: John Wiley & Sons, Inc.https://doi.org/10.1002/97811193818602: Newville, M., & et al. (2020, May 7). lmfit/lmfit-py 1.0.1 (Version 1.0.1). Zenodo.http://doi.org/10.5281/zenodo.38147093: Baudin, M., Dutfoy, A., Looss, B., & Popelin, A. L. (2017). OpenTURNS: An industrial software for uncertainty quantification in simulation. In Handbook of Uncertainty Quantification (pp. 2001–2038).https://doi.org/10.1007/978-3-319-12385-1_64
Package: imperatoraPY
imperatoraPY - Imperator API wrapper written in PythonMaintained byMyer (also known as myerfire, MyerFire)YouTubeTwittermyer#0001 on DiscordThis library is a fully featured async wrapper for theImperator API.InstallationimperatoraPYis available from the official pYpI package index.python -m pip install -U imperatoraPYDocumentationThere are relevant docstrings on the functions of the main wrapper class.Object attribute documentation may (?) be worked on but the code
inobjects.pyis easily readable.Quick StartfromimperatoraPYimportImperatorimportasyncioAPI_KEY="hahagetbaited"# if it isn't obvious enough, replace this string# with your API key obtained by going onto the Imperator server and running /apiasyncdefmain():imperator=awaitImperator(API_KEY)player=imperator.fetch.player(name="myerfire")print(player.nation)if__name__=="__main__":asyncio.get_event_loop().run_until_complete(main())
Package: imperial-dateutil
imperial-dateutilA utility to use Imperial Dating System(include Era Indomitus Dating System)The Emperor protects always and forever. He is the Omnissiah and will always live, always protect, always watch. He will protect all loyal to the Imperium and it is an honor to fight and die in the name of the emperor.pip install imperial-dateutilDocumentationHere is the documentationFeaturesOriginal Imperial Dating SystemEra Indomitus Dating SystemPrerequestiesBelief to The Emperor, the Omnisiah's avatarA little ability of Lingua-technis and row gothicGW, Games Workshop, Citadel, Black Library, Forge World, Warhammer, the Twin-tailed Comet logo, Warhammer 40,000, the ‘Aquila’ Double-headed Eagle logo, Space Marine, 40K, 40,000, Warhammer Age of Sigmar, Battletome, Stormcast Eternals, White Dwarf, Blood Bowl, Necromunda, Space Hulk, Battlefleet Gothic, Dreadfleet, Mordheim, Inquisitor, Warmaster, Epic, Gorkamorka, and all associated logos, illustrations, images, names, creatures, races, vehicles, locations, weapons, characters, and the distinctive likenesses thereof, are either ® or TM, and/or © Games Workshop Limited, variably registered around the world. All Rights Reserved.
Package: imperial.py
imperial.pyimperialbinis a code/text sharing site with the user experience in mind, it has feautures such as editing, encryption and integration with github gists and discord.API TokenAn API Token is not required, but you can't do most things without one. AddIMPERIAL_TOKENto path to set it
automatically; this will get overwritten by setting one manually.Example UsageShorthand Functions are more optimal if you have your API token set as an environmental variable.Shorthand Functionsimportimperialdocument=imperial.create_document("Hello, World!")# document.content is "Hello, World!"document.edit("Hello from Python!")# document.content is "Hello from Python!"document.delete()# document is deleted off imperial servers,# but information about the document still lives in the objectdocument.edit("This will raise an error!")# imperial.exceptions.DocumentNotFound("We couldn't find that document!")Imperial ClassfromimperialimportImperialimp=Imperial("IMPERIAL-00000000-0000-0000-0000-000000000000")document=imp.create_document("Hello, World!")# etc...DocumentationRefer toimperial documentationfor full docs.To see what goes on with imperial-py,
view the full code. All important functions have docstrings and a description.ContributingFork the repo on GitHubClone the project to your own machineCommit changes to your own branchPush your work to your forkSubmit a Pull request so that I can review your changes
Package: imperio
imperioImperio is a python sci-kit learn inspired package for feature engineering. It contains a some feature transformers to make your data more easy to learn from for Machine Learning Algorithms.This version of imperio has the next methods of feature selection:Box-Cox (BoxCoxTransformer).Clusterize (ClusterizeTransformer).Combinator (CombinatorTransformer).Frequency Imputation Transformer (FrequencyImputationTransformer).log Transformer (LogTransformer).Smoothing (SmoothingTransformer).Spatial-Sign Transformer (SpatialSignTransformer).Target Imputation Transformer (TargetImputationTransformer).Whitening (WhiteningTransformer).Yeo-Johnson Transformer (YeoJohnsonTransformer).ZCA (ZCATransformer).All these methods work like normal sklearn transformers. They have fit, transform and fit_transform functions implemented.Additionally every imperio transformer has an apply function which allows to apply an transformation on a pandas Data Frame.How to use imperioTo use a transformer from imperio you should just import the transformer from imperio in the following framework:fromimperioimportBoxCoxTransformerclass names are written above in parantheses.Next create a object of this algorithm (Box-Cox is used as an example).method=BoxCoxTransformer()Firstly you should fit the transformer, passing to it a feature matrix (X) and the target array (y).
NOTE: y argument is really used only by the Target-Imputation.method.fit(X,y)After you fit the model, you can use it for transforming new data, using the transform function. To transform function you should pass only the feature matrix (X).X_transformed=method.transform(X)Also you can fit and transform the data at the same time using thefit_transformfunction.X_transformed=method.fit_transform(X)Also you can apply a transformation directly on a pandas DataFrame, choosing the columns that you want to change.new_df=method.apply(df,'target',['col1','col2']Some advice:UseFrequencyImputationTransformerorTargetImputationTransformerfor categorical features.UseBoxCoxTransformerorYeoJohnsonTransformerfor numerical features to normalize a feature distribution.UseSpatialSignTransformeron normalized data to bring outliers to normal samples.UseCombinatorTransformeron tombine different transformers on categorical and numerical columns separately.With <3 from Sigmoid!We are open for feedback. Please send your impressions tovladimir.stojoc@gmail.com
Package: imperium
ImperiumImperium is a python package that allows you to easily evaluate python expressionsInstallationpipinstallimperiumUsagefromimperium.evaluatorimportExpressionobj={'name':'iPhone','model':'11 Pro','price':1299.90,'state':'new'}expr=Expression()ifexpr.evaluate('$subject.state == "new"',obj):# "$subject" is a reserved key# Your logicTo access the data in the given subject, use the "$subject" key as shown above.Check if the subject has an attributefromimperium.evaluatorimportExpressionobj={'name':'iPhone','model':'11 Pro','price':1299.90,'state':'new'}someother_obj={'name':'John Doe'}expr=Expression()res=expr.evaluate('exists("$subject.price", $subject)',subject=obj,source=someother_obj)# REMINDER: "$subject" key let's you access the object that you passed to the evaluate method (obj in this case)print(res)# Output: TrueTesting regular expressionsfromimperium.evaluatorimportExpressionobj={'name':'iPhone','model':'11 Pro','price':1299.90,'state':'new'}buyer={'fullname':'John Doe'}# Passing the name attribute of the subject# REMINDER: "$subject" let's you access the object/subject passed to the evaluate method (obj in this case)# and "$source" let's you access the optional source object passed to the evaluate methodexpression="exists('$subject.name', $subject) && matches('IPHONE', $subject['name'], 'i')"expr=Expression()res=expr.evaluate(expression,subject=obj,source=buyer)print(res)# Output: TrueImperiumhas built-in functions to simplify certain actions/verifications.FunctionArgument(s)Descriptionexists()key (Ex: $subject.price), $subjectChecks if the given attribute/key exists in the given subject.matches()regex, value, flag (iorm)Tests a regular expressiondate()datestring, formatdatestringandformatare both optional, provide them to the function if you want to convert a date string to date object.If these two arguments are left emtpy, the function returns date object with current date and time.date_modify()date, operation (+|-), valuetype (days|months|years), value:intThis function can add and subtract days, months and years from a date object.
Package: imperium-legacy
ImperiumImperium is a python package that allows you to easily evaluate python expressionsInstallationpipinstallimperiumUsagefromimperiumimportExpressionobj={'name':'iPhone','model':'11 Pro','price':1299.90,'state':'new'}expr=Expression()ifexpr.evaluate('$subject.state == "new"',obj):# "$subject" is a reserved key# Your logicTo access the data in the given subject, use the "$subject" key as shown above.Check if the subject has an attributefromimperiumimportExpressionobj={'name':'iPhone','model':'11 Pro','price':1299.90,'state':'new'}someother_obj={'name':'John Doe'}expr=Expression()res=expr.evaluate('exists("$subject.price", $subject)',subject=obj,source=someother_obj)# REMINDER: "$subject" key let's you access the object that you passed to the evaluate method (obj in this case)print(res)# Output: TrueTesting regular expressionsfromimperium.evaluatorimportExpressionobj={'name':'iPhone','model':'11 Pro','price':1299.90,'state':'new'}buyer={'fullname':'John Doe'}# Passing the name attribute of the subject# REMINDER: "$subject" let's you access the object/subject passed to the evaluate method (obj in this case)# and "$source" let's you access the optional source object passed to the evaluate method# INFO: "matches" function let's you evaluate a regular expression against a value, note that the supported flag are "i" and "m"# if you use something else than these two flags, the evaluation will procede by ignoring the flag since it didn't recognize it.expression="exists('$subject.name', $subject) && matches('IPHONE', $subject['name'], 'i')"expr=Expression()res=expr.evaluate(expression,subject=obj,source=buyer)print(res)# Output: TrueImperiumhas built-in functions to simplify certain actions/verifications.FunctionArgument(s)Descriptionexists()key (Ex: $subject.price), $subjectChecks if the given attribute/key exists in the given subject.matches()regex, value, flag (iorm)Tests a regular expressiondate()datestring, formatdatestringandformatare both optional, provide them to the function if you want to convert a date string to date object.If these two arguments are left emtpy, the function returns date object with current date and time.date_modify()date, operation (+|-), valuetype (days|months|years), value:intThis function can add and subtract days, months and years from a date object.
Package: impermagit
Impermagit makes it easier to test python programs that use /
integrate with git.  For example:from impermagit import fleeting_repo

with fleeting_repo() as repo:
    # there is not a git repo created in a temporary dir
    # somewhere, allowing you to do things like:

    # add some files with some contents and commit them
    repo.commit([('test.txt', 'test contents\n'),
                 ('subdir/test2.txt', 'other contents\n')])

    # update contents
    repo.commit([('test.txt', 'new test contents\n')])

    # git rm files by passing None as contents
    repo.commit([('subdir/test.txt', None)])

    # run arbitrary git cmds in the repo when you don't care
    # about the output (will raise a GitExeException if it
    # fails)
    repo.do_git(["rm", "some-other-file.txt"])

    # run arbitrary git cmds in the repo and get back
    # stdout / stderr.
    with repo.yield_git(["log"]) as (out, err):
        print out.read()
        print err.read()

 # and here, the repo is gone and the temporary dir deleted.You can also create a Repo object directly, if you’d prefer to control
the lifecycle more closely:from imperagit import Repo

repo = Repo('/some/dir/you/manage')By default, Imperagit uses “/usr/bin/env git” as the git executable,
but this can be overridden with the git_exe arg to both fleeting_repo
and Repo.You can see more detailed docs with the interactive help:>>> import impermagit
>>> help(impermagit)Impermagit requires Python 2.6+, and has not been tested with Python
3.
Package: impersonation
A utility that allows a certain routine to run under a given user. To achieve this, a
process will run under theuidandgidof the intended user. For that
reason, it is a requirement that the running process hasSETUIDandSETGIDcapabilities.Featuresdecorator for instance methodsdecorator forclassmethodandstaticmethoddecorator for classesInstallationInstall the package directly fromPyPI(recommended):$pipinstall-UimpersonationExample usageA simple example on how to work with aFlaskapplication:fromimpersonationimportimpersonate# it works on functions@impersonate("username")defprinter(string):print(string)# ... and classes@impersonate("username")classPrinter:def__init__(self,prefix=""):self.prefix=prefixdefprinter1(self,string):print(f"{self.prefix}{string}")@staticmethoddefprinter2(string):print(string)Tests & linting 🚥Run tests withtox:# ensure tox is installed$toxRun linter only:$tox-elintOptionally, run coverage as well with:$tox-ecoverageLicenseMIT licensed. SeeLICENSE.
Package: impexpr
ImpexprA simple superset of Python with import expressions added in. Beware: This project has only been made as a proof of concept and is not intended to ever be used in production.InstallationpipinstallimpexprQuickstartimpexpralias can be used in the same way aspythonalias, a few examples:To run an interactive REPL with import expression support, runimpexprTo run a script, runimpexpr script.py(all imported modules will also support import expressions)To import itertools and use it in the same line:forxin(importitertools).chain([1,2],[3,4],[5,6]):print(x)To get help about collections.deque:help((importcollections).deque)If your script must run with python alias but you want to enable import expression support in all imported modules (not in the main script!), you can use:importimpexprimpexpr.add_hook()# this will now support import expressionsimportmy_other_scriptFor everything else, runimpexpr --helpFAQRelative imports not supported yet
Package: impfxxk
This is to be a project on modifyingsys.metapathand
making Pythonimportstatement as smooth as possible.InspirationThis idea was originally inspired from theBro/Zeeklanguage,
where it uses@loadstatement whatimportdoses in
Python, except that the@loadstatement takes a
relative path as its specifier. For example:@load ./sample_local.bro@load ../sample_parent.bro@load ../sample/child.browith the project structure as following:root
|-- foo
|   |-- this_script.bro
|   |-- sample_local.bro
|   |-- sample
|       |-- child.bro
|-- sample_parent.browhich means, the@loadstatement is always relative to
where it comes from, rather than aworking directoryorpackage rootas in Python.Thus, we intend to make the Pythonimportstatement
works just like@load. This is the back story of theimpfxxkproject.ExpectationWhen your project is as such:root
|-- foo
|   |-- this_script.py
|   |-- sample_local.py
|   |-- sample
|       |-- child.py
|-- sample_parent.pyNormally, you will want to do:import.sample_localimport.sample.childimport..sample_parentthere can be some issues when the Python interpreter tries
to figure out what is what when you are not running it at/root/foo/, where the relative paths are ought to be.However, withimpfxxk, you can simply add a statement
(it’s not decided yet) before your originalimportstatements, just like__future__does; and your code will
work just as you wish.
Package: impgraph
Import GrapherA simple python module to plot graph for module imports of a python project or a file.Requirements to runGraphvizinstalled on your system.How to use it?Basic usage:impgraph path_to_file_or_dirNote:Path can be either directory or an individual file.Graph does not include these folders: venv, __pycache__, .git, .vscode and .ideaFlags:Image-i/--image image_path: provide path to store image.Default image name:graph.pngExample:impgraph path_to_file_or_dir -i out.jpgLayout-l/--layout [neato|dot|twopi|circo|fdp|nop]: Describes graph layout.Default:neatoExample:impgraph path_to_file_or_dir -l fdpJSON-j/--json json_path: provide path to store json data.Default: No json file is stored.Example:impgraph path_to_file_or_dir -j data.jsonStandard Library-std-lib: Include standard (built-in python) libraries in graph.Help-h/--help: Display helpNote: By defaultstandard libraries are not includedin graph