We are currently solving the following issue within our repository. Here is the issue text:
--- BEGIN ISSUE ---
Group parameter does not have label , description and unit  (and possibly other) kwargs
Currently, because the group parameter inherits from `_BaseParameter`, it does not have often used keyword arguments. 

--- END ISSUE ---

Below are some code segments, each from a relevant file. One or more of these files may contain bugs.
--- BEGIN FILES ---
Path: `qcodes/instrument/group_parameter.py`
Content:
```
1 from collections import OrderedDict
2 from typing import List, Union, Callable, Dict, Any
3 
4 from qcodes.instrument.parameter import _BaseParameter
5 from qcodes import Instrument
6 
7 
8 class GroupParameter(_BaseParameter):
9     """
10     Group parameter is a `Parameter` which value can be set or gotten only
11     together with other group parameters. This happens when an instrument
12     has commands which set and get more than one parameter per call.
13 
14     The `set_raw` method of a group parameter forwards the call to the
15     group, and the group then makes sure that the values of other parameters
16     within the group are left unchanged. The `get_raw` method of a group
17     parameter also forwards the call to the group, and the group makes sure
18     that the command output is parsed correctly, and the value of the
19     parameter of interest is returned.
20 
21     After initialization, the group parameters need to be added to a group.
22     See `Group` for more information.
23 
24     Args:
25         name
26             name of the parameter
27         instrument
28             instrument that this parameter belongs to; this instrument is
29             used by the group to call its get and set commands
30     """
31 
32     def __init__(self, name: str, instrument: Instrument, **kwargs) -> None:
33         self.group: Union[Group, None] = None
34         super().__init__(name, instrument=instrument, **kwargs)
35 
36         self.set_raw = lambda value: self.group.set(self, value)
37         self.set = self._wrap_set(self.set_raw)
38 
39         self.get_raw = lambda result=None: result if result is not None \
40             else self._get_raw_value()
41 
42         self.get = self._wrap_get(self.get_raw)
43 
44     def _get_raw_value(self) -> Any:
45         self.group.update()
46         return self.raw_value
47 
48 
49 class Group:
50     """
51     The group combines `GroupParameter`s that are to be gotten or set via the
52     same command. The command has to be a string, for example, a VISA command.
53 
54     The `Group`'s methods are used within `GroupParameter` in order to
55     properly implement setting and getting of a single parameter in the
56     situation where one command sets or gets more than one parameter.
57 
58     The command used for setting values of parameters has to be a format
59     string which contains the names of the parameters the group has been
60     initialized with. For example, if a command has syntax `"CMD a_value,
61     b_value"`, where `'a_value'` and `'b_value'` are values of two parameters
62     with names `"a"` and `"b"`, then the command string has to be "CMD {a},
63     {b}", and the group has to be initialized with two `GroupParameter`s
64     `a_param` and `b_param`, where `a_param.name=="a"` and `b_param.name=="b"`.
65 
66     Note that by default, it is assumed that the command used for getting
67     values returns a comma-separated list of values of parameters, and their
68     order corresponds to the order of `GroupParameter`s in the list that is
69     passed to the `Group`'s constructor. Through keyword arguments of the
70     `Group`'s constructor, it is possible to change the separator, and even
71     the parser of the output of the get command.
72 
73     The get and set commands are called via the instrument that the first
74     parameter belongs to. It is assumed that all the parameters within the
75     group belong to the same instrument.
76 
77     Example:
78         ```
79         class InstrumentWithGroupParameters(VisaInstrument):
80             def __init__(self, name, address, **kwargs):
81                 super().__init__(name, address, **kwargs)
82 
83                 ...
84 
85                 # Here is how group of group parameters is defined for
86                 # a simple case of an example "SGP" command that sets and gets
87                 # values of "enabled" and "gain" parameters (it is assumed that
88                 # "SGP?" returns the parameter values as comma-separated list
89                 # "enabled_value,gain_value")
90                 self.add_parameter('enabled',
91                                    label='Enabled',
92                                    val_mapping={True: 1, False: 0},
93                                    parameter_class=GroupParameter)
94                 self.add_parameter('gain',
95                                    label='Some gain value',
96                                    get_parser=float,
97                                    parameter_class=GroupParameter)
98                 self.output_group = Group([self.enabled, self.gain],
99                                           set_cmd='SGP {enabled}, {gain}',
100                                           get_cmd='SGP?')
101 
102                 ...
103         ```
104 
105     Args:
106         parameters
107             a list of `GroupParameter` instances which have to be gotten and
108             set via the same command; the order of parameters in the list
109             should correspond to the order of the values returned by the
110             `get_cmd`
111         set_cmd
112             format string of the command that is used for setting the values
113             of the parameters; for example, "CMD {a}, {b}"
114         get_cmd
115             string of the command that is used for getting the values of the
116             parameters; for example, "CMD?"
117         separator
118             a separator that is used when parsing the output of the `get_cmd`
119             in order to obtain the values of the parameters; it is ignored in
120             case a custom `get_parser` is used
121         get_parser
122             a callable with a single string argument that is used to parse
123             the output of the `get_cmd`; the callable has to return a
124             dictionary where parameter names are keys, and the values are the
125             values (as directly obtained from the output of the get command;
126             note that parsers within the parameters will take care of
127             individual parsing of their values)
128     """
129     def __init__(self,
130                  parameters: List[GroupParameter],
131                  set_cmd: str=None,
132                  get_cmd: str=None,
133                  get_parser: Union[Callable[[str], Dict[str, Any]], None]=None,
134                  separator: str=','
135                  ) -> None:
136         self.parameters = OrderedDict((p.name, p) for p in parameters)
137 
138         for p in parameters:
139             p.group = self
140 
141         if len(set([p.root_instrument for p in parameters])) > 1:
142             raise ValueError(
143                 "All parameters should belong to the same instrument")
144 
145         self.instrument = parameters[0].root_instrument
146 
147         self.set_cmd = set_cmd
148         self.get_cmd = get_cmd
149 
150         if get_parser:
151             self.get_parser = get_parser
152         else:
153             self.get_parser = self._separator_parser(separator)
154 
155     def _separator_parser(self, separator: str
156                           ) -> Callable[[str], Dict[str, Any]]:
157         """A default separator-based string parser"""
158         def parser(ret_str: str) -> Dict[str, Any]:
159             keys = self.parameters.keys()
160             values = ret_str.split(separator)
161             return dict(zip(keys, values))
162 
163         return parser
164 
165     def set(self, set_parameter: GroupParameter, value: Any):
166         """
167         Sets the value of the given parameter within a group to the given
168         value by calling the `set_cmd`
169 
170         Args:
171             set_parameter
172                 the parameter within the group to set
173             value
174                 the new value for this parameter
175         """
176         if any((p.get_latest() is None) for p in self.parameters.values()):
177             self.update()
178         calling_dict = {name: p.raw_value
179                         for name, p in self.parameters.items()}
180         calling_dict[set_parameter.name] = value
181         command_str = self.set_cmd.format(**calling_dict)
182         self.instrument.write(command_str)
183 
184     def update(self):
185         """
186         Update the values of all the parameters within the group by calling
187         the `get_cmd`
188         """
189         ret = self.get_parser(self.instrument.ask(self.get_cmd))
190         for name, p in list(self.parameters.items()):
191             p.get(result=ret[name])
192
```
--- END FILES ---

Please first localize the bug based on the issue statement, and then generate a patch according to the `git diff` format fenced by three backticks.

Here is an example:

```diff
diff --git a/examples/server_async.py b/examples/server_async.py
--- a/examples/server_async.py
+++ b/examples/server_async.py
@@ -313,4 +313,4 @@
 
 
 if __name__ == "__main__":
-    asyncio.run(run_async_server("."), debug=True)
+    asyncio.run(run_async_server(), debug=True)
diff --git a/examples/server_sync.py b/examples/server_sync.py
--- a/examples/server_sync.py
+++ b/examples/server_sync.py
@@ -313,5 +313,5 @@
 
 
 if __name__ == "__main__":
-    server = run_sync_server(".")
+    server = run_sync_server()
     server.shutdown()

```

diff --git a/qcodes/instrument/group_parameter.py b/qcodes/instrument/group_parameter.py
--- a/qcodes/instrument/group_parameter.py
+++ b/qcodes/instrument/group_parameter.py
@@ -1,11 +1,11 @@
 from collections import OrderedDict
-from typing import List, Union, Callable, Dict, Any
+from typing import List, Union, Callable, Dict, Any, Optional
 
-from qcodes.instrument.parameter import _BaseParameter
+from qcodes.instrument.parameter import Parameter
 from qcodes import Instrument
 
 
-class GroupParameter(_BaseParameter):
+class GroupParameter(Parameter):
     """
     Group parameter is a `Parameter` which value can be set or gotten only
     together with other group parameters. This happens when an instrument
@@ -27,9 +27,21 @@
         instrument
             instrument that this parameter belongs to; this instrument is
             used by the group to call its get and set commands
+
+        **kwargs:
+            All kwargs used by the Parameter class, except set_cmd and get_cmd
     """
 
-    def __init__(self, name: str, instrument: Instrument, **kwargs) -> None:
+    def __init__(
+            self, name: str,
+            instrument: Optional['Instrument'] = None,
+            **kwargs
+    ) -> None:
+
+        if "set_cmd" in kwargs or "get_cmd" in kwargs:
+            raise ValueError("A GroupParameter does not use 'set_cmd' or "
+                             "'get_cmd' kwarg")
+
         self.group: Union[Group, None] = None
         super().__init__(name, instrument=instrument, **kwargs)

{"golden_diff": "diff --git a/qcodes/instrument/group_parameter.py b/qcodes/instrument/group_parameter.py\n--- a/qcodes/instrument/group_parameter.py\n+++ b/qcodes/instrument/group_parameter.py\n@@ -1,11 +1,11 @@\n from collections import OrderedDict\n-from typing import List, Union, Callable, Dict, Any\n+from typing import List, Union, Callable, Dict, Any, Optional\n \n-from qcodes.instrument.parameter import _BaseParameter\n+from qcodes.instrument.parameter import Parameter\n from qcodes import Instrument\n \n \n-class GroupParameter(_BaseParameter):\n+class GroupParameter(Parameter):\n     \"\"\"\n     Group parameter is a `Parameter` which value can be set or gotten only\n     together with other group parameters. This happens when an instrument\n@@ -27,9 +27,21 @@\n         instrument\n             instrument that this parameter belongs to; this instrument is\n             used by the group to call its get and set commands\n+\n+        **kwargs:\n+            All kwargs used by the Parameter class, except set_cmd and get_cmd\n     \"\"\"\n \n-    def __init__(self, name: str, instrument: Instrument, **kwargs) -> None:\n+    def __init__(\n+            self, name: str,\n+            instrument: Optional['Instrument'] = None,\n+            **kwargs\n+    ) -> None:\n+\n+        if \"set_cmd\" in kwargs or \"get_cmd\" in kwargs:\n+            raise ValueError(\"A GroupParameter does not use 'set_cmd' or \"\n+                             \"'get_cmd' kwarg\")\n+\n         self.group: Union[Group, None] = None\n         super().__init__(name, instrument=instrument, **kwargs)\n", "issue": "Group parameter does not have label , description and unit  (and possibly other) kwargs\nCurrently, because the group parameter inherits from `_BaseParameter`, it does not have often used keyword arguments. \n", "before_files": [{"content": "from collections import OrderedDict\nfrom typing import List, Union, Callable, Dict, Any\n\nfrom qcodes.instrument.parameter import _BaseParameter\nfrom qcodes import Instrument\n\n\nclass GroupParameter(_BaseParameter):\n    \"\"\"\n    Group parameter is a `Parameter` which value can be set or gotten only\n    together with other group parameters. This happens when an instrument\n    has commands which set and get more than one parameter per call.\n\n    The `set_raw` method of a group parameter forwards the call to the\n    group, and the group then makes sure that the values of other parameters\n    within the group are left unchanged. The `get_raw` method of a group\n    parameter also forwards the call to the group, and the group makes sure\n    that the command output is parsed correctly, and the value of the\n    parameter of interest is returned.\n\n    After initialization, the group parameters need to be added to a group.\n    See `Group` for more information.\n\n    Args:\n        name\n            name of the parameter\n        instrument\n            instrument that this parameter belongs to; this instrument is\n            used by the group to call its get and set commands\n    \"\"\"\n\n    def __init__(self, name: str, instrument: Instrument, **kwargs) -> None:\n        self.group: Union[Group, None] = None\n        super().__init__(name, instrument=instrument, **kwargs)\n\n        self.set_raw = lambda value: self.group.set(self, value)\n        self.set = self._wrap_set(self.set_raw)\n\n        self.get_raw = lambda result=None: result if result is not None \\\n            else self._get_raw_value()\n\n        self.get = self._wrap_get(self.get_raw)\n\n    def _get_raw_value(self) -> Any:\n        self.group.update()\n        return self.raw_value\n\n\nclass Group:\n    \"\"\"\n    The group combines `GroupParameter`s that are to be gotten or set via the\n    same command. The command has to be a string, for example, a VISA command.\n\n    The `Group`'s methods are used within `GroupParameter` in order to\n    properly implement setting and getting of a single parameter in the\n    situation where one command sets or gets more than one parameter.\n\n    The command used for setting values of parameters has to be a format\n    string which contains the names of the parameters the group has been\n    initialized with. For example, if a command has syntax `\"CMD a_value,\n    b_value\"`, where `'a_value'` and `'b_value'` are values of two parameters\n    with names `\"a\"` and `\"b\"`, then the command string has to be \"CMD {a},\n    {b}\", and the group has to be initialized with two `GroupParameter`s\n    `a_param` and `b_param`, where `a_param.name==\"a\"` and `b_param.name==\"b\"`.\n\n    Note that by default, it is assumed that the command used for getting\n    values returns a comma-separated list of values of parameters, and their\n    order corresponds to the order of `GroupParameter`s in the list that is\n    passed to the `Group`'s constructor. Through keyword arguments of the\n    `Group`'s constructor, it is possible to change the separator, and even\n    the parser of the output of the get command.\n\n    The get and set commands are called via the instrument that the first\n    parameter belongs to. It is assumed that all the parameters within the\n    group belong to the same instrument.\n\n    Example:\n        ```\n        class InstrumentWithGroupParameters(VisaInstrument):\n            def __init__(self, name, address, **kwargs):\n                super().__init__(name, address, **kwargs)\n\n                ...\n\n                # Here is how group of group parameters is defined for\n                # a simple case of an example \"SGP\" command that sets and gets\n                # values of \"enabled\" and \"gain\" parameters (it is assumed that\n                # \"SGP?\" returns the parameter values as comma-separated list\n                # \"enabled_value,gain_value\")\n                self.add_parameter('enabled',\n                                   label='Enabled',\n                                   val_mapping={True: 1, False: 0},\n                                   parameter_class=GroupParameter)\n                self.add_parameter('gain',\n                                   label='Some gain value',\n                                   get_parser=float,\n                                   parameter_class=GroupParameter)\n                self.output_group = Group([self.enabled, self.gain],\n                                          set_cmd='SGP {enabled}, {gain}',\n                                          get_cmd='SGP?')\n\n                ...\n        ```\n\n    Args:\n        parameters\n            a list of `GroupParameter` instances which have to be gotten and\n            set via the same command; the order of parameters in the list\n            should correspond to the order of the values returned by the\n            `get_cmd`\n        set_cmd\n            format string of the command that is used for setting the values\n            of the parameters; for example, \"CMD {a}, {b}\"\n        get_cmd\n            string of the command that is used for getting the values of the\n            parameters; for example, \"CMD?\"\n        separator\n            a separator that is used when parsing the output of the `get_cmd`\n            in order to obtain the values of the parameters; it is ignored in\n            case a custom `get_parser` is used\n        get_parser\n            a callable with a single string argument that is used to parse\n            the output of the `get_cmd`; the callable has to return a\n            dictionary where parameter names are keys, and the values are the\n            values (as directly obtained from the output of the get command;\n            note that parsers within the parameters will take care of\n            individual parsing of their values)\n    \"\"\"\n    def __init__(self,\n                 parameters: List[GroupParameter],\n                 set_cmd: str=None,\n                 get_cmd: str=None,\n                 get_parser: Union[Callable[[str], Dict[str, Any]], None]=None,\n                 separator: str=','\n                 ) -> None:\n        self.parameters = OrderedDict((p.name, p) for p in parameters)\n\n        for p in parameters:\n            p.group = self\n\n        if len(set([p.root_instrument for p in parameters])) > 1:\n            raise ValueError(\n                \"All parameters should belong to the same instrument\")\n\n        self.instrument = parameters[0].root_instrument\n\n        self.set_cmd = set_cmd\n        self.get_cmd = get_cmd\n\n        if get_parser:\n            self.get_parser = get_parser\n        else:\n            self.get_parser = self._separator_parser(separator)\n\n    def _separator_parser(self, separator: str\n                          ) -> Callable[[str], Dict[str, Any]]:\n        \"\"\"A default separator-based string parser\"\"\"\n        def parser(ret_str: str) -> Dict[str, Any]:\n            keys = self.parameters.keys()\n            values = ret_str.split(separator)\n            return dict(zip(keys, values))\n\n        return parser\n\n    def set(self, set_parameter: GroupParameter, value: Any):\n        \"\"\"\n        Sets the value of the given parameter within a group to the given\n        value by calling the `set_cmd`\n\n        Args:\n            set_parameter\n                the parameter within the group to set\n            value\n                the new value for this parameter\n        \"\"\"\n        if any((p.get_latest() is None) for p in self.parameters.values()):\n            self.update()\n        calling_dict = {name: p.raw_value\n                        for name, p in self.parameters.items()}\n        calling_dict[set_parameter.name] = value\n        command_str = self.set_cmd.format(**calling_dict)\n        self.instrument.write(command_str)\n\n    def update(self):\n        \"\"\"\n        Update the values of all the parameters within the group by calling\n        the `get_cmd`\n        \"\"\"\n        ret = self.get_parser(self.instrument.ask(self.get_cmd))\n        for name, p in list(self.parameters.items()):\n            p.get(result=ret[name])\n", "path": "qcodes/instrument/group_parameter.py"}], "after_files": [{"content": "from collections import OrderedDict\nfrom typing import List, Union, Callable, Dict, Any, Optional\n\nfrom qcodes.instrument.parameter import Parameter\nfrom qcodes import Instrument\n\n\nclass GroupParameter(Parameter):\n    \"\"\"\n    Group parameter is a `Parameter` which value can be set or gotten only\n    together with other group parameters. This happens when an instrument\n    has commands which set and get more than one parameter per call.\n\n    The `set_raw` method of a group parameter forwards the call to the\n    group, and the group then makes sure that the values of other parameters\n    within the group are left unchanged. The `get_raw` method of a group\n    parameter also forwards the call to the group, and the group makes sure\n    that the command output is parsed correctly, and the value of the\n    parameter of interest is returned.\n\n    After initialization, the group parameters need to be added to a group.\n    See `Group` for more information.\n\n    Args:\n        name\n            name of the parameter\n        instrument\n            instrument that this parameter belongs to; this instrument is\n            used by the group to call its get and set commands\n\n        **kwargs:\n            All kwargs used by the Parameter class, except set_cmd and get_cmd\n    \"\"\"\n\n    def __init__(\n            self, name: str,\n            instrument: Optional['Instrument'] = None,\n            **kwargs\n    ) -> None:\n\n        if \"set_cmd\" in kwargs or \"get_cmd\" in kwargs:\n            raise ValueError(\"A GroupParameter does not use 'set_cmd' or \"\n                             \"'get_cmd' kwarg\")\n\n        self.group: Union[Group, None] = None\n        super().__init__(name, instrument=instrument, **kwargs)\n\n        self.set_raw = lambda value: self.group.set(self, value)\n        self.set = self._wrap_set(self.set_raw)\n\n        self.get_raw = lambda result=None: result if result is not None \\\n            else self._get_raw_value()\n\n        self.get = self._wrap_get(self.get_raw)\n\n    def _get_raw_value(self) -> Any:\n        self.group.update()\n        return self.raw_value\n\n\nclass Group:\n    \"\"\"\n    The group combines `GroupParameter`s that are to be gotten or set via the\n    same command. The command has to be a string, for example, a VISA command.\n\n    The `Group`'s methods are used within `GroupParameter` in order to\n    properly implement setting and getting of a single parameter in the\n    situation where one command sets or gets more than one parameter.\n\n    The command used for setting values of parameters has to be a format\n    string which contains the names of the parameters the group has been\n    initialized with. For example, if a command has syntax `\"CMD a_value,\n    b_value\"`, where `'a_value'` and `'b_value'` are values of two parameters\n    with names `\"a\"` and `\"b\"`, then the command string has to be \"CMD {a},\n    {b}\", and the group has to be initialized with two `GroupParameter`s\n    `a_param` and `b_param`, where `a_param.name==\"a\"` and `b_param.name==\"b\"`.\n\n    Note that by default, it is assumed that the command used for getting\n    values returns a comma-separated list of values of parameters, and their\n    order corresponds to the order of `GroupParameter`s in the list that is\n    passed to the `Group`'s constructor. Through keyword arguments of the\n    `Group`'s constructor, it is possible to change the separator, and even\n    the parser of the output of the get command.\n\n    The get and set commands are called via the instrument that the first\n    parameter belongs to. It is assumed that all the parameters within the\n    group belong to the same instrument.\n\n    Example:\n        ```\n        class InstrumentWithGroupParameters(VisaInstrument):\n            def __init__(self, name, address, **kwargs):\n                super().__init__(name, address, **kwargs)\n\n                ...\n\n                # Here is how group of group parameters is defined for\n                # a simple case of an example \"SGP\" command that sets and gets\n                # values of \"enabled\" and \"gain\" parameters (it is assumed that\n                # \"SGP?\" returns the parameter values as comma-separated list\n                # \"enabled_value,gain_value\")\n                self.add_parameter('enabled',\n                                   label='Enabled',\n                                   val_mapping={True: 1, False: 0},\n                                   parameter_class=GroupParameter)\n                self.add_parameter('gain',\n                                   label='Some gain value',\n                                   get_parser=float,\n                                   parameter_class=GroupParameter)\n                self.output_group = Group([self.enabled, self.gain],\n                                          set_cmd='SGP {enabled}, {gain}',\n                                          get_cmd='SGP?')\n\n                ...\n        ```\n\n    Args:\n        parameters\n            a list of `GroupParameter` instances which have to be gotten and\n            set via the same command; the order of parameters in the list\n            should correspond to the order of the values returned by the\n            `get_cmd`\n        set_cmd\n            format string of the command that is used for setting the values\n            of the parameters; for example, \"CMD {a}, {b}\"\n        get_cmd\n            string of the command that is used for getting the values of the\n            parameters; for example, \"CMD?\"\n        separator\n            a separator that is used when parsing the output of the `get_cmd`\n            in order to obtain the values of the parameters; it is ignored in\n            case a custom `get_parser` is used\n        get_parser\n            a callable with a single string argument that is used to parse\n            the output of the `get_cmd`; the callable has to return a\n            dictionary where parameter names are keys, and the values are the\n            values (as directly obtained from the output of the get command;\n            note that parsers within the parameters will take care of\n            individual parsing of their values)\n    \"\"\"\n    def __init__(self,\n                 parameters: List[GroupParameter],\n                 set_cmd: str=None,\n                 get_cmd: str=None,\n                 get_parser: Union[Callable[[str], Dict[str, Any]], None]=None,\n                 separator: str=','\n                 ) -> None:\n        self.parameters = OrderedDict((p.name, p) for p in parameters)\n\n        for p in parameters:\n            p.group = self\n\n        if len(set([p.root_instrument for p in parameters])) > 1:\n            raise ValueError(\n                \"All parameters should belong to the same instrument\")\n\n        self.instrument = parameters[0].root_instrument\n\n        self.set_cmd = set_cmd\n        self.get_cmd = get_cmd\n\n        if get_parser:\n            self.get_parser = get_parser\n        else:\n            self.get_parser = self._separator_parser(separator)\n\n    def _separator_parser(self, separator: str\n                          ) -> Callable[[str], Dict[str, Any]]:\n        \"\"\"A default separator-based string parser\"\"\"\n        def parser(ret_str: str) -> Dict[str, Any]:\n            keys = self.parameters.keys()\n            values = ret_str.split(separator)\n            return dict(zip(keys, values))\n\n        return parser\n\n    def set(self, set_parameter: GroupParameter, value: Any):\n        \"\"\"\n        Sets the value of the given parameter within a group to the given\n        value by calling the `set_cmd`\n\n        Args:\n            set_parameter\n                the parameter within the group to set\n            value\n                the new value for this parameter\n        \"\"\"\n        if any((p.get_latest() is None) for p in self.parameters.values()):\n            self.update()\n        calling_dict = {name: p.raw_value\n                        for name, p in self.parameters.items()}\n        calling_dict[set_parameter.name] = value\n        command_str = self.set_cmd.format(**calling_dict)\n        self.instrument.write(command_str)\n\n    def update(self):\n        \"\"\"\n        Update the values of all the parameters within the group by calling\n        the `get_cmd`\n        \"\"\"\n        ret = self.get_parser(self.instrument.ask(self.get_cmd))\n        for name, p in list(self.parameters.items()):\n            p.get(result=ret[name])\n", "path": "qcodes/instrument/group_parameter.py"}]}