def get_parameters(self):
        """
        Parse DockerRunBuilder options and create object with properties for docker-py run command
        :return: DockerContainerParameters
        """
        import argparse
        parser = argparse.ArgumentParser(add_help=False)

        # without parameter
        parser.add_argument("-i", "--interactive", action="store_true", dest="stdin_open")
        parser.add_argument("-d", "--detach", action="store_true", dest="detach")
        parser.add_argument("-t", "--tty", action="store_true", dest="tty")
        parser.add_argument("--init", action="store_true", dest="init")
        parser.add_argument("--privileged", action="store_true", dest="privileged")
        parser.add_argument("-P", "--publish-all", action="store_true", dest="publish_all_ports")
        parser.add_argument("--read-only", action="store_true", dest="read_only")
        parser.add_argument("--rm", action="store_true", dest="remove")

        # string parameter
        parser.add_argument("--entrypoint", action="store", dest="entrypoint")
        parser.add_argument("-h", "--hostname", action="store", dest="hostname")
        parser.add_argument("--name", action="store", dest="name")
        parser.add_argument("--ipc", action="store", dest="ipc_mode")
        parser.add_argument("--isolation", action="store", dest="isolation")
        parser.add_argument("--mac-address", action="store", dest="mac_address")
        parser.add_argument("-m", "--memory", action="store", dest="mem_limit")
        parser.add_argument("--network", action="store", dest="network")
        parser.add_argument("--platform", action="store", dest="platform")
        parser.add_argument("--runtime", action="store", dest="runtime")
        parser.add_argument("--stop-signal", action="store", dest="stop_signal")
        parser.add_argument("-u", "--user", action="store", dest="user")
        parser.add_argument("-w", "--workdir", action="store", dest="working_dir")

        # int parameter
        parser.add_argument("--pids-limit", action="store", dest="pids_limit", type=int)

        # list parameter
        parser.add_argument("-e", "--env", action="append", dest="env_variables")
        parser.add_argument("--cap-add", action="append", dest="cap_add")
        parser.add_argument("--cap-drop", action="append", dest="cap_drop")
        parser.add_argument("--device", action="append", dest="devices")
        parser.add_argument("--dns", action="append", dest="dns")
        parser.add_argument("--group-add", action="append", dest="group_add")
        parser.add_argument("--mount", action="append", dest="mounts")
        parser.add_argument("-v", "--volume", action="append", dest="volumes")

        # dict parameter
        parser.add_argument("-l", "--label", action="append", dest="labels")
        parser.add_argument("-p", "--publish", action="append", dest="port_mappings")

        # health
        parser.add_argument("--health-cmd", action="store", dest="health_cmd")
        parser.add_argument("--health-interval", action="store", dest="health_interval", type=int)
        parser.add_argument("--health-retries", action="store", dest="health_retries", type=int)
        parser.add_argument("--health-timeout", action="store", dest="health_timeout", type=int)
        parser.add_argument("--no-healthcheck", action="store_true", dest="no_healthcheck")

        args, _ = parser.parse_known_args(args=self.options)
        command = self.arguments

        options_dict = vars(args)

        # create Healthcheck object
        if not options_dict.pop("no_healthcheck", None):
            options_dict["healthcheck"] = Healthcheck(
                test=options_dict.pop("health_cmd", None),
                interval=options_dict.pop("health_interval", None),
                timeout=options_dict.pop("health_timeout", None),
                retries=options_dict.pop("health_retries", None)
            )
        else:
            options_dict['healthcheck'] = None

        # parse dictionary
        # {'name': 'separator'}
        with_dictionary_parameter = {'labels': '='}
        for name, separator in with_dictionary_parameter.items():
            if options_dict[name] is not None:
                dictionary = {}
                for item in options_dict[name]:
                    try:
                        key, value = item.split(separator)
                        dictionary[key] = value
                    except ValueError:
                        dictionary = options_dict[name]
                        raise ConuException('Wrong format of dictionary: {name}'.format(name=name))
                        break
                options_dict[name] = dictionary

        # parse ports
        # create dictionary according to https://docker-py.readthedocs.io/en/stable/containers.html
        if options_dict['port_mappings'] is not None:
            dictionary = {}
            for port_string in options_dict['port_mappings']:
                colon_count = port_string.count(':')
                if colon_count == 2:
                    split_array = port_string.split(':')
                    if split_array[1] == '':
                        # format - ip::containerPort
                        # create dictionary - {'1111/tcp': ('127.0.0.1', None)}
                        dictionary[split_array[2]] = (split_array[0], None)
                    else:
                        # format - ip:hostPort:containerPort
                        # create dictionary - {'1111/tcp': ('127.0.0.1', 1111)}
                        dictionary[split_array[2]] = (split_array[0], int(split_array[1]))
                elif colon_count == 1:
                    # format - hostPort:containerPort
                    # create dictionary - {'2222/tcp': 3333}
                    split_array = port_string.split(':')
                    dictionary[split_array[1]] = int(split_array[0])
                elif colon_count == 0:
                    # format - containerPort
                    # create dictionary - {'2222/tcp': None}
                    dictionary[port_string] = None
                else:
                    raise ConuException('Wrong format of port mappings')

            options_dict['port_mappings'] = dictionary

        container_parameters = DockerContainerParameters(cap_add=options_dict['cap_add'],
                                                         cap_drop=options_dict['cap_drop'],
                                                         command=command, detach=options_dict['detach'],
                                                         devices=options_dict['devices'], dns=options_dict['dns'],
                                                         entrypoint=options_dict['entrypoint'],
                                                         env_variables=options_dict['env_variables'],
                                                         group_add=options_dict['group_add'],
                                                         healthcheck=options_dict['healthcheck'],
                                                         hostname=options_dict['hostname'],
                                                         init=options_dict['init'],
                                                         ipc_mode=options_dict['ipc_mode'],
                                                         isolation=options_dict['isolation'],
                                                         labels=options_dict['labels'],
                                                         mac_address=options_dict['mac_address'],
                                                         mem_limit=options_dict['mem_limit'],
                                                         mounts=options_dict['mounts'],
                                                         name=options_dict['name'],
                                                         network=options_dict['network'],
                                                         pids_limit=options_dict['pids_limit'],
                                                         platform=options_dict['platform'],
                                                         port_mappings=options_dict['port_mappings'],
                                                         privileged=options_dict['privileged'],
                                                         publish_all_ports=options_dict['publish_all_ports'],
                                                         read_only=options_dict['read_only'],
                                                         remove=options_dict['remove'],
                                                         runtime=options_dict['runtime'],
                                                         stdin_open=options_dict['stdin_open'],
                                                         stop_signal=options_dict['stop_signal'],
                                                         tty=options_dict['tty'],
                                                         user=options_dict['user'],
                                                         volumes=options_dict['volumes'],
                                                         working_dir=options_dict['working_dir']
                                                         )

        return container_parameters
Parse DockerRunBuilder options and create object with properties for docker-py run command
        :return: DockerContainerParameters