Saravanan666/pypi-org huggingface dataset:
Package: attowiki
attowiki is a very small wiki engine for personal use.Its main features are:can be started in any directoryuses all .rst files in directory structure as “wiki” filesuses git for revision controlautomatic background savinghistory view of old version of pages, including source and diff viewsadded 2 new directives: ‘todo’ and ‘done’some meta pages, including:/__index__: gives a list of all meta pages and normal pages/__cheatsheet__: docutils reStructuredText cheat sheet/__todo__: gives a list of all todo found in all pages/__done__: gives a list of all done found in all pages/__xxxxxxx__: gives a list of allxxxxxxxfound in all pages,xxxxxxxrepresent any reStructurenode, like all admonitions:__todo____done____attention____caution____danger____error____hint____important____note____tip____warning____admonition__“admonition” meta pages for one page only
using this kind of url: /name of the doc.__admonitionname__usageLaunching a wiki$ attowikithat’s all.attowiki will start a small server
(by default, serving tohttp://localhost:8080)all the .rst files inside the current directory will be used for the wikiinstallation$ pip install attowikiproject dependenciesbottledocutilsgitpythonVersion Historyv0.5.1Bug Correctionschanged error handling when pdf production failv0.5added pdf export buttonadded static file serving as fall back (and 404 still fall back of static files-
It’s useful when a reST doc tries to include local files (like images), which
are now server by attowikiBug Correctionsgit history was not available when serving attowiki in a subdir of a git repov0.4added a ‘view diff’ button when viewing a previous version of a fileadded a ‘view source’ button when viewing a previous version of a fileadded an history view of previous versions of a fileadded __todo__ meta page which scan all the directory for todo directives
and display it in one pageadded more generic __xxxxxxxx__ meta page which scan all the directory
for the xxxxxxxx admnonition. This may work with any registered node,
especially admonitions:__todo____done____attention____caution____danger____error____hint____important____note____tip____warning____admonition__added possibility to use the “admonition” meta pages for one page only
using this kind of url: /name of the doc.__admonition_name__added __cheatsheet__ meta page which provides locally a docutils reST
cheatsheetadded ‘done’ directive, in order to work with todo: when a task is done,
edit the page and change ‘todo’ to ‘done’ (it will remove it from
__todo__ meta page)removed iframeimproved docutils csssome other refactorsv0.3added todo directive support in rest files (now display correctly a todo)changed a little bit the default docutils cssadded background saving featurev0.2start in a dir, looks for .rst files and serve them in htmllooks for index.rst at first and serve itif index.rst not found serve a page with the list of filessimple edition (text area). Save and Cancel buttonsgit commit when savingv0.1first (non-working) version
Package: attr
Usage example:# Django proposes:
def my_calculated_field(...
my_calculated_field.short_description = 'Field'
my_calculated_field.admin_order_field = 'real_field'

# DRY:
@attr(short_description='Field', admin_order_field='real_field')
def my_calculated_field(...Get it:sudo pip install attr
from attr import attrNew popularattrs.orgused bypytest.orgdefines another “attr” package that shadows this “attr” module.Please use “dry_attr” alias to unshadow it:from dry_attr import attr
from dry_attr import dry_attr
Package: attractors
attractorsattractors is a package for simulation and visualization of strange
attractors.InstallationThe simplest way to install the module is via PyPi using pippip install attractorsAlternatively, the package can be installed via github as followsgit clone https://github.com/Vignesh-Desmond/attractors
cd attractors
python -m pip install .To set up the package for development and debugging, it is recommended
to usePoetry. Just install withpoetry installand let Poetry manage the environment and
dependencies.PrerequisitesTo generate video output, the package usesffmpeg. Download and install fromhereaccording to your os and
distribution and set PATH accordingly. Note that this is only required
for generating video output.UsageSeedocumentationon readthedocs.ioChangelogSeechangelogfor previous versionsDevelopmentThis package is under early stages of development it’s open to any constructive suggestions.
Please send bug reports and feature requests through issue trackers and pull requests.LicenseThis package is licensed under theMIT
License
Package: attrcheck
attrcheck: attribution checkerThis module provides a simple attribution checker implemented as a decorator.
All functionality are provided as keyword arguments of the decorator.Sample example of usage is following:>>> from attrcheck import attrcheck
>>> @attrcheck(x=['real'], y=['index', 'strip'], z=dir(list))
... def foo(x, y, z=[]): passThe code above means the following:>>> def foo(x, y, z=[]):
...     if not hasattr(x, 'real'):
...         raise AttributeError
...     if not hasattr(y, 'index'):
...         raise AttributeError
...     if not hasattr(y, 'strip'):
...         raise AttributeError
...     for name in dir(list):
...         if not hasattr(z, name):
...             raise AttributeErrorIn addition, attrcheck can check default argument values.
Thus, the following code throws AttributeError.>>> @attrcheck(y=dir(str))
... def bar(x, y=[]): pass
Package: attrd
Attribute dictionary implementation that allow get access to their elements by keys (as native dict) and attributes.Installation:pipinstallattrdUsage:fromattrdimportAttrDicta=AttrDict(key1=123)# Set value by attributea.key2=123# Set value by keya['key3']=123# Set and delete value by attributea.key4=123dela.key4# Set and delete value by keya['key5']=123dela['key5']print(a)# -> {'key1': 123, 'key2': 123, 'key3': 123}Convert existed dict to AttrDict:print(AttrDict({'key1':123,'key2':123}))# -> {'key1': 123, 'key2': 123}print(AttrDict(**{'key1':123,'key2':123}))# -> {'key1': 123, 'key2': 123}Nested level:d={'key1':{'sub_key1':123,'sub_key2':{'deep_key':'abc'}}}d=AttrDict(d)d.key1.sub_key3=123print(d.key1)# -> {'sub_key1': 123, 'sub_key2': {'deep_key': 'abc'}, 'sub_key3': 123}print(d.key1.sub_key1)# -> 123print(d.key1.sub_key2.deep_key)# -> abcdeld.key1.sub_key2print(d)# -> {'key1': {'sub_key1': 123, 'sub_key3': 123}}Nested values with kwargs:d=AttrDict(key1={'sub_key1':123,'sub_key2':123})print(d)# -> {'key1': {'sub_key1': 123, 'sub_key2': 123}}print(d.key1.sub_key1)# -> 123deld.key1.sub_key2print(d)# -> {'key1': {'sub_key1': 123}}Dicts in lists:d=AttrDict({'key1':[{'sub_key1':123,'sub_key2':456},{'sub_key1':123,'sub_key2':456},]})deld.key1[0].sub_key2,d.key1[1].sub_key1print(d)# -> {'key1': [{'sub_key1': 123}, {'sub_key2': 456}]}print(d.key1[0].sub_key1)# -> 123Iterate items:g=AttrDict(a=1,b=2,c=3,items=[10,11,12])print(g.items)# -> <built-in method items of AttrDict>print(g.get('items'))# -> [10, 11, 12]fork,ving.items():print(k,v)# a 1# b 2# c 3
Package: attr-descriptions
Copyright (c) 2018 deniz195Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the “Software”), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.Description: # attr-descriptionsA mini-framework that helps to add descriptions to attributes from sensors in a distributed system or machine.Platform: UNKNOWN
Classifier: Development Status :: 4 - Beta
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.5
Classifier: Programming Language :: Python :: 3.6
Package: attrdict2
AttrDict2Docs🌐 Telif Hakkı ve LisansCopyright (C) 2021 by@ofarukbicer❤️️MIT LICENSEKoşullarına göre lisanslanmıştır..♻️ İletişimBenimle iletişime geçmek isterseniz,Telegram'dan mesaj göndermekten çekinmeyin;@ofarukbicerKolektifAPIveKekikAkademiiçin yazılmıştır..
Package: attrdictx
AttrDictXOverviewAttrDictX is a lightweight Python package that allows seamless access to dictionary values as if they were class attributes. This package offers an elegant and dependency-free solution, enhancing code legibility and ease of use.Unlike traditional dictionary access (random_dict["key"]), AttrDictX simplifies the process (random_dict.key), saving three characters per access. Additionally, it supports nested dictionaries and is free of any dependency-related errors, addressing limitations present in other packages likeattrdict.InstallationTo installattrdictx, you can usepip:pipinstallattrdictxAlternatively, you may just copy & paste the following source code to use this package:classAttrDictX(dict):def__init__(self,*args,**kwargs):super(AttrDictX,self).__init__(*args,**kwargs)forkey,valueinself.items():ifisinstance(value,dict):self[key]=AttrDictX(value)def__getattr__(self,name):ifnameinself:returnself[name]raiseAttributeError(f"'AttrDictX' object has no attribute '{name}'")def__setattr__(self,name,value):self[name]=valueUsageAfter importing theAttrDictXclass (whenimport AttrDictalso works), you can create an instance from your dictionary and access values like class attributes.fromattrdictximportAttrDictX# Example: configuration for a random web appconfig={'database':{'host':'localhost','port':5432,'username':'my_user','password':'my_password'},'api_keys':{'weather_api':'abc123def456','news_api':'xyz789'},'cache_enabled':True}# Create an AttrDictX instance from the configuration dictionaryapp_config=AttrDictX(config)# Accessing configuration settings with recursive attributesprint(app_config.cache_enabled)# => Trueprint(app_config.api_keys.weather_api)# => abc123def456ContributionsWe welcome contributions from the community to improve and expand AttrDictX. If you encounter any issues, have suggestions, or want to contribute code, feel free to open an issue or submit a pull request on our GitHub repository:https://github.com/kyo-takano/AttrDictXLicenseAttrDictX is released under theMIT License.
Package: attr-dot-dict
DotDictA simple Python library that builds uponargparse.Namespaceto make chained attributes possible.Why?Configs of all kinds follow a dict-like structure.
However, nobody likes thedict["key"]syntax. We all much prefer thedict.keysyntax.There are a number of workarounds for this, includingeasydictorargparse.Namespace(upon which this library is based).The downside of these libraries, though, is that when you want to start a new level, you must explicitly define it first. For example:config=edict()config.host='localhost'config.users=edict()# or {}config.users.foo='bar'This isugly.Wouldn't you much prefer the following syntax?config=dd()config.host='localhost'config.users.foo='bar'InstallationInstallation is simple:pip install attr-dot-dict. Alternatively:pip install .from the root of the repository.UsageUsage is equally as simple:fromdotdictimportDotDictasddx=dd()x.a.b.c=1x.a.d=2x.a.b.e=3print(x)# DotDict(a=DotDict(b=DotDict(c=1, e=3), d=2))print(vars(x))# {'a': DotDict(b=DotDict(c=1, e=3), d=2)}print(vars(x.a))# {'b': DotDict(c=1, e=3), 'd': 2}
Package: attribench
AttriBenchis aPytorch-based implementation of
several metrics for the evaluation of feature attribution maps and methods.
AttriBench provides a functional and an object-oriented API for the computation
of these metrics, along with a set of utility functions for the necessary
preparations (e.g. computing attribution maps) as well as for the visualization
of the results.Thefunctional APIis generally easier to use, and can be used to get
started quickly if the scale of the evaluation is not too large. Theobject-oriented APIis more flexible and can use multiple GPUs for
evaluation of large datasets.For more information, see thedocumentation.InstallationAttriBench can be installed from PyPI using pip:pipinstallattribench
Package: attribmanager
attribmanagerA simple pythonic module to lock (make read-only) and hide class attributesInstallationpip install attribmanagerUsageimport attribmanger

class example(attribmanger.manage):

	def __init__(self):

		self.mylist = ["item 1", "item2"]
		self.lock("mylist")
		# mylist is read only and cannot be edited now, changing it
		# will raise an error, 

		self.myvar = "foo"
		self.hide("myvar")
		# myvar will not show up anywhere, and cannot be edited

		self.unhide("myvar")
		# Hiding an object without being able to unhide it would be
		# the same as deleting it, that's why you can unhide it
Package: attribtool
AttribToolThe project contains base classes that limit the possibility of adding new attributes without their prior declaration inside classes inheriting from them or their objects.Classes throw an AttributeError exception when trying to add an undefined attribute to a derived class or its object.Usage examplesfrom attribtool.ndattrib import NoDynamicAttributes

class Example(NoDynamicAttributes):
    __name = None

    def __init__(self):
        self.__name = self.__class__.__name__

if __name__ == "__main__":
    obj = Example()
    obj.data = "abc"% ./example.py
Traceback (most recent call last):
  File "/home/szumak/Projects/ToolBox/AttribTool/./example.py", line 22, in <module>
    obj.data = "abc"
  File "/home/szumak/Projects/ToolBox/AttribTool/attribtool/ndattrib.py", line 22, in __setattr__
    raise AttributeError(
AttributeError: Cannot add new attribute 'data' to Example objectfrom attribtool.nnattrib import NoNewAttributes

class Example(NoNewAttributes):
    __name = None

    def __init__(self):
        self.__name = self.__class__.__name__
        self.__data = 1

if __name__ == "__main__":
    obj = Example()% ./example.py
Traceback (most recent call last):
  File "/home/szumak/Projects/ToolBox/AttribTool/./example.py", line 22, in <module>
    obj = Example()
  File "/home/szumak/Projects/ToolBox/AttribTool/./example.py", line 18, in __init__
    self.__data = 1
  File "/home/szumak/Projects/ToolBox/AttribTool/attribtool/nnattrib.py", line 24, in __setattr__
    raise AttributeError(
AttributeError: Undefined attribute _Example__data cannot be added to <__main__.Example object at 0x7f7129ccc2b0>
Package: attributecode
Tool for Attribution Notice generation.Read more about AttributeCodehere.FeaturesAccept data from multiple formats:A spreadsheet file (csv or xlsx)A JSON file format for Attribution that would have the primary Attribution fieldsA ScanCode JSON file.A configuration option to map input data to Attribution output fields.Jinja templates to customize the Attribution Notice output.Access to a database of license texts based on ScanCode license keys.Build and tests statusBranchLinux/macOSMasterDevelopREQUIREMENTSPython3.6On Linux and Mac, Python is typically pre-installed. To verify which
version may be pre-installed, open a terminal and type:python –versionOn Windows or Mac, you can download the latest Python here:https://www.python.org/downloads/Download the .msi installer for Windows or the .dmg archive for Mac.
Open and run the installer using all the default options.INSTALLATIONCheckout the AttributeCode from:https://github.com/nexB/attributecodeRead thesetup process.HELP and SUPPORTIf you have a question or find a bug, enter a ticket at:https://github.com/nexB/attributecodeFor issues, you can use:https://github.com/nexB/attributecode/issuesSOURCE CODEThe AttributeCode is available through GitHub. For the latest version visit:https://github.com/nexB/attributecodeHACKINGWe accept pull requests provided under the same license as this tool.
You agree to thehttp://developercertificate.org/LICENSEThe AttributeCode is released under the Apache 2.0 license.
See the about.ABOUT file for details.
Package: attributedict
attributedictA dictionary object with attributes support.InstallInstall usingpip:$pipinstallattributedictUseExample:fromattributedict.collectionsimportAttributeDictdata=AttributeDict({'foo':{'bar':[1,2,3]}})data.foo# => `{'bar': [1, 2, 3]}}`data.foo.bar# => `[1, 2, 3]`data.foo={'baz':True}data.foo=# => `{'baz': True}`deldata.foo.baz# and/or...data=AttributeDict({'foo':{'bar':[1,2,3]}})data['foo']# => `{'bar': [1, 2, 3]}}`data['foo']['bar']# => `[1, 2, 3]`data['foo']={'baz':True}data['foo']=# => `{'baz': True}`deldata['foo']['baz']# instance of `dict`...isinstance(data,dict)# => Trueisinstance(data,attributedict.collections.AttributeDict)# => Trueisinstance(data.__dict__,dict)# => Trueisinstance(data.__dict__,attributedict.collections.AttributeDict)# => False# no need for custom encoders...data=AttributeDict({'foo':{'bar':[1,2,3]}})json.dumps(data)# => `{"foo": {"bar": [1, 2, 3]}}`json.dumps(data.__dict__)# => `{"foo": {"bar": [1, 2, 3]}}`# etc.TestClone down source code and run:$makeinstall
$maketestLicenseReleased under the MIT license.
Package: attribute-dict
attribute_dictA subclass of dict that allows object-style access to its entries.Installationpipenvinstallattribute_dictUsagefromattribute_dictimportAttributeDictsample_dict=AttributeDict({'foo':'bar'})sample_dict# => AttributeDict({'foo': 'bar'})# The object is just subclassed from dict, and has all of the standard functionsisinstance(sample_dict,dict)# => True# Create a new AttributeDict by "stacking" iterables# Each iterable will overwrite keys in the previous one (kwargs are processed last!)sample_dict=AttributeDict({'foo':'foo'},{'foo':'ba','bar':'foo'},{'foo':'bar'},{'foobar':'bar'},foobar='foo')# => AttributeDict({'foo': 'bar', 'bar': 'foo', 'foobar': 'foo'})# Create a new AttributeDict by shallow-copying an existing onenew_sample_dict=sample_dict.copy()new_sample_dict# => AttributeDict({'foo': 'bar', 'bar': 'foo', 'foobar': 'foo'})isinstance(new_sample_dict,AttributeDict)# => True# NOTE: Child values are NOT processed!sample_dict=AttributeDict({'foo':iterable_two})sample_dict# => AttributeDict({'foo': {'foo': 'ba', 'bar': 'foo'}})sample_dict.foo# => {'foo': 'ba', 'bar': 'foo'}sample_dict.__class__.__name__# => 'AttributeDict'sample_dict.foo.__class__.__name__# => 'dict'TestsTests use nose2. Clone the Github project. Install dev dependencies, and run tests using the nose2 command.pipenvinstall--dev
pipenvshell
nose2
Package: attributee
AboutAttributee is a Python 3 library for declarative object initialization. Input arguments are defined as class attributes and are automatically processed when creating an object. It is in a way similar to Django ORM or some other ORMs, but the main purpose of this library is to simplify parsing input arguments to object constructors.The library is a work-in-progress, I am adding stuff that I consider useful for my other projects.Simple use casefrom attributee import Attributee, String, Float

class Model(Attributee):

    # Simply list the attributes of the object ...

    name = String(default="noname")
    value1 = Float()
    value2 = Float(default=0, val_min=-10, val_max=10)

    # ... no constructor needed


# default arguments assigned
model1 = Model(value1=10)

# automatic type conversion where possible
model2 = Model(value1=10, value2="5")DocumentationI am working on it.AuthorsLuka Čehovin ZajcLicenseThe library is available under thesimplified BSD license.
Package: attribute-mapping
attribute-mappingis a minimalistic Python library for
attribute-based access to dictionaries and other mappings.Compared to many other implementations of the same idea, going by
names such asAttrDictand various others, this library is
extremely minimal and free of cruft:Almost no APIAttributeMappinginstances do not pretend to be adictCan be used withdictas well as other objects implementing thecollections.abc.Mappingabstract base classNo restrictions on key/attribute namesNo unpleasant surprises in behaviour or weird corner casesModern code; Python 3.4+ only100% test coverageInstallationpython -m pip install attribute-mappingUsageMake anAttributeMappinginstance by passing a dictionary or
another mapping:from attribute_mapping import AttributeMapping

d = {"a": 1, "b": {"c": 2, "d": 3}}
x = AttributeMapping(d)Now you can access the contents using attribute lookups:x.a  # gives 1
x.b.c  # gives 2

x.foo = 123
hasattr(x, "foo")  # True
del x.fooIn addition to attribute access, subscription (__getitem__and
friends) and containment checks (in) also work:x["a"]  # gives 1
x["b"]["c"]  # gives 2
x["foo"] = 123
"foo" in x  # True
del x["foo"]However, there arenoother dict-like methods or reserved names, so
you can happily use attributes likekeysanditems:x.items = [1, 2, 3]Iteration yields(key, value)tuples, just like.items()on
normal mappings would do:for key, value in x:
    ...Finally, to obtain the original object that was used for theAttributeMapping, use the built-invars()function:d = {"a": 1}
x = AttributeMapping(d)
vars(x) is d  # TrueCreditsThis library is written by wouter bolsterlee (wbolster).There are a gazillion similar implementations, so the author thanks
the whole Python community for the inspiration to make yet another
implementation of this idea.Version history1.3.0 (2019-03-13)Add support forlen()1.2.0 (2019-03-12)Add support for (in)equality tests1.1.0 (2019-03-09)Add support for custom mappings1.0.0 (2019-03-08)Initial releaseLicenseBSD; see LICENSE file for details.