Provided by: python-muranoclient_1.1.1-0ubuntu1_all bug

NAME

       python-muranoclient - python-muranoclient

       This  is  a  client  for the OpenStack Application Catalog API.  There's a Python API (the
       muranoclient module) and a command-line script (installed as murano).

MURANO API CLIENT

       In order to use the python api directly, you must first obtain an auth token and  identify
       which endpoint you wish to speak to. Once you have done so, you can use the API like so:

          >>> from muranoclient import Client
          >>> murano = Client('1', endpoint=MURANO_URL, token=OS_AUTH_TOKEN)
          ...

   Command-line Tool
       In  order  to use the CLI, you must provide your OpenStack username, password, tenant, and
       auth  endpoint.  Use  the  corresponding  configuration  options   (:option:--os-username,
       :option:--os-password,  :option:--os-tenant-id,  and :option:--os-auth-url) or set them in
       environment variables:

          export OS_USERNAME=user
          export OS_PASSWORD=pass
          export OS_TENANT_ID=b363706f891f48019483f8bd6503c54b
          export OS_AUTH_URL=http://auth.example.com:5000/v2.0

       The command line tool will attempt to reauthenticate using your provided  credentials  for
       every  request.  You  can override this behavior by manually supplying an auth token using
       :option:--os-image-url  and  :option:--os-auth-token.  You  can  alternatively  set  these
       environment variables:

          export MURANO_URL=http://murano.example.org:8082/
          export OS_AUTH_TOKEN=3bcc3d3a03f44e3d8377f9247b0ad155

       Once  you've  configured  your authentication parameters, you can run murano help to see a
       complete listing of available commands.

   Application Catalog service (murano) command-line client
       The murano client is the command-line interface (CLI) for the Application Catalog  service
       (murano) API and its extensions.

       This chapter documents murano version 0.13.0.

       For help on a specific murano command, enter:

          $ murano help COMMAND

   murano usage
          usage: murano [--version] [-d] [-v] [--cert-file OS_CERT] [--key-file OS_KEY]
                        [--ca-file OS_CACERT] [--api-timeout API_TIMEOUT]
                        [--os-tenant-id OS_TENANT_ID] [--os-tenant-name OS_TENANT_NAME]
                        [--os-region-name OS_REGION_NAME]
                        [--os-auth-token OS_AUTH_TOKEN] [--os-no-client-auth]
                        [--murano-url MURANO_URL] [--glance-url GLANCE_URL]
                        [--glare-url GLARE_URL]
                        [--murano-api-version MURANO_API_VERSION]
                        [--os-service-type OS_SERVICE_TYPE]
                        [--os-endpoint-type OS_ENDPOINT_TYPE] [--include-password]
                        [--murano-repo-url MURANO_REPO_URL]
                        [--murano-packages-service {murano,glance,glare}] [--insecure]
                        [--os-cacert <ca-certificate>] [--os-cert <certificate>]
                        [--os-key <key>] [--timeout <seconds>]
                        [--os-auth-url OS_AUTH_URL] [--os-domain-id OS_DOMAIN_ID]
                        [--os-domain-name OS_DOMAIN_NAME]
                        [--os-project-id OS_PROJECT_ID]
                        [--os-project-name OS_PROJECT_NAME]
                        [--os-project-domain-id OS_PROJECT_DOMAIN_ID]
                        [--os-project-domain-name OS_PROJECT_DOMAIN_NAME]
                        [--os-trust-id OS_TRUST_ID] [--os-user-id OS_USER_ID]
                        [--os-username OS_USERNAME]
                        [--os-user-domain-id OS_USER_DOMAIN_ID]
                        [--os-user-domain-name OS_USER_DOMAIN_NAME]
                        [--os-password OS_PASSWORD]
                        <subcommand> ...

       Subcommands:

       app-show
              List applications, added to specified environment.

       bundle-import
              Import a bundle.

       bundle-save
              Save a bundle.

       category-create
              Create a category.

       category-delete
              Delete a category.

       category-list
              List all available categories.

       category-show
              Display category details.

       class-schema
              Display class schema

       deployment-list
              List deployments for an environment or multiple environments.

       env-template-add-app
              Add application to the environment template.

       env-template-clone
              Create a new template, cloned from template.

       env-template-create
              Create an environment template.

       env-template-create-env
              Create a new environment from template.

       env-template-del-app
              Delete application from the environment template.

       env-template-delete
              Delete an environment template.

       env-template-list
              List the environments templates.

       env-template-show
              Display environment template details.

       env-template-update
              Update an environment template.

       environment-action-call
              Call action `ACTION` in environment `ID`.

       environment-action-get-result
              Get result of `TASK` in environment `ID`.

       environment-apps-edit
              Edit environment's object model.

       environment-create
              Create an environment.

       environment-delete
              Delete an environment.

       environment-deploy
              Start deployment of a murano environment session.

       environment-list
              List the environments.

       environment-model-edit
              Edit an environment's object model.

       environment-model-show
              Display an environment's object model.

       environment-rename
              Rename an environment.

       environment-session-create
              Creates a new configuration session for environment ID.

       environment-show
              Display environment details.

       package-create
              Create an application package.

       package-delete
              Delete a package.

       package-download
              Download a package to a filename or stdout.

       package-import
              Import a package.

       package-list
              List available packages.

       package-save
              Save a package.

       package-show
              Display details for a package.

       package-update
              Update an existing package.

       static-action-call
              Call static method `METHOD` of the class `CLASS` with `ARGUMENTS`.

       bash-completion
              Prints all of the commands and options to stdout.

       help   Display help about this program or one of its subcommands.

   murano optional arguments
       --version
              Show program's version number and exit.

       -d, --debug
              Defaults to env[MURANOCLIENT_DEBUG].

       -v, --verbose
              Print more verbose output.

       --cert-file OS_CERT
              DEPRECATED! Use --os-cert.

       --key-file OS_KEY
              DEPRECATED! Use --os-key.

       --ca-file OS_CACERT
              DEPRECATED! Use --os-cacert.

       --api-timeout API_TIMEOUT
              Number of seconds to wait for an API response, defaults to system socket timeout.

       --os-tenant-id OS_TENANT_ID
              Defaults to env[OS_TENANT_ID].

       --os-tenant-name OS_TENANT_NAME
              Defaults to env[OS_TENANT_NAME].

       --os-region-name OS_REGION_NAME
              Defaults to env[OS_REGION_NAME].

       --os-auth-token OS_AUTH_TOKEN
              Defaults to env[OS_AUTH_TOKEN].

       --os-no-client-auth
              Do not contact keystone for a token. Defaults to env[OS_NO_CLIENT_AUTH].

       --murano-url MURANO_URL
              Defaults to env[MURANO_URL].

       --glance-url GLANCE_URL
              Defaults to env[GLANCE_URL].

       --glare-url GLARE_URL
              Defaults to env[GLARE_URL].

       --murano-api-version MURANO_API_VERSION
              Defaults to env[MURANO_API_VERSION] or 1.

       --os-service-type OS_SERVICE_TYPE
              Defaults to env[OS_SERVICE_TYPE].

       --os-endpoint-type OS_ENDPOINT_TYPE
              Defaults to env[OS_ENDPOINT_TYPE].

       --include-password
              Send os-username and os-password to murano.

       --murano-repo-url MURANO_REPO_URL
              Defaults                 to                 env[MURANO_REPO_URL]                 or
              http://apps.openstack.org/api/v1/murano_repo/liberty/

       --murano-packages-service {murano,glance,glare}
              Specifies if murano-api ("murano") or Glance Artifact Repository  ("glare")  should
              be  used  to  store murano packages. Defaults to env[MURANO_PACKAGES_SERVICE] or to
              "murano"

       --insecure
              Explicitly allow client to perform "insecure" TLS (https)  requests.  The  server's
              certificate  will  not be verified against any certificate authorities. This option
              should be used with caution.

       --os-cacert <ca-certificate>
              Specify a CA bundle file to use in verifying  a  TLS  (https)  server  certificate.
              Defaults to env[OS_CACERT].

       --os-cert <certificate>
              Defaults to env[OS_CERT].

       --os-key <key>
              Defaults to env[OS_KEY].

       --timeout <seconds>
              Set request timeout (in seconds).

       --os-auth-url OS_AUTH_URL
              Authentication URL

       --os-domain-id OS_DOMAIN_ID
              Domain ID to scope to

       --os-domain-name OS_DOMAIN_NAME
              Domain name to scope to

       --os-project-id OS_PROJECT_ID
              Project ID to scope to

       --os-project-name OS_PROJECT_NAME
              Project name to scope to

       --os-project-domain-id OS_PROJECT_DOMAIN_ID
              Domain ID containing project

       --os-project-domain-name OS_PROJECT_DOMAIN_NAME
              Domain name containing project

       --os-trust-id OS_TRUST_ID
              Trust ID

       --os-user-id OS_USER_ID
              User ID

       --os-username OS_USERNAME, --os-user-name OS_USERNAME, --os-user_name OS_USERNAME
              Username

       --os-user-domain-id OS_USER_DOMAIN_ID
              User's domain id

       --os-user-domain-name OS_USER_DOMAIN_NAME
              User's domain name

       --os-password OS_PASSWORD
              User's password

   murano app-show
          usage: murano app-show [-p <PATH>] <ID>

       List applications, added to specified environment.

       Positional arguments:

       <ID>   Environment ID to show applications from.

       Optional arguments:

       -p <PATH>, --path <PATH>
              Level  of  detalization  to  show.  Leave  empty  to browse all applications in the
              environment.

   murano bundle-import
          usage: murano bundle-import [--is-public] [--exists-action {a,s,u}]
                                      <FILE> [<FILE> ...]

       Import a bundle.  `FILE` can be either a path to a zip file, URL, or name  from  repo.  If
       `FILE`  is  a  local  file, treat names of packages in a bundle as file names, relative to
       location of the bundle file. Requirements are first searched in the same directory.

       Positional arguments:

       <FILE> Bundle URL, bundle name, or path to the bundle file.

       Optional arguments:

       --is-public
              Make packages available to users from other tenants.

       --exists-action {a,s,u}
              Default action when a package already exists.

   murano bundle-save
          usage: murano bundle-save [-p <PATH>] [--no-images] <BUNDLE>

       Save a bundle. This will download a bundle of packages with all dependencies to  specified
       path. If path doesn't exist it will be created.

       Positional arguments:

       <BUNDLE>
              Bundle URL, bundle name, or path to the bundle file.

       Optional arguments:

       -p <PATH>, --path <PATH>
              Path to the directory to store packages. If not set will use current directory.

       --no-images
              If set will skip images downloading.

   murano category-create
          usage: murano category-create <CATEGORY_NAME>

       Create a category.

       Positional arguments:

       <CATEGORY_NAME>
              Category name.

   murano category-delete
          usage: murano category-delete <ID> [<ID> ...]

       Delete a category.

       Positional arguments:

       <ID>   ID of a category(ies) to delete.

   murano category-list
          usage: murano category-list

       List all available categories.

   murano category-show
          usage: murano category-show <ID>

       Display category details.

       Positional arguments:

       <ID>   ID of a category(s) to show.

   murano class-schema
          usage: murano class-schema [--package-name PACKAGE_NAME]
                                     [--class-version CLASS_VERSION]
                                     <CLASS> [<METHOD> [<METHOD> ...]]

       Display class schema

       Positional arguments:

       <CLASS>
              Class FQN

       <METHOD>
              Method name

       Optional arguments:

       --package-name PACKAGE_NAME
              FQN of the package where the class is located

       --class-version CLASS_VERSION
              Class version or version range (version spec)

   murano deployment-list
          usage: murano deployment-list [--all-environments] [<ID>]

       List deployments for an environment or multiple environments.

       Positional arguments:

       <ID>   Environment ID for which to list deployments.

       Optional arguments:

       --all-environments
              Lists all deployments for all environments in user's tenant.

   murano env-template-add-app
          usage: murano env-template-add-app <ENV_TEMPLATE_ID> <FILE>

       Add application to the environment template.

       Positional arguments:

       <ENV_TEMPLATE_ID>
              Environment template ID.

       <FILE> Path to the template.

   murano env-template-clone
          usage: murano env-template-clone <ID> <ENV_TEMPLATE_NAME>

       Create a new template, cloned from template.

       Positional arguments:

       <ID>   Environment template ID.

       <ENV_TEMPLATE_NAME>
              New environment template name.

   murano env-template-create
          usage: murano env-template-create [--is-public] <ENV_TEMPLATE_NAME>

       Create an environment template.

       Positional arguments:

       <ENV_TEMPLATE_NAME>
              Environment template name.

       Optional arguments:

       --is-public
              Make the template available for users from other tenants.

   murano env-template-create-env
          usage: murano env-template-create-env [--region <REGION_NAME>] <ID> <ENV_NAME>

       Create a new environment from template.

       Positional arguments:

       <ID>   Environment template ID.

       <ENV_NAME>
              New environment name.

       Optional arguments:

       --region <REGION_NAME>
              Name of the target OpenStack region.

   murano env-template-del-app
          usage: murano env-template-del-app <ENV_TEMPLATE_ID> <ENV_TEMPLATE_APP_ID>

       Delete application from the environment template.

       Positional arguments:

       <ENV_TEMPLATE_ID>
              Environment template ID.

       <ENV_TEMPLATE_APP_ID>
              Application ID.

   murano env-template-delete
          usage: murano env-template-delete <ID> [<ID> ...]

       Delete an environment template.

       Positional arguments:

       <ID>   ID of environment(s) template to delete.

   murano env-template-list
          usage: murano env-template-list

       List the environments templates.

   murano env-template-show
          usage: murano env-template-show <ID>

       Display environment template details.

       Positional arguments:

       <ID>   Environment template ID.

   murano env-template-update
          usage: murano env-template-update <ID> <ENV_TEMPLATE_NAME>

       Update an environment template.

       Positional arguments:

       <ID>   Environment template ID.

       <ENV_TEMPLATE_NAME>
              Environment template name.

   murano environment-action-call
          usage: murano environment-action-call --action-id <ACTION>
                                                [--arguments [<KEY=VALUE> [<KEY=VALUE> ...]]]
                                                id

       Call  action  `ACTION`  in  environment  `ID`.   Returns  id of an asynchronous task, that
       executes the action. Actions can only be called  on  a  `deployed`  environment.  To  view
       actions available in a given environment use `environment-show` command.

       Positional arguments:

       id     ID of Environment to call action against.

       Optional arguments:

       --action-id <ACTION>
              ID of action to run.

       --arguments [<KEY=VALUE> [<KEY=VALUE> ...]]
              Action arguments.

   murano environment-action-get-result
          usage: murano environment-action-get-result --task-id <TASK> <ID>

       Get result of `TASK` in environment `ID`.

       Positional arguments:

       <ID>   ID of Environment where task is being executed.

       Optional arguments:

       --task-id <TASK>
              ID of action to run.

   murano environment-apps-edit
          usage: murano environment-apps-edit --session-id <SESSION_ID> <ID> [FILE]

       Edit  environment's  object model. `FILE` is path to a file, that contains jsonpatch, that
       describes changes to be made to environment's object-model. [ { "op": "add", "path": "/-",
       "value": { ... your-app object model here ... } }, { "op": "replace", "path": "/0/?/name",
       "value": "new_name" }, ] NOTE: Values '===id1===',  '===id2===',  etc.  in  the  resulting
       object-model will be substituted with uuids. For more info on jsonpatch see RFC 6902

       Positional arguments:

       <ID>   ID of Environment to edit.

       FILE   File to read jsonpatch from (defaults to stdin).

       Optional arguments:

       --session-id <SESSION_ID>
              Id of a config session.

   murano environment-create
          usage: murano environment-create [--join-net-id <NET_ID>]
                                           [--join-subnet-id <SUBNET_ID>]
                                           [--region <REGION_NAME>]
                                           <ENVIRONMENT_NAME>

       Create an environment.

       Positional arguments:

       <ENVIRONMENT_NAME>
              Environment name.

       Optional arguments:

       --join-net-id <NET_ID>
              Network id to join.

       --join-subnet-id <SUBNET_ID>
              Subnetwork id to join.

       --region <REGION_NAME>
              Name of the target OpenStack region.

   murano environment-delete
          usage: murano environment-delete [--abandon] <NAME or ID> [<NAME or ID> ...]

       Delete an environment.

       Positional arguments:

       <NAME or ID>
              Id or name of environment(s) to delete.

       Optional arguments:

       --abandon
              If set will abandon environment without deleting any of its resources.

   murano environment-deploy
          usage: murano environment-deploy --session-id <SESSION> <ID>

       Start deployment of a murano environment session.

       Positional arguments:

       <ID>   ID of Environment to deploy.

       Optional arguments:

       --session-id <SESSION>
              ID of configuration session to deploy.

   murano environment-list
          usage: murano environment-list [--all-tenants] [--tenant <TENANT_ID>]

       List the environments.

       Optional arguments:

       --all-tenants
              Allows to list environments from all tenants (admin only).

       --tenant <TENANT_ID>
              Allows to list environments for a given tenant (admin only).

   murano environment-model-edit
          usage: murano environment-model-edit --session-id <SESSION_ID> <ID> [<FILE>]

       Edit an environment's object model.

       Positional arguments:

       <ID>   ID of Environment to edit.

       <FILE> File to read JSON-patch from (defaults to stdin).

       Optional arguments:

       --session-id <SESSION_ID>
              Id of a config session.

   murano environment-model-show
          usage: murano environment-model-show [--path <PATH>]
                                               [--session-id <SESSION_ID>]
                                               <ID>

       Display an environment's object model.

       Positional arguments:

       <ID>   ID of Environment to show.

       Optional arguments:

       --path <PATH>
              Path to Environment model section. Defaults to '/'.

       --session-id <SESSION_ID>
              Id of a config session.

   murano environment-rename
          usage: murano environment-rename <NAME or ID> <ENVIRONMENT_NAME>

       Rename an environment.

       Positional arguments:

       <NAME or ID>
              Environment ID or name.

       <ENVIRONMENT_NAME>
              A name to which the environment will be renamed.

   murano environment-session-create
          usage: murano environment-session-create <ID>

       Creates a new configuration session for environment ID.

       Positional arguments:

       <ID>   ID of Environment to add session to.

   murano environment-show
          usage: murano environment-show [--session-id <SESSION_ID>] [--only-apps]
                                         <NAME or ID>

       Display environment details.

       Positional arguments:

       <NAME or ID>
              Environment ID or name.

       Optional arguments:

       --session-id <SESSION_ID>
              Id of a config session.

       --only-apps
              Only print apps of the environment (useful for automation).

   murano package-create
          usage: murano package-create [-t <HEAT_TEMPLATE>] [-c <CLASSES_DIRECTORY>]
                                       [-r <RESOURCES_DIRECTORY>] [-n <DISPLAY_NAME>]
                                       [-f <full-name>] [-a <AUTHOR>]
                                       [--tags [<TAG1 TAG2> [<TAG1 TAG2> ...]]]
                                       [-d <DESCRIPTION>] [-o <PACKAGE_NAME>]
                                       [-u <UI_DEFINITION>] [--type TYPE] [-l <LOGO>]

       Create an application package.

       Optional arguments:

       -t <HEAT_TEMPLATE>, --template <HEAT_TEMPLATE>
              Path to the Heat template to import as an Application Definition.

       -c <CLASSES_DIRECTORY>, --classes-dir <CLASSES_DIRECTORY>
              Path to the directory containing application classes.

       -r <RESOURCES_DIRECTORY>, --resources-dir <RESOURCES_DIRECTORY>
              Path to the directory containing application resources.

       -n <DISPLAY_NAME>, --name <DISPLAY_NAME>
              Display name of the Application in Catalog.

       -f <full-name>, --full-name <full-name>
              Fully-qualified name of the Application in Catalog.

       -a <AUTHOR>, --author <AUTHOR>
              Name of the publisher.

       --tags [<TAG1 TAG2> [<TAG1 TAG2> ...]]
              A list of keywords connected to the application.

       -d <DESCRIPTION>, --description <DESCRIPTION>
              Detailed description for the Application in Catalog.

       -o <PACKAGE_NAME>, --output <PACKAGE_NAME>
              The name of the output file archive to save locally.

       -u <UI_DEFINITION>, --ui <UI_DEFINITION>
              Dynamic UI form definition.

       --type TYPE
              Package type. Possible values: Application or Library.

       -l <LOGO>, --logo <LOGO>
              Path to the package logo.

   murano package-delete
          usage: murano package-delete <ID> [<ID> ...]

       Delete a package.

       Positional arguments:

       <ID>   Package ID to delete.

   murano package-download
          usage: murano package-download <ID> [file]

       Download a package to a filename or stdout.

       Positional arguments:

       <ID>   Package ID to download.

       file   Filename  to  save  package  to.  If  it  is  not  specified and there is no stdout
              redirection the package won't be saved.

   murano package-import
          usage: murano package-import [-c [<CATEGORY> [<CATEGORY> ...]]] [--is-public]
                                       [--package-version PACKAGE_VERSION]
                                       [--exists-action {a,s,u}]
                                       [--dep-exists-action {a,s,u}]
                                       <FILE> [<FILE> ...]

       Import a package. `FILE` can be either a path to a zip file, url or a FQPN.  You  can  use
       `--`  to  separate  `FILE`s  from other arguments.  Categories have to be separated with a
       space and have to be already present in murano.

       Positional arguments:

       <FILE> URL of the murano zip package, FQPN, path to zip package or path to directory  with
              package.

       Optional arguments:

       -c [<CATEGORY> [<CATEGORY> ...]], --categories [<CATEGORY> [<CATEGORY> ...]]
              Category list to attach.

       --is-public
              Make the package available for users from other tenants.

       --package-version PACKAGE_VERSION
              Version of the package to use from repository (ignored when importing with multiple
              packages).

       --exists-action {a,s,u}
              Default action when a package already exists: (s)kip, (u)pdate, (a)bort.

       --dep-exists-action {a,s,u}
              Default action when a dependency package already exists: (s)kip, (u)pdate, (a)bort.

   murano package-list
          usage: murano package-list [--limit LIMIT] [--marker MARKER]
                                     [--include-disabled] [--owned]
                                     [--search <SEARCH_KEYS>] [--name <PACKAGE_NAME>]
                                     [--fqn <PACKAGE_FULLY_QUALIFIED_NAME>]
                                     [--type <PACKAGE_TYPE>]
                                     [--category <PACKAGE_CATEGORY>]
                                     [--class_name <PACKAGE_CLASS_NAME>]
                                     [--tag <PACKAGE_TAG>]

       List available packages.

       Optional arguments:

       --limit LIMIT
              Show limited number of packages

       --marker MARKER
              Show packages starting from package with id excluding it

       --include-disabled

       --owned

       --search <SEARCH_KEYS>
              Show packages, that match search keys fuzzily

       --name <PACKAGE_NAME>
              Show packages, whose name match parameter exactly

       --fqn <PACKAGE_FULLY_QUALIFIED_NAME>
              Show packages, whose fully qualified name match parameter exactly

       --type <PACKAGE_TYPE>
              Show packages, whose type match parameter exactly

       --category <PACKAGE_CATEGORY>
              Show packages, whose categories include parameter

       --class_name <PACKAGE_CLASS_NAME>
              Show packages, whose class name match parameter exactly

       --tag <PACKAGE_TAG>
              Show packages, whose tags include parameter

   murano package-save
          usage: murano package-save [-p <PATH>] [--package-version PACKAGE_VERSION]
                                     [--no-images]
                                     <PACKAGE> [<PACKAGE> ...]

       Save a package. This will download package(s) with all dependencies to specified path.  If
       path doesn't exist it will be created.

       Positional arguments:

       <PACKAGE>
              Package URL or name.

       Optional arguments:

       -p <PATH>, --path <PATH>
              Path to the directory to store package. If not set will use current directory.

       --package-version PACKAGE_VERSION
              Version  of  the  package to use from repository (ignored when saving with multiple
              packages).

       --no-images
              If set will skip images downloading.

   murano package-show
          usage: murano package-show <ID>

       Display details for a package.

       Positional arguments:

       <ID>   Package ID to show.

   murano package-update
          usage: murano package-update [--is-public {true|false}]
                                       [--enabled {true|false}] [--name NAME]
                                       [--description DESCRIPTION]
                                       [--tags [<TAG> [<TAG> ...]]]
                                       <ID>

       Update an existing package.

       Positional arguments:

       <ID>   Package ID to update.

       Optional arguments:

       --is-public {true|false}
              Make package available to users from other tenants.

       --enabled {true|false}
              Make package active and available for deployments.

       --name NAME
              New name for the package.

       --description DESCRIPTION
              New package description.

       --tags [<TAG> [<TAG> ...]]
              A list of keywords connected to the application.

   murano static-action-call
          usage: murano static-action-call [--arguments [<KEY=VALUE> [<KEY=VALUE> ...]]]
                                           [--package-name <PACKAGE>]
                                           [--class-version CLASS_VERSION]
                                           <CLASS> <METHOD>

       Call static method `METHOD` of the class `CLASS` with `ARGUMENTS`.  Returns the result  of
       the  method  execution.  `PACKAGE` and `CLASS_VERSION` can be specified optionally to find
       class in  a  particular  package  and  to  look  for  the  specific  version  of  a  class
       respectively.

       Positional arguments:

       <CLASS>
              FQN of the class with static method

       <METHOD>
              Static method to run

       Optional arguments:

       --arguments [<KEY=VALUE> [<KEY=VALUE> ...]]
              Method arguments. No arguments by default

       --package-name <PACKAGE>
              Optional FQN of the package to look for the class in

       --class-version CLASS_VERSION
              Optional version of the class, otherwise version =0 is used

COPYRIGHT

       OpenStack Foundation

                                           Aug 03, 2018                    PYTHON-MURANOCLIENT(1)