Saravanan666/pypi-org huggingface dataset:
Package: annotate-lineinfo
annotate_lineinfoThis IDAPython script/plugin will parse the PDB for the loaded executable and annotate the disassembly with source and line number information.UsageScriptOption 1) Runannotate_lineinfo.pyas a regular IDAPython script.Option 2) From another script or the IDAPython console:importannotate_lineinfoannotate_lineinfo.ida_annotate_lineinfo()PluginTo installOption 1) Runpython setup.py install --install-ida-plugin=PATHto installannotate_lineinfo_plugin.pytoPATH\pluginsIfPATHis not specified,%IDAUSR%will be tried firstIf%IDAUSR%does not exist, it defaults to%APPDATA%\Hex-Rays\IDA ProOption 2) Manually placeannotate_lineinfo_plugin.pyin thepluginsdirectory of your IDA installation.Annotate entire fileUse shortcut keyAlt-Shift-Aor run fromEdit->Annotate lineinfomenu.Disassembly view popup menuRight click inside a function, select annotateSelect a range of instructions, right click, select annotateFunctions view popup menuSelect one or more functions, right click, select annotateEach of the above actions has a correspondingremove annotationsaction.On load, annotate_lineinfo attempts to locate the PDB in the following locations:_NT_SYMBOL_PATHif setIDA's default PDB download directory%TEMP%\idaMSDIA defaults - Path in debug directory of executable, same path as executableYou may specify the PDB path manually, or request another auto-locate attempt (e.g. after IDA downloads the PDB),
from theEdit->Annotate lineinfomenu.CaveatsOnly runs on Windows. This script makes use of the COM API provided by msdia[ver].dll to parse the PDB.
Package: annotation-analysis
BRRAnnotation AnalysisPackage to analyse inter-annotator agreement.Simple package to compute Interannotation Agreement with a simple interface.Getting StartedInstall package:pip3installannotation_analysisExample usage:fromannotation_analysisimportinterannotator_metricsif__name__=="__main__":annotations=[["A","B","A"],["A","B","B"]]k_alpha=interannotator_metrics.krippendorff_alpha(annotations)f_kappa=interannotator_metrics.fleiss_kappa(annotations)print(k_alpha)print(f_kappa)Documentationfunction krippendorf_alpha(annotations:List[List],labels:Optional[List], ignore=Optional[List])"""Arguments:- annotations:- The list of annotations, assumed to be one "row" per annotator (i.e. annotations[0] is annotator #1).- Number of Columns represents the number of datapoints.- Important: at this stage only hashable values are allowed.- E.g. with labels ["A","B"], and three datapoints and 2 annotators the following would be the valid structure:- [["A","B","A"],["A","B","B"]],- Annotator #1 (index=0) -> ["A","B","A"]- Annotator #2 (index=1) -> ["A","B","B"]- labels:- Represents the optional list of valid labels.- Important: at this stage only hashable values are allowed.- ignore:- Represents a list of optional labels that should be ignored- I.e. If this is non-empty then for any datapoint, if any of the annotators has the ignored label, the data point with all annotators is ignoredReturn:- Krippendorff Alpha score for all annotators."""function fleiss_kappa(annotations:List[List],labels:Optional[List], ignore=Optional[List])"""Arguments:- annotations:- The list of annotations, assumed to be one "row" per annotator (i.e. annotations[0] is annotator #1).- Number of Columns represents the number of datapoints.- Important: at this stage only hashable values are allowed.- E.g. with labels ["A","B"], and three datapoints and 2 annotators the following would be the valid structure:- [["A","B","A"],["A","B","B"]],- Annotator #1 (index=0) -> ["A","B","A"]- Annotator #2 (index=1) -> ["A","B","B"]- labels:- Represents the optional list of valid labels.- Important: at this stage only hashable values are allowed.- ignore:- Represents a list of optional labels that should be ignored- I.e. If this is non-empty then for any datapoint, if any of the annotators has the ignored label, the data point with all annotators is ignoredReturn:- Fleiss Kappa score for all annotators."""(C) - Nikolai Rozanov 2022
Package: annotationfactory
IntroductionAnnotation-Factory Python SDK. This package works specifically with Microsoft Cognitive Services detection results.AnnotationWritertakes a JSON object received from Cognitive Services and produces annotation files in both VOC and YOLO formats for use in training machine learning models.Getting StartedInstallannotationfactorypackage via pip:pip install annotationfactorySample to usefromannotationfactory.annotationwriterimportAnnotationWriterimportannotationfactory.annotationconverterasconverterexample={'tagId':0,'tagName':'Apples','region':{'left':0.288039029,'top':0.411838,'width':0.291451037,'height':0.4237842}}# Initialise AnnotationWriter.writer=AnnotationWriter()# Initialise annotation handlers.writer.initVoc("test.jpg",608,608)writer.initYolo()# Add VOC object to writer.writer.addVocObject(example)writer.addVocObject(example)# Add YOLO object to writer.writer.addYoloObject(example)writer.addYoloObject(example)# Output VOC annotations to file.writer.saveVoc("myannotation.xml")# Output YOLO annotations to file.writer.saveYolo("myannotation.txt")# Converts VOC annotations back to CustomVision annotation format.voc2cv=converter.convertVocFromPath("myannotation.xml")# Converts YOLO annotations back to CustomVision annotation format.# Requires a txt file with list of label names as an input.yolo2cv=converter.convertYoloFromPath("myannotation.txt","class.names")Run locallypip install -r requirements.txt 
python example/test.pyContributingThis project welcomes contributions and suggestions.  Most contributions require you to agree to a
Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us
the rights to use your contribution. For details, visithttps://cla.microsoft.com.When you submit a pull request, a CLA-bot will automatically determine whether you need to provide
a CLA and decorate the PR appropriately (e.g., label, comment). Simply follow the instructions
provided by the bot. You will only need to do this once across all repos using our CLA.This project has adopted theMicrosoft Open Source Code of Conduct.
For more information see theCode of Conduct FAQor
contactopencode@microsoft.comwith any additional questions or comments.
Package: annotation-tool
InstallationAll stable versions can be installed fromPyPIby usingpipor your favorite package managerpip install annotation-toolYou can get pre-published versions fromTestPyPIor this repositoryTest PyPI:pip install -i https://test.pypi.org/simple/ --extra-index-url https://pypi.org/simple/ annotation-toolFrom Source:pip install git+https://github.com/TUD-Patrec/annotation-tool@masterAfter installation the annotation tool can be run as simple asannotation-toolDevelopmentRequirements:Python 3.8 or higherpoetry1.2 or highermakedocker(if you want to build the binaries)For installing the development environment runmakesetup
Package: annotation-validation
Annotation ValidationAnnotation Validation ensures type checking for function annotations.Free software: MIT licenseDocumentation:https://annotation-validation.readthedocs.io.FeaturesValidates input to match data types of annotations of function argumentsValidates output to match data type of annotation of return argumentUsed as a decorator!Possible ImprovementsValidation of ranges of inputThrow warnings instead of errorsLoggingCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.Inspiration is fromthis blog post.History0.1.1 (2019-02-05)Adding caching togetfullargspecandget_type_hints.0.1.0 (2019-02-04)First release on PyPI.
Package: annot-attrs
annot_attrsDesigned to get list of annotated but not defined/not used attrs from class (not instance!).may be helpful further in instance to check that really have values.Featuresget set of unused attributes from class(not instance!)work with nested classesget valuesby case insensitive namesby dict key access methodwork on any object (over Obj parameter!)at least for NamedTupleLicenseSee theLICENSEfile for license rights and limitations (MIT).Release historySee theHISTORY.mdfile for release history.Installationpip install annot-attrsImportfromannot_attrsimport*GUIDE1. inheritanceBEST practice - dont mess classes! use as separated object!fromannot_attrsimport*classCls:ATTR1:intATTR2:int=2obj=Cls(1)assertAnnotAttrs().annots_get_set(obj)=={"ATTR1",}assertAnnotAttrs().annots_get_dict(obj)=={"ATTR1":1,}fromannot_attrsimport*classCls(AnnotAttrs):ATTR1:intATTR2:int=2assertCls().annots_get_set()=={"ATTR1",}classCls2(Cls):ATTR1:int=2ATTR3:intassertCls2().annots_get_set()=={"ATTR1","ATTR3",}inst=Cls2()inst.ATTR1=1inst.ATTR2=1inst.ATTR3=1assertCls2().annots_get_set()=={"ATTR1","ATTR3",}assertCls().ATTR2==2assertCls().attr2==2assertCls()["ATTR2"]==2assertCls()["attr2"]==2obj=Cls()try:obj.annots_get_dict()exceptExx_AttrNotExist:passelse:assertFalseobj.ATTR1=1assertobj.annots_get_dict()=={"ATTR1":1}2. Indepandant usagefromannot_attrsimport*try:classCls(AnnotAttrs,NamedTuple):ATTR1:intATTR2:int=2exceptTypeError:# TypeError: can only inherit from a NamedTuple type and Genericpasselse:assertTrueclassCls(NamedTuple):ATTR1:intATTR2:int=2obj=Cls(1)assertAnnotAttrs().annots_get_set(obj)=={"ATTR1",}assertAnnotAttrs().annots_get_dict(obj)=={"ATTR1":1}
Package: annotell-auth
Annotell AuthenticationPython 3 library providing foundations for Annotell Authentication
on top of therequestsorhttpxlibraries.Install withpip install annotell-auth[requests]orpip install annotell-auth[httpx]Builds on the standard OAuth 2.0 Client Credentials flow. There are a few ways to provide auth credentials to our api
clients. Annotell Python clients such as inannotell-input-apiaccept anauthparameter that
can be set explicitly or you can omit it and use environment variables.There are a few ways to set your credentials inauth.Set the environment variableANNOTELL_CREDENTIALSto point to your Annotell Credentials file.
The credentials will contain the Client Id and Client Secret.Set to the credentials file path likeauth="~/.config/annotell/credentials.json"Set environment variablesANNOTELL_CLIENT_IDandANNOTELL_CLIENT_SECRETSet to credentials tupleauth=(client_id, client_secret)API clients such as theInputApiClientaccept thisauthparameter.Under the hood, they commonly use the AuthSession class which is implements arequestssession with automatic token
refresh. Anhttpximplementation is also available.fromannotell.auth.requests.auth_sessionimportRequestsAuthSessionsess=RequestsAuthSession()# make call to some Annotell service with your token. Use default requestssess.get("https://api.annotell.com")Changelog2.0.0 (2022-05-02)Refactor for backend separation, with optional dependencies for eitherhttpxorrequests.1.8.0 (2022-04-12)Initial support for httpx (BETA). Solves refresh token expiry by reset without theFaultTolerantAuthRequestSessionThe library will be refactored by a breaking 2.0 release, and make the same changes to the requests version.
Theauthsessionmodule backed byrequestsis untouched for now.1.7.0 (2022-04-11)Fix compatibility issue with authlib >= 1.0.0. Resetting the auth session failed, when the refresh token had expired.1.6.0 (2021-02-21)Expose underlyingrequests.SessiononFaultTolerantAuthRequestSessionFix some thread locks1.5.0 (2020-10-20)AddFaultTolerantAuthRequestSessionthat handles token refresh on long running sessions.1.4.0 (2020-04-16)Add support forauthparameter, with path to credentials file orAnnotellCredentialsobjectDrop support for legacy API token
Package: annotell-export
Annotell Export API ClientPython 3 library providing access to Annotell Export APITo install with pip runpip install annotell-exportExampleSet env ANNOTELL_CREDENTIALS to the credentials file provided to you by Annotell,
seeannotell-auth.ChangelogAll notable changes to this project will be documented in this file.[0.2.1] - 2022-08-09Bump annotell-auth to 2.0.1[0.2.0] - 2020-11-09Update docsBump annotell-auth to 1.5.0[0.1.0] - 2020-09-28First draft
Package: annotell-openlabel
Annotell OpenLABELInstallationInstall the Annotell OpenLABEL package from pip withpip install annotell-openlabelSerialization and deserializationSince all models inherit frompydantic'sBaseModel, serialization and deserialization from dicts or json strings are relatively straight forward.data={"openlabel":{"metadata":{"schema_version":"1.0.0"}}}importannotell.openlabel.modelsasOLM# Deserialize dictopenlabel_annotation=OLM.OpenLabelAnnotation.parse_obj(data)# Serialize to jsonjson_data=openlabel_annotation.json(exclude_none=True)# Deserialize jsonopenlabel_annotation=OLM.OpenLabelAnnotation.parse_raw(json_data)# Serialize to dictdict_data=openlabel_annotation.dict(exclude_none=True)Further readinghttps://www.asam.net/project-detail/asam-openlabel-v100/Changelog[0.1.4] - 2022-01-24Improved serializability for enum classes[0.1.3] - 2022-01-04Fixed issues with version 0.1.2[0.1.2] - 2021-12-29Updated several fields with multiple types to fix issues with serialization and deserialization.
For example, the coordinates onPoly2dobjects were previously always parsed to strings.
This update means that an attempt to parse them to floats is made. If this fails the they will be parsed to strings.[0.1.1] - 2021-11-24Updated stream properties model generation to be nicer to work with[0.1.0] - 2021-11-18Updated json schema and model to be true to the 1.0.0 release of openlabel. Previously it was based on the release-candidate
Package: annotell-query
Annotell Query API ClientPython 3 library providing access to the Annotell Query API.To install with pip runpip install annotell-querySet env ANNOTELL_CREDENTIALS, seeannotell-auth.Judgement Query ExampleStream all items matching a queryfromannotell.query.query_api_clientimportQueryApiClientquery_client=QueryApiClient()resp=query_client.query_judgements(query_filter="requestId = X")foriteminresp.items():print(item)Change log2.5.0A new base Query client that can be inherrited for other applications2.4.1Useannotell-auth[requests]>=2.0.02.3.0Useannotell-auth>=1.6Remove metadata queries2.2.0Useannotell-auth>=1.5with fault tolerant auth request session2.1.0Use server default query limits2.0.0Rename library toannotell-queryRenameQueryApitoQueryApiClientAdd KPI query method1.3.0Change constructor for authentication to only acceptauth.
Package: annotest
aNNoTestaNNoTest is a tool (and an approach) to automatically
generating bug-finding inputs for NN program testing.
PaperAn annotation-based approach for finding bugs in
neural network
programsby
Mohammad Rezaalipour and Carlo A. Furia explains aNNoTest
in details and provides guidelines on how to use it, effectively.InstallationRun the following command to install aNNoTest:pip install annotestWe have tested aNNoTest on Python 3.6.
But it should work on Python 3.6+ as well.Using aNNoTestaNNoTest is a command line tool.
After annotating your project with
aN (aNNoTest's annotation language)
you cancdto your project directory
and then run aNNoTest.cd path_to_python_projectannotestOr you can input the project path to aNNoTest:annotest path_to_python_projectExamplesTo see examples of using aNNoTest, see
the following repository:https://github.com/atom-sw/annotest-subjectsCitationsaNNoTest's Journal
Paper:@article{Rezaalipour:2023,
title = {An annotation-based approach for finding bugs in neural network programs},
journal = {Journal of Systems and Software},
volume = {201},
pages = {111669},
year = {2023},
issn = {0164-1212},
doi = {https://doi.org/10.1016/j.jss.2023.111669},
url = {https://www.sciencedirect.com/science/article/pii/S016412122300064X},
author = {Mohammad Rezaalipour and Carlo A. Furia},
keywords = {Test generation, Neural networks, Debugging, Python}
}MirrorsThe current repository is a public mirror of
our internal private repository.
We have two public mirrors, which are as follows:https://github.com/atom-sw/annotesthttps://github.com/mohrez86/annotest
Package: annotlib
annotlib: Simulation of Annotatorsauthors: Marek Herde and Adrian CalmaIntroductionannotlibis a Python package for simulating annotators in an active learning setting.
Solving classification problems by using supervised machine learning models requires samples assigned to class labels.
However, labeling these samples causes costs (e.g. workload, time, etc.), so that active learning strategies aim at reducing these costs by selecting samples, which are the most useful for training a classifier.In real-world scenarios, human annotators are often responsible for providing the class labels.
Unfortunately, there is no guaranty for the omniscience of such annotators.
Hence, annotators are prone to error, respectively uncertain, so that the class labels assigned to samples may be false.
The labeling performance of an annotator is affected by many factors, e.g. expertise, experience, concentration, level of fatigue and so on.
Moreover, the difficulty of a sample influences the outcome of a labeling process.To evaluate an active learning strategy in the setting of uncertain annotators, class labels of these uncertain
annotators are required to be available, but there is a lack of publicly accessible real-world data sets labeled by error-prone annotators.
As a result, recently published active learning strategies are evaluated on simulated annotators where the used simulation techniques are diverse.
Our developedannotlibPython package represents a of these techniques and implements additional methods, which simulate realistic characteristics of uncertain annotators.
This way, we establish a library simplifying and standardising the evaluation of active learning strategies coping with uncertain annotators.For more information go to thedocumentation.
Package: annotmerge
This Library helps in merging multiple Pascall VOC Annotation file into a single Annotation.The Package contains a single function called merge. Which takes a single param: base_directory
you need to specity the folder name where your multiple annotation files are present and then a log
is created and also output directory is created with merged files and foldersThe Structure of folderChange Log0.0.1 (12/02/2021)First Release
Package: annots
Annotsannotsis the package that allow to use Python 3.6 variable annotations in handy way. Thanks for inspiration toattrslibrary.When you wrap a class withannotsdecoratorimport annot

@annot.s
class Account:
    __tablename__ = 'account'

    username: str
    password: strAnnots add class attribute annotations into__init__class Account:
    def __init__(self, username, password):
        self.username = str
        self.password = strFree software: MIT licenseDocumentation:https://annots.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.2 (2017-01-09)Fix value initialization errorAdd type annotation for args into__init__functionUpdate test0.1.1 (2017-01-08)Add few tests0.1.0 (2017-01-08)First release on PyPI.Working version with basic annotation support
Package: annot-utils
annot_utilsIntroductionannot_utilsis a software for generating tabix-indexed annotation files, which can be shared by other softwares by Y.S.
Currently, this software support only annotatioin files for hg19 (GRCh37), hg38 (GRCh38) and mm10 (GRCm38).DependencyPython packagespkg_resourcesSoftwarehstlibInstallannot_utilsis available through pypi.
To install, type:pip install annot_utilsWhen you are not the root user, you may want to type:pip install annot_utils --userAlternatively, install from the source code:wget https://github.com/friend1ws/annot_utils/archive/v0.3.0.tar.gz
tar xzvf v0.3.0.tar.gz 
cd annot_utils-0.3.0
python setup.py build install --userThis package has been tested on Python 2.7, 3.5, 3.6.Update databseCurrently,annot_utilsalready store annotation files fromUCSC genome browserand several other sources upon installation.
If you want to update the annotation files:cd annot_utils/resource
bash prep_data.shThen, install the software from the source code.CommandsgeneGenerate gene annotation bed flies indexed by tabix.annot_utils gene [-h] 
                 [--gene_model {refseq,gencode}] [--grc]
                 [--genome_id {hg19,hg38,mm10}] [--add_ref_id]
                 gene.bed.gzexonGenerate exon annotation bed flies indexed by tabix.annot_utils exon [-h] 
                 [--gene_model {refseq,gencode}] [--grc]
                 [--genome_id {hg19,hg38,mm10}] [--add_ref_id]
                 exon.bed.gzcodingGenerate regional (coding, intronic, 5'UTR, 3'UTR and so on) annotation bed flies indexed by tabix.annot_utils coding [-h] 
                   [--gene_model {refseq,gencode}] [--grc]
                   [--genome_id {hg19,hg38,mm10}] [--add_ref_id]
                   coding.bed.gzjunctionGenerate annotated splicing junction bed files indexed by tabix.annot_utils junction
usage: annot_utils junction [-h] 
                            [--gene_model {refseq,gencode}] [--grc]
                            [--genome_id {hg19,hg38,mm10}] [--add_ref_id]
                            junction.bed.gzboundaryGenerate exon intron boundary annotation files index by tabix.annot_utils boundary [-h] 
                     [--genome_id {hg19,hg38,mm10}] [--grc]
                     [--donor_size donor_size]
                     [--acceptor_size acceptor_size]
                     boudary.bed.gz
Package: annotype
Annotypecombines Python 3 annotations and Marshmallow for powerful
validation of function arguments.fromannotypeimportannotypedfrommarshmallowimport(Schema,fields)classPersonSchema(Schema):firstname=fields.Str(required=True)lastname=fields.Str(required=True)@annotyped()defsalute(person:PersonSchema):print'Hello{}{}'.format(person['firstname'],person['lastname'])person=dict(firstname='John')# This will raise a ValidationError because lastname is not definedsalute(person)@annotyped()defwelcome(firstname:fields.Str(),lastname:fields.Str()):print'Welcome{}{}'.format(firstname,lastname)# This will also raise a ValidationError because lastname is not a stringwelcome('Jane',1)In short, annotype allows you to validate data using the powerful
marshmallow library and the Python 3 annotations.Get It Now$ pip install -U annotypeDocumentationSee marshmallow documentation available herehttp://marshmallow.readthedocs.io/.RequirementsPython >= 3.4marshmallow >= 3.0.0LicenseMIT licensed. See the bundledLICENSEfile for more details.
Package: annotyped
annotypedAnnotyped is a simple library with utilities and decorators for type checking and type casting automatically
on annotated functions at runtime.pip install annotyped --userThe basics# Simple typecheck, this uses the instance checker to check equality.# You can set your own with `@annotyped.checkers.custom(callable)`@annotyped.checkdefadd(a:int,b:int)->int:returna+badd(1,2)# 3add(2,'10')# Param 'b' requires type '<class 'int'>', found '<class 'str'>': '10'# Simple typecast, this runs the annotation like it were an expression and uses the# result  `annotation(value)`@annotyped.castdefadd(a:int,b:int)->str:returna+badd('10','20')# '30'add(1,2)# '3'add('1.1',2)# Param 'a' could not convert to '<class 'int'>' from '<class 'str'>': invalid literal for int() with base 10: '1.1'Custom converters / casterseg:Convert from a tuple or a str into namedtuple.importannotypedimportmathfromcollectionsimportnamedtuplePosition=namedtuple('Position','x, y')defposition(pos):ifisinstance(pos,str)and','inpos:pos=map(int,pos.split(','))returnPosition(*pos)@annotyped.castdefdiff(p1:position,p2:position):returnmath.sqrt((p2.x-p1.x)**2+(p2.y-p1.y)**2)p1=(10,20)p2='20,50'print(diff(p1,p2))