Saravanan666/pypi-org huggingface dataset:
Package: irkit
# IRKit api interface for python## What is IRKit?That is kind of a learning remote control system which has HTTP API interface.Details is http://getirkit.com/## install```bash$ pip install irkit```## Command Usage```usage: irkit [-h] {local,internet} ...IRKit CLI Client for Python. v0.0.1 See also http://getirkit.com/#IRKit-Device-APIpositional arguments:{local,internet}  sub-command helplocal           api for locals.internet        api for internets.optional arguments:-h, --help        show this help message and exit```Local API:```usage: irkit local [-h] [--host] [-k] [-r] [--save signal-name] [-l][-s signal-info] [-v]optional arguments:-h, --help            show this help message and exit--host                show irkit host-k, --keys            get a client token.-r, --retrieve        retrieve a signal--save signal-name    you should appoint a name. save retrieved signal to~/.config/irkit-py/signal.json with name-l, --list            list of stored signals-s signal-info, --send signal-infosend a signal. that excepted as json response orraw_data or key name of store-v, --verbose         put verbose logs```Internet API:```usage: irkit internet [-h] [-r] [-s signal-info] [--save signal-name][-c CLIENT_KEY] [-d DEVICE_ID] [-v]optional arguments:-h, --help            show this help message and exit-r, --retrieve        retrieve a signal-s signal-info, --send signal-infosend a signal. that excepted as json response orraw_data or key name of store--save signal-name    you should appoint a name. save retrieved signal to~/.config/irkit-py/signal.json with name-c CLIENT_KEY, --client-key CLIENT_KEYclient key-d DEVICE_ID, --device-id DEVICE_IDdevice id-v, --verbose         put verbose logs```### Examplecopy and paste style```bash## you must send signal to IRKit before$ irkit local --retrieve{"freq": 38, "data": [... ...], "format": "raw"}## copy and paste the json$ irkit local --send '{"freq": 38, "data": [... ...], "format": "raw"}'```store with key```bash$ irkit local --retrieve --save toggle-room-light{"freq": 38, "data": [... ...], "format": "raw"}$ cat ~/.config/irkit-py/signal.json{"freq": 38, "data": [... ...], "format": "raw"}$ irkit local --send movie-room-toggle```#### Internet APIThen you want to send internet API, you need to appoint device_id or client_key or both.```bash## retrieve needs client key$ irkit internet --retrieve --client-key YOUR_CLIENT_KEY## send needs client key and device id$ irkit internet --send '{"freq": 38, "data": [... ...], "format": "raw"}' \-c 0A9B3FFB240444A2BA70A9835BFE4F89 \--device-id 6B08F5EA443E4983864908B4AFF897AA```This tool haven't follow client-key and device-key smart integration (it can only get {*see --key option*}).It'll be implemented next version (and I welcome to your contlibute!).## as LibraryYou can also use as api.Document is now writing... but `main.py` will help you to understand API interfaces.## Support Versions- 2.7- 3.6 (might unstable)## Bug report or request or somethingGitHub issue is opend ;)https://github.com/hachibeeDI/IRKit/issues
Package: irl
irlirlis a URL parser library that has a mixture of very strict rules around
a URL's host and port section but very relaxed in all other sections making it
the ideal balance of secure, tolerant, and performant.It's primary use-case is for being used in HTTP client libraries as they have
to deal with the Internet and lots URLs that are definitely not compliant but
users expect them to work anyways!InstallationSupports Python 3.6 or later.python -m pip install irlUsage>>>importirl>>>url=irl.URL.parse("https://user:pass@example.com:1234/path?q=ue&r=&y#frag")>>>print(repr(url))URL(scheme="https",userinfo="user:pass",host="example.com",port=1234,path="/path",query="q=ue&r=&y",fragment="frag")>>>url.target()b"/path?qu=e&r=&y">>>url.host_header()b"example.com:1234">>>url.query_to_items()[("q","ue"),("r",""),("y",None)>>>url.address()("example.com",1234)Standards ImplementedRFC 3986RFC 3987RFC 4007RFC 6874AcknowledgementsThis URL parser library wouldn't be possible without therfc3986library
or the test suite fromurllib3.  This parser is based
heavily on techniques used in both libraries and they directly inspired this libraries creation.LicenseMIT
Package: ir-ldr-mingjie
ir_ldrThe packageir_ldris for measuring the spectral line depth of the APOGEE and WINERED spectra, calculating the line depth ratio (LDR) and finally deriving the effective temperature (T_LDR).The LDR-Teff relations inside this package are fromJian+19,Taniguchi+18and Jian+20a (in prep.). Please also refer toFukue+15.This package relys onnumpy,pandas,matplotlibandscipy; it is based on python 3.Installationpip install ir_ldrTutorialThe synthetic spectra of a dwarf star (Teff=5000 K, logg=4.5 dex and feh=0 dex; generated from MOOG) inir_ldr/file/dwarffor an example of T_LDR calculation.# Load the linelist.linelist=ir_ldr.load_linelist('yj','dwarf-j20a')# Here we use all the orders of synthetic spectra.fororderin[43,44,45,46,47,48,52,53,54,55,56,57]:# Load the synthetic spectraspec=pd.read_csv(ir_ldr.__path__[0]+'/file/example_spectra/dwarf/order{}.txt'.format(order),sep=' +',skiprows=2,engine='python',names=['wav','residual'])wav=spec['wav'].valuesresidual=spec['residual'].values# Select the line pairs for a specific orderlinelist_sub=linelist[linelist['order']==order]iflen(linelist_sub)==0:continuelinelist_sub.reset_index(drop=True,inplace=True)# Measure the line depth of low(1)- and high(2)-EP line.# Here the signal to noise ratio for the target star and telluric standard are# manually set as 300, but the S_N of synthetic spectra is much higher than that.d1=ir_ldr.depth_measure(wav,residual,linelist_sub['linewav1'],suffix=1,S_N=[300,300])d2=ir_ldr.depth_measure(wav,residual,linelist_sub['linewav2'],suffix=2,S_N=[300,300])# Calculate the logLDR value.lgLDR=ir_ldr.cal_ldr(d1,d2,type='lgLDR')# Combine the Dataframes of one order.record=ir_ldr.combine_df([linelist_sub,d1,d2,lgLDR])iforder==43:record_all=recordelse:record_all=pd.concat([record_all,record],sort=False)# Calculate T_LDRLDR=ir_ldr.ldr2tldr_winered_solar(record_all,df_output=True)And the result(T_LDR, T_LDR_err)is:LDR[0:2]>>>(5009.857201559249,22.35966233607925)# Note the T_LDR_err is not an accurate estimation here since the S_N is manually set.AuthorMingjie Jian (ssaajianmingjie@gmail.com)PhD student, Department of Astronomy, the University of Tokyo
Package: irl-maxent
Maximum Entropy Inverse Reinforcement LearningThis is a python implementation of the Maximum Entropy Inverse Reinforcement Learning (MaxEnt IRL) algorithm based on the similarly named paper by Ziebart et al. and the Maximum Causal Entropy Inverse Reinforcement Learning (MaxCausalEnt IRL) algorithm based on his PhD thesis.You may also want to have a look at the accompanyingpresentation.For an example demonstrating how the Maximum (non-causal) Entropy IRL algorithm works, see the corresponding Jupyter notebook (notebooks/maxent.ipynb).
Note that this python package contains a slightly more optimized implementation of the algorithms.For an example on how to use this framework, have a look at theexample.pyfile.
The framework contains:Two GridWorld implementations for demonstration (irl_maxent.gridworld)The algorithm implementations (irl_maxent.maxent)A gradient based optimizer framework (irl_maxent.optimizer)Plotting helper functions (irl_maxent.plot)A MDP solver framework, i.e. value iteration and corresponding utilities (irl_maxent.solver)A trajectory/trajectory generation framework (irl_maxent.trajectory)
Package: i-rly-like-lemons
how to use:sentiment analysis:from i_rly_like_lemons import sentiment

1: get_sentence_sentiment("your sentence here")   <--   returns a single number which is the sentence's sentiment.

2: get_text_sentiment("i really like lemons, however pineapples are also good. and this is another sentence.")   <---   returns a list of all sentiments from the sentences.meaning extraction:from i_rly_like_lemons import meaning

1: word_to_index("word")   <---   returns the "meaning index" of a single word.

2: index_to_word(912873)   <---   gets the "meaning index" of a word, and translates the index into the word.

3: sentence_to_index("your sentence here")   <---   gets a sentence and returns the list of all meaning indexe's of the words inside.

4: index_to_sentence([129038, 238745, 39874,... 93824])   <---   gets a list of meaning indexe's and returns a sentence.keyword detection:from i_rly_like_lemons import keywords

1: detect_keywords("your sentence here")   <---   will get a text prompt and return a list with all the keywords that it found.extras:from i_rly_like_lemons import extras

1: cleanup("you,r co<<rupte///d [tex]t he.re")   <---   will get text and clean it up from unwanted characters (all special characters).

2: split_with_multiple_seperators("|", ",", " ", text = "this|is,a test")   <--- just like normal split(" ") command but supports multiple seperators.

3: rephrase([238094, 78245, 879435, 38490], 2)   <--- takes in a meaning list (from meaning extraction) and randomizes them with the "strength" value.

4: compare("word1", "werd2")   <--- gets two strings and returns the % of their match: 0% > no matching characters, 100% > identical strings.

5: autocorrect_word("misspled")   <--- gets a word and autocorrects it

6: autocorrect_text("ths si a misppled txte")   <--- gets a wrond text and autocorrects it
Package: ir-metric
ir_metricsOverviewir_metrics is a Python package designed to facilitate information retrieval (IR) metric calculations. It provides a simple and convenient way to compute various metrics commonly used in IR evaluation.InstallationInstall the package using pip:pip install ir_metricQuick StartTo use ir_metrics, import the metric module and call the desired metric function. Here's a quick example of computing the average precision:from ir_metric import metric

# Example data
actual_ranking = [1, 2, 3]
predicted_ranking = [5, 3, 1]

# Compute average precision at k=2
result = metric.average_precision_at_k(actual_ranking, predicted_ranking, k=2)

print(result)  # Output: 0.25Available MetricsCurrently, ir_metrics supports the following metrics:Average Precision (average_precision_at_k)Precision at k (precision_at_k)Recall at k (recall_at_k)ContributionsContributions and bug reports are welcome! Feel free to open issues or submit pull requests on the GitHub repository: [https://github.com/harshkumarchourasia/ir_metric]LicenseThis project is licensed under the MIT License.
Package: ir-metrics
A set of the most common metrics in used in information retrieval.UsageThe metrics are designed to work for array-like structures and integers:>>>fromirmetrics.topkimportrr>>>y_true="apple">>>y_pred=["banana","apple","grapes"]>>>rr(y_true,y_pred)0.5The same function works also for the matrix-like structures:>>>importnumpyasnp>>>fromirmetrics.topkimportrr>>>y_trues=np.repeat(y_true,128)>>>y_preds=np.repeat([y_pred],128,axis=0)>>># Calculate the Mean Reciprocal Rank>>>rr(y_trues,y_preds).mean()0.5>>># Calculate the standard deviation for Reciprocal Ranks>>>rr(y_trues,y_preds).std()0.0Check thedocsfor more examples.InstallationTo install with pip, run:pipinstallir-metrics
Package: irmin
irmin-pyirminbindings for PythonThis crate enables you to call directly into irmin from your Python application and
can be used to open an existing irmin store from Python that may have been created
by an application written in OCaml.Dependenciescffipytest(for testing)InstallationAfter installinglibirminusing opam, you can run:$ pip3 install irmin --userTo install the development version:$ pip3 install git+https://github.com/mirage/irmin-py.git --userOr from the root of the project:Using pip:$ pip3 install . --userUsing poetry:$ POETRY_VIRTUALENVS_CREATE=false poetry installAnd the build script should be able to find the location of thelibirminlibrary and header files.Iflibirmin.soandirmin.hwere not installed using opam and they're not in~/.localor/usr/local, then you can specify where to look for them using theLIBIRMIN_PREFIXenv
variable.TestingRun the tests:$ poetry run pytest
Package: irmlearn
irmlearn is a algorithms for Infinite Relational Model.DependenciesThe required dependencies to use irmlearn are,scikit-learnnumpyscipyYou also need matplotlib, seaborn to run the demo and pytest to run the tests.installpipinstallirmlearnUSAGEWe have posted a usage example in the github’s demo folder.LicenseThis code is licensed under MIT License.Testpythonsetup.pytest
Package: irnl-rdt-correction
IRNL RDT CorrectionPerforms local correction of the Resonance Driving Terms (RDTs)
in the Insertion Regions (IRs) based on the principle described in[1]with the addition of correcting
feed-down and using feed-down to correct lower order RDTs.
Details can be found in[2].DocumentationThe note containing background, derivation and implementation details can be found in the attachednote.Autogenerated docs viaSphinxcan be found athttps://pylhc.github.io/irnl_rdt_correction/.InstallingThis package isPython 3.7+compatible, and can be installed throughpip:python-mpipinstallirnl-rdt-correctionAfter installing, scripts can be run with eitherpython -m irnl_rdt_correction --FLAG ARGUMENTor by calling the Python files directly.For development purposes, we recommend creating a new virtual environment and installing from VCS in editable mode with all extra dependencies:gitclonehttps://github.com/pylhc/irnl_rdt_correction
python-mpipinstall--editable"irnl_rdt_correction[all]"Main Scriptirnl_rdt_correction.py- Script to compute RDT correction in the (HL)LHC IRs including feed-down effects.LicenseThis project is licensed under theMITLicense - see theLICENSEfile for details.References[1]:
O. Bruening et al.,
Dynamic aperture studies for the LHC separation dipoles. (2004)https://cds.cern.ch/record/742967[2]:
J. Dilly and R. Tomás,
A flexible nonlinear Resonance Driving Term based Correction Algorithm with feed-down. (2022)note.pdf
Package: irods-fsspec
irods_fsspecAllows you to open files from iRODS servers usingirods://URLs infsspec.UsageImplicit authenticationIf you already have the iRODS iCommands, log in withiinitto store your username and password. Subsequent use of irods_fsspec will use those credentials automatically. (You may also set$IRODS_ENVIRONMENT_FILEin your shell to point to anirods_environment.json.)importfsspecimportirods_fsspecirods_fsspec.register()# register irods:// handler# Write to iRODS pathf1=fsspec.open('irods://data.cyverse.org/iplant/home/myuser/test.txt','wb')withf1asfh:fh.write(b'test\n')# Read from iRODS pathf2=fsspec.open('irods://data.cyverse.org/iplant/home/myuser/test.txt','rb')withf2asfh:assertfh.read()==b'test\n'Explicit authenticationThe user, zone, password, and port can all be included in the URL, bypassing the need foriinit/ iCommands:f3=fsspec.open('irods://myuser+iplant:mypass@data.cyverse.org:1247/iplant/home/myuser/test.txt','rb')withf3asfh:assertfh.read()==b'test\n'The format looks like this:irods://<username>+<zone>:<password>@<hostname>[:<port>]/<path to data object>Note the+to separate user name from the zone name. irods_fsspec will use the default port if:<port>is omitted, but all other components are required.Filesystem API usageTo use theIRODSFileSystemAPI, either import it yourself or use fsspec:irodsfs=fsspec.filesystem('irods',user='myuser',zone='iplant',password='mypass',host='data.cyverse.org',port=1247)irodsfs.mkdir('/iplant/home/myuser/_irods_fsspec_test/')irodsfs.mv('/iplant/home/myuser/test.txt','/iplant/home/myuser/_irods_fsspec_test/test2.txt')f4=irodsfs.open('/iplant/home/myuser/_irods_fsspec_test/test2.txt','rb')withf4asfh:assertfh.read()==b'test\n'
Package: irods-shell
ISHELL(Irods in a nutSHELL)DescriptionISHELLis a UNIX shell like client foriRODS.  It is written in pure Python,
encapsulating thepython-irodsclient. It provides similar
functionalities than theirods-icommandspackage but
following a different strategy. Instead of prefixing UNIX like commands ISHELL
simulates an ssh connection to an iRODS server. From there, the usual UNIX
syntax can be used, e.g.cd,ls,mkdir,rm, ...Notethat the current version is very preliminary.InstallationFromPyPi, e.g. usingpip:pipinstall--userirods-shellAlternatively, you can also clone thesourceand runpython setup.py install --user. Note that you'll needpython-irodsclientto be installed first.DocumentationThe ISHELL package currently exports two executables:iinitandìshell.
You might need to add their install location to yourPATH.Theiinitexecutable is provided as a partial replacement to the standard
one, from irods-icommands. It allows to encode your iRODS password in order
to authenticate. You'll also need to configure yourirods_environment.jsonfile. Note that currently this is the only supported mode of authentication.Theishellexecutable simulates an ssh connection to your iRODS server.
Once connected you can typehelpfor a list of the supported commands.
Alternatively it can also be run in interpreted mode, e.g.ìshell -c "cd ..; ls"or reading from a script file, e.g.ìshell script.ish.LicenseTheISHELLpackage is under theGNU LGPLv3license. See the
providedLICENSEandCOPYING.LESSERfiles.
Package: iroh
Iroh PythonThis is theIrohpython api!The api was generated usinguniffi-rs.All iroh classes, methods, functions, and enums contain docstrings.The current best way to understand how the iroh python api can be used is to check out ourtests.We currently ship binary wheels on pypi for:amd64 winx86_64 manylinux2014aarch64 manylinux2014arm64 maxosxx86_64 maxosxIf you need another platform you will have to build from source using the repository athttps://github.com/n0-computer/iroh-ffi/
Package: iroha
Python library for Hyperledger IrohaThis is a source repository for HL Iroha Python library.Currently, latestHL Iroha release 1.5is supported. It can be ussed with one of official docker images:hyperledger/iroha:latesthyperledger/iroha-burrow:latestwith Hyperledger-Burrow support (smart contracts).The library works in Python 3 environment (Python 2 is not supported).InstallationpipinstallirohaUsage ExamplefromirohaimportIroha,IrohaCrypto,IrohaGrpciroha=Iroha('alice@test')net=IrohaGrpc('127.0.0.1:50051')alice_key=IrohaCrypto.private_key()alice_tx=iroha.transaction([iroha.command('TransferAsset',src_account_id='alice@test',dest_account_id='bob@test',asset_id='bitcoin#test',description='test',amount='1')])IrohaCrypto.sign_transaction(alice_tx,alice_key)net.send_tx(alice_tx)forstatusinnet.tx_status_stream(alice_tx):print(status)Please exploreexamplesdirectory for more usage examples.All the library methods have docstrings in its sourceiroha.py.The links above are broken outside thehyperledger/iroha-pythonGitHub repository.If you are interested in different HL Iroha client libraries you can check ourWiki.
Package: iroin-python-pptx
Copyright (c) 2013 Steve Canny,https://github.com/scannyPermission 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: Some Text
Keywords: powerpoint ppt pptx office open xml
Platform: UNKNOWN
Classifier: Development Status :: 4 - Beta
Classifier: Environment :: Console
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 2
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.6
Classifier: Topic :: Office/Business :: Office Suites
Classifier: Topic :: Software Development :: Libraries
Package: iromeku
Iromeku色めく (hiragana いろめく, rōmaji iromeku) 1. to become lively 2. to become roused 3. to look arousingIromeku is a library to extract a colour palette from a given image.The implementation is heavily inspired by the Stack Overflow answer here:The way it works is by clustering similar colours together, based on the
Euclidean distances of the pixel's value in the YUV colour space, which more
closely approximates colour perception.Getting Started$pipinstalliromekufromiromekuimportload_image,generate_clusters,get_dominant_colourrgb_values=load_image("test.jpg")clusters=generate_clusters(rgb_values,0.1)colour=get_dominant_colour(clusters)print(colour.r,colour.g,colour.b)0.1in the second argument ofgenerate_clustersrefers to the threshold under which we consider two colours to be similar. Try adjusting the threshold for different results.ContributingThe library is type hinted using the comment-based syntax for backward compatibility with Python 2. Tests are run using tox.TODOAdd example imagesAdd support for generating complimentary coloursAdd support for selective sampling (e.g borders + center)Improve clustering algorithmLicenseMIT License
Package: ironbot
ironbotRequirementsironbotdepends on Python 3.9 or newer, and onCamelot, which requiresghostscript.Install$pipinstallironbotUsage$ironbot--helpUsage: ironbot [OPTIONS] COMMAND [ARGS]...Options:--install-completion [bash|zsh|fish|powershell|pwsh]Install completion for the specified shell.--show-completion [bash|zsh|fish|powershell|pwsh]Show completion for the specified shell, tocopy it or customize the installation.--help                          Show this message and exit.Commands:calendar     List the details of the upcoming Ironman professional races.start-list   Gets the start list for an Ironman professional race (use...start-lists  List upcoming Ironman professional races with start list...ExemplesDetails of upcoming Ironman professional races$ironbotcalendar2023-06-04	IRONMAN Hamburg - MPRO European Championship	$75,000	5MPRO	CLOSED	CLOSED2023-06-10	IRONMAN 70.3 Boulder	$50,000	2MPRO/2WPRO	CLOSED	CLOSED2023-06-11	IRONMAN 70.3 Warsaw	$15,000	2MPRO/2WPRO	CLOSED	CLOSED…List events with start list available$ironbotstart-listsChoose one of the followign events to use with `start-list` command:[1] 2023 IRONMAN European Championship Hamburg[2] 2023 IRONMAN 70.3 Boulder…Get the start list of an event$ironbotstart-list41	Daniela Ryf	CHE (Switzerland)3	Ashleigh Gentle	AUS (Australia)4	Anne Reischmann	DEU (Germany)…ContributingMake sure that all tests pass:$poetryrunpytest