Saravanan666/pypi-org huggingface dataset:
Package: ietf-comments
The IETF Comments ProcessorHandling comments from the IESG, multiple directorate reviews, and in AUTH48 can be burdensome for document authors, because of the sheer number of comments, and because they come in an unstructured format that has to be manually processed.This package installs two commands:ietf-commentsprocesses comments from the IESG and directorates in amarkdown-based format.rfced-commentsprocesses comments from the RFC Editor in RFC XML files.Both can be used to create GitHub issues for the comments they find. When used properly, they can help automate formerly tiresome tasks.For IESG and directorate comments, this tool uses theIETF Comment Markdown format, which is a semi-structured format that is similar to that which ADs and directorates use now. Ideally, they will create comments in that format for easy processing, but even when they don't, most comments can easily be transformed into it for processing.Online ValidatorIf you just need to validate markdown comments, see theonline comments valdiator.InstallationTo install ietf-comments, you'll needPython 3.6or greater. Then, run:pip3 install ietf-commentsNotethat to use rfced-comments, you'll need Python 3.10 or greater. To assure that Python 3.10 is being used, you may need to use something like:python3.10 -m pip install ietf-commentsUseProcessing AD and Directorate CommentsTo validate a AD or Directorate review in theIETF Comment Markdown formatand see the identified issues, run:ietf-commentsfilenameTo create a GitHub issue for each issue, setGITHUB_ACCESS_TOKENin your environment to aGitHub Personal Access Tokenand run:ietf-comments -gowner/repofilename... whereowner/repois the repo owner and name, separated by a slash.If you'd like these issues to have a specific label, run:ietf-comments -gowner/repofilename-llabelnameIf you'd likediscuss,comment, andnit labelsadded as appropriate, along with areviewlabel, pass-a:ietf-comments -gowner/repofilename-aProcessing RFC Editor CommentsTo validate RFC Editor comments in a local RFC XML file and see the identified issues, run:rfced-commentsfilenameAlternatively, if you're in AUTH48 and the RFC Editor has published a draft of your RFC-to-be, you can just runrfced-commentsNNNNwhereNNNNis the RFC number.To create a GitHub issue for each issue, setGITHUB_ACCESS_TOKENin your environment to aGitHub Personal Access Tokenand run:rfced-comments -gowner/repoNNNN_or_filename... whereowner/repois the repo owner and name, separated by a slash.If you'd like these issues to have a specific label, run:rfced-comments -gowner/repoNNNN_or_filename-llabelnameSpecial FeaturesThe following features are currently supported (more soon!):When recognised, internal section references (e.g.,Section 2.4) are auto-linked in created issues.Likewise, references to external RFCs (e.g.,Section 5.3 of [RFC1234]) will also be auto-linked in created issues when recognised.Text in blockquotes (preceded by>) in comments will be checked for presence in the document; if they aren't found, a warning will be raised.
Package: ietfdata
ietfdata- Access the IETF Datatracker and related resourcesThis project contains Python 3 libraries to interact with, and
access, theIETF datatracker,RFC index, and related resources.Getting startedThe project uses Pipenv for dependency management. To begin, run:pipenv install --dev -e .to create a Python virtual environment with appropriate packages install.
Then, run:pipenv shellto start the virtual environment, within which you can run the scripts.Once the virtual environment is started, running:python3 tests/test_datatracker.pywill run the test suite for the datatracker module. Running:python3 tests/test_rfcindex.pyWill test the rfcindex module.CachingThe ietfdata library can use aMongoDBinstance as a cache. Using a cache reduces the number of requests that are made
directly to the Datatracker, improving performance, and reducing the impact on
the IETF's infrastructure. While using a cache is optional when accessing the
Datatracker, it is required when accessing the mail archive.The hostname, port, username, and password for the MongoDB instance that is to
be used as the cache can be set when instantiated theDataTrackerorMailArchiveobjects. Alternatively, the following environment variables can be
set:IETFDATA_CACHE_HOST(defaults tolocalhostwhen accessing the mail archive)IETFDATA_CACHE_PORT(defaults to27017)IETFDATA_CACHE_USER(optional)IETFDATA_CACHE_PORT(optional)Release ProcessEdit CHANGELOG.md and ensure up-to-dateEdit setup.py to ensure the correct version number is presentEdit ietfdata/datatracker.py to fix version number in DataTracker::uaRunmake testto run the test suite. If any tests fail, fix then
restart the release processCommit changes and push to GitHubCheck that the GitHub Continuous Integration run succeeds, and fix
any problems (this runs with a fresh cache, so can sometimes catch
problems that aren't found by local tests).Runpython3 setup.py sdist bdist_wheelto prepare the packageRunpython3 -m twine upload dist/*to upload the packageCommit the packages files indist/*push to GitHubTag the release in GitHub
Package: ietfparse
Wait… Why? What??This is a gut reaction to the wealth of ways to parse URLs, MIME headers,
HTTP messages and other things described by IETF RFCs.  They range from
the Python standard library (urllib) to be buried in the guts of otherkitchen sinklibraries (werkzeug) and most of them are broken in one
way or the other.So why create another one?  Good question… glad that you asked.  This is
a companion library to the great packages out there that are responsible for
communicating with other systems.  I’m going to concentrate on providing a
crisp and usable set of APIs that concentrate on parsing text.  Nothing more.
Hopefully by concentrating on the specific task of parsing things, the result
will be a beautiful and usable interface to the text strings that power the
Internet world.Here’s a sample of the code that this library lets you write:from ietfparse import algorithms, headers

def negotiate_versioned_representation(request, handler, data_dict):
    requested = headers.parse_accept(request.headers['Accept'])
    selected = algorithms.select_content_type(requested, [
        headers.parse_content_type('application/example+json; v=1'),
        headers.parse_content_type('application/example+json; v=2'),
        headers.parse_content_type('application/json'),
    ])

    output_version = selected.parameters.get('v', '2')
    if output_version == '1':
        handler.set_header('Content-Type', 'application/example+json; v=1')
        handler.write(generate_legacy_json(data_dict))
    else:
        handler.set_header('Content-Type', 'application/example+json; v=2')
        handler.write(generate_modern_json(data_dict))

def redirect_to_peer(host, port=80):
    flask.redirect(algorithms.rewrite_url(flask.request.url,
                                          host=host, port=port))OK… Where?Sourcehttps://github.com/dave-shawley/ietfparseStatushttps://circleci.com/gh/dave-shawley/ietfparse/tree/masterDownloadhttps://pypi.org/project/ietfparseDocumentationhttps://ietfparse.readthedocs.io/en/latestIssueshttps://github.com/dave-shawley/ietfparse
Package: ietools
ietoolsA Python package implementing commonly used Industrial Engineering and Management toolsAuthor: Gana Natarajan,gana1984@gmail.comUniversity of Wisconsin - PlattevilleThere are two main modules and one utility module developed for now. Minimal testing has been performed. So, if anyone notices issues, please add Issues, and we will address it.The main modules in this version are:EnggEcon - Engineering Economy ModuleDecision - Decision making under uncertainty moduleUtils has utility functions to find an effective interest rate and to provide cash flows adjusted to a Least Common Multiple (LCM) time horizon.If you use any of these tools, please cite this repository.Other modules in the making:Inventory ManagementAggregate PlanningForecastingFlow Systems AnalysisControl ChartsStatistical Quality ControlWell-known packages like scipy, pandas, numpy, sklearn, pulp, etc. were used and will be used in developing the modules in this package.
Package: ieugwaspy
Perform fast queries in Python against a massive database of complete GWAS summary dataTheIEU GWAS databasecomprises over 10,000 curated, QC'd and harmonised complete GWAS summary datasets and can be queried using an API. Seeherefor documentation on the API itself. This Python package package is a wrapper to make generic calls to the API, plus convenience functions for specific queries.See ieugwaspy documentationfor details of how to use this package.Installation:Install usingpip install ieugwaspyFeatures:Get meta data about specific or all studiesObtain the top hits (with on the fly clumping as an option) from each of the GWAS datasets. Clumping and significance thresholds can be specifiedObtain the summary results of specific variants across specific studies. LD-proxy lookups are performed automatically if a specific variant is absent from a studyPerform PheWAS (look up all associations for a variant)Convert between chromosome:position and rsids and getting annotations
Package: ievm
ievm is a tool to download Microsoft IE virtual machine images.Currently nothing more than download and checksum.Create this since the old ievm.sh script is never timely updated.Usage-----Basic usage::$ ievm [OPTIONS]``OPTIONS `` includes the following required items:- `-t TYPE`, `--type TYPE`:VM types, valid types are `hyperv`, `vagrant`, `virtualbox`, and `vmware`- `-v VERSION`, `--version VERSION`:IE versions, valid version are `ie11-win7`, `msedge-win10`, `ie11-win81`,`ie9-win7`, and `ie10-win7`- `-p PATH`, `--path PATH`:path to save downloaded file- `-h`, `--help`:show help messagesInstallation------------Install from PyPI::$ pip install ievmLicense-------ievm is released under Apache License Version 2.0. See the LICENSE_ file for more details... _LICENSE: https://github.com/zenixls2/ievm/blob/master/LICENSE
Package: iewt
IEWT(Interactive Embedded Web Terminal)This release has minor bug fixes.Installation:Python 3.8+Runpip install iewtto install iewt package. IEWT requires file creation permissions, hence run in a location with sufficient permissions.To run the application you need to haveA remote machine with a Unix(Linux, MacOS etc.) OS.Tmux installed on the computer/VM.(Optional)SSH server running on the computer/VM.Network access to the SSH server.Once all the above steps are performed, run the commandiewt. Open a browser and gotolocalhost:8888/iewtEnter the SSH credentials in the form at the bottom of the screen. The terminal will appear soon after. To automatically execute commands, type the commands in the input field and click on thesend commandbutton. The command is executed in the terminal and after its completion its time will appear in the readonly input field below the command status button. The command status turns green on success and red on failure.Integration Tests and Load Test:pip install -r requirements.txtrun each test individually.change remote server credentials as per your requirements.provide correct input paths where required.Unit Tests:pip install flake8 mockpython -m unittest discover testsCode Coverage:coverage run -m unittest discover testscoverage report -m > coverage_report.txtDocker Image:docker compose upLegacy files:dbservice-skeleton.py: part of release 1.2.0setup.sql: part of releases 1.0.0 and 1.1.0
Package: iex
A Python module to retrieve stock market data fromThe Investors Exchange (IEX)Developer Platform.DocumentationRead the IEX Developer Platform documentationhere.InstallationFrom PyPI with pip:$ pip3 install iexFrom GitHub:$gitclonehttps://github.com/udrea/iex.git$cdiex$python3setup.pyinstallModule stabilityThis Python module is currently under heavy development and nowhere near any
stable version. It is subject to regular breaking changes.LicenseCopyright 2018 Iulian Udrea <iulian.udrea14@alumni.imperial.ac.uk>See LICENSE.
Package: iex-api
iex-apiUnofficial Python IEX Cloud Api.FeaturesSupports Income, CashFlow, Financials, Quote, EndOfDayPricePrimarily uses time-series to make it easier to query older dataIs asynchronousTypedQuick Startimportasyncioimportosfromiex_api.model.companyimportIncome,CashFlow,Financialsos.environ.update({"IEX_API_URL":"https://sandbox.iexapis.com/stable/","IEX_API_TOKEN":"<>",})asyncdefgather_company_info(symbol:str):income,cashflow,financials=awaitasyncio.gather(Income.latest(symbol),CashFlow.latest(symbol),Financials.latest(symbol))print(income.gross_profit)print(cashflow.cash_flow)print(financials.ebit)loop=asyncio.get_event_loop()loop.run_until_complete(gather_company_info('AAPL'))InstallationStable Release:pip install iex_apiDevelopment Head:pip install git+https://github.com/volpyx/iex_api.gitDocumentationFor full package documentation please visitvolpyx.github.io/iex_api.DevelopmentSeeCONTRIBUTING.mdfor information related to developing the code.The Four Commands You Need To Knowpip install -e .[dev]This will install your package in editable mode with all the required development
dependencies (i.e.tox).make buildThis will runtoxwhich will run all your tests in both Python 3.7
and Python 3.8 as well as linting your code.make cleanThis will clean up various Python and build generated files so that you can ensure
that you are working in a clean environment.make docsThis will generate and launch a web browser to view the most up-to-date
documentation for your Python package.
Package: iexparsing
iexparsingA collection of parsers forIEX.Use the parsers to gather relevant quotes and trades information.Currently, only IEX-TP and TOPS parsing is supported.IEX-TP Parsing Examplefromiexparsingimportiextpsession=iextp.Session()outbound_segment=session.decode_packet(b'\x01\x00\xFF\xFF\x01\x00\x00\x00\x00\x00\x87\x42\x07\x00\x02\x00\x8c\xa6\x21\x00\x00\x00\x00\x00\xca\xc3\x00\x00\x00\x00\x00\x00\xec\x45\xc2\x20\x96\x86\x6d\x14\x01\x00\x69\x02\x00\xBE\xEF')print(outbound_segment)IEX-TP outbound segment: [b'i', b'\xbe\xef']You can then passoutbound_segment.messagesto a messages-protocol parser, e.g. TOPS.TOPS Parsing Examplefromiexparsingimporttopssession=tops.Session()print(session.decode_message(b'\x51\x00\xac\x63\xc0\x20\x96\x86\x6d\x14\x5a\x49\x45\x58\x54\x20\x20\x20\xe4\x25\x00\x00\x24\x1d\x0f\x00\x00\x00\x00\x00\xec\x1d\x0f\x00\x00\x00\x00\x00\xe8\x03\x00\x00'))best bid: 9700 ZIEXT shares for 99.05 USD; best ask: 1000 ones for 99.07 USD @ 2016-08-23 19:30:32.572716TODOMake a basic parserWrite documentationReport errorsAdd a DEEP parserParse trading breaks
Package: iext
iextAdd new imports tied to a specific class.InstallationInstall this package viapip:python -m pip install iextUsageTo extend the imports within a specific class, subclassExtendImportsand add an__imports__method with all the extra imports. Everything imported here will be added to the namespace ofself.fromiextimportExtendImportsclassExampleClass(ExtendImports):def__imports__(self):importpkg1frompkg2importthingdefexample_method(self):returnself.pkg1.func(self.thing)
Package: ifa
Information Flow Analysis=========================IFA is a simple and fast library for information theory research and information flow analysis. It's a Python module written C++, Cython.Installation============Dependencies:* numpyIf you have Cython some cpp files will get regenerated during installation```bashpip install ifa```Or if you want the developmen version:```bashgit clone https://github.com/janekolszak/ifa.git;cd ifa;sudo make install;```Usage=====Computing Jensen–Shannon divergence:```pythonfrom ifa.distribution import Distributionfrom ifa.divergence import jsdfrom numpy.testing import assert_allclosep = Distribution(["A", "B"], [0.5, 0.5])q = Distribution(["A", "C"], [0.5, 0.5])assert_allclose(jsd(p, 0.5, q, 0.5), [0.5])```What's inside:==============* Distribution class with some basic operations* Divergences:* Jensen–Shannon divergence* Kullback–Leibler divergence* Functions to compute information flow between distributions
Package: iface
Implementable interfaces for Python.Example UsageTestingAll tests suites are paired one-to-one with the module they test and live
directly adjacent to that same module. All tests are expected to pass for
Python 3.3 and above. To run tests use tox with the included tox.ini file or
create a virtualenv and install the ‘[testing]’ extras.LicenseCopyright 2015 Kevin ConwayLicensed under the Apache License, Version 2.0 (the “License”);
you may not use this file except in compliance with the License.
You may obtain a copy of the License athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an “AS IS” BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.ContributingFirstly, if you’re putting in a patch then thank you! Here are some tips for
getting your patch merged:StyleAs long as the code passes the PEP8 and PyFlakes gates then the style is
acceptable.DocsThe PEP257 gate will check that all public methods have docstrings. If you’re
adding something new, like a helper function, try out thenapoleon style of docstrings.TestsMake sure the patch passes all the tests. If you’re adding a new feature don’t
forget to throw in a test or two. If you’re fixing a bug then definitely add
at least one test to prevent regressions.
Package: ifaddr
ifaddris a small Python library that allows you to find all the Ethernet and
IP addresses of the computer. It is tested onLinux,OS X, andWindows. Other BSD derivatives likeOpenBSD,FreeBSD, andNetBSDshould work too, but I haven’t personally tested those.Solaris/Illumosshould also work.This library is open source and released under the MIT License. It works
with Python 3.7+.You can install it withpip install ifaddr. It doesn’t need to
compile anything, so there shouldn’t be any surprises. Even on Windows.Project links:ifaddr GitHub pageifaddr documentation (although there isn’t much to document)ifaddr on PyPILet’s get going!importifaddradapters=ifaddr.get_adapters()foradapterinadapters:print("IPs of network adapter "+adapter.nice_name)foripinadapter.ips:print("%s/%s"%(ip.ip,ip.network_prefix))This will print:IPs of network adapter H5321 gw Mobile Broadband Driver
   IP ('fe80::9:ebdf:30ab:39a3', 0L, 17L)/64
   IP 169.254.57.163/16
IPs of network adapter Intel(R) Centrino(R) Advanced-N 6205
   IP ('fe80::481f:3c9d:c3f6:93f8', 0L, 12L)/64
   IP 192.168.0.51/24
IPs of network adapter Intel(R) 82579LM Gigabit Network Connection
   IP ('fe80::85cd:e07e:4f7a:6aa6', 0L, 11L)/64
   IP 192.168.0.53/24
IPs of network adapter Software Loopback Interface 1
   IP ('::1', 0L, 0L)/128
   IP 127.0.0.1/8You get both IPv4 and IPv6 addresses. The later complete with
flowinfo and scope_id.If you wish to include network interfaces that do not have a configured IP
addresss, pass theinclude_unconfiguredparameter toget_adapters().
Adapters with no configured IP addresses will have an zero-lengthipsproperty.  For example:importifaddradapters=ifaddr.get_adapters(include_unconfigured=True)foradapterinadapters:print("IPs of network adapter "+adapter.nice_name)ifadapter.ips:foripinadapter.ips:print("%s/%s"%(ip.ip,ip.network_prefix))else:print("  No IPs configured")Changelog0.2.0Added an option to include IP-less adapters, thanks to memoryFixed a bug where an interface’s name wasbytes, notstr, on WindowsAdded an implementation ofnetifaces.interfaces()(available throughifaddr.netifaces.interfaces())Added type hintsBackwards incompatible/breaking changes:Dropped Python 3.6 support0.1.7Fixed Python 3 compatibility in the examples, thanks to Tristan Stenner and Josef SchlehoferExposed network interface indexes in Adapter.index, thanks to Dmitry TantsurAdded the license file to distributions on PyPI, thanks to Tomáš ChvátalFixed Illumos/Solaris compatibility based on a patch proposed by Jorge SchrauwenSet up universal wheels, ifaddr will have both source and wheel distributions on PyPI from now onAlternativesAlastair Houghton developsnetifaceswhich can do  everything this library can, and more. The only drawback is that it needs
to be compiled, which can make the installation difficult.As of ifaddr 0.2.0 we implement the equivalent ofnetifaces.interfaces(). It’s available throughifaddr.netifaces.interfaces().
Package: ifalg
Python ifalgifalgis a Python 3 library to interface with the Linux kernel crypto API.
This is generally slower than using a library like OpenSSL or PyCrypto,
but it could be useful if you have cryptographic hardware supported by Linux.FeaturesFor the moment onlyskcipherandhashalgorithms are supported.Algorithm metadata is parsed from/proc/cryptoInstallationifalgshould work on any Linux distribution with a modern kernel, in order to use this tool you need to have the folowing options enabled on the kernel:CONFIG_CRYPTO_USER_APICONFIG_CRYPTO_USER_API_HASHCONFIG_CRYPTO_USER_API_SKCIPHERTo install just use pip:pip install ifalgSamplesUsing a hash algorithm:>>> from ifalg import Hash
>>> hash = Hash('sha1')
>>> hash.hexdigest(b'hello world')
'2aae6c35c94fcfb415dbe95f408b9ce91ee846ed'Using a keyed hash algorithm:>>> from ifalg import Hash
>>> hash = Hash('cmac(des3_ede)', key=bytes.fromhex('8aa83bf8cbda10620bc1bf19fbb6cd58bc313d4a371ca8b5'))
>>> hash.hexdigest(bytes.fromhex('6bc1bee22e409f96'))
'8e8f293136283797'Encryption and Decryption:>>> from ifalg import SKCipher
>>> cipher = SKCipher('cbc(aes)', key=bytes.fromhex('790afba9cfbc095b682666a6999a38ed'), iv=bytes.fromhex('fb1f88c0f23d6aa6dde475c018d7f482'))
>>> msg = bytes.fromhex('4e0c74c8d67862a9732604f62f4ad316')
>>> cipherText = cipher.encrypt(msg)
>>> cipherText
b'\x7ftT$Z\xf4\xe6|\xd2)cA\xf2\x1d\xcb\xa9'
>>> plainText = cipher.decrypt(cipherText)
>>> plainText
b'N\x0ct\xc8\xd6xb\xa9s&\x04\xf6/J\xd3\x16'
>>> plainText == msg
TrueStreaming encryption and decryption:>>> from ifalg import SKCipherStream
>>> stream = SKCipherStream('cbc(aes)', key=bytes.fromhex('790afba9cfbc095b682666a6999a38ed'), iv=bytes.fromhex('fb1f88c0f23d6aa6dde475c018d7f482'))
>>> stream.write(b'0123456789abcdef0123456789abcdef')
32
>>> cipherText = stream.read(32)AuthorManolo Ramirez Tmanologab@gmail.comContactFor any thoughts about this software, please contact me atmanologab@gmail.com.If you find a bug or have any idea to improve this tool, please use Github’sissues <https://github.com/manologab/python-ifalg/issues>.LicenseThe MIT License (MIT)Copyright (c) 2015 Manolo Ramirez T.Permission 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.