python-openstackclient 9.0.0__py3-none-any.whl → 10.1.0__py3-none-any.whl

openstackclient/network/v2/network.py

@@ -12,25 +12,34 @@
 
 """Network action implementations"""
 
+import argparse
+from collections.abc import Iterable, Sequence
+import logging
+from typing import Any
+
 from cliff import columns as cliff_columns
+from openstack.network.v2 import network as _network
 from osc_lib.cli import format_columns
 from osc_lib import exceptions
 from osc_lib import utils
 from osc_lib.utils import tags as _tag
 
-from openstackclient.api import compute_v2
+from openstackclient import command
+from openstackclient.common import pagination
 from openstackclient.i18n import _
 from openstackclient.identity import common as identity_common
 from openstackclient.network import common
 
+LOG = logging.getLogger(__name__)
+
 
 class AdminStateColumn(cliff_columns.FormattableColumn[bool]):
-    def human_readable(self):
+    def human_readable(self) -> str:
         return 'UP' if self._value else 'DOWN'
 
 
 class RouterExternalColumn(cliff_columns.FormattableColumn[bool]):
-    def human_readable(self):
+    def human_readable(self) -> str:
         return 'External' if self._value else 'Internal'
 
 
@@ -47,7 +56,9 @@ _formatters = {
 }
 
 
-def _get_columns_network(item):
+def _get_columns_network(
+    item: _network.Network,
+) -> tuple[tuple[str, ...], tuple[str, ...]]:
     column_map = {
         'subnet_ids': 'subnets',
         'is_admin_state_up': 'admin_state_up',
@@ -67,11 +78,13 @@ def _get_columns_network(item):
     )
 
 
-def _get_columns_compute(item):
+def _get_columns_compute(item: Any) -> tuple[tuple[str, ...], tuple[str, ...]]:
     return utils.get_osc_show_columns_for_sdk_resource(item, {})
 
 
-def _get_attrs_network(client_manager, parsed_args):
+def _get_attrs_network(
+    client_manager: Any, parsed_args: argparse.Namespace
+) -> dict[str, Any]:
     attrs = {}
     if parsed_args.name is not None:
         attrs['name'] = parsed_args.name
@@ -137,13 +150,22 @@ def _get_attrs_network(client_manager, parsed_args):
         attrs['qos_policy_id'] = _qos_policy.id
     if 'no_qos_policy' in parsed_args and parsed_args.no_qos_policy:
         attrs['qos_policy_id'] = None
+
+    # Set pvlan
+    if parsed_args.pvlan:
+        attrs['pvlan'] = True
+    if parsed_args.no_pvlan:
+        attrs['pvlan'] = False
+
     # Update DNS network options
     if parsed_args.dns_domain is not None:
         attrs['dns_domain'] = parsed_args.dns_domain
     return attrs
 
 
-def _get_attrs_compute(client_manager, parsed_args):
+def _get_attrs_compute(
+    client_manager: Any, parsed_args: argparse.Namespace
+) -> dict[str, Any]:
     attrs = {}
     if parsed_args.name is not None:
         attrs['name'] = parsed_args.name
@@ -156,7 +178,7 @@ def _get_attrs_compute(client_manager, parsed_args):
     return attrs
 
 
-def _add_additional_network_options(parser):
+def _add_additional_network_options(parser: argparse.ArgumentParser) -> None:
     # Add additional network options
 
     parser.add_argument(
@@ -197,14 +219,11 @@ def _add_additional_network_options(parser):
     )
 
 
-# TODO(sindhu): Use the SDK resource mapped attribute names once the
-# OSC minimum requirements include SDK 1.0.
-class CreateNetwork(
-    common.NetworkAndComputeShowOne, common.NeutronCommandWithExtraArgs
-):
+class CreateNetwork(command.ShowOne, common.NeutronCommandWithExtraArgs):
     _description = _("Create new network")
 
-    def update_parser_common(self, parser):
+    def get_parser(self, prog_name: str) -> argparse.ArgumentParser:
+        parser = super().get_parser(prog_name)
         parser.add_argument(
             'name', metavar='<name>', help=_("New network name")
         )
@@ -220,35 +239,32 @@ class CreateNetwork(
             action='store_true',
             help=_("Do not share the network between projects"),
         )
-        return parser
-
-    def update_parser_network(self, parser):
         admin_group = parser.add_mutually_exclusive_group()
         admin_group.add_argument(
             '--enable',
             action='store_true',
             default=True,
-            help=self.enhance_help_neutron(_("Enable network (default)")),
+            help=_("Enable network (default)"),
         )
         admin_group.add_argument(
             '--disable',
             action='store_true',
-            help=self.enhance_help_neutron(_("Disable network")),
+            help=_("Disable network"),
         )
         parser.add_argument(
             '--project',
             metavar='<project>',
-            help=self.enhance_help_neutron(_("Owner's project (name or ID)")),
+            help=_("Owner's project (name or ID)"),
         )
         parser.add_argument(
             '--description',
             metavar='<description>',
-            help=self.enhance_help_neutron(_("Set network description")),
+            help=_("Set network description"),
         )
         parser.add_argument(
             '--mtu',
             metavar='<mtu>',
-            help=self.enhance_help_neutron(_("Set network mtu")),
+            help=_("Set network mtu"),
         )
         identity_common.add_project_domain_option_to_parser(parser)
         parser.add_argument(
@@ -256,133 +272,117 @@ class CreateNetwork(
             action='append',
             dest='availability_zone_hints',
             metavar='<availability-zone>',
-            help=self.enhance_help_neutron(
-                _(
-                    "Availability Zone in which to create this network "
-                    "(Network Availability Zone extension required, "
-                    "repeat option to set multiple availability zones)"
-                )
+            help=_(
+                "Availability Zone in which to create this network "
+                "(Network Availability Zone extension required, "
+                "repeat option to set multiple availability zones)"
             ),
         )
         port_security_group = parser.add_mutually_exclusive_group()
         port_security_group.add_argument(
             '--enable-port-security',
             action='store_true',
-            help=self.enhance_help_neutron(
-                _(
-                    "Enable port security by default for ports created on "
-                    "this network (default)"
-                )
+            help=_(
+                "Enable port security by default for ports created on "
+                "this network (default)"
             ),
         )
         port_security_group.add_argument(
             '--disable-port-security',
             action='store_true',
-            help=self.enhance_help_neutron(
-                _(
-                    "Disable port security by default for ports created on "
-                    "this network"
-                )
+            help=_(
+                "Disable port security by default for ports created on "
+                "this network"
             ),
         )
         external_router_grp = parser.add_mutually_exclusive_group()
         external_router_grp.add_argument(
             '--external',
             action='store_true',
-            help=self.enhance_help_neutron(
-                _(
-                    "The network has an external routing facility that is not "
-                    "managed by Neutron and can be used. For example: "
-                    "openstack router set --external-gateway NETWORK "
-                    "(external-net extension required)"
-                )
+            help=_(
+                "The network has an external routing facility that is not "
+                "managed by Neutron and can be used. For example: "
+                "openstack router set --external-gateway NETWORK "
+                "(external-net extension required)"
             ),
         )
         external_router_grp.add_argument(
             '--internal',
             action='store_true',
-            help=self.enhance_help_neutron(
-                _("Opposite of '--external' (default)")
-            ),
+            help=_("Opposite of '--external' (default)"),
         )
         default_router_grp = parser.add_mutually_exclusive_group()
         default_router_grp.add_argument(
             '--default',
             action='store_true',
-            help=self.enhance_help_neutron(
-                _(
-                    "Specify if this network should be used as the default "
-                    "external network"
-                )
+            help=_(
+                "Specify if this network should be used as the default "
+                "external network"
             ),
         )
         default_router_grp.add_argument(
             '--no-default',
             action='store_true',
-            help=self.enhance_help_neutron(
-                _(
-                    "Do not use the network as the default external network "
-                    "(default)"
-                )
+            help=_(
+                "Do not use the network as the default external network "
+                "(default)"
             ),
         )
         parser.add_argument(
             '--qos-policy',
             metavar='<qos-policy>',
-            help=self.enhance_help_neutron(
-                _("QoS policy to attach to this network (name or ID)")
-            ),
+            help=_("QoS policy to attach to this network (name or ID)"),
         )
         vlan_transparent_grp = parser.add_mutually_exclusive_group()
         vlan_transparent_grp.add_argument(
             '--transparent-vlan',
             action='store_true',
-            help=self.enhance_help_neutron(
-                _("Make the network VLAN transparent")
-            ),
+            help=_("Make the network VLAN transparent"),
         )
         vlan_transparent_grp.add_argument(
             '--no-transparent-vlan',
             action='store_true',
-            help=self.enhance_help_neutron(
-                _("Do not make the network VLAN transparent")
-            ),
+            help=_("Do not make the network VLAN transparent"),
         )
 
         vlan_qinq_grp = parser.add_mutually_exclusive_group()
         vlan_qinq_grp.add_argument(
             '--qinq-vlan',
             action='store_true',
-            help=self.enhance_help_neutron(
-                _("Enable VLAN QinQ (S-Tag ethtype 0x8a88) for the network")
-            ),
+            help=_("Enable VLAN QinQ (S-Tag ethtype 0x8a88) for the network"),
         )
         vlan_qinq_grp.add_argument(
             '--no-qinq-vlan',
             action='store_true',
-            help=self.enhance_help_neutron(
-                _("Disable VLAN QinQ (S-Tag ethtype 0x8a88) for the network")
-            ),
+            help=_("Disable VLAN QinQ (S-Tag ethtype 0x8a88) for the network"),
         )
 
-        _add_additional_network_options(parser)
-        _tag.add_tag_option_to_parser_for_create(
-            parser, _('network'), enhance_help=self.enhance_help_neutron
+        pvlan_grp = parser.add_mutually_exclusive_group()
+        pvlan_grp.add_argument(
+            '--pvlan',
+            action='store_true',
+            help=_(
+                "Enable Private VLAN for the network "
+                "(PVLAN extension required)"
+            ),
         )
-        return parser
-
-    def update_parser_compute(self, parser):
-        parser.add_argument(
-            '--subnet',
-            metavar='<subnet>',
-            required=True,
-            help=self.enhance_help_nova_network(
-                _("IPv4 subnet for fixed IPs (in CIDR notation)")
+        pvlan_grp.add_argument(
+            '--no-pvlan',
+            action='store_true',
+            help=_(
+                "Disable Private VLAN for the network "
+                "(PVLAN extension required)"
             ),
         )
+
+        _add_additional_network_options(parser)
+        _tag.add_tag_option_to_parser_for_create(parser, _('network'))
         return parser
 
-    def take_action_network(self, client, parsed_args):
+    def take_action(
+        self, parsed_args: argparse.Namespace
+    ) -> tuple[Sequence[str], Iterable[Any]]:
+        client = self.app.client_manager.network
         attrs = _get_attrs_network(self.app.client_manager, parsed_args)
         if parsed_args.transparent_vlan:
             attrs['vlan_transparent'] = True
@@ -394,6 +394,11 @@ class CreateNetwork(
         if parsed_args.no_qinq_vlan:
             attrs['vlan_qinq'] = False
 
+        if parsed_args.pvlan:
+            attrs['pvlan'] = True
+        if parsed_args.no_pvlan:
+            attrs['pvlan'] = False
+
         if attrs.get('vlan_transparent') and attrs.get('vlan_qinq'):
             msg = _(
                 "--transparent-vlan and --qinq-vlan can not be both enabled "
@@ -401,6 +406,14 @@ class CreateNetwork(
             )
             raise exceptions.CommandError(msg)
 
+        if (
+            attrs.get('port_security_enabled') is False
+            and attrs.get('pvlan') is True
+        ):
+            msg = _(
+                "--disable-port-security and --pvlan can not be used together."
+            )
+            raise exceptions.CommandError(msg)
         if (
             parsed_args.segmentation_id
             and not parsed_args.provider_network_type
@@ -425,81 +438,83 @@ class CreateNetwork(
         data = utils.get_item_properties(obj, columns, formatters=_formatters)
         return (display_columns, data)
 
-    def take_action_compute(self, client, parsed_args):
-        attrs = _get_attrs_compute(self.app.client_manager, parsed_args)
-        obj = compute_v2.create_network(client, **attrs)
-        display_columns, columns = _get_columns_compute(obj)
-        data = utils.get_dict_properties(obj, columns)
-        return (display_columns, data)
-
 
-class DeleteNetwork(common.NetworkAndComputeDelete):
+class DeleteNetwork(command.Command):
     _description = _("Delete network(s)")
 
-    # Used by base class to find resources in parsed_args.
-    resource = 'network'
-    r = None
-
-    def update_parser_common(self, parser):
+    def get_parser(self, prog_name: str) -> argparse.ArgumentParser:
+        parser = super().get_parser(prog_name)
         parser.add_argument(
             'network',
             metavar="<network>",
             nargs="+",
             help=_("Network(s) to delete (name or ID)"),
         )
-
         return parser
 
-    def take_action_network(self, client, parsed_args):
-        obj = client.find_network(self.r, ignore_missing=False)
-        client.delete_network(obj)
+    def take_action(self, parsed_args: argparse.Namespace) -> None:
+        client = self.app.client_manager.network
+        result = 0
+
+        for net in parsed_args.network:
+            try:
+                obj = client.find_network(net, ignore_missing=False)
+                client.delete_network(obj)
+            except Exception as e:
+                result += 1
+                LOG.error(
+                    _(
+                        "Failed to delete network with "
+                        "name or ID '%(network)s': %(e)s"
+                    ),
+                    {'network': net, 'e': e},
+                )
 
-    def take_action_compute(self, client, parsed_args):
-        network = compute_v2.find_network(client, self.r)
-        compute_v2.delete_network(client, network['id'])
+        if result > 0:
+            total = len(parsed_args.network)
+            msg = _("%(result)s of %(total)s networks failed to delete.") % {
+                'result': result,
+                'total': total,
+            }
+            raise exceptions.CommandError(msg)
 
 
-# TODO(sindhu): Use the SDK resource mapped attribute names once the
-# OSC minimum requirements include SDK 1.0.
-class ListNetwork(common.NetworkAndComputeLister):
+class ListNetwork(command.Lister):
     _description = _("List networks")
 
-    def update_parser_network(self, parser):
+    def get_parser(self, prog_name: str) -> argparse.ArgumentParser:
+        parser = super().get_parser(prog_name)
         router_ext_group = parser.add_mutually_exclusive_group()
         router_ext_group.add_argument(
             '--external',
             action='store_true',
-            help=self.enhance_help_neutron(_("List only external networks")),
+            help=_("List only external networks"),
         )
         router_ext_group.add_argument(
             '--internal',
             action='store_true',
-            help=self.enhance_help_neutron(_("List only internal networks")),
+            help=_("List only internal networks"),
         )
         parser.add_argument(
             '--long',
             action='store_true',
-            help=self.enhance_help_neutron(
-                _("List additional fields in output")
-            ),
+            help=_("List additional fields in output"),
         )
         parser.add_argument(
             '--name',
             metavar='<name>',
-            help=self.enhance_help_neutron(
-                _("List only networks with the specified name")
-            ),
+            help=_("List only networks with the specified name"),
         )
         admin_state_group = parser.add_mutually_exclusive_group()
         admin_state_group.add_argument(
             '--enable',
             action='store_true',
-            help=self.enhance_help_neutron(_("List only enabled networks")),
+            help=_("List only enabled networks"),
         )
         admin_state_group.add_argument(
             '--disable',
             action='store_true',
-            help=self.enhance_help_neutron(_("List only disabled networks")),
+            help=_("List only disabled networks"),
         )
         parser.add_argument(
             '--project',
@@ -508,85 +523,70 @@ class ListNetwork(common.NetworkAndComputeLister):
                 "List only networks with the specified project (name or ID)"
             ),
         )
-        identity_common.add_project_domain_option_to_parser(
-            parser, enhance_help=self.enhance_help_neutron
-        )
+        identity_common.add_project_domain_option_to_parser(parser)
         shared_group = parser.add_mutually_exclusive_group()
         shared_group.add_argument(
             '--share',
             action='store_true',
-            help=self.enhance_help_neutron(
-                _("List only networks shared between projects")
-            ),
+            help=_("List only networks shared between projects"),
         )
         shared_group.add_argument(
             '--no-share',
             action='store_true',
-            help=self.enhance_help_neutron(
-                _("List only networks not shared between projects")
-            ),
+            help=_("List only networks not shared between projects"),
         )
         parser.add_argument(
             '--status',
             metavar='<status>',
             choices=['ACTIVE', 'BUILD', 'DOWN', 'ERROR'],
-            help=self.enhance_help_neutron(
-                _(
-                    "List only networks with the specified status "
-                    "('ACTIVE', 'BUILD', 'DOWN', 'ERROR')"
-                )
+            help=_(
+                "List only networks with the specified status "
+                "('ACTIVE', 'BUILD', 'DOWN', 'ERROR')"
             ),
         )
         parser.add_argument(
             '--provider-network-type',
             metavar='<provider-network-type>',
             choices=['flat', 'geneve', 'gre', 'local', 'vlan', 'vxlan'],
-            help=self.enhance_help_neutron(
-                _(
-                    "List only networks with the specified physical "
-                    "mechanisms. "
-                    "The supported options are: flat, geneve, gre, local, "
-                    "vlan and vxlan."
-                )
+            help=_(
+                "List only networks with the specified physical "
+                "mechanisms. "
+                "The supported options are: flat, geneve, gre, local, "
+                "vlan and vxlan."
             ),
         )
         parser.add_argument(
             '--provider-physical-network',
             metavar='<provider-physical-network>',
             dest='physical_network',
-            help=self.enhance_help_neutron(
-                _(
-                    "List only networks with the specified physical network "
-                    "name"
-                )
+            help=_(
+                "List only networks with the specified physical network name"
             ),
         )
         parser.add_argument(
             '--provider-segment',
             metavar='<provider-segment>',
             dest='segmentation_id',
-            help=self.enhance_help_neutron(
-                _(
-                    "List only networks with the specified provider segment "
-                    "ID (VLAN ID for VLAN networks or "
-                    "Tunnel ID for GENEVE/GRE/VXLAN networks)"
-                )
+            help=_(
+                "List only networks with the specified provider segment "
+                "ID (VLAN ID for VLAN networks or "
+                "Tunnel ID for GENEVE/GRE/VXLAN networks)"
             ),
         )
         parser.add_argument(
             '--agent',
             metavar='<agent-id>',
             dest='agent_id',
-            help=self.enhance_help_neutron(
-                _('List only networks hosted the specified agent (ID only)')
-            ),
-        )
-        _tag.add_tag_filtering_option_to_parser(
-            parser, _('networks'), enhance_help=self.enhance_help_neutron
+            help=_('List only networks hosted the specified agent (ID only)'),
         )
+        _tag.add_tag_filtering_option_to_parser(parser, _('networks'))
+        pagination.add_marker_pagination_option_to_parser(parser)
         return parser
 
-    def take_action_network(self, client, parsed_args):
+    def take_action(
+        self, parsed_args: argparse.Namespace
+    ) -> tuple[Sequence[str], Iterable[Any]]:
+        client = self.app.client_manager.network
         identity_client = self.app.client_manager.identity
         if parsed_args.long:
             columns: tuple[str, ...] = (
@@ -615,7 +615,15 @@ class ListNetwork(common.NetworkAndComputeLister):
                 'Availability Zones',
                 'Tags',
             )
-        elif parsed_args.agent_id:
+        else:
+            columns = ('id', 'name', 'subnet_ids')
+            column_headers = (
+                'ID',
+                'Name',
+                'Subnets',
+            )
+
+        if parsed_args.agent_id:
             columns = ('id', 'name', 'subnet_ids')
             column_headers = (
                 'ID',
@@ -624,7 +632,6 @@ class ListNetwork(common.NetworkAndComputeLister):
             )
             client = self.app.client_manager.network
             dhcp_agent = client.get_agent(parsed_args.agent_id)
-            data = client.dhcp_agent_hosting_networks(dhcp_agent)
 
             return (
                 column_headers,
@@ -634,16 +641,9 @@ class ListNetwork(common.NetworkAndComputeLister):
                         columns,
                         formatters=_formatters,
                     )
-                    for s in data
+                    for s in client.dhcp_agent_hosting_networks(dhcp_agent)
                 ),
             )
-        else:
-            columns = ('id', 'name', 'subnet_ids')
-            column_headers = (
-                'ID',
-                'Name',
-                'Subnets',
-            )
 
         args = {}
 
@@ -692,9 +692,14 @@ class ListNetwork(common.NetworkAndComputeLister):
             args['provider:segmentation_id'] = parsed_args.segmentation_id
             args['provider_segmentation_id'] = parsed_args.segmentation_id
 
-        _tag.get_tag_filtering_args(parsed_args, args)
+        if parsed_args.marker is not None:
+            args['marker'] = parsed_args.marker
+        if parsed_args.limit is not None:
+            args['limit'] = parsed_args.limit
+        if parsed_args.max_items is not None:
+            args['max_items'] = parsed_args.max_items
 
-        data = client.networks(**args)
+        _tag.get_tag_filtering_args(parsed_args, args)
 
         return (
             column_headers,
@@ -704,43 +709,15 @@ class ListNetwork(common.NetworkAndComputeLister):
                     columns,
                     formatters=_formatters,
                 )
-                for s in data
-            ),
-        )
-
-    def take_action_compute(self, client, parsed_args):
-        columns = (
-            'id',
-            'label',
-            'cidr',
-        )
-        column_headers = (
-            'ID',
-            'Name',
-            'Subnet',
-        )
-
-        data = compute_v2.list_networks(client)
-
-        return (
-            column_headers,
-            (
-                utils.get_dict_properties(
-                    s,
-                    columns,
-                    formatters=_formatters,
-                )
-                for s in data
+                for s in client.networks(**args)
             ),
         )
 
 
-# TODO(sindhu): Use the SDK resource mapped attribute names once the
-# OSC minimum requirements include SDK 1.0.
 class SetNetwork(common.NeutronCommandWithExtraArgs):
     _description = _("Set network properties")
 
-    def get_parser(self, prog_name):
+    def get_parser(self, prog_name: str) -> argparse.ArgumentParser:
         parser = super().get_parser(prog_name)
         parser.add_argument(
             'network',
@@ -835,11 +812,28 @@ class SetNetwork(common.NeutronCommandWithExtraArgs):
             action='store_true',
             help=_("Remove the QoS policy attached to this network"),
         )
+        pvlan_grp = parser.add_mutually_exclusive_group()
+        pvlan_grp.add_argument(
+            '--pvlan',
+            action='store_true',
+            help=_(
+                "Enable Private VLAN for the network. PVLAN extension "
+                "required."
+            ),
+        )
+        pvlan_grp.add_argument(
+            '--no-pvlan',
+            action='store_true',
+            help=_(
+                "Disable Private VLAN for the network (Default). "
+                "PVLAN extension required."
+            ),
+        )
         _tag.add_tag_option_to_parser_for_set(parser, _('network'))
         _add_additional_network_options(parser)
         return parser
 
-    def take_action(self, parsed_args):
+    def take_action(self, parsed_args: argparse.Namespace) -> None:
         client = self.app.client_manager.network
         obj = client.find_network(parsed_args.network, ignore_missing=False)
 
@@ -847,6 +841,14 @@ class SetNetwork(common.NeutronCommandWithExtraArgs):
         attrs.update(
             self._parse_extra_properties(parsed_args.extra_properties)
         )
+        if (
+            attrs.get('port_security_enabled') is False
+            and attrs.get('pvlan') is True
+        ):
+            msg = _(
+                "--disable-port-security and --pvlan can not be used together."
+            )
+            raise exceptions.CommandError(msg)
         if attrs:
             with common.check_missing_extension_if_error(
                 self.app.client_manager.network, attrs
@@ -857,10 +859,11 @@ class SetNetwork(common.NeutronCommandWithExtraArgs):
         _tag.update_tags_for_set(client, obj, parsed_args)
 
 
-class ShowNetwork(common.NetworkAndComputeShowOne):
+class ShowNetwork(command.ShowOne):
     _description = _("Show network details")
 
-    def update_parser_common(self, parser):
+    def get_parser(self, prog_name: str) -> argparse.ArgumentParser:
+        parser = super().get_parser(prog_name)
         parser.add_argument(
             'network',
             metavar="<network>",
@@ -868,23 +871,20 @@ class ShowNetwork(common.NetworkAndComputeShowOne):
         )
         return parser
 
-    def take_action_network(self, client, parsed_args):
+    def take_action(
+        self, parsed_args: argparse.Namespace
+    ) -> tuple[Sequence[str], Iterable[Any]]:
+        client = self.app.client_manager.network
         obj = client.find_network(parsed_args.network, ignore_missing=False)
         display_columns, columns = _get_columns_network(obj)
         data = utils.get_item_properties(obj, columns, formatters=_formatters)
         return (display_columns, data)
 
-    def take_action_compute(self, client, parsed_args):
-        obj = compute_v2.find_network(client, parsed_args.network)
-        display_columns, columns = _get_columns_compute(obj)
-        data = utils.get_dict_properties(obj, columns)
-        return (display_columns, data)
-
 
 class UnsetNetwork(common.NeutronUnsetCommandWithExtraArgs):
     _description = _("Unset network properties")
 
-    def get_parser(self, prog_name):
+    def get_parser(self, prog_name: str) -> argparse.ArgumentParser:
         parser = super().get_parser(prog_name)
         parser.add_argument(
             'network',
@@ -894,7 +894,7 @@ class UnsetNetwork(common.NeutronUnsetCommandWithExtraArgs):
         _tag.add_tag_option_to_parser_for_unset(parser, _('network'))
         return parser
 
-    def take_action(self, parsed_args):
+    def take_action(self, parsed_args: argparse.Namespace) -> None:
         client = self.app.client_manager.network
         obj = client.find_network(parsed_args.network, ignore_missing=False)