You can get a dictionary representation copy of the Gitlab Object. Modifications made to

the dictionary will have no impact on the GitLab Object.

* `asdict()` method. Returns a dictionary representation of the Gitlab object.

* `attributes` property. Returns a dictionary representation of the Gitlab

object. Also returns any relevant parent object attributes.

..note::

`attributes` returns the parent object attributes that are defined in

`object._from_parent_attrs`. What this can mean is that for example a `ProjectIssue`

object will have a `project_id` key in the dictionary returned from `attributes` but

`asdict()` will not.

..code-block::python

You can get a JSON string represenation of the Gitlab Object. For example:

..code-block::python

Base types

def__setattr__(self,name:str,value:Any)->None:

self.__dict__["_updated_attrs"][name]=value

defasdict(self,*,with_parent_attrs:bool=False)->Dict[str,Any]:

data= {}

ifwith_parent_attrs:

data.update(copy.deepcopy(self._parent_attrs))

data.update(copy.deepcopy(self._attrs))

data.update(copy.deepcopy(self._updated_attrs))

defattributes(self)->Dict[str,Any]:

returnself.asdict(with_parent_attrs=True)

defto_json(self,*,with_parent_attrs:bool=False,**kwargs:Any)->str:

returnjson.dumps(self.asdict(with_parent_attrs=with_parent_attrs),**kwargs)

def__str__(self)->str:

data=self._attrs.copy()

data.update(self._updated_attrs)

defpformat(self)->str:

data=self._attrs.copy()

data.update(self._updated_attrs)

defpprint(self)->None:

print(self.pformat())

obj_id=gitlab.utils.EncodedId(obj_id)

defattributes(self)->Dict[str,Any]:

d=self.__dict__["_updated_attrs"].copy()

d.update(self.__dict__["_attrs"])

d.update(self.__dict__["_parent_attrs"])

classRESTObjectList:

classFakeParent:

classFakeManagerWithParent(base.RESTManager):

_from_parent_attrs= {"test_id":"id"}

deffake_gitlab():

returnFakeGitlab()

returnFakeManager(fake_gitlab)

deffake_manager_with_parent(fake_gitlab):

returnFakeManagerWithParent(fake_gitlab,parent=FakeParent)

deffake_object(fake_manager):

returnFakeObject(fake_manager, {"attr1":"foo","alist": [1,2,3]})

deffake_object_with_parent(fake_manager_with_parent):

returnFakeObject(fake_manager_with_parent, {"attr1":"foo","alist": [1,2,3]})

classTestRESTManager:

deftest_computed_path_simple(self):

classMGR(base.RESTManager):

FakeObject._id_attr=None

assertrepr(obj)=="<FakeObject>"

deftest_attributes_get(self,fake_object):

assertfake_object.attr1=="foo"

result=fake_object.attributes

assertresult== {"attr1":"foo","alist": [1,2,3]}

deftest_attributes_shows_updates(self,fake_object):

fake_object.attr1="hello"

assertfake_object.attributes== {"attr1":"hello","alist": [1,2,3]}

assertfake_object.attr1=="hello"

fake_object.new_attrib="spam"

assertfake_object.attributes== {

"attr1":"hello",

"new_attrib":"spam",

"alist": [1,2,3],

}

deftest_attributes_is_copy(self,fake_object):

result=fake_object.attributes

result["alist"].append(10)

assertresult== {"attr1":"foo","alist": [1,2,3,10]}

assertfake_object.attributes== {"attr1":"foo","alist": [1,2,3]}

deftest_attributes_has_parent_attrs(self,fake_object_with_parent):

assertfake_object_with_parent.attr1=="foo"

result=fake_object_with_parent.attributes

assertresult== {"attr1":"foo","alist": [1,2,3],"test_id":"42"}

deftest_asdict(self,fake_object):

assertfake_object.attr1=="foo"

result=fake_object.asdict()

assertresult== {"attr1":"foo","alist": [1,2,3]}

deftest_asdict_no_parent_attrs(self,fake_object_with_parent):

assertfake_object_with_parent.attr1=="foo"

result=fake_object_with_parent.asdict()

assertresult== {"attr1":"foo","alist": [1,2,3]}

assert"test_id"notinfake_object_with_parent.asdict()

assert"test_id"notinfake_object_with_parent.asdict(with_parent_attrs=False)

assert"test_id"infake_object_with_parent.asdict(with_parent_attrs=True)

deftest_asdict_modify_dict_does_not_change_object(self,fake_object):

result=fake_object.asdict()

result["attr1"]="testing"

result["alist"].append(4)

assertresult== {"attr1":"testing","alist": [1,2,3,4]}

assertfake_object.attr1=="foo"

assertfake_object.alist== [1,2,3]

deftest_asdict_modify_dict_does_not_change_object2(self,fake_object):

fake_object.attr1= [9,7,8]

assertfake_object.asdict()== {

"attr1": [9,7,8],

"alist": [1,2,3],

}

result=fake_object.asdict()

result["attr1"].append(1)

assertfake_object.asdict()== {

"attr1": [9,7,8],

"alist": [1,2,3],

}

deftest_asdict_modify_object(self,fake_object):

fake_object.attr1="spam"

assertfake_object.asdict()== {"attr1":"spam","alist": [1,2,3]}