Saravanan666/pypi-org huggingface dataset:
Package: attribute-name-validator
attribute-name-validatorThis pacakge provides a CLI for column name analysis. It also acts as library for catalog of approved abbreviations and codified column naming rules.The CLI, when provided a text file with column names used in the physical data layer for a given entity,
generates a report, based on Data Modeling and Naming Standards defined within this repository.SeeATTRIBUTE NAMING GUIDELINES AND ANALYSIS REPORT USAGEfor further
information pertaining to the issues faced during the naming of columns and how this package
can be used to get feed back on column names, and help standardize column naming.SeeCONTRIBUTING.mdfor information pertaining to
development of this package.InstallInstall the package using pip from githubpip3installgit+https://github.com/siddartham/attribute-name-validator.gitUsageReport of each execution has the catalog of class words, acronyms included. This way, we can see the source data set, based on which reports were produced and lookup approved acronyms.Work Flow$anv-h
usage:attribute-name-validator[-h][-l][--write-to-text-files]target_path

Thiscommandgeneratesreportonnaminganalysisfromeitheralistofcolumnnamefilesinafolder,
oragivencolumnnamesfile,bylookingupthewordsusedtothecolumnnamesinalocalAbbreviationcatalogthatcomeswiththeinstallationofpackage.Ontheexecutionofthiscommand,youwillalsohaveareports
foldercreatedwithCATALOG.xlsxandCOLUMN_NAMING_GUIDELINES_AND_ANALYSIS_REPORT_USAGE.htmlfiles,
whichhavemoreinformationrelatedtotheworkingofthetool

ToaddasetofClassWordsAbbreviationsandAcronyms,asexceptionsbeyondcurrententerpriseguidelines
createncna.inifileandaddexceptionsunderrespectivesections,asshownbelow[additional-catalog]acronyms=LOB
class-word-abbreviations=IN,IN3,CM3,LB

positionalarguments:target_pathPathtofilewithcolumnnamesorfolderwithcolumnnamefilestoanalyze

optionalarguments:-h,--helpshowthishelpmessageandexit-l,--logThisflag,ifpresent,showslogsofexecutioninsys.stdout.--write-to-text-files,-wttfThisflag,ifpresent,alsocreatestextfilesofreportsundertheirrespectiveentityspecificfolder.Provide a relative/absolute path to file with the list of column names to be used for the entity, with each column in a new line.$anv<PATH_TO_<ENTITY_NAME>>
$lsreports/
ATTRIBUTE_NAMING_GUIDELINES_AND_REPORT_USAGE.htmlCATALOG.xlsxTABLE_NEW_REPORT.xlsx
$anv<PATH_TO_ENTITY_FOLDER>
$lsreports/
ATTRIBUTE_NAMING_GUIDELINES_AND_REPORT_USAGE.htmlENTITY_1_REPORT.xlsxENTITY_3
CATALOG.xlsxENTITY_2ENTITY_3_REPORT.xlsx
ENTITY_1ENTITY_2_REPORT.xlsxTASK LOGSeeTASKLOG.mdfor information pertaining to the development history of the package and
the next set of tasks.
Package: attributes
attributesa python version attribute like attribute of csharp.UsagefromattributesimportAttributeclassData(Attribute):# make your own attributedef__init__(self,*args,**kwargs):self.args=argsself.kwargs=kwargs@Data(1,2)# use your attributeclassSomeClass:passdata,=Attribute.get_attrs(SomeClass)# than load on runtime and use it.Parameter Attribute@param_attr('a',Data(1,2),Data(3,4))deffunc(a):passdata,=Attribute.get_attrs(param_of(func,'a'))# ordata,=Data.get_from_param(func,'a')
Package: attributes-doc
attributes-docHacky implementation ofPEP 224.UsageThis package provides the following functions:attributes_docget_attributes_docenum_docget_docDecoratorattributes_docThis function is a class decorator, and using it on a class will set class attributes called__doc_ATTRNAME__for each existing attribute.fromattributes_docimportattributes_doc@attributes_docclassFoo:bar=1"""This is the docstring for the bar attribute.It will be stored in `Foo.__doc_bar__` and will be accessible at runtime."""baz=2"""This is the docstring for the baz attribute."""print(Foo.__doc_bar__)print(getattr(Foo,"__doc_baz__"))Functionget_attributes_docThis function will return a dictionary with the docstrings for all attributes of a class without setting them.fromattributes_docimportget_attributes_docclassGoo:"""This class doesn't use attributes_doc and we don't want to modify it at all."""bar=1"""This is the docstring for the bar attribute."""baz=2"""This is the docstring for the baz attribute."""docs=get_attributes_doc(Goo)print(docs["bar"])print(docs["baz"])Decoratorenum_docThis is also a class decorator, but it is intended for Enum classes. Instead of setting one doc attribute per attribute to the containing class, it will set the__doc__attribute for each enum value.fromattributes_docimportenum_docfromenumimportEnum@enum_docclassFoo(Enum):bar=1"""This is the docstring for the bar attribute."""baz=2"""This is the docstring for the baz attribute."""print(Foo.bar.__doc__)Functionget_docThis function will return the docstring of an attribute of a class.fromattributes_docimportget_docprint(get_doc(Foo,"baz"))# Instead of getattr(Foo, "__doc_baz__") above
Package: attribution
Automate releases and changelogs based on commit tags and shortlogs.attribution provides a simple tool for automating a basic release workflow
for Python projects. At its core, it generates Markdown-formatted changelogs
based on the version tags in your repository, and can both fit into existing
workflows, or automate the entire release preparation process with a single
command.When generating a changelog, attribution will find all tag names starting with
“v” followed by a validPEP 440 version identifier. It will then use the
message from each tag, combined with the “shortlog”, to generate an ordered
changelog that includes recognition for all contributers to your project.
The output can be saved to your preferred changelog file, or piped to other
tools as part of your release workflow:$attributiongenerateproject name
============

v0.2
----

Another release

```$gitshortlog-sv0.1...v0.21 Ash
    3 Misty
```

v0.1
----

First release

```$gitshortlog-s...v0.11 Ash
```If you prefer and end-to-end solution, attribution can also be used for creating
release notes, updating a__version__.pyfile with a matching version,
and tagging a signed version bump commit containing the final changelog:$attributiontag-m"Final release"1.0$headCHANGELOG.mdproject name
============

v1.0
----

Final release

```$gitshortlog-sv0.2...v1.03 Ash
    2 Brock
```attribution is a fully bootstrapped project. TheChangelogis generated by
attribution, and from version 1.2.0 onward, all releases are created with
attribution as well.Installattribution requires Python 3.7 or newer.
You can install it from PyPI:$pipinstallattributionattribution should guess reasonable defaults for most common Python projects,
but for best results, you should initialize your project configuration:$attributioninitProject name [attribution]:
Package namespace [attribution]:
Use __version__.py file [Y/n]:This will automatically add the appropriate configuration to your project’spyproject.toml:[tool.attribution]name="attribution"package="attribution"version_file=trueMore details can be found in theUser Guide.Licenseattribution is copyrightAmethyst Reese, and licensed under
the MIT license. I am providing code in this repository to you under an open
source license. This is my personal repository; the license you receive to my
code is from me and not from my employer. See theLICENSEfile for details.
Package: attribution-quality
Attribution QualityThis package was designed to both generate explanations for deep learning segmentation models as well as to provide comprehensive metrics for evaluating new explanation methods.We have included our novel explanation method, Kernel-Weighted Contribution, as well as a number of other XAI methods adapted for use with segmentation models. With the additional use of ourexplanation ground-truth dataset, we can evaluate the quality of these methods and provide a comprehensive comparison of their performance.Startup InstructionsNote - We usemambato install packages, but you can usecondain the same way if you prefer.Installattribution_qualityrequirementsEitherinstall torch or build from sourcemamba install -c conda-forge numpy scikit-image tqdmInstallattribution_qualityMETHOD 1 (recommended)pip install attribution_quality --no-depsMETHOD 2 (for local development)git clone git@github.com:Mullans/AttributionQuality.gitcd AttributionQualitypip install -e . --no-deps(Optional) Install SimpleITK and matplotlib for the example notebooks and for some evaluation metricsmamba install -c simpleitk -c conda-forge simpleitk matplotlibnnUNet Setup Instructions (optional)Note: We used nnUNet for the experiments described in our paper. You can skip this section unless you want to reproduce our results.Install nnUNet requirementsmamba install -c conda-forge -c simpleitk dicom2nifti medpy scikit-learn simpleitk pandas nibabel matplotlibpip install batchgeneratorsInstall nnUNet v1git clone -b nnunetv1 --single-branch git@github.com:MIC-DKFZ/nnUNet.gitcd nnunetpip install -e . --no-depsFinish setting up nnUNetSetnnUNet_raw_data_base,nnUNet_preprocessed, andRESULTS_FOLDERenvironment variablesAttribution Quality Example Notebooksexamples/SingleLayer_Example.ipynb- Example Jupyter notebook showing how to use this package to generate explanations for a single layer of a segmentation modelexamples/Full_KWC_Example.ipynb- Example Jupyter notebook showing how to run Kernel-Weighted Contribution on all layers of a segmentation model and evaluate the resulting attribution mapCurrently included methods of explanation:Kernel-Weighted ContributionScoreCAMGradCAMGradCAM++LayerCAMXGradCAMElement-wise GradCAMHiResCAM
Package: attribuutit
attribuutitNodes, Edges, Faces, and Attributes (Finnish: "Solmut, reunat, pinnat ja attribuutit").License: MITDocumentationUser and developerdocumentation of attribuutit.Bug TrackerFeature requests and bug reports are bested entered in thetodos of attribuutit.Primary Source repositoryThe primary source repository ofattribuutit is at sourcehuta collection of tools useful for software development.StatusExperimental.NoteThe default branch isdefault.
Package: attridict
attridictA Python package implementing atrribute dictionary.This provides an easier and cleaner way to access dict values using their keys as attributes. It is typically a dict child, maintaining all the dict functionalities, but including some extra features.InstallationTo install the package from PyPI, use:pip install attridictUsageCreating an attridict object>>>importattridict>>>att=attridict()>>>att{}>>>att.foo="bar">>>att.foo'bar'>>>att{'foo':'bar'}A dict can be converted into an attridict object by passing it as an argument>>>importattridict>>>data={'red':'hot','blue':'cold'}>>>colors=attridict(data)>>>colors{'red':'hot','blue':'cold'}>>>colors.red'hot'Modifying attridict object>>>importattridict>>>data={'red':'hot','blue':'cold'}>>>colors=attridict(data)>>>colors{'red':'hot','blue':'cold'}>>>colors.blue'cold'>>>colors.blue="sky">>>colors.red="rose">>>colors.blue'sky'>>>colors.red'rose'>>>colors{'red':'rose','blue':'sky'}>>>colors.green="grass">>>colors{'red':'rose','blue':'sky','green':'grass'}Typicaldictoperations work on attridict objects>>>importattridict>>>data={'red':'rose','blue':'sky'}>>>colors=attridict(data)>>>colors{'red':'rose','blue':'sky'}>>>colors.red'rose'>>>colors["red"]'rose'>>>colors["red"]="tomato">>>colors["red"]'tomato'>>>colors.red'tomato'Nested attribute access>>>importattridict>>>data={'foo':{}}>>>att=attridict(data)>>>att{'foo':{}}>>>att.foo.bar='baz'>>>att.foo.bar'baz'>>>att{'foo':{'bar':'baz'}}YAML serializable>>>importattridict>>>importyaml>>>data={'foo':{'bar':'baz'}}>>>att=attridict(data)>>>yaml.dump(att)'!attridict\nfoo:\nbar: baz\n'>>>yaml.safe_dump(att)'foo:\nbar: baz\n'LicenseThe project is MIT licensed
Package: attrify
AttrifyAccess python dict keys as attributesInstallationInstall using pip:pip install attrifyExamplesConvert normal dictfromattrifyimportAttrifynormal_dict={'name':'Cool'}attrified_dict=Attrify(normal_dict)# orattrified_dict=Attrify(**normal_dict)assertattrified_dict['name']==attrified_dict.nameConvert complex nested dictcomplex_nested_normal_dict={"data":{"results":[{"name":"something"},{"name":"anything"}]}}complex_nested_attrified_dict=Attrify(complex_nested_normal_dict)# orcomplex_nested_attrified_dict=Attrify(**complex_nested_normal_dict)assertcomplex_nested_attrified_dict.data.results[0].name==complex_nested_normal_dict['data']['results'][0]['name']Convert back to dictnormal_dict={'name':'Cool'}attrified_dict=Attrify(normal_dict)asserttype(attrified_dict.to_dict())==type(normal_dict)Keys inside dir:Will only contain with alphabetic keys, To see which keys are considered alphabetic seehelp(str.isalpha)attrified_dict=Attrify({'name':'Cool'})print(dir(attrified_dict))# List return will contain the key 'name'.There is also a shortcut method to prettify dict, Just calls json.dumps with some args set.print(complex_nested_attrified_dict.prettify())
Package: attrs2bin
attrs2binattrs2binis a Python library that lets you serialize/deserialize yourattrs-based classes to/from a byte stream. It is compatible with Rust'sbincode, so you can seralize objects in Python, send the resulting byte stream through a socket or any other transport and deserialize it back to a Rust object. It can also deserialize objects from a socket (see below).Exampleattrs2binprovides just two simple funcions:serialize(), which takes an object and returns a byte stream, anddeserialize(), that takes a byte stream and anattrs-based class and returns an object.import attrs2bin

@attr.s(auto_attribs=True)
class Sprite:
    name: str
    x: int
    y: int

my_sprite = Sprite("My sprite", 35, 70)
serialized = attrs2bin.serialize(my_sprite)
deserialized = attrs2bin.deserialize(serialized, Sprite)
assert my_sprite == deserializedWhat can be serialized?Objects of anyattrs-based class can be serialized, as long as all their fields have a type (using type annotations orattr.ib(type=...)).attrs2binships with serializer for the following types:intfloatbytesstrboolYou can create and register your own serializers for specific types by creating a class that implementsattrs2bin.interfaces.ITypeSerializerand callingattrs2bin.register_serializer().Deserializing from a socketInstead ofdeserialize(bytes, cls), you can usedeserialize_from_socket(sck, cls), which will read the necessary bytes from a socket and return a Python object.sckmust be any object that implementsattrs2bin.interfaces.IReadableSocket.Rust compatibilityThe serializers that ships withattrs2binare all compatible with Rust'sbincodelibrary. Keep under your pillow the following table in order to create compatible types between Python and Rust:Python typeRust typeint/attrs2bin.SignedInti64attrs2bin.UnsignedIntu64float/attrs2bin.Float64f64attrs2bin.Float32f32bytesVec<u8>strStringboolbool
Package: attrsmallow
Welcome toattrsmallowDocumentationattrsis a powerful library helps you to write concise and correct classes. Andmarshmallowis a powerful framework to write serializer/deserializer and data validator for complex object.attrsmallowis a glue layer to taking advantage from them.Quick LinksUsageA blog example:importattrimportmarshmallowfromattrsmallowimportBaseModel,BaseSchema@attr.sclassUser(BaseModel):id=attr.ib()name=attr.ib()classUserSchema(BaseSchema):id=fields.Integer(required=True)name=fields.String(required=True)Model=UserUser.Schema=UserSchema@attr.sclassPost(BaseModel):id=attr.ib()title=attr.ib()user=attr.ib()classPostSchema(BaseSchema):id=fields.Integer()title=fields.String()user=fields.Nested(UserSchema)Model=PostPost.Schema=PostSchemapost_data=dict(id=1,title="Hello World!",user=dict(id=1,name="Alice"))post=Post.load(post_data)Installattrsmallowis released on PyPI, so all you need is:$pipinstallattrsmallowTo upgrade to latest version:$pipinstall--upgradeattrsmallow
Package: attrs-mate
Welcome toattrs_mateDocumentation📔 SeeFull Documentation HERE.attrsmakes writing class a lot of more fun!attrs_mateaims to bring more features toattrs, less code, and better code pattern.Installattrs_mateis released on PyPI, so all you need is:$pipinstallattrs_mateTo upgrade to latest version:$pipinstall--upgradeattrs_mate
Package: attrs-sqlalchemy
Useattrsto add__repr__,__eq__,__cmp__, and__hash__methods according to the fields on a SQLAlchemy
model class.fromattrs_sqlalchemyimportattrs_sqlalchemy@attrs_sqlalchemyclassMyModel(Base):__tablename__='mymodel'id=sa.Column(Integer,primary_key=True)text=sa.Column(sa.String)instance=MyModel(id=1,text='hello')same_data=MyModel(id=1,text='hello')same_pk=MyModel(id=1,text='world')assertinstance==same_dataassertinstance!=same_pkassertrepr(instance)=="MyModel(id=1, text='hello')"
Package: attrs-to-sql
attrs to sqlConvertattrsclass to sqlCREATE TABLEcommand.UsageDefine class decorated withattr.s:@attr.s(auto_attribs=True)classModel:id:int=attr.ib(metadata={"primary_key":True})name:str=attr.ib(metadata={"not_null":True,"length":30})floats:List[float]=attr.ib(factory=list)Runattrs_to_tablewith defined class:fromattrs_to_sqlimportattrs_to_tableattrs_to_table(Model)Output:CREATETABLEpublic.model(idintPRIMARYKEY,namevarchar(30)NOTNULL,floatsfloat[]);
Package: attrtables
AttrTablesAttrTables is a library for storing attributes of entities in a database,
where the entities are rows and the attributes are columns in an automatically
managed set of tables.Basic conceptsEachentity(identified by an unique ID) can have as manyattributesas
desired. These consist in one or multiple values, each stored in an independent
database column. New attributes can be added at any time.Alongside with the values, attributes can store a computation ID (which can
refer to an external table of computation metadata). Computation IDs can be
stored for individual attributes and optionally also for groups of attributes.The attribute columns are automatically spread among multiple database tables,
so that the total number of columns does not exceed a given limit.Comparison to entity-attribute-valueAn alternative to the model implemented by AttrTables is the
entity-attribute-value (EAV) model, in which there is a single table, where
entities are rows and the attribute name and value are two columns.The EAV model has some disadvantages, compared to AttrTables:the values of a single attribute generally cannot be indexedthe values must be stored in a generic data type (such as blobs),
and the application must convert back and forth to the correct
datatypeSetupThe library is based on SqlAlchemy, which must be installed (seerequirements.txt).Furthermore, a database must be setup. The connection to the database is done
using SqlAlchemy, and the connectable is passed to the library, as explained
below.Running the tests suiteTo run the test suite, a database is needed, where the test tables can be
stored. The user must create such database.The database configuration is provided using a YAML configuration file
"config.yaml", which shall be stored in the "tests" subdirectory (see as an
example "tests/config.yaml").UsageThe usage of the library is explained in theuser manual.
Package: attr-tracers
Easily debug and trace attribute changes in your Python classespip install attr-tracersUsageTo use this module, simply importtracefrom it, and decorate your chosen class:fromtracersimporttrace@trace("test")classMyClass:def__init__(self)->None:self.test=0...You can set custom setter and getter methods for your trace, practically allowing you to subcribe to read/write events of an attribute.fromtypingimportAnyfromtracersimporttracedefhandle_get(obj:object)->Any:"""Get variable"""# Note the namespace-based reference to `attr`print(f"Trying to get{attr}from{obj}")returngetattr(obj,"_"+attr)defhandle_set(obj:object,new:Any)->None:"""Set variable"""print(f"Setting{attr}for{obj}from{getattr(obj,attr)}->{new}")setattr(obj,"_"+attr,new)attr="test"@trace(attr,getter=handle_get,setter=handle_set)classMyClass:def__init__(self)->None:self.test=0Please note that these methods doNOTget a reference toattr. This is a quirk of properties, but you can work around it using namespace-based referencing, like above.Inner workingsThis module under the hood is just an easy way to assign properties to a class.When decorated withtrace("attr"), a class has its attributeattrreplaced with a property. The default setter and getter of this property access the "_attr" attribute, as the property takes up "attr".Essentially, what it becomes is this:classMyClass:@propertydefattr(self)->Any:returnself._attr@attr.setterdefattr(self,new:str)->None:# Display current trace# Take input, quit or dismiss if chosenself._attr=newWhy use this over manually defining properties?While defining the properties manuallyisdoable, this module comes in really handy for debugging.Imagine having a pretty complex hierarchy of class-inheritance and objects all relating to eachother (like it happens inpytermgui).
It often happens that there is a certain attribute that isn't quite behaving how it is supposed to. While youcoulddefine these properties yourself, being able to importtraceand plop it on top of a class is really efficient for debugging.It also looks much nicer!
Package: attr-utils
Utilities to augment attrs.DocsTestsPyPIAnacondaActivityQAOtherInstallationattr_utilscan be installed from PyPI or Anaconda.To install withpip:$python-mpipinstallattr_utilsTo install withconda:First add the required channels$condaconfig--addchannelshttps://conda.anaconda.org/conda-forge$condaconfig--addchannelshttps://conda.anaconda.org/domdfcodingThen install$condainstallattr_utilsAttention!In v0.6.0 and above thepprintermodule requires thepprintextra to be installed:$python-mpipinstallattr-utils[pprint]
Package: attrz
attrz - python alternative for getfattr/setfattr tools for different platformsCopyright (C) 2015 HarshavardhanaLicensed under the Apache License, Version 2.0 (the “License”);
you may not use this file except in compliance with the License.
You may obtain a copy of the License athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an “AS IS” BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Package: atts
ATTS (Auto Train Test Splitter) splits the given dataframe to train and test taking into account the Concept Drift. It does this with xgboost running in the background.Calculates roc_auc scores for the given test size values. Creates a dataframe with these values.
Provides easier change visibility with chart.The code is Python 3InstallationFast install:pip install attsFor a manual install get this package:wget https://github.com/alikula314/att_split/atts/archive/master.zip
unzip master.zip
rm master.zip
cd atts-masterInstall the package:python setup.py installExample on Red Wine Quality Datasetpipinstallattsfromatts.auto_test_splitterimportatts# run modulek=ATTS(df,"quality",0.05,0.50,0.05)# get auc_score - test_size dataframek.test_sizes_df()#get the plotk.test_sizes_plot(800,400)