Saravanan666/pypi-org huggingface dataset:
Package: instanceTuner
InstanceTunerSet limited type instances and overload functions like Java in pythonyou can install it by:pip install instanceTunerDo you want to be able overload every function and method, even constructors (init) like Java in python?Do you want to never write 'raise' or 'assert' in your python code when it comes to function arguments?from instanceTuner.set import setFunction

class Test:
    @setFunction
    def __init__(self, a: int, b) -> None:
        pass

    @setFunction
    def __init__(self, a: int, b: str) -> None:
        passThis package will raise error for you if 'a' does'nt get integer valuewith checking types by using 'setFunction' we are able to distinguish signatures of functions from each other like java compiler and using it for overload purposesif you pass some object for 'b' which is'nt str, firstinitwould executedeven the return value can raise an error. but it does'nt have any use for overload due.for example :@setFunction
def test() -> None:
    return 0
Package: instanet
Author:Behrouz SafariLicense:MITinstanetA python package for analysing Instagram networkInstallationInstall the latest version ofinstanetfromPyPI:pip install instanetRequirements arerequests,networkxandmatplotlib.Quick startfrominstanetimportInstagramins=Instagram(USERNAME,PASSWORD)ins.login()ins.save_friends(['friend1','friend2','friend3','friend4','friend5'])ins.graph()
Package: instanseg
Instance Segmentation MetricsInstanseg is an open-source python library that provides various metrics for evaluating the results of the algorithms for segmenting and associating instances.List of metrics implemented in the library:Summary segmentation metricsPanopticFull statisticsInstance-based segmentation metricsPrecisionRecallF-ScoreUnder segmented ratioOver segmented ratioNoise ratioMissed ratioPoint-based segmentation metricsIntersection over Union (IoU)DiceMean of some metric for matched instancesFor more, please visit theInstanseg documentation.You can also find full information about the project on theInstanseg project website.Python quick startLibrary can be installed using the pip package manager:$# Install package$pipinstallinstanseg

$# Check installed version of package$pipshowinstansegExample of usageBelow is an example of using the precision metric:>>>frominstanseg.metricsimportprecision
>>>pred_labels=np.array([1,1,3,3])>>>gt_labels=np.array([2,2,0,3])>>>tp_condition="iou">>>precision(pred_labels,gt_labels,tp_condition)0.5Citation@misc{kornilova2022evops,
      title={EVOPS Benchmark: Evaluation of Plane Segmentation from RGBD and LiDAR Data}, 
      author={Anastasiia Kornilova, Dmitrii Iarosh, Denis Kukushkin, Nikolai Goncharov, Pavel Mokeev, Arthur Saliou, Gonzalo Ferrer},
      year={2022},
      eprint={2204.05799},
      archivePrefix={arXiv},
      primaryClass={cs.CV}
}LicenseThis project is licensed under the Apache License - see theLICENSEfile for details.
Package: instant
Instant is a Python module that allows for instant inlining of C and
C++ code in Python. It is a small Python module built on top of SWIG
and Distutils.Instant is part of the FEniCS Project.For more information, visithttp://www.fenicsproject.org.DocumentationDocumentation can be viewed athttp://fenics-instant.readthedocs.org/.Automated TestingWe use Bitbucket Pipelines and Atlassian Bamboo to perform automated
testing.Code CoverageCode coverage reports can be viewed athttps://coveralls.io/bitbucket/fenics-project/instant.LicenseThis program is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.You should have received a copy of the GNU Lesser General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
Package: instant2fa
instant2faInstant2FA Python bindings.InstallationInstall it via PyPI:pipinstallinstant2faUsageimportinstant2fainstant2fa.access_key='YOUR_ACCESS_KEY'instant2fa.access_secret='YOUR_ACCESS_SECRET'distinct_id='A_UNIQUE_ID_FOR_A_USER'hosted_page_url=instant2fa.create_settings(distinct_id)hosted_page_url=instant2fa.create_verification(distinct_id)verification_succeeded=instant2fa.confirm_verification(distinct_id,token)DevelopmentTo start development, run:$gitclonegit@github.com:clef/instant2fa-python.gitinstant2fa$cdinstant2fa$makedevelopHistory1.0.0First release on PyPI.1.0.1Validatedistinct_idparameter has a value.
Package: instantAPI
instantAPIDescriptionA scripts that generates a fully functional flask api from databases;the script is ready to use in production environement right after it ; you can add yout jwt security token and tweek some code but the rest is already there (sqlite3 for the moment and looking for contributers)Dependenciessqlite3python3.xinstallationno installation neededusagepython instantAPI.py link/to/your/sqlite3/database.dbexamplebefore execution:after execution:the reparation_models.py contains the api for your database (get and post methods for all tables)example of one table :the name of the classes are the name of the db table+List and the links have the same name as your databasesfor more examples make sure you test it your self or see the example folderBefore usingmake sure your databasesâ€™s tables all contain an auto incremental index.
Package: instant-api-client
IntroductionIf you've ever tried to make an API wrapper
you probably know that the code written can
only be used as sync or async, well, not anymore.FeaturesLightweight: Extremely lightweight and minimalEasy to use: Implement features in no time with theAsync and blocking: Provides both async and blocking callsTest without a server: Since the library internally uses httpx, it can be used to test itself using anASGIorWSGIapplication.DRY:Don't repeat yourself, helps avoid code duplication and write reusable codeRouting: AnAPIRouterclass with simliar API toAPIClientModular: Create reusable routers that can be added to any client, independant of each otherExample UsagefromapiclientimportAPIClient,endpoint,PostclassCodeExecClient(APIClient):base_url="https://pathtomysite.com/api/1.0"# Note the missing / suffix@endpointdefrun(self,language:str,code:str):# Do any processing with the data here!# Also note the / prefix in the urlreturnPost("/execute",params={'lang':language,'code':code})# Using the API clientfromhttpximportClientclient=CodeExecClient(session=Client())response=client.run("py","print('hello world!')")Documentation is under works
Package: instant-client
instant_clientA type-safeJSON-RPCclient with automatic (de)serialization.pip install instant-clientFor communication over HTTP (like in the example below):pip install 'instant-client[requests]'instant_clientcan be used with any server implementing JSON-RPC, but it's best paired withinstant_api. For example, suppose the API server is set up like this:fromdataclassesimportdataclassfromflaskimportFlaskfrominstant_apiimportInstantAPIapp=Flask(__name__)@dataclassclassPoint:x:inty:int@InstantAPI(app)classMethods:deftranslate(self,p:Point,dx:int,dy:int)->Point:returnPoint(p.x+dx,p.y+dy)defscale(self,p:Point,factor:int)->Point:returnPoint(p.x*factor,p.y*factor)if__name__=='__main__':app.run()Then using the client is as simple as:fromserverimportMethods,Point# the classes we defined abovefrominstant_clientimportInstantClient# The type hint is a lie, but your linter/IDE doesn't know that!methods:Methods=InstantClient("http://127.0.0.1:5000/api/",Methods()).methodsassertmethods.scale(Point(1,2),factor=3)==Point(3,6)That looks a lot like it just calledMethods.scale()directly, which is the point (no pun intended), but under the hood it did in fact send an HTTP request to the server! The same code written more manually looks like this:importrequestsresponse=requests.post('http://127.0.0.1:5000/api/',json={'id':0,'jsonrpc':'2.0','method':'scale','params':{'p':{'x':1,'y':2},'factor':3,},},)assertresponse.json()['result']=={'x':3,'y':6}In general, theInstantClientconstructor has two required parameters:A client from the jsonrpcclient libraryfor your desired transport. For example:fromjsonrpcclient.clients.zeromq_clientimportZeroMQClientfrominstant_clientimportInstantClientclient=InstantClient(ZeroMQClient("tcp://localhost:5000"),Methods())As a convenience, you can also just pass a string representing a URL, which will be used to construct anHTTPClient.An object defining your methods. The method body can be empty,InstantClientjust uses the signature and type hints to serialize the arguments and deserialize the result with the help ofdatafunctions.Themethodsattribute of the client is a simple proxy so that this:client.methods.scale(Point(1,2),factor=3)is equivalent to:client.request("scale",Point(1,2),factor=3)which in turn looks up the signature of the original method.Your IDE/linter/type-checker should think thatclient.methodsis the object you passed at the beginning, so you can get all the usual warnings and autocompletions. Adding your own type hint can help but shouldn't be necessary.
Package: instant-clip-tokenizer
Instant CLIP Tokenizer: a fast tokenizer for the CLIP neural networkInstant CLIP Tokenizer is a fast pure-Rust text tokenizer forOpenAI's CLIP model. It is intended to be a replacement for the original Python-based tokenizer included in the CLIP repository, aiming for 100% compatibility with the original implementation. It can also be used withOpenCLIPand other implementations using the same tokenizer.In addition to being usable as a Rust crate it also includes Python bindings built withPyO3so that it can be used as a native Python module.For the microbenchmarks included in this repository, Instant CLIP Tokenizer is ~70x faster than the Python implementation (with preprocessing and caching disabled to ensure a fair comparison).Using the libraryRust[dependencies]instant-clip-tokenizer="0.1.0"# To enable additional functionality that depends on the `ndarray` crate:# instant-clip-tokenizer = { version = "0.1.0", features = ["ndarray"] }Python(>= 3.9)pipinstallinstant-clip-tokenizerUsing the library requiresnumpy >= 1.16.0installed in your Python environment (e.g., viapip install numpy).Examplesuseinstant_clip_tokenizer::{Token,Tokenizer};lettokenizer=Tokenizer::new();letmuttokens=Vec::new();tokenizer.encode("A person riding a motorcycle",&muttokens);lettokens=tokens.into_iter().map(Token::to_u16).collect::<Vec<_>>();println!("{:?}",tokens);// -> [320, 2533, 6765, 320, 10297]importinstant_clip_tokenizertokenizer=instant_clip_tokenizer.Tokenizer()tokens=tokenizer.encode("A person riding a motorcycle")print(tokens)# -> [320, 2533, 6765, 320, 10297]batch=tokenizer.tokenize_batch(["A person riding a motorcycle","Hi there"],context_length=5)print(batch)# -> [[49406   320  2533  6765 49407]#     [49406  1883   997 49407     0]]TestingTo run the tests run the following:cargotest--all-featuresYou can also test the Python bindings with:maketest-pythonAcknowledgementsThe vocabulary file and original Python tokenizer code included in this repository are copyright (c) 2021 OpenAI (MIT-License).
Package: instant-distance
Instant Distance: fast HNSW indexingInstance Distance is a fast pure-Rust implementation of theHierarchical
Navigable Small Worlds paperby Malkov and Yashunin for finding
approximate nearest neighbors. This implementation powers theInstantDomainSearch.combackend services used for word vector indexing.What it doesInstant Distance is an implementation of a fast approximate nearest neighbor
search algorithm. The algorithm is used to find the closest point(s) to a given
point in a set. As one example, it can be used to makesimple translations.Using the libraryRust[dependencies]instant-distance="0.5.0"Exampleuseinstant_distance::{Builder,Search};fnmain(){letpoints=vec![Point(255,0,0),Point(255,0,0),Point(255,0,0)];letvalues=vec!["red","green","blue"];letmap=Builder::default().build(points,values);letmutsearch=Search::default();letcambridge_blue=Point(163,193,173);letclosest_point=map.search(&cambridge_blue,&mutsearch).next().unwrap();println!("{:?}",closest_point.value);}#[derive(Clone, Copy, Debug)]structPoint(isize,isize,isize);implinstant_distance::PointforPoint{fndistance(&self,other:&Self)->f32{// Euclidean distance metric(((self.0-other.0).pow(2)+(self.1-other.1).pow(2)+(self.2-other.2).pow(2))asf32).sqrt()}}TestingRust:cargo t -p instant-distance --all-featuresPython:make test-python
Package: instantdl
# InstandDL: An easy and convenient deep learning pipeline for image segmentation and classification[![Build Status](https://travis-ci.com/marrlab/InstantDL.svg?branch=develop-test)](https://travis-ci.com/marrlab/InstantDL)InstantDL enables experts and non-experts to use state-of-the art deep learning methods on biomedical image data. InstantDL offers the four most common tasks in medical image processing: Semantic segmentation, instance segmentation, pixel-wise regression and classification. For more in depth discussion on the methods, as well as comparing the results and bechmarks using this package, please refer to our preprint on bioRxiv [here](https://doi.org/10.1101/2020.06.22.164103)<p align=”center”>
<img src=”docs/Instand_DL_farbig_RGB.png”  width=”400” />
</p>## DocumentationFor documentation please refere to [docs](docs)For a short video introducing InstantDL please see:<a href=”http://www.youtube.com/watch?v=Wy4wlEyE2fA”>
<p align=”center”>
<img href=”InstantDL” src=”http://img.youtube.com/vi/Wy4wlEyE2fA/0.jpg”
width=”500” align=”center”>
</p>
<a>## ContributingWe are happy about any contributions. For any suggested changes, please send a pull request to thedevelopbranch.## CitationIf you use InstantDL, please cite this paper:` @article { author = {Waibel, Dominik Jens Elias and Shetab Boushehri, Sayedali and Marr, Carsten}, title = {InstantDL - Aneasy-to-usedeep learning pipeline for image segmentation and classification}, year = {2021}, doi ={10.1186/s12859-021-04037-3},URL ={https://bmcbioinformatics.biomedcentral.com/articles/10.1186/s12859-021-04037-3#article-info},eprint ={https://doi.org/10.1186/s12859-021-04037-3},journal = {BMC Bioinformatics} } `
Package: instanthost
Instant-HostHost static pages and Files from your Terminal. It can host your HTML, JSON, XML, and many non-binary files. All hosted files are encrypted and compressed.Installation$pipinstallinstanthostUsageUsage of Instanthost is very simpleHost new pageinstanthost~/path/to/fileOutput is like this✌️  Hosted Successfully ✨

created_at: 05/16/2021, 16:39:56

hosted_at: http://instant-host.herokuapp.com/render/U4uhdM4

mimetype: application/xml

private_key: U4uhdM4bnovt

public_key: U4uhdM4

tiny_url: https://tinyurl.com/yehcy54nEditing the existing pageYou can change the data in the file without causing any issues to link with the secret private key. Store your private key for editing content.instanthost~/path/to/new/file--edit--key<your-private-key>Output is✌️  Hosted Successfully ✨

hosted_at: http://instant-host.herokuapp.com/render/U4uhdM4

mimetype: application/xml

private_key: U4uhdM4bnovt

public_key: U4uhdM4

updated_at: 05/16/2021, 16:43:34

tiny_url: https://tinyurl.com/yehcy54nDelete the existing pageinstanthostdelete--key<your-private-key>Like this you can host all non-binary type file from your terminalyou can host your simple static web page, blog post and etc ..
Package: instantly
instantly is a simple tool that makes it incredibly quick and easy to
create, manage, and share project templates and setup projects. It
provides a command line tool, Python API, and web-interface so you can
expand templates exactly where you need to. It currently cleanly
supports Python 2.6 - 3.4 using pies
(https://github.com/timothycrosley/pies) to achieve this without ugly
hacks and/or py2to3.instantly create_my_next_big_thingInstalling instantlyInstalling instantly is as simple as:pip install instantlyor if you prefereasy_install instantly
Package: instantmailer
instant-mailerpipinstallinstantmailerA Python module that allows you to send instant mails using Python.
Python Requires <= 3.6FeaturesFully secured withSSLInstant mailsSend mails with attachmentAdditional LibrariesemailsslGetting Startedimportinstant-mailermail=instant-mailer.Mail("example@example.com","12345678")# Replace with your email and passwordAttributesawaitmail.send()Sends the emailParameters
	----------
	reciever: :class: `str`
		The recievers mail address
	body: :class: `str`
		The body of the mail
	subject: :class: `str`
		The subject of the mail
	bcc: :class: `str`
		The bcc of the mail
	attachment_name: :class: `str`
		The name of the attachment
	attachment_bytes: :class: `str`
		The bytes of the attachment
Package: instant-runoff
write e-mails in groff.SetupInstall.pip2 install instant-runoffThen add these macros to your muttrc.macro compose g '<pgp-menu>c<enter-command>set sendmail="instant-runoff"<enter><send-message><enter-command>set sendmail=/usr/lib/sendmail<enter>
macro compose <Esc>g '<pipe-entry>instant-runoff --preview<enter>
macro compose <Esc>r '<pipe-entry>instant-runoff --save<enter><attach-file>/tmp/runoff.txt<enter><attach-file>/tmp/runoff.groff<enter><edit-type>^A^Ktext/x-groff-ms<enter><previous-entry><previous-entry><detach-file>UsagePressgin mutt to send a multi-part html/txt/groff message;ESC+gcan be used to preview a message’s groff output.ESC+rwill replace the message with txt+groff and allow nor-
mal sending. This may be useful for encrypted groff-mails.instant-runoff is set up to use themsmacro package,
and preprocess input withtbl.
Package: instant-segment
Instant Segment: fast English word segmentation in RustInstant Segment is a fast Apache-2.0 library for English word segmentation. It
is based on the Pythonwordsegmentproject written by Grant Jenks,
which is in turn based on code from Peter Norvig's chapterNatural Language
Corpus Datafrom the bookBeautiful Data(Segaran and
Hammerbacher, 2009).For the microbenchmark included in this repository, Instant Segment is ~100x
faster than the Python implementation. The API was carefully constructed
so that multiple segmentations can share the underlying state to allow parallel
usage.How it worksInstant Segment works by segmenting a string into words by selecting the splits
with the highest probability given a corpus of words and their occurrences.For instance, provided thatchooseandspainoccur more frequently thanchoosesandpain, and that the pairchoose spainoccurs more frequently
thanchooses pain, Instant Segment can help identify the domainchoosespain.comasChooseSpain.comwhich more likely matches user intent.Read abouthow we built and improvedInstant Segment for use in production
atInstant Domain Searchto help our users
find relevant domains they can register.Using the libraryPython(>= 3.9)pipinstallinstant-segmentRust[dependencies]instant-segment="0.8.1"ExamplesThe following examples expectunigramsandbigramsto exist. See the
examples (Rust,Python) to see how to construct
these objects.importinstant_segmentsegmenter=instant_segment.Segmenter(unigrams,bigrams)search=instant_segment.Search()segmenter.segment("instantdomainsearch",search)print([wordforwordinsearch])-->['instant','domain','search']useinstant_segment::{Search,Segmenter};usestd::collections::HashMap;letsegmenter=Segmenter::new(unigrams,bigrams);letmutsearch=Search::default();letwords=segmenter.segment("instantdomainsearch",&mutsearch).unwrap();println!("{:?}",words.collect::<Vec<&str>>())-->["instant","domain","search"]Check out the tests for more thorough examples:Rust,PythonTestingTo run the tests run the following:cargo t -p instant-segment --all-featuresYou can also test the Python bindings with:make test-python
Package: instapaperlib
Python library for the instapaper.com API.http://instapaper.comUsageUse the library directly:import instapaperlib

instapaperlib.auth("username", "password")
instapaperlib.add_item("username", "password", "URL", "title")
# with selection test set
instapaperlib.add_item("username", "password", "URL", "title", "selection")Create an instance to work with:from instapaperlib import Instapaper

i = Instapaper("username", "password")
i.auth()Catch the return codes to work with:from instapaperlib import Instapaper

i = Instapaper("username", "password")
(statuscode, statusmessage) = i.add_item("URL", "title")Also catch the response header:from instapaperlib import Instapaper

i = Instapaper("username", "password")
(statuscode, statusmessage, title, location) = i.add_item("URL", "title", response_info=True)Or use the cli client:instapaper.py -u user -p password -t title URLIf you have set your username:password in ~/.instapaperrc:instapaper.py URLInstallationInstall via pip:pip install instapaperlibOr, if you must:easy_install instapaperlibContributingfork the repoadd your changes and tests so I don’t accidentally break anything in the futurerun the tests:python instapaperlib/instapaperlib.pyopen a pull request (also runs the tests via Travis CI)high-five yourself, you’re awesomeMetaProject:http://github.com/mrtazz/InstapaperLibraryIssues:http://github.com/mrtazz/InstapaperLibrary/issuesHistory0.5.1 (2016-01-13)fix travis.yml misconfig that only ran tests on master branch0.5.0 (2016-01-13)add support for new instapaper API0.4.0 (2010-09-06)add support for JSONPadd support for redirect=close0.3.1 (2010-06-05)add doctest unit testcatch exception in auth because of new query method0.3.0 (2010-05-24)Choose between HTTP/HTTPS (HTTPS standard)Set selection for added URLproper use of auto-title parameterResponse headers (Content-Location, X-Instapaper-Title) are returned0.2.0 (2010-05-20)Restructured as python packagePyPi compatibilityAdd CLI client0.1.0 (2010-05-01)Basic library workingWorking add_item