Saravanan666/pypi-org huggingface dataset:
Package: ipromise
This repository provides a Python base class, and various decorators for specifying promises relating to inheritance.
It provides three inheritance patterns:implementing,overriding, andaugmenting.Base classChecking promises depends on inheritance from the base classAbstractBaseClass.  Unlike the standard library’s similar classabc.ABCMeta,AbstractBaseClassdoes not bring in any metaclasses.  This is thanks to Python 3.6’s PEP 487, which added__init_subclass__.ImplementingImplementingis the pattern whereby an inheriting class’s method implements an abstract method from a base class method.
It is declared using the decorators:abc.abstractmethodfrom the standard library, andimplements, which indicates that a method implements an abstract method in a base classFor example:classHasAbstractMethod(AbstractBaseClass):@abstractmethoddeff(self):raiseNotImplementedErrorclassImplementsAbstractMethod(HasAbstractMethod):@implements(HasAbstractMethod)deff(self):return0OverridingOverridingis the pattern whereby an inheriting class’s method replaces the implementation of a base class method.
It is declared using the decoratoroverrides, which marks the overriding method.An overriding method could call super, but does not have to:classHasRegularMethod(AbstractBaseClass):deff(self):return1classOverridesRegularMethod(HasRegularMethod):@overrides(HasRegularMethod)deff(self):return2AugmentingAugmentingis a special case ofoverridingwhereby the inheriting class’s method not onlyoverridesthe base class method, butextendsits functionality.
This means that it must delegate tosuperin all code paths.
This pattern is typical in multiple inheritance.We hope that Python linters will be able to check for the super call.Augmenting is declared using two decorators:augmentsindicates that this method must call super within its definition and thus augments the behavior of the base class method, andmust_agugmentindicates that child classes that define this method must decorate their method overriddes withaugments.For example:classHasMustAugmentMethod(AbstractBaseClass):@must_augmentdeff(self):# must_augment prevents this behavior from being lost.self.times_f_called+=1return0classAugmentsMethod(HasMustAugmentMethod):@augments(HasMustAugmentMethod)deff(self,extra=0,**kwargs):returnsuper().f(**kwargs)+extraclassAugmentsMethodFurther(AugmentsMethod):@augments(HasMustAugmentMethod)deff(self,**kwargs):print("f has been called")returnsuper().f(**kwargs)
Package: ip-rotator
Ip_rotatorip_rotator helps to hides your ip address in http request.This library searches every free proxy server that is available and set proxy in the request library.This library will allow the user to bypass IP-based rate-limits for sites and services.Installationpip install ip-rotatorip_rotator officially supports Python 3.7+.UsageDefaultimportip_rotatorproxy=ip_rotator.Proxy(https=False)# To access https url set (https = True)response=proxy.session.get('http://api.ipify.org/?format=json')# https requestTo Change Ipproxy.changeIp()# to change ip
Package: iproxpy
Introductioniproxis an integrated proteome resources center in China, which is built to accelerate the worldwide data sharing in proteomics.iproxpy is an unofficial Python package for data queries and downloads of iprox database.Home Pagehttps://github.com/phage-GP/iproxpy/Dependenciesaspera-clicondainstall-chccaspera-cliUseageInstallationpipinstalliproxpyExampleimportiproxpyidentifier='PXD043774'URL=f'https://www.iprox.cn/proxi/datasets/{identifier}'file_url_list=iproxpy.get_file_urls(URL,identifier=identifier)iproxpy.download(file_url_list[0],engine='aspera',path='~/')iproxpy.batch_download(file_url_list[:4],engine='aspera',path='~/',processes_num=4)Refshttps://www.iprox.cn/page/helpApi.htmlhttps://www.ibm.com/docs/en/ahts/4.4?topic=line-ascp-command-reference
Package: iprPy
IntroductionThe iprPy framework providesThe calculation methodology scripts used by the NIST Interatomic potentials
Repository for evaluating crystalline and crystal defect materials properties,Tools allowing for users to interact with databases and the records contained
within to easily explore the results of the calculations, andWorkflow tools that allow for preparing and performing high throughput runs
of the implemented calculation methods.The design of the package aims for being user-friendly, open and transparent at
all levels.  To this endAll code is open source,Calculation documentation and the Python code can be easily accessed and
explored,Calculations can be performed individually oren masseusing the workflow
tools,Command line options allow for runs to be set up and performed with limited
or no Python knowledge,Calculations are modular meaning that new methods can be easily added,Calculation methodology is separated from the workflow operations as much as
possible,Implementation of new calculations can be supported by sharing input/output
terms with existing calculations, andThe results records are in a format that is both human and machine readable.DocumentationDocumentation can be found in the doc directory or by visitinghttps://www.ctcms.nist.gov/potentials/iprPy/.The notebook directory contains Jupyter Notebooks that outline how the
implemented calculation methods work and provides an example run.For help using the package, feel free to contactpotentials@nist.govor
submit an issue or pull request to thehttps://github.com/lmhale99/iprPygithub repository.
Package: ipsecparse
Parse and edit your ipsec configuration files (ipsec.conf)InstallationTo install ipsecparse, simply:pip install ipsecparseExamples# Load the configuration from a string.fromipsecparseimportloadsconf=loads(open('/etc/ipsec.conf').read())# The configuration is represented as a dictionnary# (actually a subclass of OrderedDict)# Each section of the configuration is an OrderedDict.# Let's modify some settings:conf['config','setup']['nat_traversal']='yes'conf['conn','myconn']['left']='192.168.0.10'# Create a connection:conf['conn','mynewconn']={'leftsubnet':'10.0.0.0/16','right':'192.168.0.1'}# You can also use an OrderedDict if order matters to you:fromcollectionsimportOrderedDictconf['conn','mynewconn']=OrderedDict(lefsubnet='10.0.0.0/16',right='192.168.0.1')# Delete a connection:delconf['conn','mynewconn']# Same thing with certification authorities. Create a CA:conf['ca','myca']={'cacert':'MyCert.pem','crluri':'http://crl.example.com/mycrl.crl','auto':'add'}# Delete it:delconf['ca','myca']# Add an include:conf['include','/etc/ipsec.d/ipsec.include']=True# Delete it:delconf['include','/etc/ipsec.d/ipsec.include']# Display the new configuration as a string:print(conf.dumps())# with four spaces indents instead of the default tabulations:print(conf.dumps(indent='    '))# Replace the old configuration file:withopen('/etc/ipsec.conf','w')asfd:fd.write(conf.dumps())# Search for connections inside the configuration.# Pass a callable to the `conn_filter` method.forname,sectioninconf.conn_filter(lambdaconn:conn.get('leftsubnet')=='10.0.0.0/16'):section['auto']='start'# Or use the Key and Keys class# (just to make queries a bit shorter)fromipsecparseimportKey,Keysforname,sectioninconf.conn_filter(Key('leftsubnet')=='10.0.0.0/16'):section['auto']='start'forname,sectioninconf.conn_filter(Keys('left','right').contains('192.168.0.1')):delconf['conn',name]GitHub repo:https://github.com/leforestier/ipsecparse
Package: ipsetpy
This library is a Python wrapper around ipset.For ipset documentation access:http://ipset.netfilter.org/ipset.man.htmlInstallationTo install ipsetpy, you want to run:`bash $ pip install ipsetpy `GoalsProvide an interface to allow Python programs to manipulate ipsets.Be fast, small and robustVersionsCurrently ipsetpy is developed and tested on python3.4.LicenseThis project is made available under the MIT License (MIT)
Package: ipsframework
Integrated Plasma Simulator (IPS) FrameworkThe IPS was originally developed for the SWIM project and is designed
for coupling plasma physics codes to simulate the interactions of
various heating methods on plasmas in a tokamak. The physics goal of
the project is to better understand how the heating changes the
properties of the plasma and how these heating methods can be used to
improve the stability of plasmas for fusion energy production.The IPS framework is thus designed to couple standalone codes flexibly
and easily using python wrappers and file-based data coupling. These
activities are not inherently plasma physics related and the IPS
framework can be considered a general code coupling framework. The
framework provides services to manage:the orchestration of the simulation through component invocation,
task launch and asynchronous event notification mechanismsconfiguration of complex simulations using familiar syntaxfile communication mechanisms for shared and internal (to a
component) data, as well as checkpoint and restart capabilitiesThe framework performs the task, configuration, file and resource
management, along with the event service, to provide these features.
Package: ipspan
ipspan is a basic library that supports converting between a list
of IP addresses and several different forms of range notation.The primary audience is developers looking to concisely communicate lists
of IP addresses.The source for this project is available here.Copyright (c) 2018 Akamai Technologies, Inc.This project was based on the Python Sample Project distributed fromhttps://packaging.python.org/.This is the README file for the project.The file should use UTF-8 encoding and be written usingreStructuredText. It
will be used to generate the project webpage on PyPI and will be displayed as
the project homepage on common code-hosting services, and should be written for
that purpose.Typical contents for this file would include an overview of the project, basic
usage examples, etc. Generally, including the project changelog in here is not
a good idea, although a simple “What’s New” section for the most recent version
may be appropriate.
Package: ips.py
ips.pyA Python library for handling IPS patches.I wanted to create this as there was no suitable library for how I wanted to manipulate IPS patches, which at the time was just changing the offsets in the records. Since then I have wanted to extend it for my own needs, and for the potential needs of others.The logic for creating patches from two file objects is taken fromflips, which creates very good, small patches.How to useTo import the library, doimportipsTo get aPatchobject from an IPS file, dowithopen("path/to/patch.ips","rb")asf:p=ips.Patch.load(f)If you already have the bytes of the IPS file, you can dowithopen("path/to/patch.ips","rb")asf:cont=f.read()...p=ips.Patch.load(cont)To apply aPatchobject, dowithopen("path/to/original/file.bin","rb")asold,open("path/to/new/file.bin","wb")asnew:p.apply(old,new)If you don't want to necessarily write it to a new file, you can doimportionew=io.BytesIO()withopen("path/to/original/file.bin","rb")asold:p.apply(old,new)To create aPatchobject from two file objects, dowithopen("path/to/original/file.bin","rb")asold,open("path/to/new/file.bin","rb")asnew:p=ips.Patch.create(old,new)To pack aPatchobject into abytesobject, dobytes(p)To add a record to aPatchobject, use theadd_recordmethod.To get a list of records in aPatchobject, use therecordsattribute.To get whether aPatchobject is using the IPS32 format, which allows for offsets up to 4 GiB, check theips32attribute.
Package: ipsrvdb
ipsrvdb-pythonFeatureSupport Python2 & Python3.Support IPv4 & IPv6.Support output db date, description and header.Support output raw IP info and IP info in a dinctionary.Support load the database into memory or using MMAP.No dependent.Installingpip install ipsrvdbExampleimport ipsrvdb

if __name__ == "__main__":
    # mode options: MEMORY, MMAP
    a = ipsrvdb.IPSrvDB("/path/to/ipsrv.dat", mode="MEMORY")
    print(a.find('8.8.8.255'))
    print(a.findx('8.8.8.255'))
    print(a.findx('2001:250::ffff'))
    print(a.get_header())
    print(a.get_date())
    print(a.get_description())OutputNA,北美洲,US,美国,,,,,,
{u'isp_zh': u'', u'country_iso_code': u'US', u'country_zh': u'\u7f8e\u56fd', u'province_zh': u'', u'city_zh': u'', u'continent_code': u'NA', u'org': u'', u'continent_zh': u'\u5317\u7f8e\u6d32', u'city_code': u'', u'province_iso_code': u''}
{u'isp_zh': u'\u4e2d\u56fd\u6559\u80b2\u7f51', u'country_iso_code': u'CN', u'country_zh': u'\u4e2d\u56fd', u'province_zh': u'\u5317\u4eac\u5e02', u'city_zh': u'', u'continent_code': u'AS', u'org': u'', u'continent_zh': u'\u4e9a\u6d32', u'city_code': u'', u'province_iso_code': u'11'}
[u'continent_code', u'continent_zh', u'country_iso_code', u'country_zh', u'province_iso_code', u'province_zh', u'city_code', u'city_zh', u'isp_zh', u'org']
20210811
IPSrv, Inc. Dat database.
Package: ipsuite
IPS - The Inter Atomic Potential SuiteIPS provides you with tools to generate Machine Learned Interatomic Potentials.Install the package to get started or check out an interactive notebookpipinstallipsuiteExamples can be found at:https://dagshub.com/PythonFZ/IPS-Examples/src/intro/main.ipynbhttps://dagshub.com/PythonFZ/IPS-Examples/src/graph/main.ipynbhttps://dagshub.com/PythonFZ/IPS-Examples/src/modify_graph/main.ipynb
Package: ipsw
ipsw-pyipswSDK for Python 🚧NOTE:This is a work in progress ⚠️Getting StartedStart theipswdaemon:macOSbrewinstallblacktop/tap/ipswd
brewservicesstartblacktop/tap/ipswdLinux⚠️ UNTESTED ⚠️sudosnapinstallipswdDockerdockerrun-d-p3993:3993-v`pwd`:/datablacktop/ipswdstartInstallingThe latest stable version isavailable on PyPI. Either addipswto yourrequirements.txtfile or install withpip:pipinstallipswGeting StartedGet IPSW infoimportipswclient=ipsw.IpswClient(base_url='tcp://127.0.0.1:3993')info=client.info.get("iPhone15,2_16.5_20F5028e_Restore.ipsw")print(f'{info.version}({info.build})')fordeviceininfo.devices:print(f'-{device}')16.5(20F5028e)-iPhone14ProGet DSC infoimportipswclient=ipsw.IpswClient(base_url='tcp://127.0.0.1:3993')dsc=client.dsc.open("20F5028e__iPhone15,2/dyld_shared_cache_arm64e")print(dsc)print(dsc.dylibs[0])<DSC:'(dyld_v1  arm64e) - iOS - FAEC7714-4CCD-3B99-B18F-F5EAB60DE31E'>{'index':1,'name':'/usr/lib/libobjc.A.dylib','version':'876.0.0.0.0','uuid':'085A190C-6214-38EA-ACCB-428C3E8AFA65','load_address':6443204608}<Dylib:'64-bit MachO AARCH64 (ARM64e)'>Get dylib inside DSC infolibswiftCore=dsc.dylib("libswiftCore.dylib")print(libswiftCore)Get DSC symbol addressessyms=dsc.sym_addrs([{'pattern':'.*zero.*','image':'libsystem_c.dylib'}])print(syms)Convert between DSC offsets and addressesoff=dsc.a2o(7624591060)adr=dsc.o2a(61146836)Lookup DSC symbol by addressprint(next(dsc.a2s([7624591060]))){"address":7624591060,"symbol":"__exit","demanged":"__exit","mapping":"__TEXT","uuid":"3AB55994-1201-3908-BE27-52BB7EFA7573","ext":".21","image":"/usr/lib/system/libsystem_kernel.dylib","section":"__text","segment":"__TEXT"}Get MachO infoimportipswclient=ipsw.IpswClient(base_url='tcp://127.0.0.1:3993')macho=client.macho.open("/bin/ls",arch="arm64e")print(macho)<Macho:'64-bit MachO AARCH64 (ARM64e)'>CommunityYou have questions, need support and or just want to talk aboutipsw-py?Here are ways to get in touch with theipsw-pycommunity:LicenseMIT Copyright (c) 2023blacktop
Package: ipsw-parser
Overviewpython3 utility for parsing and extracting data from IPSW.Installationpython3-mpipinstallipsw-parserAdditionally, if you installedblacktop/ipsw, the IPSW extraction will also contain
the split DSC.UsageUsage: python -m ipsw_parser [OPTIONS] COMMAND [ARGS]...

Options:
  --help  Show this message and exit.

Commands:
  extract  extract .ipsw into filesystem layout
  info     parse given .ipsw basic info
Package: ipsync
ipsyncipsync is a script to update multiple cloud DNS providers with your
external IP address. Useful for when you need to connect to a system on
a dynamic IP.Getting StartedRequirementsPython 2.7+ or Python 3.3+Installationipsync can be installed with pip:$ pip install ipsyncor directly from the source code:$ git clone https://github.com/jon-walton/ipsync.git
$ cd ipsync
$ python setup.py installBasic UsageUsage:
    ipsync [options] <command>

Options:
    -h --help               Show this screen.
    -v --version            Show version.
    -c FILE --config=FILE   Configuration FILE to use [default: ~/.config/ipsync.conf]
    --dry-run               Run but don't make any changes.

Available commands:
    update                  Resolve current IP address and update all providersConfigurationBy default, ipsync will look in ~/.config/ipsync.conf for a yaml
formatted file. A sample file is inconfig/config.sample.ymlNamecheap.comFor ipsync to work with namecheap, you must firstenable it within the
control
paneland then configure a namecheap section within the ipsync configuration
filenamecheap:
  test.com:
    hostname: www
    password: password

  example.com:
    hostname: test
    password: 123456For ContributorsRequirementsMake:Windows:http://cygwin.com/install.htmlMac:https://developer.apple.com/xcodeLinux:http://www.gnu.org/software/make(likely already installed)virtualenv:https://pypi.python.org/pypi/virtualenv#installationPandoc:http://johnmacfarlane.net/pandoc/installing.htmlGraphviz:http://www.graphviz.org/Download.phpInstallationCreate a virtualenv:$ mkvirtualenv ipsync
$ workon ipsync
$ pip install -r requirements.txtRun the tests:$ make test
$ make tests  # includes integration testsRun static analysis:$ make pep8
$ make pep257
$ make pylint
$ make check  # includes all checksChangelog0.1.0 (2015/01/03)Initial release with namecheap.com support
Package: ipt
ipt: a Python 2.7 package for causal inference by inverse probability tiltingby Bryan S. Graham, UC - Berkeley, e-mail:bgraham@econ.berkeley.eduThis package includes a Python 2.7 implementation of the Average Treatment Effect of the
Treated (ATT) estimator introduced in Graham, Pinto and Egel (2016). The function att()
allows for sampling weights as well as “clustered standard errors”, but these features have not
yet been extensively tested.An implementation of the Average Treatment Effect (ATE) estimator introduced in Graham,
Pinto and Egel (2012) is planned for a future update.This package is offered “as is”, without warranty, implicit or otherwise. While I would
appreciate bug reports, suggestions for improvements and so on, I am unable to provide any
meaningful user-support. Please e-mail me atbgraham@econ.berkeley.eduPlease cite both the code and the underlying source articles listed below when using this
code in your research.A simple example script to get started is:>>>> # Append location of ipt module root directory to systems path
>>>> # NOTE: Only required if ipt not "permanently" installed
>>>> import sys
>>>> sys.path.append('/Users/bgraham/Dropbox/Sites/software/ipt/')

>>>> # Load ipt package
>>>> import ipt as ipt

>>>> # View help file
>>>> help(ipt.att)

>>>> # Read nsw data directly from Rajeev Dehejia's webpage into a
>>>> # Pandas dataframe
>>>> import numpy as np
>>>> import pandas as pd

>>>> nsw=pd.read_stata("http://www.nber.org/~rdehejia/data/nsw_dw.dta")

>>>> # Make some adjustments to variable definitions in experimental dataframe
>>>> nsw['constant'] = 1                # Add constant to observational dataframe
>>>> nsw['age']      = nsw['age']/10    # Rescale age to be in decades
>>>> nsw['re74']     = nsw['re74']/1000 # Recale earnings to be in thousands
>>>> nsw['re75']     = nsw['re75']/1000 # Recale earnings to be in thousands

>>>> # Treatment indicator
>>>> D = nsw['treat']

>>>> # Balancing moments
>>>> t_W = nsw[['constant','black','hispanic','education','age','re74','re75']]

>>>> # Propensity score variables
>>>> r_W = nsw[['constant']]

>>>> # Outcome
>>>> Y = nsw['re78']

>>>> # Compute AST estimate of ATT
>>>> [gamma_as, vcov_gamma_ast, study_test, auxiliary_test, pi_eff_nsw, pi_s_nsw, pi_a_nsw, exitflag] = \
>>>>                                                                 ipt.att(D, Y, r_W, t_W, study_tilt=True)CODE CITATIONGraham, Bryan S. (2016). “ipt: a Python 2.7  package for causal inference by inverse probability tilting,” (Version 0.2.2)[Computer program]. Available athttps://github.com/bryangraham/ipt(Accessed 04 May 2016)PAPER CITATIONSGraham, Bryan S., Cristine Pinto and Daniel Egel. (2012). “Inverse probability tilting for moment condition modelswith missing data,” Review of Economic Studies 79 (3): 1053 - 1079Graham, Bryan S., Cristine Pinto and Daniel Egel. (2016). “Efficient estimation of data combination models by themethod of auxiliary-to-study tilting (AST),” Journal of Business and Economic Statistics 31 (2): 288 - 301
Package: iptables-converter
iptables-converteriptables-converter: convert iptables to iptables-save format, output
comes with [0:0] for iptables-restore -cip6tables-converter: convert ip6tables to ip6tables-save format,
output comes with [0:0] for ip6tables-restore -cSource:https://github.com:sl0/conv.gitVersion: 0.9.10Date: 2017-11-16Licenses:GNU GENERAL PUBLIC LICENSE Version 3 laterApache License Version 2.0Author: Johannes Hubertzjohannes@hubertz.deiptables-converterspeeds up loading of iptables-commands by
converting them to iptables-save format, and then loading them through
iptables-restore is much more quicker than loading the plain commands.
The loading itself is not part of iptables-converter.Usage:iptables-converter [ -d destination ] [ -s source ] [ --sloppy ]
ip6tables-converter [ -d destination ] [ -s source ] [ --sloppy ]This assumes thatsourceis a plain ascii-file containing lines
starting withiptablesto build a firewall ruleset. Lines starting
with/sbin/iptablesare understood as well. Omitting -s source
defaults to reading a file namedrules. An optionalsloppyparameter makes premature definitions (-N name) of any user defined
chains unneccessary, they are defined automatically by first mentioning
them. Optionally-d destinationwrites everything into the given
destination file since verstion 0.9.10. Omitting this option results in
writing Output to stdout, which is the default behavior. Packet-counters
and byte-counters include [0:0] which keeps compatibility to
iptables-restore as well as toiptables-restore -c.ip6tables-converterworks for ip6tables just the same way.Both they work forfilter,mangle,natandrawtables,securitytables are not supported for now.From version 0.9.10 on it works as a python-module using entry-points
for easier imports. For your convienience, the module is namediptables_conv.At travis-ci.org thetestsare run automatically, thanks to Guido!
To run them locally, please use python:python setup testor tox, which is the preferred testrunner.iptables-converteris tested to work well with python2.7, python3.5
and python3.6.  The tests are
done using pytest for easier writing future testcases. Some sphinx
documentation is prepared. Debian packages are provided for thebinariesandsphinx-documentation.
git-buildpackage creates them on the fly. RPMs may be created by python:setup.py bdist_rpmAny comments welcome.Have fun!Johannes
Package: iptables-dynamic
Dynamically save and restore iptables rules for some chain(s)DescriptionDependenciesInstallationUsageCreditsDescriptionWhen there’s an iptables service restart, all of the docker rules gets wiped out. This script was written to dynamically save and restore iptables rules pertaining to some chain(s) and make them persist.Dependenciesiptables(Must have the commandsiptables-saveandiptables-restorecommands available)Installationpip install iptables-dynamicUsageiptables-dynamic --chains DOCKER SOME-OTHER-CHAIN --savewhich would save them at/etc/iptables/rules.v4One can restore those rules byiptables-dynamic --restoreOne may also useip6tables-dynamicfor IPv6.CreditsThe copyright owner isRegents of the University of Californiaand this script is published under aBSD 3-Clauselicense.Developed atUCSB LSIT