Saravanan666/pypi-org huggingface dataset:
Package: ironman
What is Ironman?Ironman is a general purpose software toolbox to be run on L1Calo
hardware with embedded processors (SoCs).Look how easy it is to use>>>importironman>>># Get your stuff done>>>ironman.engage()FeaturesBe awesomeMake things fasterGetting StartedInstallingInstall ironman by runningpip install ironmanDevelopingIf it is your first time…git clone git@github.com:kratsg/ironman
cd ironman && mkvirtualenv ironman
pip install -r requirements.txtand then afterwards…workon ironman
python setup.py develop
... do work here ...
pip uninstall ironmanTestingtoxor withpy.testContributingIssue TrackerSource CodeSupportIf you are having issues, let us know.ReleasingDo some work on your package (i.e. fix bugs, add features, etc)Make sure the tests pass. Runpytest.Update the__version__number viabump2version.Push to the default branch.TutorialSince we will be predominantly using Twisted within the Zynq to manage
the Reactor workflow (“callbacks”), I suggest reading throughthis
tutorialon your own time to get up
to speed on how it works and some details of sockets.I’m following the guide based onsandmanhereTo Dosplit udp and tcp into different, separate protocols:http://stackoverflow.com/questions/33224142/twisted-protocol-that-simultaneously-handles-tcp-and-udp-at-onceIdeasmake it like twisted.web - we build Request objects which need to
find Resource objects that provide actions (maybe too complicated,
try and simplify?)link
Package: iron-man
Project descriptionIron-Man is a bloom filter based Cython & C. It is designed to make getting started quick and easy, with the ability to scale up to complex applications. It began as a simple Instance around Redis.Irom-Man offers suggestions, but doesn't enforce any dependencies or project layout. It is up to the developer to choose the tools and libraries they want to use.InstallingInstall and update using pip:pipinstall-Uiron-manA Simple Examplefromiron_manimportLocalBloomFilterlbf=LocalBloomFilter(capacity=10000,error=0.0001)# check item is it in filterprint(lbf.is_contain("content"))# add item to filterlbf.add("content")print(lbf.is_contain("content"))A Redis Examplefromiron_manimportRedisBloomFilterfromredisimportRedisredis_conn:Redis=Redis()lbf=RedisBloomFilter(capacity=100000000,error=0.0001,redis_conn=redis_conn,prime_length=True,filter_prefix="bf_test")# show the how many string will used by redis.# every string will use 512MB mem.print(lbf.mem_block_counts)# check item is it in filterprint(lbf.is_contain("content"))# add item to filterlbf.add("content")print(lbf.is_contain("content"))# warning. normally, you don't need to clean BloomFilter.lbf.clean()LinksReleases:https://pypi.org/project/iron-man/Code:http://gitlab.nuist.pro:3000/aberstone/IronMan.gitIssue tracker:http://gitlab.nuist.pro:3000/aberstone/IronMan/issues
Package: ironmill-oxide
Oxide, IronMill's zero-knowledge circuit package-managerOxide is a package-manager that makes integrating verifiable and zero-knowledge computation into your projects a breeze.To learn more and use the tool, register for the open-alpha:https://oxide.is/InstallationOxide is best installed globally with pip or your choice of python package-manager:$sudo-Hpython3-mpipinstallironmill-oxideAboutOxide has the following design-decisions made as opposed to other package-managers:Version specifier is version (Not branch or revision)No lock-file present (Shallow dependency trees)Not synced (Expected large file sizes)PDM (Project dependency manager)"Asymmetric" - Bundled circuits we download and projects we are used in are different: Circuit manifests and project manifests look different
Package: iron-mq
This package wraps the IronMQ API. It provides a simple and intuitive way
to interact with the IronMQ service.IronMQ is a service provided by Iron.io. A flexible, scalable,
and durable messaging system lets different parts of a cloud app
connect with and scale independently from other internal and external
processes. IronMQ offers developers ready-to-use messaging with reliable
delivery and cloud-optimized performance.
Package: ironoak
A package for a convenient interface to oak cameras.Free software: Apache Software License 2.0Installationpip install ironoakYou can also install the in-development version with:pip install https://github.com/prasannavk/python-ironoak/archive/master.zipDocumentationhttps://python-ironoak.readthedocs.io/DevelopmentTo run all the tests run:toxNote, to combine the coverage data from all the tox environments run:Windowsset PYTEST_ADDOPTS=--cov-append
toxOtherPYTEST_ADDOPTS=--cov-append toxChangelog0.0.0 (2022-05-18)First release on PyPI.
Package: ironpipe
Official Ironpipe Bindings for Python===================================A Python library for Ironpipe's API.Setup-----You can install this package by using the pip tool and installing:$ pip install ironpipeSetting up an Ironpipe Account---------------------------Sign up for Ironpipe at https://dashboard.ironpipe.io/register.Using the Ironpipe API--------------------Documentation for the python bindings can be found here:- https://ironipe.io/docs
Package: ironpython-pytest
ironpython-pytestRidiculously minimal and incomplete pytest replacement for IronPython.This isnotan attempt to forkpytestto IronPython (as the abandonedpytest-ironpython), instead it's intended to provide the bare minimum for a drop-in replacement of a subset ofpytestconventions and framework required to run unit tests on IronPython.It makes a ton of assumptions and has very little configurability.Deal with it.(•_•) ( •_•)>⌐■-■ (⌐■_■)Installationipy -X:Frames -m ensurepip
ipy -X:Frames -m pip install ironpython-pytestUsageFrom the command line:ipy -m pytest file_or_dirOr programmatically:importosimportpytestif__name__=='__main__':# Fake some modulespytest.load_fake_module('Rhino')pytest.load_fake_module('Rhino.Geometry',fake_types=['RTree','Sphere','Point3d'])pytest.run('project/test_dir/')ReleaseTo release a new version of this project:Update the changelog with all noveltyBump version:bump2version [major|minor|patch] --verbosePush it:git push && git push --tagsPrepare the changelog for next release
Package: ironsmslib
Iron Sms LibraryLibrary for APIiron-sms.comFeatures:[+] Full support API from 14.08.2021   
 [+] Support for both sync and asyncExampleA small synchronous examplefrom ironsms import SyncIronSMS
from loguru import logger

from ironsms.exceptions import BadQueryException

api = SyncIronSMS('YOUR_API_KEY')

balance = api.get_balance()
logger.info(f'Your balance: {balance.balance}')

services = api.get_services()
logger.info(f'All services: {services}')

countries = api.get_countries()
logger.info(f'All countries: {countries}')

prices = api.get_prices('US')
logger.info(f'USA prices: {prices}')Installpip install ironsmslib
Package: ironsource-mobile-api
ironsource_api_pythonInstallationThis module is installed via pip:pip install ironsrc_mobile_apiSimple Example:importosfromironsource_api.ironsource_apiimportIronSourceAPIfromironsource_api.promote_apiimportMetrics,Breakdownsironsrc_api=IronSourceAPI()ironsrc_api.set_credentials(API_USER,API_TOKEN,API_SECRET)#Get Monetization Datares=ironsrc_api.monetize_api().get_monetization_data(start_date='2020-01-01',end_date='2020-01-01')#Get Advertiser Statisticsbytes_io=ironsrc_api.promote_api().get_advertiser_statistics('2020-10-03','2020-10-04',[Metrics.Impressions,Metrics.Clicks,Metrics.Installs],[Breakdowns.Application,Breakdowns.Day],response_format='csv')line=bytes_io_r.readline()whilelen(line)>0:print(line)line=bytes_io_r.readline()bytes_io_r.close()AuthenticationBefore starting to use the API make sure to get the credentials from ironSource dashboard.And set the Access Key, Secret Key and Refresh Token:set_credentialsdefset_credentials(user:str,token:str,secret:str)sets credentials for the APIs## ModulesIronSourceAPImonetize_apipromote_apiContributing:Please follow contributionguideDependenciesrequestshttpxpydash
Package: iron-toolbox
Iron ToolboxUtilização da BibliotecaPara importar a biblioteca, basta usar a nomenclaturairon_toolbox.Atualização da BibliotecaTodo commit no repositório vai publicar a atualização automaticamente noPyPI.org, por isso sempre que
for commitar qualquer atualização é necessário modificar a versão no arquivosetup.pyemsetuptools.setup (...version='0.0.00'...).Atualizar layer na AWSTodo commit no repositório irá gerar um arquivo zip (iron_toolbox-iron_toolbox-YYYY-MM-DD.zip.zip), onde YYYY-MM-DD
corresponde ao ANO-MES-DIA do commit. Este.zipserá salvo num bucket do S3 no seguinte caminhos3://iron-datalake-curated/LAMBDA_LAYERS/.
Package: iron-worker
This package offers a client interface to the Iron.io IronWorker service. It
offers a full, native interface to the IronWorker API, including creating
and uploading code package, queuing and scheduling tasks, viewing task logs,
and more.IronWorker is a background processing and task queuing system that lets your
applications use the cloud to do their heavy lifting. Find out more athttp://www.iron.io/products/worker.
Package: iron-worker-utils
# iron-worker-utilsA collection of utilities for writing [IronWorker](http://www.iron.io/worker) tasks in Python.## Functions
### get_payload`py >>> from iron_worker_utils import get_payload >>> get_payload() {u'repo': u'mwarkentin/lab', u'domain':u'http://shrinkray.io'}`### get_task_id`py >>> from iron_worker_utils import get_task_id >>> get_task_id() 58f38c1512e3687da7be0696cbc132de29f3a1a6 `## InstallationAddpip “iron-worker-utils”to your.workerfile.If you’d like to pin the version, usepip “iron-worker-utils”, “==0.1.1”
Package: irori
irori - build toolCopyright 2019 SiLeader.featuresconfiguration file is Python scriptsuffix ruleconcurrent executionhow to usepipinstalliroriwrite configuration script (makefile.py).fromirori.rulesimportSuffixRule,StaticRule,LinkRulefromiroriimportcontextasctxt,runnerfromirori.dependimportDependenciesimportglobtarget='hello.elf'defbuild(_:ctxt.BuildContext):returnLinkRule(command='clang++ -fPIC -o $@ $^',debug='-O0 -g',release='-O2',rules=SuffixRule(cpp=StaticRule('g++ -std=c++11 -c $< -o $@',debug='-O0 -g',release='-O2'),c=StaticRule('gcc -std=c11 -c -O2 $< -o $@',debug='-O0 -g',release='-O2')))defdepend(_:ctxt.BuildContext):returnSuffixRule(cpp=StaticRule('g++ -MMD -c $< -o $@'),c=StaticRule('gcc -MMD -c $< -o $@'))defrecipes():return{'build':build,'depend':depend}defarguments(parser):passdeffind_files(_:ctxt.BuildContext):returnglob.glob('*.c')+glob.glob('*.cpp')runner.start(target,recipes=recipes,finder=find_files,arguments=arguments,dependencies=Dependencies(files=glob.glob('obj/*.d')))run inmakefile.py's directory.iroribuildlicenseGNU GPL version 3.0
Package: irp
AIRPort city name resolver. And back.This is how you use it:$ pip install irp
$ export IATACODES_API_KEY="..."  # Get it for free at iatacodes.org
$ ipython

In [1]: from irp import get_airports, get_name

In [2]: list(get_airports('Portland'))
Out[2]: [('PDX', 'US'), ('PTJ', 'AU'), ('PWM', 'US')]

In [3]: list(get_airports('Portland, US'))
Out[3]: [('PDX', 'US'), ('PWM', 'US')]

In [4]: list(get_airports('PDX'))
Out[4]: [('PDX', 'US')]

In [5]: list(get_airports('Isiro'))
Out[5]: [('IRP', 'CD')]

In [6]: get_name('IRP')
Out[6]: 'Isiro'NOTEWe’re ATM bypassing iatacodes.org SSL verification. If you don’t want
this, patch it, it’s probably easy but we needed a hotfix.
Package: irpf90
IRPF90![Gitter](https://badges.gitter.im/Join Chat.svg)IRPF90 is a Fortran90 preprocessor written in Python for programming using the Implicit Reference to Parameters (IRP) method. It simplifies the development of large fortran codes in the field of scientific high performance computing.DependenciesGNU make (>= 3.81 recommended)Python >2.6Any Fortran 90 compiler (Intel recommended)Installing IRPF90pip install irpf90or${IRPF90_HOME}is the location of your irpf90 directory::cd${IRPF90_HOME}make
cat<< EOF >> ${HOME}/.bash_profileexport PYTHONPATH=${IRPF90_HOME}/src:${PYTHONPATH}export PATH=${IRPF90_HOME}/bin:${PATH}export MANPATH=${IRPF90_HOME}/man:${MANPATH}EOFsource${HOME}/.bash_profileUsing IRPF90In an empty directory, run:irpf90--initThis command creates a new Makefile suitable for most irpf90 projects.
Now you can start to program using irpf90.Web Sitehttp://irpf90.ups-tlse.fr
Package: irpf-investidor
IRPF InvestidorPrograma auxiliar para calcular custos de ações, ETFs e FIIs. Este programa foi feito para calcular emolumentos, taxa de liquidação e custo total para a declaração de Bens e Direitos do Imposto de Renda Pessoa Física.Essa aplicação foi testada e configurada para calcular tarifas referentes aos anos de 2019 a 2022 (IRPF 2020/2023) e não faz cálculos para compra e venda no mesmo dia (Day Trade), contratos futuros e Índice Brasil 50.RequisitosPythonInstale na sua máquina o Python 3.10.0 ou superior (versão 3.10 recomendada) para o seu sistema operacional empython.org.Usuários do Windows devem baixar a versãoWindows x86-64 executable installere na tela de instalação marcar a opçãoAdd Python 3.10 to PATH::alt: "Checkbox PATH na instala\xE7\xE3o Windows"
:width: 400Suporte a língua Português (Brasil) no seu sistema operacional.Pode ser instalado no Linux (Debian/Ubuntu) pelo comando:$apt-getinstalllanguage-pack-pt-baseInstalaçãoYou can installIRPF InvestidorviapipfromPyPI:$pipinstallirpf-investidorUsoEntre naÁrea do Investidorda B3, faça login e entre no menu Extratos e Informativos → Negociação de Ativos → Escolha uma corretora e as datas 1 de Janeiro e 31 de Dezembro do ano em que deseja declarar. Em seguida clique no botão “Exportar para EXCEL”. Ele irá baixar o arquivo “InfoCEI.xls”.Ainda não é possível rodar o programa usando os novos arquivos XLSX, gerar no formato antigo.Baixe e altere oTemplate_InfoCEI.xls.Você pode combinar lançamentos de anos diferentes em um mesmo documento colando as linhas de um relatório em outro, mas mantenha a ordem cronológica.Execute o programa através do comando:$irpf-investidorO programa irá procurar o arquivo "InfoCEI.xls" na pasta atual (digitepwdno terminal para sabe qual é) ou na pasta downloads e exibirá na tela os resultados.Ao executar, o programa pede para selecionar operações realizadas em leilão. Essa informação não pode ser obtida nos relatórios daÁrea do Investidorda B3 e precisam ser buscadas diretamente com a sua corretora de valores. Isso afeta o cálculo dos emolumentos e do custo médio.Aviso legal (disclaimer)Esta é uma ferramenta com código aberto e gratuita, com licença MIT. Você pode alterar o código e distribuir, usar comercialmente como bem entender. Contribuições são muito bem vindas. Toda a responsabilidade de conferência dos valores e do envio dessas informações à Receita Federal é do usuário. Os desenvolvedores e colaboradores desse programa não se responsabilizam por quaisquer incorreções nos cálculos e lançamentos gerados.CréditosEsse projeto foi gerado pelo template@cjolowicz'sHypermodern Python Cookiecutter.
Package: irradiance-pv
Irradiance PVIrradiance is a simple implementation of solar position and irradiance models to calculate the incident in plane irradiance in PV Modules.The package works its way from an horizontal global irradince, calculating solar positions, then transforming the components into a
Plane-of-Array (POA) Irradiance, necessary for the modeling of photovoltaic energy yields.Installation$pipinstallirradiance-pvfilesirradiance.pyContains the main classes to create and transform the irradiance components falling into a photovoltaic system, represented by a location and a surface.spa_sb.pyContains an implementation of the solar positions algorithm developped by the Astronomical Applications Department of the US Naval Observatory.
Package: iRRBS
# iRRBS
# iRRBS tool
## Overview
3’ ends of RRBS reads overlapping with genomic MspI sites include non-methylated cytosines introduced through end-repair. These cytosines are not recognized by Trim Galore and are therefore not trimmed but considered during methylation calling. To avoid methylation bias we developed iRRBS, which identifies and hides end-repaired cytosines from methylation calling.## Features
- Detecting whether the input file is single-read or paired-end
- Logging the “Number of unique MspI reads”, the “Number of MspI reads” and the “Number of all reads”
- Outputting a BAM file without the biased cytosines## Usage
To run iRRBS the following input parameters are required in this order:
- infile: path to input sorted BAM file
- chromsizes: path to chrom.sizes file to define the chromosome lengths for a given genome
- genome: path to genome file
-outfile: name for the output file## Dependencies
- samtools
- bedtools
Package: irrcac
TheirrCACis a Python package that provides several functions for
calculating various chance-corrected agreement coefficients. This package
closely follows the general framework of inter-rater reliability assessment
presented by Gwet (2014).The functionality covers calculations for various chance-corrected agreement
coefficients (CAC) among 2 or more raters. Among the CAC coefficients covered
are Cohen’s kappa, Conger’s kappa, Fleiss’ kappa, Brennan-Prediger coefficient,
Gwet’s AC1/AC2 coefficients, and Krippendorff’s alpha. Multiple sets of weights
are proposed for computing weighted analyses.The functions included in this package can handle 2 types of input data. Those
types with the corresponding coefficients are in the following list:Contingency TableBrennar-PredigerCohen’s kappaGwet AC1/AC2Krippendorff’s AlphaPercent AgreementSchott’s PiRaw DataFleiss’ kappaGwet AC1/AC2Krippendorff’s AlphaConger’s kappaBrennar-PredigerNoteAll of these statistical procedures are described in details in
Gwet, K.L. (2014,ISBN:978-0970806284):
“Handbook of Inter-Rater Reliability,” 4th edition, Advanced Analytics, LLC.This package is a port(with permission)to Python of theirrCAClibrary for R by Gwet, K.L.ImportantThis is awork in progressanddoes nothave (yet) the full
functionality found in the R library.InstallationTo install the package, run:pipinstallirrCACDevelopersTo run the tests, installpoetryand run:poetryinstallNext run:poetryrunpytestThere is also a config file fortoxso you can automatically run the tests for various python versions like this:toxDocumentationThe documentation of the project is available at the following page:http://irrcac.readthedocs.io/
Package: irrd
Internet Routing Registry daemon version 4 is an IRR database server,
processing IRR objects in the RPSL format.
Its main features are:Validating, cleaning and storing IRR data, and extracting
information for indexing.Providing several query interfaces to query the IRR data.Handling authoritative IRR data, and allowing users with the appropriate
authorisation to submit requests to change objects.Mirroring other IRR databases using file imports and NRTM.Offering NRTM mirroring and full export services to other databases.This IRRd version 4 project was originally commissioned in 2018 byNTTand
designed and developed byReliably Coded(known as DashCare until 2021).
Since then,Reliably Codedhas been maintaining and extending IRRd significantly,
for, or with support of,NTT,ARIN,Merit,RIPE NCC Community Projects Fund,LACNIC,NetnodandInternetstiftelsen. This has taken place in the form of
development contracts, support contracts, or grants.Older versionsof IRRd are or were in use by various IRR operators.
Difficulties with continued maintenance and extension of these
older versions led to the IRRd v4 project.Please see the extensivedocumentationfor more on how to deploy and use IRRd.
Package: irreceiver
IRReceiverA module to parse the NEC IR remote control protocol in PythonDescriptionThis is a fully tested module that creates a parser for the NEC IR remote control protocol.The NEC protocol is used by many remotes, you can read about ithere.NOTE: Although there is an example of this sketch that is made for the Raspberry PI, it is unlikely to work.
The Raspberry Pi doesnot have a real time operating systemand in my testing this did not work reliably.DependenciesThis project has no external dependencies but the example code does depend on being run on a Raspberry Pi.All code follows PEP 8 and there is a Github action to run code throughYAPFbefore it is merged to the main branch.Tested OnA Raspberry Pi (first generation)A Yamaha MRX-90M remoteTo Installpip install irreceiverTo UseAn example file can be found in theexamplesdirectory.Here is a basic example of decoding an list of IR timing pulses:fromirreceiverimportNecDecoderdecoder=NecDecoder()# PULSES should be a list of IR pulse timingsmessage=decoder.decode(PULSES)# Message will be a number such as 0x00AD where the first byte 00 is the address and the second byte AD is the commandProject StructureDirectory structure should be clear. All code is in theirreceiverdirectory.License:copyright: Willy Nolan 2020MIT License
Package: irreducible
Irreducible: Python Web Framework built for learning purposesIrreducible is a Python web framework built for learning purposes.It's a WSGI framework and can be used with any WSGI application server such as Gunicorn.InstallationpipinstallirreducibleHow to use itBasic usage:fromirreducible.apiimportAPIapp=API()@app.route("/home")defhome(request,response):response.text="Hello from the HOME page"@app.route("/hello/{name}")defgreeting(request,response,name):response.text=f"Hello,{name}"@app.route("/book")classBooksResource:defget(self,req,resp):resp.text="Books Page"defpost(self,req,resp):resp.text="Endpoint to create a book"@app.route("/template")deftemplate_handler(req,resp):resp.body=app.template("index.html",context={"name":"Irreducible","title":"Best Framework"}).encode()Unit TestsThe recommended way of writing unit tests is withpytest. There are two built in fixtures
that you may want to use when writing unit tests with Irreducible. The first one isappwhich is an instance of the mainAPIclass:deftest_route_overlap_throws_exception(app):@app.route("/")defhome(req,resp):resp.text="Welcome Home."withpytest.raises(AssertionError):@app.route("/")defhome2(req,resp):resp.text="Welcome Home2."The other one isclientthat you can use to send HTTP requests to your handlers. It is based on the famousrequestsand it should feel very familiar:deftest_parameterized_route(app,client):@app.route("/{name}")defhello(req,resp,name):resp.text=f"hey{name}"assertclient.get("http://testserver/matthew").text=="hey matthew"TemplatesThe default folder for templates istemplates. You can change it when initializing the mainAPI()class:app=API(templates_dir="templates_dir_name")Then you can use HTML files in that folder like so in a handler:@app.route("/show/template")defhandler_with_template(req,resp):resp.html=app.template("example.html",context={"title":"Awesome Framework","body":"welcome to the future!"})Static FilesJust like templates, the default folder for static files isstaticand you can override it:app=API(static_dir="static_dir_name")Then you can use the files inside this folder in HTML files:<!DOCTYPE html><htmllang="en"><head><metacharset="UTF-8"><title>{{title}}</title><linkhref="/static/main.css"rel="stylesheet"type="text/css"></head><body><h1>{{body}}</h1><p>This is a paragraph</p></body></html>MiddlewareYou can create custom middleware classes by inheriting from theirreducible.middleware.Middlewareclass and overriding its two methods
that are called before and after each request:fromirreducible.apiimportAPIfromirreducible.middlewareimportMiddlewareapp=API()classSimpleCustomMiddleware(Middleware):defprocess_request(self,req):print("Before dispatch",req.url)defprocess_response(self,req,res):print("After dispatch",req.url)app.add_middleware(SimpleCustomMiddleware)