Saravanan666/pypi-org huggingface dataset:
Package: ineedpy2
Find the latest Python 2 version installed on the system and if this
program is not running on that version, re-invoke it with that version.BackgroundOne of the problems of a system administrator is that enterprise Linux distros
which ship with, and often require, /usr/bin/python to be a fairly old versions.
For example, Python 2.1.  Applications can be very difficult to write such that
they are happy on Python 2.1 and Python 2.7.  Many of these distros include a
newer Python, but it has to be invoked as “python2.6”, for example.You can change the “#!” line in the script, but this makes packaging
more difficult.ExamplesTo make sure you are running on the absolutely latest installed Python 2 on
the system:import sys
print ‘Version:’, sys.version_info
import ineedpy2
ineedpy2.rerunonlatest()If run on a system with the default Python version being 2.1, but python
2.6 also installed will display:Version: (2, 1, 3, ‘final’, 0)
Version: (2, 6, 5, ‘final’, 0)NOTE: Anything run before the “runonlatestpy2” will be run once on the
older version and once on the newer version.You can also request the reinvocation only if the python minor version
isn’t at least a specific value.  In other words, “I know I need at least
Python 2.4”:from ineedpy2 import requireminor
requireminor(4)LicenseCopyright (c) 2011, Sean Reifschneider <jafo@tummy.com>, tummy.com, ltd.
Released under the Python Software Foundation License
For more information, see:http://docs.python.org/license.html
Package: inekf
Invariant Extended Kalman FilterInEKF is a C++ library with python bindings that implements the Invariant Extend Kalman Filter (InEKF) in a modular to enable easy application to any system.FeaturesSupport for Right & Left filters.Base classes provide easy extension via inheritance.Coded using static Eigen types for efficient structure.Fully featured python interface for use in classroom, prototyping, etc.C++14 and above supported.Fullly templated Lie Groups SO2, SO3, SE2, SE3 to enable additional tracking of Euclidean states and multiple extra columns in SE2/SE3.Dynamic Lie Groups types to add columns to SE2/SE3 on the fly (for InEKF SLAM and others).Various examples to get started.DocumentationTo get started, pleaseread the docs. We have attempted to thoroughly document everything, and it should be
fairly straightforward to get up and running. They have information on all of the following (and more!)InstallationGetting StartedMaking Custom ModelsFull API DocumentationStructureInEKF is split into a couple different librariesCoreThis library includes all the Lie Groups andInEKFclasses along with the base classesMeasureModelandProcessModel.InertialThis is the implementation of the Lie GroupSE_2(3)along with an augmented bias state. Along with it are various process/measurement models defined on this group including as of nowDVLSensor,DepthSensor, andInertialProcess.SE2ModelsExactly what it sounds like, is used for SLAM in SE2. Includes dynamic models that adjust as more landmarks are seen, including aGPSSensorandLandmarkSensor.ContributingThis is an open-source project and contributions are more then welcome. If any there are any features or bugs you'd like to report, please add then to theissue tracker. If you would like to contribute code, please feel free to fork, modify, and create a pull request.
Package: inelegant
“Inelegant” is a set of not very elegant tools to help testing. So far
there are nine packages:inelegant.net: the most important tools are the waiter functions.
inelegant.net.wait_server_down() will block until a port in a host is not
accepting connections anymore, and inelegant.net.wait_server_up() will
block until a port in the host will be ready for receiving data. There is
also inelegant.net.Server, that sets up a very dumb SocketServer.TCPServer
subclass for testing.inelegant.finder: contains the inelegant.finder.TestFinder class. It is a
unittest.TestSuite subclass that makes the task of finding test cases and
doctests way less annoying.inelegant.module: with inelegant.module.create_module(), one can create
fully importable Python modules. inelegant.module.installed_module() will
create and remove the importable module. There are other related functions.inelegant.process: home of inelegant.process.Process, a nice
multiprocessing.Process subclass that makes the process of starting,
stopping and communicating with a function in another process easier
enough.inelegant.fs: tools for file system operations. Most notably, context
managers to make such operations reverted. So, now once can “cd” into a
directory and be back to the original one, create a temporary file and have
it automatically deleted after the context, and the same with temporary
directories.inelegant.dict: it provides the temp_key() context manager. It adds a key
to a dictionary and, once its context is done, removes the key.inelegant.toggle: it provides the Toggle class. It is used to create
flags to enable global behaviors. A toggle is, indeed, something you would
rather avoid but may need.inelegant.io: tools to process standard input/output/error. Right now it
has four context managers: redirect_stdout() and redirect_stderr(), that
redirect the standard output and the standard error, respectively, to a
file, and suppress_stdout() and suppress_stderr(), that only discard
content written to these files.inelegant.object: currently, it has a context manager/decorator to
set and restore attributes.For more info, check the project page.
Package: inels-mqtt-new
Inels-mqttA Python library that handles communication with inels over mqttiNELSby ElkoEP company.PypiRequirementsFor smooth using you need to have Python 3.9 or higher.InstallUse PyPI repositorypip install inels-mqtt-devTestingI usetoxfor testing.$ pip install toxDevelopment statusSupported RF devicesSwitches (01, 02)Shutters (03, 21)Light dimmers (04, 05)RGB light (06)Switches with external temperature sensors (07)Wireless thermovalves (09)Temperature sensors (10)Thermostats (12)Flood detectors (15)Generic detector (16)Motion detector (17)Controllers/buttons (18, 19)Temperature and humidity sensors (29)Supported bus devicesSA3-01B (100)DA3-22M (101)GRT3-50 (102)GSB3-90Sx (103)SA3-02B (104)SA3-02M (105)SA3-04M (106)SA3-06M (107)SA3-012M (108)SA3-022M (109)FA3-612M (111)RC3-610DALI (114)IM3_20B (115)IM3_40B (116)IM3_80B (117)DMD3-1 (120)IM3-140M (121)WSB3-20 (122)WSB3-40 (123)WSB3-20H (124)WSB3-40H (125)GCR3-11 (128)GCH3-31 (129)GSP3-100 (136)GDB3-10 (137)GSB3-40SX (138)GSB3-60SX (139)GSB3-20SX (140)GBP3-60 (141)DAC3-04B (147)DAC3-04M (148)DCDA-33M (150)DA3-66M (151)ADC3-60M (156)TI3-10B (157)TI3-40B (158)TI3-60M (159)IDRT3-1 (160)JA3-018M (163)Virtual heating regulator (167)Virtual cooling regulator (168)
Package: inema
This is a python module for interfacing the “Internetmarke” API provided
by the German postal company “Deutsche Post”.  It implements V3 of this
API.  It also implements the new (2020) “Warenpost International API”.The Internetmarke API allows you to buy online franking for national and
international postal products like post cards and letters of all weight
classes and service classes (normal, registered, …).Internetmarke APIIn order to use the Internetmarke API (SOAP), you will need to be registered
with Deutsche Post for accessing the “1C4A Webservice”.  You can request
related details frompcf-1click@deutschepost.de.  Upon registration, you
will receive your individual parameters PARTNER_ID, KEY and KEY_PHASE.This module makes use of the fairly new “zeep” module for SOAP/WSDL.Warenpost International APIIn order to use the Warenpost International API (REST), you will need to
be separately registered with Deutsche Post for accessing that API.
Upon registration, you will have the following individual parameters,
which you must use when initializing the WarenpostInt() class:PARTNER_IDSCHLUESSEL_DPWN_PARTNER (same as KEY?)EKPKEY_PHASEPortokasseFurthermore, for actual payment of purchases made via both APIs, you
will need the user name (email address) and password to a “Portokasse”
account.Authors / Historypython-inema was originally developed by Harald Welte <hwelte@sysmocom.de>
for internal use at his company sysmocom, in order to provide franking
from the Odoo based logistics system.  Like most other software at sysmocom,
it was released as open source software under a strong network copyleft
license.Shortly after the initial release, Georg Sauthoff <mail@georg.so> joined
the development and improved and extended the code im various ways.  He
also added the command-linefrank.pytool.
Package: inept
ineptAn "interactiveeditable options" library for handling complex option hierarchies
from multiple sources (script, CLI, config files, ...).InstallationInstall inept with pippipinstallineptDocumentationThe documentation is available online :https://inept.rtfd.io/Take a look at thequick startfor a demo or at theroadmapto see where the project is heading.ContributingYou are welcome to help the project, seehow.Used ByThis project is used by the following softwares:https://github.com/BRGM/ComPASSLicenseGPLv3
Package: inequalipy
InequalipyGithub LinkPython Pip LinkGitHub Link for R versionInequalipy contains functions for the calculating the inequality of a distribution:Kolm-Pollak Equally-Distributed Equivalent (EDE) and IndexAtkinson EDE and IndexGini IndexThe Atkinson and Gini approaches are traditionally used for evaluating the inequality of income distribution. The Kolm-Pollak has recently been modified so that it is suitable for quantities that are undesirable, e.g., exposure to health risks or environmental burdens. This means it is suitable for use in urban planning contexts.The Kolm-Pollak functions are also separable, meaning they can be used to evaluate
subgroups and thus evaluate the inequity of the distribution.When using this code, please cite the following two papers:Sheriff, G., & Maguire, K. B. (2020). Health Risk, Inequality Indexes, and Environmental Justice.Risk Analysis: An Official Publication of the Society for Risk Analysis.https://doi.org/10.1111/risa.13562Logan, T. M., Anderson, M. J., Williams, T. G., & Conrow, L. (2021). Measuring inequalities in urban systems: An approach for evaluating the distribution of amenities and burdens. Computers, Environment and Urban Systems, 86, 101590.https://doi.org/10.1016/j.compenvurbsys.2020.101590This library contains the following functions:kolmpollak.ede(a, epsilon, kappa, weights)for calculating the Kolm-Pollak equally-distributed equivalent (EDE)kolmpollak.index(a, epsilon, kappa, weights)for calculating the Kolm-Pollak inequality indexatkinson.ede(a, epsilon, weights)for calculating the Atkinson equally-distributed equivalentatkinson.index(a, epsilon, weights)for calculating the Atkinson inequality indexgini(a, weights)for calculating the Gini indexUsageInstallationpip install inequalipyUsageImport the package and call the required function:import inequalipy as ineq  
ineq.kolmpollak.ede(a, epsilon, weights)
ineq.gini(a)Alternatively, you may import all of the packages:from inequalipy import *
gini(a)
atkinson.index(a)ExamplesCheck out example.ipynb for examples orhttps://github.com/MitchellAnderson112/access_inequality_indexfor the function applied in a non-trivial context.
Package: inequality
Spatial Inequality  Analysis in PySALMethods for measuring spatial inequality.InstallationInstall inequality from PyPI by running:$ pip install inequalityInstall inequality from conda-forge by running:$ conda install -c conda-forge inequalityRequirementslibpysalnumpyscipyContributePySAL-inequality is under active development and contributors are welcome.If you have any suggestion, feature request, or bug report, please open a newissueon GitHub. To submit patches, please follow the PySAL developmentguidelinesand open apull request. Once your changes get merged, you’ll automatically be added to theContributors List.SupportIf you are having issues, please talk to us in thegitter room.LicenseThe project is licensed under theBSD license.FundingAward #1421935New Approaches to Spatial Distribution Dynamics
Package: inequality-coefficients
Inequality Coefficients:This is small library with some implemented coefficients (or indices)
intended to measure inequality or concentration of the values in a
population.Implemented coefficientsGini Coefficient:Ordinary. Follows this formula:Corrected. Uses a correction for small datasets based onDeltas,
2003.Ratio top / rest. Follows this formula:Where k is is the ceil value for 100 - percentage you define.
For instance, if you take k = 10, you are getting the ratio of inequality between the top 10% percentage and the rest 90% percentage. In particular, this specific value of k is given to you directly by theratio_top10_rest()function.InstallationThis library is hosted on PyPI, so installation is straightforward. The
easiest way to install type this at the command line (Linux, Mac, or
Windows):pip install inequality_coefficientsThis library also depends on numpy, butpipshould take of that for
you already.Basic UsageFor the simplest, typical use cases, this tells you everything you need
to know.:import inequality_coefficients as ineq
data = array([1.7, 3.2 ...]) # data can be list of nums or numpy array
gini_coeff = ineq.gini(data)
ratio_top_rest = ineq.ratio_top10_rest(data)DevelopmentTo setup the development environment install all the dev dependiencies withpip install -r requirements.txtand install the latest version in your sites-packages withpython setup.py develop.Run testsI use pytest. Install it withpip install -U pytestand run the test with the development setup withpytest.AcknowledgementsFirstly, I was based on Felipe Ortega's wikixray code for implementing the gini coefficient, however, my code has changed so much (I have even fixed a bug in his code) and also now I'm using numpy as backend.Anyway, I want to thank him for open sourcing that project.
Package: inetnums
Tool for building the tree of [inetnums](https://www.ripe.net/manage-ips-and-asns/db/support/documentation/ripe-database-documentation/rpsl-object-types/4-2-descriptions-of-primary-objects/4-2-4-description-of-the-inetnum-object) (WHOIS IPv4 intervals).
Works on CPython3. Usage:` pip3 install inetnums inetnums-oinetnums.pickle `Released under MIT License. Copyright © 2016 Mail.Ru Group LLC.
Package: inetsix-config-builder
Configuration BuilderProvide python script to render templates based on :Python 2.7 & 3.xJinja2YamlInstallationScripts can be installed with pip:$pipinstallinetsix-config-builderFor latest version (dev)$pipinstallgit+https://github.com/titom73/inetsix-config-builderUsageUsage is like below:$inetsix-config-builder-htgrimonet@tgrimonetusage:inetsix-config-builder[-h][-yYAML][-tTEMPLATE][-bBASE][-oOUTPUT][-ofOUTPUT_FORMAT]ConfigurationBuilderoptionalarguments:-h,--helpshowthishelpmessageandexit-yYAML,--yamlYAMLProvidesYAMLfiletofillJinja2template,default=dict.yml-tTEMPLATE,--templateTEMPLATEtemplatefile,default=./template.j2-bBASE,--baseBASEBasetoconstructfilename,default=generated-conf--oOUTPUT,--outputOUTPUTDirectorytostoreconfiguration,default.-ofOUTPUT_FORMAT,--output_formatOUTPUT_FORMATFileextension,default:.conf
Package: inewave
inewaveOinewaveé um pacote Python para manipulação dos arquivos de entrada e saída do programaNEWAVE. O NEWAVE é desenvolvido peloCEPELe utilizado para os estudos de planejamento e operação do Sistema Interligado Nacional (SIN).O inewave oferece:Meios para leitura dos arquivos de entrada e saída do NEWAVE e programas associados: NWLISTCF e NWLISTOPFacilidades para estudo e análise dos dados utilizando DataFrames do pandasDados estruturados em modelos com o uso do paradigma de orientação a objetos (OOP)InstalaçãoO inewave é compatível com versões de Python >= 3.8.É possível instalar a versão distribuída oficialmente com pip:python -m pip install inewaveÉ possível realizar a instalação da versão de desenvolvimento fazendo o uso do Git.pip install git+https://github.com/rjmalves/inewaveDocumentaçãoGuias, tutoriais e as referências podem ser encontrados no site oficial do pacote:https://rjmalves.github.io/inewave
Package: inexactsearch
This is aFuzzy string searchapplication. This application illustrates the combined use ofEdit
distanceandIndic Soundexalgorithm.By mixing both written like(edit distance) and sounds like(soundex),
we achieve an efficient aproximate string searching. This application
is capable of cross language string search too. That means, you can
search Hindi words in Malayalam text. If there is any Malayalam word,
which is approximate transliteration of hindi word, or sounds alike
the hindi words, it will be returned as an approximate match. The
“written like” algorithm used here is a bigram average algorithm.  The
ratio of common bigrams in two strings and average number of bigrams
will give a factor which is greater than zero and less
than 1. Similarly the soundex algorithm also gives a weight. By
selecting words which has comparison weight more than the threshold
weight(which 0.6), we get the search results.
Package: inex-nats-bridge-client
Проект Python-клиента для dmz-nats-bridgeИспользованиеДля использования клиентского модуля необходимо:Скопировать файл bridge_client.py в основной проектВ основной проект установить библиотекуpipenv install nats-pythonПример кода:frombridge_clientimportBridgeClient,BridgeResponse,BridgeRequestimportloggingclassSampleOneRequest(BridgeRequest):def__init__(self):super().__init__()self.Name:str=''one=SampleOneRequest()one.Name="Вася"logger=logging.getLogger()client=BridgeClient(logger,'nats://nats-client.k8s.vitebsk.energo.net:4222',10)result:dict=client.send_and_recive('sample.one',one)
Package: inface-dl
Example Code:>>> # instagram video downloader
>>> import inface-dl
>>> ses = inface-dl.Session()
>>> ses.ig(url='url here', output='output.mp4')>>> # facebook video downloader
>>> import inface-dl
>>> ses = inface-dl.Session()
>>> ses.fb(url='url here', output='output.mp4')
Home-page: https://github.com/anonkyuhuu/inface-dl
Author: sCuby07
Author-email: ajaanonk@gmail.com
License: MIT
Download-URL: https://github.com/user/reponame/inface-dl.tar.gz
Description: UNKNOWN
Keywords: download,python,video
Platform: UNKNOWN
Classifier: Development Status :: 3 - Alpha
Classifier: Intended Audience :: Developers
Classifier: Topic :: Software Development :: Build Tools
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.4
Classifier: Programming Language :: Python :: 3.5
Classifier: Programming Language :: Python :: 3.6
Package: infapy
Infapy is the Informatica Intelligent Cloud Services Software Development Kit (SDK)
for Python, which allows Python developers to write software that makes use
of services like Informatica CDI, Informatica Cloud Administrator, Informatica Cloud Monitor,
Informatica CAI etc. You can find the latest, most
up to date, documentation at ourdoc site, including a list of
services that are supported.Getting Started$pipinstallinfapyUsing InfapyAfter installing infapy>>>importinfapy>>>infapy.encrypt()Enteryourusername:myInfaUserEnteryourpassword:myInfaPasswdinfa_access_key_id={youraccesskeyid}infa_secret_access_key={yoursecretaccesskey}Next, set up credentials (in e.g.~/.infa/credentials):[default]infa_access_key_id=YOUR_KEYinfa_secret_access_key=YOUR_SECRET[dev]infa_access_key_id=YOUR_KEYinfa_secret_access_key=YOUR_SECRETThen, set up a default region (in e.g.~/.infa/config):[default]region=us[dev]region=emThen, from a Python interpreter:>>>importinfapy>>>infaHandler=infapy.connect()or>>>infaHandler=infapy.connect(profile="dev")>>>v3=infaHandler.v3()>>>securityLogs=v3.getSecurityLogs().getSecurityLogsForLastOneDay()>>>print(securityLogs)Getting HelpWe use GitHub issues for tracking bugs and feature requests and might have limited
bandwidth to address them. Please use these community resources for getting
help:Ask a question onStack Overflowand tag it withinfapyIf it turns out that you may have found a bug, pleaseopen an issueContributingWe value feedback and contributions from our community. Whether it’s a bug report, new feature, correction, or additional documentation, we welcome your issues and pull requests.Maintenance and Support for SDK Major VersionsInfapy was made generally available on 25-Sep-2021 and is currently in the full support phase of the availability life cycle.More ResourcesLicense
Package: infdata
# infinity-dataThis is a simple package that helps read Infinity data format and get data in such format.## Quick start### Get dataJust `pip install infdata`, and start getting data.For example,```$ inf pull example.com/posts==crawler-1.0.0```pulls records that are posts from `example.com/posts`, `crawler-1.0.0` version.### Publish data```$ int init                     # initiates folder .inf/$ inf login                    # saves token to .inf/config$ inf search example.com/posts # searches for dataset versions$ inf push file.json           # uploads Infinity JSON or JSON-L data to specified infinity server```**Note:** the tokens `['example.com/posts', 'crawler-1.0.0']` together define a unique `[source-specific, crawler-specific]` schema.# Infinity JSONInfinity JSON format includes a header line, which specifies schemas (`[S]`) and types (`[T]`) for its records.Example:```[{'': [[S],[T], 'x': [[S],[T]], 'y': [{'': [[S],[T]], 'z': [[S],[T]]}]},{'x': '1,330.98', 'y': [{'z': 1}, {'u': 2}]},{'x': '2,011.19', 'y': [{'z': 4}, {'u': 3}]},]```The schemas, types specification for the empty string key `''` specifies the schema and type for the records themselves (required in every level separated by curly braces), whereas the rest of keys specify schemas and types for the data accessible via the keys.This way, if we want to specify, that the `x` must be casted to a `float`, and means the [elevation](https://www.wikidata.org/wiki/Q2633778), we can do:```[{'': [], 'x': {'': [['str'],['https://www.wikidata.org/wiki/Q2633778']]}},{'x': '1,330.98', 'y': [{'z': 1}, {'u': 2}]},{'x': '2,011.19', 'y': [{'z': 4}, {'u': 3}]},]```If you want to additionally, add conversion rules, you can include lambda expression after the final type:```[{'': [], 'x': {'': [['float', "lambda x: x.replace(',','')"],['https://www.wikidata.org/wiki/Q2633778']]}},{'x': '1,330.98', 'y': [{'z': 1}, {'u': 2}]},{'x': '2,011.19', 'y': [{'z': 4}, {'u': 3}]},]```This way, the final data becomes:```from inf import normalizenormalize([{'x': [['float', "lambda x: x.replace(',','')"],['https://www.wikidata.org/wiki/Q2633778']]},{'x': '1,330.98', 'y': [{'z': 1}, {'u': 2}]},{'x': '2,011.19', 'y': [{'z': 4}, {'u': 3}]},])```Result is:```[{'Q2633778': 1330.98, 'y': [{'z': 1}, {'u': 2}]},{'Q2633778': 2011.19, 'y': [{'z': 4}, {'u': 3}]},]```# Infinity CSVSometimes we want to include schema and type (`S`, `T`) into CSV. In that case, we use `|` to separate them:```Column Name|S|T,```For example:```Name||,Surname||,```If we want to enforce some rules, we could do then:```Name|str|https://www.wikidata.org/wiki/Q82799,Surname|str,lambda x: x[:10]|https://www.wikidata.org/wiki/Q101352,```
Package: infect-net-inference
InfectionThis package will allow you to create a credible set for the patient zero given a set of infected nodes on a graph.InstallationRun the following to install:pipinstallinfect-net-inferenceUsagefrominfect_tools_noisy_convimport*# Simulate an infection on graf. Outputs a list containing the infected nodes in the order they were infectedorder=simulateInfection(graf,first,n_inf,q)# Create a dict mapping each node index to the posterior root probabilityfreq=inferInfection(foo,q,**mcmc_params)