Saravanan666/pypi-org huggingface dataset:
Package: imp-grpc-client
impgrpcA python grpc client for Impervious Network ⚡⚡⚡This is a wrapper around the default grpc interface that handles setting up credentials (including macaroons). An async client is also available to do fun async stuff like listening for invoices in the background.DependenciesPython 3.6+Working LND lightning node, take note of its ip address.Copy your admin.macaroon and tls.cert files from your node to a directoy on your machine.Installationpipinstallimp-grpc-clientEnvironment VariablesThese environment variables are only used when testing node connectivity and/or correct module installation from the command line. This library is primarily used through Python scripting.exportCRED_PATH=/path/to/macaroon/and/tls/certexportLND_NODE_IP=192.168.1.xxBasic UsageThe api mirrors the underlying lnd grpc api (http://api.lightning.community/) but methods will be in pep8 style. ie..GetInfo()becomes.get_info().</code></pre><h3>SpecifyingMacaroon/Certfiles</h3><p>Bydefaulttheclientwillattempttolookupthe<code>readonly.macaron</code>and<code>tls.cert</code>filesinthemainnetdirectory.Howeverifyouwanttospecifyadifferentmacaroonordifferentpathyoucanpassinthefilepathexplicitly.</p><prelang="python"><code>lnd=LNDClient(macaroon_filepath='~/.lnd/invoice.macaroon',cert_filepath='path/to/tls.cert')Generating LND Proto Filesvirtualenvlndsourcelnd/bin/activate
pipinstallgrpciogrpcio-toolsgoogleapis-common-protossh
gitclonehttps://github.com/lightningnetwork/lnd.git
mkdirgenprotos
gitclonehttps://github.com/googleapis/googleapis.gitfrompathlibimportPathimportshutilimportshforprotoinlist(Path("../imp-releases/proto").rglob("*.proto")):shutil.copy(proto,Path.cwd().joinpath("impgrpc/compiled"))protos=list(Path(".").joinpath("impgrpc/compiled").glob("**/*.proto"))args=["-m","grpc_tools.protoc",# "--proto_path=../imp-releases/proto/:.",# "--proto_path=../imp-releases/proto/google/api:.",# "--proto_path=../imp-releases/proto/protoc-gen-openapiv2/options:.",# "--proto_path=impgrpc/compiled/:.",# "--proto_path=impgrpc/compiled/protoc-gen-openapiv2/:.","--proto_path=impgrpc/compiled/",# "--proto_path=.:.","--python_out=impgrpc/compiled","--grpc_python_out=impgrpc/compiled",]forprotofileinprotos:args.append(str(protofile))# Generate the compiled protofilessh.python(args)Last Step:
In File: verrpc_pb2_grpc.py
Change:
import verrpc_pb2 as verrpc__pb2
To:
from lndgrpc import verrpc_pb2 as verrpc__pb2Deploy to Test-PyPipoetrybuild
twinecheckdist/*
twineupload--repository-urlhttps://test.pypi.org/legacy/dist/*
Package: impi
Intel(R) MPI Runtime is a multifabric message-passing library that implements the open-source MPICH specification. Use the library to create, maintain, and test advanced, complex applications that perform better on HPC clusters based on Intel(R) processors.One of many Intel(R) accelerated Python packages and performance library runtimes available on [PyPI](https://software.intel.com/en-us/articles/installing-the-intel-distribution-for-python-and-intel-performance-libraries-with-pip-and), and as part of [Intel(R) Distribution for Python](https://software.intel.com/en-us/distribution-for-python).For latest release updates and security notifications, please [subscribe](https://software.intel.com/en-us/forums/intel-distribution-for-python) to the Intel(R) Distribution for Python Community forum.Free to use and redistribute pursuant to the [Intel Simplified Software License](https://software.intel.com/en-us/license/intel-simplified-software-license).
Package: impick
ImPick ServerThe ImPick Server is a web application that allows users to view and select images from different groups. It is built usingFastAPIandimage-picker.FeaturesSequential or individual mode for viewing groups of imagesSelection of one images from each groupCSV reporting of selected imagesPrerequisitesPython 3.7 or higherInstallationClone the repository:gitclonegit@github.com:rilshok/impick.git
pipinstall-eimpickor install it from pippipinstallimpickUsageTo run the ImPick Server, follow these steps:Prepare your image groups:Create a directory for each image group.Place the images for each group in their respective directories.Start the server:Open a terminal or command prompt.Run the following command:impick_server--images-root<path-to-image-groups-directory>--report-file<path-to-report-file.csv>--mode{individual|sequential}--host<host>--port<port>Replace  with the path to the directory containing your image groups, and <path-to-report-file.csv> with the desired path to the CSV file for reporting the selected images.For example:impick_server--images-root~/images--report-file~/impick-report.csv--modeindividual--hostlocalhost--port8000Access the web interface:Open a web browser.
Visithttp://localhost:8000/(or the specified host and port if different) to start viewing and selecting images.Note:When the server is running in theindividualmode, each user will view and select their own set of images. In thesequentialmode, all users will view the image groups one by one.The root path (/) of the server sets the path value in the report toanonym. Navigating to any other path will update the report with the corresponding path value. The image selection process is based on the selected server mode.ScreenshotsContributingContributions are welcome! If you encounter any issues or have suggestions for improvements, please open an issue or submit a pull request on the GitHub repository.LicenseThis project is licensed under the MIT License. See the LICENSE file for details.
Package: impi-devel
The Intel® MPI Library is a multi-fabric message passing library that implements the Message Passing Interface, version 3.1 (MPI-3.1) specification. Use the library to develop applications that can run on multiple cluster interconnects.
The Intel MPI Library has the following features:
•	High scalability
•	Low overhead, enables analyzing large amounts of data
•	MPI tuning utility for accelerating your applications
•	Interconnect independence and flexible runtime fabric selection
The Intel MPI Library is available as a standalone product and as part of oneAPI or the Intel Parallel Studio XE Cluster Edition.
Package: im-pipelines-utils
Theim-pipelines-utilsmodule is a core set of utilities employed byInformatics Matters’ computational pipelines, its automatedPipeline
Testerand distributed in a number of our container images.pipelines_utilsIs a generally useful collection of utility modules for any Informatics Matters’
pipelines. These consist of utilities to process multi-value (comma-separated)
command-line parameter values along with numerous helper and convenience
methods for file handling and logging.
Package: im-pipelines-utils-rdkit
Theim-pipelines-utils-rdkitmodule is a core set of utilities employed byInformatics Matters’ computational pipelines and distributed in a number of
our container images.The utility modules provide convenient wrappers around the
correspondingrdkitdistribution.rdkit_utilsdepends on theRDKitopen source cheminformatics software,
which you will need to install separately if you need to use this module.
Package: impipes
Welcome toimpipesAbout this packageimpipesis a Python package built to automate the image preprocessing to feed an AI model.What was this built for?This package was originally developed byLukasz Kaczmarek,Cristian Vargas,Ramón Ontiveros, andRodolfo Ferroas part of theTree Identification Challenge with AIatOmdena.Refer to this package# We will be providing more info about how to refer
# to this Python package.
from impipes import pipes
...More content will be added soon.
Package: impi-rt
The Intel® MPI Library is a multi-fabric message passing library that implements the Message Passing Interface, version 3.1 (MPI-3.1) specification. Use the library to develop applications that can run on multiple cluster interconnects.
The Intel MPI Library has the following features:
•	High scalability
•	Low overhead, enables analyzing large amounts of data
•	MPI tuning utility for accelerating your applications
•	Interconnect independence and flexible runtime fabric selection
The Intel MPI Library is available as a standalone product and as part of oneAPI or the Intel Parallel Studio XE Cluster Edition.
Package: impish
impish - Interprocess communication made easy!impish (interprocessmessagepassingissimple enough) is a library to simplify interprocess communication. Inspired by MQTT it comes with two classes:ImpishBrokerImpishClientthat work with the publish/subscribe pattern. On Unix they use a Unix-domain socket to communicate. On Windows you´ll have to use a INET socket.
You can however also use an INET socket on Unix if you wish. Using a Inet socket should also allow IPC between separate machines. Unix-domain sockets however can only be used locally.Getting startedTo learn how to use impish have a look at the provided exampleshere.TestsComplete tests will (probably) be provided in a later release.
Package: imPixelate
ImPixelateThis snippet of code attempts to pixelate images.Usageimportcv2,osimportnumpyasnpfromimPixelateimportpiximg_fullname="assets/lotus.jpg"img_name,img_ext=os.path.splitext(img_fullname)img=cv2.imread(img_fullname)img_out=img.copy()[h,w,d]=img.shapeforiinrange(d):img_out[:,:,i]=pix(img[:,:,i].copy())cv2.imwrite(f'{img_name}-pixelate{img_ext}',img_out)OutputThis is a sample image:This is the sample image pixelated:
Package: imp-kit
:smiling_imp:IMP:Icon Mosaicking in PythonDescriptionPython module for flexible, corpus-based icon mosaicking. Here are some emoji-art examples made withIMP.AcknowledgementsThis code is a Python porting and expansion ofemoji-mosaicbyericandrewlewis, and inspired byYung Jake'semoji art.InstallationIMPis not yet available through PyPI. In the meantime, however, you can clone this repo and runpip install -r requirements.txtto try it out.LicenseISC License
Copyright (c) 2023, Felipe Tovar-HenaoPermission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.TO DOCreate Poisson-like section filter whereby dominant colors are constrasting enough
Package: implant
implantA proof-of-concept for asynchronous adhoc remote procedure calls in Python.This is work in progress and serves basically as an exercise.FeaturesPython >= 3.5 asyncioadhoc transferable remote proceduresremote part of aimplant.core.Commandmay reside in a separate moduleaimplant.core.Commandspecificimplant.core.Channelenables arbitrary protocols between local and remote sideeventsquite small coretestsLimitationsPython >= 3.5only pure Python modules are supported for remote import, if no venv is usedimplant.core.Commands must reside in a module other then__main__at the moment sudo must not ask for passwordExampleGeneral applicationimportasyncioimportpathlibfromimplantimportcore,connect,commandsasyncdefremote_tasks():# create a connector for a python processconnector=connect.Lxd(container='zesty',hostname='localhost')connector_args={'python_bin':pathlib.Path('/usr/bin/python3')}# connect to a remote python processremote=awaitconnector.launch(**connector_args)# start remote communication taskscom_remote=asyncio.ensure_future(remote.communicate())try:# execute commandcmd=commands.SystemLoad()result=awaitremote.execute(cmd)print("Remote system load:",result)finally:# stop communication taskscom_remote.cancel()awaitcom_remoteif__name__=='__main__':loop=asyncio.get_event_loop()loop.run_until_complete(remote_tasks())loop.close()An example Echo Commandimportloggingimportosfromimplantimportcorelog=logging.getLogger(__name__)classEcho(core.Command):"""Demonstrate the basic command API."""asyncdeflocal(self,context):"""The local side of the RPC.

           :param context: :py:obj:`implant.core.DispatchLocalContext`
        """# custom protocol# first: sendawaitcontext.channel.send_iteration("send to remote")# second: receivefrom_remote=[]asyncforxincontext.channel:from_remote.append(x)log.debug("************ receiving from remote:%s",from_remote)# third: wait for remote to finish and return resultremote_result=awaitcontext.remote_futureresult={'from_remote':''.join(from_remote),}result.update(remote_result)returnresultasyncdefremote(self,context):"""The remote side of the RPC.

           :param context: :py:obj:`implant.core.DispatchRemoteContext`
        """# first: receivefrom_local=[]asyncforxincontext.channel:from_local.append(x)log.debug("************ receiving from local:%s",from_local)# second: sendawaitcontext.channel.send_iteration("send to local")# third: return resultreturn{'from_local':''.join(from_local),'remote_self':self,'pid':os.getpid()}Internalsmaster <-----------------------------------------> remote
                            |
                       stdin/stdout
                            |
                          chunks
                            |
                         channels
                            |
    --> send ---> |                   |  --> queue -->
                  | module:class/fqin |
    <-- queue <-- |                   |  <--- send <--
Package: impler
Implementation pattern*/*inspired by RustUseful when it is needed to extend a class (usually 3d party) with some methods
or interfacesInstallpipinstallimplerorpoetryaddimplerUsageMethods implementationUsing implementation pattern you can extend any class (even 3rd party) with
regular, class or static methods.fromimplerimportimplfrompydanticimportBaseModel@impl(BaseModel)deffields_count(self:BaseModel):returnlen(self.__fields__)classPoint(BaseModel):x:int=0y:int=1point=Point()print(point.fields_count())Class methods@impl_classmethod(BaseModel)deffields_count(cls):returnlen(cls.__fields__)# or@impl(BaseModel)@classmethoddeffields_count(cls):returnlen(cls.__fields__)Static methods@impl_staticmethod(BaseModel)defzero(cls):return0# or@impl(BaseModel)@staticmethoddefzero(cls):return0Async methods@impl(BaseModel)asyncdefzero(cls):awaitasyncio.sleep(1)return0Interfaces implementationThe same way you can extend any class with the whole interfaceHere is example of the base interface, whichfrompathlibimportPathclassBaseFileInterfase:defdump(self,path:Path):...@classmethoddefparse(cls,path:Path):...This is how you can implement this interface for PydanticBaseModelclass:fromimplerimportimplfrompydanticimportBaseModelfrompathlibimportPath@impl(BaseModel,as_parent=True)classModelFileInterface(BaseFileInterface):defdump(self,path:Path):path.write_text(self.json())@classmethoddefparse(cls,path:Path):returncls.parse_file(path)Ifas_parentparameter isTruethe implementation will be injected to the list of the target class parents.Then you can check if the class or object implements the interface:print(issubclass(BaseModel,BaseFileInterfase))# Trueprint(issubclass(Point,BaseFileInterfase))# Trueprint(isinstance(point,BaseFileInterface))# TrueThe whole api documentation could be found by thelink
Package: implicitdict
implicitdictThis library primarily provides theImplicitDictbase class which enables the inheriting class to implicitly be treated like adictwith entries corresponding to the fields of the inheriting class.  Simple example:classMyData(ImplicitDict):foo:strbar:int=0baz:Optional[float]data:MyData=ImplicitDict.parse({'foo':'asdf','bar':1},MyData)assertjson.dumps(data)=='{"foo": "asdf", "bar": 1}'Seeclass documentation forImplicitDictandtest_normal_usage.pyfor more information.
Package: implicit-reca
Implicit_recaThis is an implementation of the ALS algorithm under Apache Spark's mllib library, designed specifically for designing recommendation systems on implicit data, with the recent update on the regularization parameter.What is implicit data ?The standard approach to matrix factorization-based collaborative filtering treats the entries in the user-item matrix as explicit preferences given by the user to the item, for example, users giving ratings to movies.It is common in many real-world use cases to only have access to implicit feedback (e.g. views, clicks, purchases, likes, shares etc.). This is called implicit data.InstallationUse the package managerpipto install foobar.pipinstallimplicit_recaUsageimportimplicit_recaasirir.create_lookup(dataset)# Create the lookup table for future reference.ir.create_sparse(dataset,name_of_implicit_feautre)# Create the sparse matrix of user x items (R).ir.implicit_als(spmx,alpha,iterations,lambd,features)# Main function behind the ALS algorithm.ir.item_recommend(item_ID,item_vecs,item_lookup,no_items_rec)# Item vs item recommendation.ContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.Please make sure to update tests as appropriate.LicenseMIT
Package: implicits
# ImplicitsGlobal state can be hard to reason about, but piping dependencies from function to function is a pain. With implicits, you _explicitly_ which function parameters are _implicit_ dependencies. When you call the function, no need to explicilty provide these parameters; instead, the parameters will be implicitly passed! All that's required is that there exists local variables in scope that match the names of the parameters you're calling.```python3@implicits("current_user")def create_task(title, *, current_user):print(f"{current_user} created a task titled '{title}'")current_user = "Jaden"create_task("Hooray, a task!") # Jaden created a task titled 'Hooray, a task!'create_task("Buy some trackpants") # Jaden created a task titled 'Buy some trackpants'```## Usage1) Install via `pip install implicits`.2) Import with `from implicits import implicits`.3) Decorate using `@implicits("names", "of", "implicit", "parameters")`.## Example```python3import loggingimport boto3from implicits import implicitsclass Giraffe:@implicits("logger")def __init__(self, name, *, logger):self.name = namelogger.info(f"Creating a Giraffe named {name}")@property@implicits("logger")def full_name(self, *, logger):logger.info(f"Getting {self.name}'s full name")return f"{self.name} the Giraffe"@property@implicits("food")def is_hungry(self, *, food):return "leaves" in food@implicits("logger")def main(*, logger):jeff = Giraffe("Jeff") # Creating a Giraffe named Jeffname = jeff.full_name  # Getting Jeff's full namefood = ["rocks", "dirt"]logger.info(jeff.is_hungry) # Falsefood.append("leaves")logger.info(jeff.is_hungry) # Truelogger = logging.getLogger()logger.setLevel(logging.INFO)logger.addHandler(logging.StreamHandler())main()```## ReferencesI didn't invent this idea! Quite a few other languages support implicit parameters. The most mainstream of these languages is Scala. [Check out how implicits work in Scala!](https://docs.scala-lang.org/tour/implicit-parameters.html)
Package: implicit-sdk
implicit SDKImplicit SDK is a new generation of software development tools where you no longer need to write code to build or to consume any server-side APIs (such as SOAP APIs, RESTful API, GraphQL, gRPC, etc..)All you need to do is just to write any functions in your server-side that needs to be accessiable from the client-side and the implicit SDK generates a JavaScript module that contains the same functions with the same names, parameters documentation, and return value and when the client side developer uses any of these functions, they automatically invoke the corresponding function in the server side and returns a promise that when resolved, it returns the value returned by the function on the server side.Implicit SDK doesn't only make the work easier for the software developer but also for the machine. Because it automatically manages the communication between clients and the server to enhance performance. For example, if the client script triggered multiple function calls at the same time, it will automatically merge them into one request to the server.Supported server-side programming languagesPHPPythonJavaScript(Under development)
Package: implicit-word-network
Implicit Word NetworkIntroductionThis python package can be used to extract context-enriched implicit word networks as described by Spitz and Gertz. The theoretical background is explained in the following publications:Spitz, A. (2019). Implicit Entity Networks: A Versatile Document Model. Heidelberg University Library.https://doi.org/10.11588/HEIDOK.00026328Spitz, A., & Gertz, M. (2018). Exploring Entity-centric Networks in Entangled News Streams. In Companion of the The Web Conference 2018 on The Web Conference 2018 - WWW ’18. Companion of the The Web Conference 2018. ACM Press.https://doi.org/10.1145/3184558.3188726DependenciesThis project uses models from the spaCy and sentence_transformers package. These packages are not installed automatically. You can use the following commands to install them.pip install sentence_transformerspip install spacypython -m spacy download en_core_web_smExample Usageimportspacyasspimportimplicit_word_networkaswn# Path to text filepath="data.txt"# Entities to search for in corpusentity_types=["PERSON","LOC","NORP","ORG","WORK_OF_ART"]c=2# Cut-off parameter# Importing data ...D=wn.readDocuments(path)# Parsing data ...nlp=sp.load("en_core_web_sm")D_parsed=wn.parseDocuments(D,entity_types,nlp=nlp)# Converting parsing results ...D_mat=wn.createCorpMat(D_parsed)# Building graph ...V,Ep=wn.buildGraph(D_mat,c)
Package: implor
implor - Image ExplorerSuppose you have images under./images, you can start the image server via:run_implor -p 8080 -d ./imagesThen you can explorer the image folder via:http://0.0.0.0:8080There are some GET optsw: image width
h: image height
n: images per page
s: show the s-th ~ (s+n-1)-th imagesExample:http://0.0.0.0:8080?s=4&n=4&w=1024This will show the 4th~7th images withwidth=1024;Alternatively, you can put images undersub-directory, suppose you have directory structure like this:images/
├── imgs001
│   ├── 0000.jpg
│   └── 0001.jpg
└── imgs002after starting the image server viarun_implor -p 8080 -d ./images, you can access images fromimages/imgs001byhttp://0.0.0.0:8080/imgs001?s=4&n=4&w=1024
Package: impl-pattern
Implements theimplpattern*/*inspired by RustUseful when it is needed to extend a class (usually 3d party) with some methodsInstallpipinstallimpl_patternorpoetryaddimpl_patternUsageRegular methodsfromimpl_patternimportimplclassSample:def__init__(self):self.value=10@impl(Sample)defplus_one(self:Sample):self.value+=1s=Sample()s.plus_one()print(s.value)# 11it works with async methods as wellfromasyncioimportsleep@impl(Sample)asyncdefplus_one(self:Sample):awaitsleep(1)self.value+=1s=Sample()awaits.plus_one()print(s.value)# 11Class methodsTo register function as a classmethod you can useimpl_classmethoddecoratorfromimpl_patternimportimpl_classmethodclassSample:value=10@impl_classmethod(Sample)defplus_one(cls):cls.value+=1Sample.plus_one()print(Sample.value)# 11This works with async methods toofromasyncioimportsleep@impl_classmethod(Sample)asyncdefplus_one(cls):awaitsleep(1)self.value+=1awaitSample.plus_one()print(Sample.value)# 11Static methodsStatic methods use the same syntax but with theimpl_staticmethoddecoratorfromimpl_patternimportimpl_staticmethodclassSample:...@impl_staticmethod(Sample)defget_one():return1print(Sample.get_one())# 1This works with async methods toofromasyncioimportsleep@impl_staticmethod(Sample)asyncdefget_one():return1print(awaitSample.get_one())# 1