Saravanan666/pypi-org huggingface dataset:
Package: nested2nested
converts a nested list into a nested dictionary with support for multi-level keys and preserving the orderpip install nested2nestedTested against Windows 10 / Python 3.10 / AnacondaConversion of nested lists to nested dictionaries:The function provides a convenient way to convert nested lists into nested dictionaries. This can be useful when working with data structures that require a hierarchical representation, such as JSON-like structures or when organizing data in a tree-like format.Support for multi-level keys:The function utilizes the MultiKeyIterDict class, which allows the use of multi-level keys in the resulting nested dictionary. This means that each level of the nested list can be represented as a key in the corresponding level of the dictionary.Preservation of order:The MultiKeyIterDict class used in the function preserves the order of elements during conversion. This is important when the order of elements in the nested list needs to be maintained in the resulting dictionary.Flexibility and reusability:The function is designed to be flexible and can handle nested lists of any depth or structure. It uses a separate module, flatten_any_dict_iterable_or_whatsoever, to flatten the nested list, making it adaptable to various use cases. The MultiKeyIterDict class can also be used independently for other projects involving multi-level dictionaries.This function can be useful for developers or data analysts working with hierarchical or nested data structures. It simplifies the process of converting nested lists to nested dictionaries and provides flexibility in handling multi-level keys. It can be applied in various domains, including data manipulation, data preprocessing, and working with complex data structures.fromnested2nestedimportnested_list_to_nested_dictd=nested_list_to_nested_dict(l=[33,4,['baba',4,['babx',[[4,4,5,2],4],4,32],4,3],423])print(d){0:33,1:4,2:{0:'baba',1:4,2:{0:'babx',1:{0:{0:4,1:4,2:5,3:2},1:4},2:4,3:32},3:4,4:3},3:423}
Package: nestedaccess
NestedaccessNestedaccess is a simple, elegant way to retrieve nested data from deep dictionaries. If the field does not exist, you can customize the return to the default value, and you can also choose whether to output an error message.importnestedaccessdata={'foo':{'bar':[1,2,3],'baz':{'qux':'hello','quux':{'corge':True,'grault':[4,5,6]}}},'empty_list':[],'empty_dict':{}}# normal data test.print(nestedaccess.get(data,['foo','baz','quux','grault',1]))# Output: 5# Field does not exist, return default value data test.print(nestedaccess.get(data,['nonexistent'],default='Not found'))# Output: 'Not found'# The field does not exist, no error message data test is returned.print(nestedaccess.get(data,['foo','baz','quux','corge','invalid']))# Output: None# The field does not exist and returns an error message test.test_key=['foo','baz','quux','corge','invalid']print(nestedaccess.get(data,test_key,error_info=True))# Output: None (dictionary key does not exist)print(nestedaccess.get(data,test_key,error_info=True,default='Not found'))# Output: 'Not found'Installing Nestedaccess and Supported VersionsNestedaccess is available on PyPI:$python-mpipinstallnestedaccessNestedaccess officially supports Python 3.7+.Supported Features & Best–PracticesIt is used to obtain nested data. In the case of a deep nested structure, the data is obtained through a list, which makes the code more elegant.Takes a nested data object (which can be a dictionary or a list), a list of keys or indices, and an optional default value.It will attempt to fetch nested data in the given key or index order, and fall back to the default value if fetching fails.If the field does not exist, output the non-existent field name and return the default value.Customize the output error message (no error message is output by default).
Package: nestedarchive
Allows simplified access to files in nested archives.ExampleGiven an archive placed in/tmp/foobar/foo.tarwith this structure:foo.tar
    - foo1
    - foo2
    - bar.tar
       - bar1
       - bar2
       - foo3.tar.gz
            - foo4
            - foo5
       - foo6.tar.gz
            - foo7
            - foo8
    - abc/
       - def
       - ghiThis library will allow reading the contents of the files in this nested archive in
the following "seamless" manner:nestedarchive.get("/tmp/foobar/foo.tar/foo1")
nestedarchive.get("/tmp/foobar/foo.tar/abc/def")
nestedarchive.get("/tmp/foobar/foo.tar/bar.tar/bar1")
nestedarchive.get("/tmp/foobar/foo.tar/bar.tar/foo3.tar.gz/foo4")Globs are also supported - all matches are tried until one is found that (eventually) contains the expected file, e.g.:- nestedarchive.get("/tmp/foobar/foo.tar/bar.tar/foo*.tar.gz/foo7")Will first silently tryfoo3.tar.gzand fail because it does not containfoo7, then it will tryfoo6.tar.gzand
succeed becausefoo6.tar.gzcontainsfoo7Currently supported extensions:tartar.gzCurrently tested operating systems:linux
Package: nested-argparse
nested-argparse 💬 → 🅰.🅱.🆒nested-argparse is a python module that non-invasively builds on top of the built-inargparselibrary to allow subparsers to parse into their own nested namespaces.The library exposes a classNestedArgumentParserwhich allows arbitrary nesting without worry of namespace conflicts. This is achieved with the following principles of this library:Inversion of Control:A parser, when adding a subparser, is in control of what name to use for the sub-namespace which the subparser sends its parsed args to.Drop-In Replacement:The constructor fornested_argparse.NestedArgumentParsercan be substituted in directly to where the constructor forargparse.ArgumentParseris being used. All subsequent method calls and subparser API calls should work without any additional code change!Customizeability:There are additionalkwargsexposed to further customize the nesting options to your liking, if the defaults do not suit your scenario.The main difference between this library and its built-in counterpart is the return value of theparse_argsmethod. Instead of a flat namespace containing all parsed arguments across all subparsers,NestedArgumentParserwill produce a namespace tree.Simple Conceptual ExampleGiven the following parser:Root Parser
 ├─ positional_1
 ├─ --optional_1
 ├─ --optional_2
 └─ sub parsers with dest='subcommand'
     ├─ Sub Parser 1 with name='sub1'
     │   ├─ --optional_1
     │   └─ --optional_2 with dest='optional2AltName'
     └─ Sub Parser 2 with name='sub2'
         ├─ --optional_1
         └─ --optional_2And the following args to parse:Alice--optional_1=Bobsub1--optional_1=Carol--optional_2=DavidThe built-inArgumentParserwould not be able to handle the duplication indests, butNestedArgumentParserwill produce the following result when run throughparse_args:Namespace(subcommand='sub1',positional_1='Alice',optional_1='Bob',sub1=Namespace(optional_1='Carol',optional2AltName='David'))
Package: nested-chat-plugin-sdk
Plugin SDK for FastAPIThe Plugin SDK nested-chat-plugin-sdk is a FastAPI extension that provides a convenient way to handle requests for creating, updating, deleting, and executing operations.InstallationInstall dependencies using Poetry and activate the virtual environment.Learn how to install Poetrypoetryinstall
poetryshellInstall the SDK usingPoetry:poetryaddnested-chat-plugin-sdkExamplefromfastapiimportFastAPI,Requestfromnested_chat_plugin_sdk.sdkimportPluginRouter,SyncRequestapp=FastAPI()plugin_router=PluginRouter(api_url="")@plugin_router.on_createasyncdefhandle_create(data:SyncRequest):print("create",data)@plugin_router.on_updateasyncdefhandle_update(data:SyncRequest):print("update",data)@plugin_router.on_deleteasyncdefhandle_delete(data:SyncRequest):print("delete",data)@plugin_router.on_executeasyncdefhandle_execute(request:Request):print("execute",request)app.include_router(plugin_router)API Routes/syncPOST: Create dataPUT: Update dataDELETE: Delete data/executePOST: Execute operationSyncRequest Schemafromnested_chat_plugin_sdk.schemesimportSyncRequestclassSyncRequest(BaseModel):project:dict[str,Any]core:dict[str,Any]variable:dict[str,Any]variable_enum_item:dict[str,Any]={}variable_group:str|None=None
Package: nested-csv
nested_csvnested_csv generates CSV from nesteddictlistdata structure such as JSON.nested_csv.NestedDictWriterhave same interface (writerow,writerows,writeheader) withcsv.DictWriter.Install$pipinstallnested-csvDependencynested_csv requires Python 3.nested_csv only use standard packages (csv,itertools,re).How to UseEstimate fieldsfromnested_csvimportgenerate_fieldnamesdata=[{"hello":{"world":"value0"},"list":[[1,2,3],[4,5,6]],"fixed":[1,2]},{"hello":{"world":"value1"},"list":[[7,8],[10,11]],"fixed":[3,4]},]fieldnames=generate_fieldnames(data[0])# ['fixed[id]', 'fixed[]', 'hello.world', 'list[id]', 'list[][id]', 'list[][]']Generate Nested CSVimportiofromnested_csvimportNestedDictWriterdata=[{"hello":{"world":"value0"},"list":[[1,2,3],[4,5,6]],"fixed":[1,2]},{"hello":{"world":"value1"},"list":[[7,8],[10,11]],"fixed":[3,4]},]fieldnames=['hello.world','list[id]','list[][id]','list[][]','fixed[1]']file=io.StringIO()w=NestedDictWriter(file,fieldnames)w.writeheader()w.writerows(data)file.seek(0)file.read()# hello.world,list[id],list[][id],list[][],fixed[1]# value0,0,0,1,2# value0,0,1,2,2# value0,0,2,3,2# value0,1,0,4,2# value0,1,1,5,2# value0,1,2,6,2# value1,0,0,7,4# value1,0,1,8,4# value1,1,0,10,4# value1,1,1,11,4Field FormatYou can generate fields format automatically by usinggenerate_fieldnames().Butgenerate_fieldnames()is sometimes not appropriate when ...the order of csv row is importantgenerate_fieldnames()will generate fields ordered by lexical orderthe base object includes length listgenerate_fieldnames()can't estimate the scheme of empty objectPlease set fieldnames manually on those situations.The format of fieldnames is following.nested keysNested dict key is joined by.(dot).JSON : {"a": {"b": 1, "c": 2}}
format : ["a.b", "a.c"]
--- CSV ---
1,2id supportNestedDictWriterwill insertidpassed onwriterow(rowdict, id=0)orwriterows(rowdicts, first_id=0).JSON : {"a": {"b": 1, "c": 2}}
format : ["id", "a.b", "a.c"]
--- CSV ---
0,1,2fixed size listWhen the size of the list is known, list elements can be specified by index[<index number>].JSON : {"a": [1,2], "b": [0]}
format : ["a[0]", "a[1]", "b[0]"]
--- CSV ---
1,2,0listNestedDictWriterunfolds the list elements into multiple rows when specified by[].Nested list is also supported.The level of each list must match.Bad Cases"a[]"+"a.b": key and list at same level"a[]"+"b.c[]": list level not match"a[][]"+"b[].c[]": sub list level not matchThe count of unfolding loop is maximum length of list at each level. If list size is shorter than maximum, the value of exceeded index is empty.JSON : {"a": [[{"x": 1}], [{"x": 2}, {"x": 3}]], "b": [4, 5, 6], "c": [[7, 8, 9]]}
format : ["a[][].x", "b[]", "c[][]"]
--- csv ---
1,4,7
,4,8
,4,9
2,5,
3,5,
,5,
,6,
,6,
,6,list indexThe unfolding loop index of list is specified by[id].JSON: {"a": [[1,2,3], [4,5]}
format : ["a[id]", "a[][id]", "a[][]"]
--- csv ---
0,0,1
0,1,2
0,2,3
1,0,4
1,1,5
1,2,LICENSEMIT
Package: nested-dataclasses
nested-dataclassesImplements decoratornestedthat adds a parent and children to a dataclass.Both parent and child class should be decorated with nested.Usage:Example usage of the parent attribute on a nested dataclass:fromdataclassesimportdataclassfromtypingimportListfromnested_dataclassesimportnested@nested@dataclassclassTextCount:text:strcount:int@propertydeffraction(self):returnself.count/self.parent.total_count@nested@dataclassclassTextCounts:counts:List[TextCount]@propertydeftotal_count(self):returnsum(count.countforcountinself.counts)hello=TextCount("hello",3)hi=TextCount("hi",1)counts=TextCounts([hello,hi])counts.validate()print(counts.counts[0].fraction)print(counts.children)print(counts.to_dict())InstallationWe can be installed with:pipinstallnested-dataclassesDevelopment installation of this project itselfWe're installed withpipenv, a handy wrapper
around pip and virtualenv. Install that first withpip install pipenv. Then run:PIPENV_VENV_IN_PROJECT=1pipenvinstall--python3.8--devIn case you do not have python 3.8 on your machine, install python usingpyenvand try the previous command again.
See install pyenv below for instructions.In order to get nicely formatted python files without having to spend manual
work on it, run the following command periodically:pipenvrunblacknested_dataclassesRun the tests regularly. This also checks with pyflakes, black and it reports
coverage. Pure luxury:pipenvrunpytestIf you need a new dependency (likerequests), add it insetup.pyininstall_requires. Afterwards, run install again to actually install your
dependency:pipenvinstall--devReleasingPipenv installs zest.releaser which allows you to release the package to a git(hub) repo. It has afullreleasecommand that asks you a few questions, which you all respond to with<enter>:pipenvrunfullreleaseInstall pyenvWe can install pyenv by running the following commands:sudoapt-getinstall-ymakebuild-essentiallibssl-devzlib1g-devlibbz2-devlibreadline-devlibsqlite3-devwgetcurlllvmlibncurses5-devlibncursesw5-devxz-utilstk-devlibffi-devliblzma-dev
curl-Lhttps://github.com/pyenv/pyenv-installer/raw/master/bin/pyenv-installer|bashAlso make sure to put pyenv in your.bashrcor.zshrcas instructed by the previous commands.Changelog of nested-dataclasses0.1 (2020-06-08)Initial project structure created with cookiecutter andhttps://github.com/PDOK/cookiecutter-python-baseAddednesteddecorator.nesteddecorator uses ValidationMixin and ToDictMixin.
Package: nesteddict
nesteddictVERSION=0.1.1.alphaclass collections.NestedDict(self, seq=None, **kwargs)Return an instance of a dict subclass, supporting the usual dict
methods. An NestedDict is a dict that that only supports keys of typestr. Those keys may be nested by separating them with dots '.'. Hence a
valid uses ofNestedDictare:>>>fromnesteddictimportNestedDict>>>a=NestedDict()>>>a['x.y.z']=1>>>a{'x':{'y':{'z':1}}}>>>a['x.y']{'z':1}Nonstrkeys will throw aKeyErrorexception.
Package: nested_dict
NoteSource code athttps://github.com/bunbun/nested-dictDocumentation athttp://nested-dict.readthedocs.orgnested_dictnested_dictextendsdefaultdictto support pythondictwith multiple levels of nested-ness:Drop in replacement fordict>>>fromnested_dictimportnested_dict>>>nd=nested_dict()>>>nd["one"]="1">>>nd[1]["two"]="1 / 2">>>nd["uno"][2]["three"]="1 / 2 / 3">>>... for keys_as_tuple, value in nd.items_flat():
...    print ("%-20s == %r" % (keys_as_tuple, value))
...
('one',)             == '1'
(1, 'two')           == '1 / 2'
('uno', 2, 'three')  == '1 / 2 / 3'Specifying the contained typeIf you want the nested dictionary to holda collection (like thesetin the first example) ora scalar with useful default values such asintorstr.dictoflists#   nested dict of listsnd=nested_dict(2,list)nd["mouse"]["2"].append(12)nd["human"]["1"].append(12)dictofsets#   nested dict of setsnd=nested_dict(2,set)nd["mouse"]["2"].add("a")nd["human"]["1"].add("b")dictofints#   nested dict of intsnd=nested_dict(2,int)nd["mouse"]["2"]+=4nd["human"]["1"]+=5nd["human"]["1"]+=6nd.to_dict()#{'human': {'1': 11}, 'mouse': {'2': 4}}dictofstrs#   nested dict of stringsnd=nested_dict(2,str)nd["mouse"]["2"]+="a"*4nd["human"]["1"]+="b"*5nd["human"]["1"]+="c"*6nd.to_dict()#{'human': {'1': 'bbbbbcccccc'}, 'mouse': {'2': 'aaaa'}}Iterating throughnested_dictIterating through deep or unevenly nested dictionaries is a bit of a pain without recursion.nested dictallows you toflattenthe nested levels intotuples before iteration.You do not need to know beforehand how many levels of nesting you have:fromnested_dictimportnested_dictnd=nested_dict()nd["one"]="1"nd[1]["two"]="1 / 2"nd["uno"][2]["three"]="1 / 2 / 3"forkeys_as_tuple,valueinnd.items_flat():print("%-20s==%r"%(keys_as_tuple,value))#   (1, 'two')           == '1 / 2'#   ('one',)             == '1'#   ('uno', 2, 'three')  == '1 / 2 / 3'nested_dict providesitems_flat()keys_flat()values_flat()(iteritems_flat(),iterkeys_flat(), anditervalues_flat()are python 2.7-style synonyms. )Converting to / from dictionariesThe magic ofnested_dictsometimes gets in the way (ofpickleing for example).We can convert to and from a vanilla pythondictusingnested_dict.to_dict()nested_dict constructor>>>fromnested_dictimportnested_dict>>>nd=nested_dict()>>>nd["one"]=1>>>nd[1]["two"]="1 / 2"#
#   convert nested_dict -> dict and pickle
#>>>nd.to_dict(){1: {'two': '1 / 2'}, 'one': 1}>>>importpickle>>>binary_representation=pickle.dumps(nd.to_dict())#
#   convert dict -> nested_dict
#>>>normal_dict=pickle.loads(binary_representation)>>>new_nd=nested_dict(normal_dict)>>>nd==new_ndTruedefaultdictnested_dictextendscollections.defaultdictYou can get arbitrarily-nested “auto-vivifying” dictionaries usingdefaultdict.fromcollectionsimportdefaultdictnested_dict=lambda:defaultdict(nested_dict)nd=nested_dict()nd[1][2]["three"][4]=5nd["one"]["two"]["three"][4]=5However, onlynested_dictsupports adictofdictofsetsetc.
Package: nesteddictionary
Nested DictionaryVersion:1.2.2A wrapper for python dicts that allows you to search and navigate through nested dicts usingkey paths. Also works with mixed dictionaries (mixuture of nested lists and dicts). Derived from a need to search for keys in a nested dictionary; too much time was spent on building yet another full class for nested dictionaries, but it suited our needs.Quick Start Example:>>>fromnesteddictionaryimportNestedDict#import the NestedDict class>>>d={'path':{'to':{'key':'val'}}}#normal way of doing nested dictionary>>>nested_dict=NestedDict(d)#created a nested dictionary from a normal dictionaryFeatures:Uses keypaths in subscripting to navigate nested dictionaries ( ex:nested_dict[ ['path','to','key'] ]which is the same asnested_dict['path']['to']['key'])Adds functionality without violating any existing dict operations (that I know of); keypaths are in the form of a list which cannot be used as a key for a normal dict anyway. All other dict rules still apply.findall method: Finds all nested keys within a nested dictionary.get and set methods: Navigate using a keypath string with seperator ( ex:nested_dict.get('path.to.key'))insert method: create a full path to a nested key and set a value, even if the parent keys leading to the destination key don't already exist ( i.e.,nested_dict.insert( ['newpath','to','key'], 'newval') will add to the existing dictionay, resulting in:NestedDict({ 'path':{'to':{'key':'val'}}, 'newpath':{'to':{'key':'newval'}} })).Limitations:While fast, it adds some overhead and therefore cannot ever be as fast as accessing dicts the regular way.Changes (PEP 440: major.minor.patch):v0.1.0: Developed methods for searching keys in nested dictionaries.v1.0.1: Initial working version of the nesteddictionary class.v1.2.0: Changed dictionary traversing from recursive to functools.reduce; This is less pythonic yet faster (however, still not nearly as fast as directly accessing dicts and list).v1.2.2: Minor patch - removes a debugging print statement in the get method.For comparison, when doing (these are not included in tests, but are easy enough to write and test on your own):>>>d=[{1:{2:'value'}}]>>>%timeitusing_reduce(d,[0,1,2])#reduce from functools>>>%timeitusing_recursion(d,[0,1,2])#what was used in v1, more pythonic>>>%timeitd[0][1][2]#direct access; fastestYields:>>>648ns±3.17nsperloop(mean±std.dev.of7runs,1000000loopseach)#reduce>>>1.77µs±4.05nsperloop(mean±std.dev.of7runs,1000000loopseach)#recursion>>>89.3ns±0.448nsperloop(mean±std.dev.of7runs,10000000loopseach)#directReferences:Scalpl: A similar implementation to nested dictionaries. Some good methodology here.Functools Reduce for dicts: Speed up dictionary acces, but non-pythonic.Others I'm sure I forgot to mention. Thank you.
Package: nested-dicts
Nested DictsPython multiple-default dicts, list-keyed dicts, dotted-key dicts and Arrays of Tables classes.pip install nested_dictsExamplesDefaultsDictABCImplement the choose_factory method on a subclass
to select a factory.  The returned factory is itself
called with the key value (unlike collections.defaultdict.missing)The following 4 examples all define a dictionary subclassdfor whichd == {'k': {'sub_dict_key': 'v'}}is True.NestedDefaultsDict>>> d = NestedDefaultsDict()
>>> d['k']['sub_dict_key'] = 'v'ListKeyedDict>>> d = ListKeyedDict.from_nested_dict({'k': {'sub_dict_key': 'v'}})
>>> d[['k', 'sub_dict_key']]
'v'ListKeyedNestedDefaultsDict>>> d = ListKeyedNestedDefaultsDict()
>>> d[['k', 'sub_dict_key']] = 'v'DottedKeyedNestedDefaultsDict>>> d = DottedKeyedNestedDefaultsDict()
>>> d['k.sub_dict_key'] = 'v'TOMLTable>>> from nested_dicts import TOMLTable
>>> t = TOMLTable()
>>> t['table-1'].update(
... key1 = "some string",
... key2 = 123)

>>> t['table-2'].update(
... key1 = "another string",
... key2 = 456)
>>> t
{'table-1': {'key1': 'some string', 'key2': 123}, 'table-2': {'key1': 'another string', 'key2': 456}}Values in TOMLTable()s indexed with lists behave likeArrays of Tables,
even when only read>>> from nested_dicts import TOMLTable
>>> t = TOMLTable()
>>> t[['products']].update(
name = "Hammer",
sku = 738594937
)

>>> t[['products']]  # empty table within the array
{}
>>> t[['products']].update(
name = "Nail",
sku = 284758393,

color = "gray"
)


>>> t
{'products': [{'name': 'Hammer', 'sku': 738594937}, {}, {'name': 'Nail', 'sku': 284758393, 'color': 'gray'}]}
Package: nested-diff-restful
RESTful Nested-DiffREST API and web UI forNested-Diff.pyLive DemoInstallpipinstallnested_diff_restfulRunnested_diff_restful--bind127.0.0.1:8080--workers=4Run testspipinstall-e.[test]pytestLicenseLicensed under the terms of theApache License, Version 2.0.
Package: nestedDive
NestedDivePython package to sort nested itemsThis package is made to sort list with deep nested items in your dictionory.Create setup : py setup.py sdist bdist_wheel
Uploud to pypy : py -m twine upload dist/*To installpip install nestedDiveFunctions:getHighestif you call the function sum it will count all the items in the layer and give back a lised sorted on item;
Package: nested-django-serializer
Nested Django SerializerAn updated version of wadofstuff that is compatible with python3 and Django 4. Used to fully serialize Django model
foreign key and many-to-many relations.InstallationThe package is available on pypi and can be installed via$ pip install nested-django-serializerTo use the package in your Django project, simply add the following variable to your settings.pySERIALIZATION_MODULES={'json':'nested_django_serializer.django.serializers.json'}Featuresrelations - a list or dictionary of model related fields to be followed
and serialized.extras - a list of non-model field properties or callables to be
serialized.excludes - a list of fields to be excluded from serialization. The
excludes list takes precedence over the fields argument.RelationsThe Nested Django Serializer has the ability to fully serialize referenced Django models as opposed to the default
behaviour of simply returning the primary key value.To override the default behaviour, supply therelationskeyword argument toserializers.serialize()The argument should either be a list of relations to be serialized or a dictionary of key/value pairs where the keys are
relations to be serialized and the values are lists of arguments to be passed to the serializer when serializing that
relation.serializers.serialize('json',Group.objects.all(),indent=4,relations=('permissions',))[{"pk":2,"model":"auth.group","fields":{"name":"session","permissions":[{"pk":19,"model":"auth.permission","fields":{"codename":"add_session","name":"Can add session","content_type":7}}]}}]serializers.serialize('json',Group.objects.all(),indent=4,relations={'permissions':{'fields':('content_type',),'relations':('content_type',)}})[{"pk":2,"model":"auth.group","fields":{"name":"session","permissions":[{"pk":19,"model":"auth.permission","fields":{"content_type":{"pk":7,"model":"contenttypes.contenttype","fields":{"model":"session","name":"session","app_label":"sessions"}}}}]}}]