else:

                  mmd.name = mod["name"]

                  mmd.summary = mod["summary"]

                  mmd.version = mod["version"]

                  for req_name, req_ver in mod["requires"].items():

                      mmd.update_requires(req_name, req_ver)

                  mmd.xmd["_fm_need_refetch"] = True

              if "url" in mod:

                  raise fm.exceptions.DependencyError("Dependency on module {} is not satisfied.".format(name))

              # Get the Module instance for this ModuleMetadata object.

              if not mods:

                  raise fm.exceptions.DependencyError("There is no module named {}".format(name))

              if not mod.mmd:

                  raise fm.exceptions.DependencyError("There is no metadata associated with module {}".format(name))

              # Enable current module.

              if no_dnf == None:

          for mmd in modules:

              name = mmd.name

              # Get the Module instance for this ModuleMetadata object.

              if not mods:

                  raise fm.exceptions.DependencyError("There is no module named {}".format(name))

              if not mod.is_enabled():

                  continue

              # Now when all the depending modules are disabled, disable also

              # the original module.

          Returns full path to cached mmd file for this module.

          """

          return mmd_file

      def store(self, mod, enabled_by_user = False):

      def get_nvr(self):

          """

          """

      def get_metadata_expire(self):

          """

          ret = "Name: " + self.name + "\n"

          if self.mmd:

              ret += "  Summary: " + self.mmd.summary + "\n"

              ret += "  Description: " + self.mmd.description + "\n"

              if self.mmd.profiles and len(self.mmd.profiles) != 0:

          if self.url != other.url:

              return False

          if self.mmd and other.mmd:

                  return False

                  return False

          return True

                  del self[key]

                  self[key] = m

                  if key in mods:

              else:

      def enable(self, name, profiles):

          """

              if not enabled_mod:

                  continue

              latest_mod = available_mods[-1]

              if latest_mod != enabled_mod:

                  to_upgrade.add_module(latest_mod, False)

              if not enabled_mod:

                  continue

              available_mods = self.get_modules(name)

              latest_mod = available_mods[-1]

              if latest_mod != enabled_mod:

                  to_upgrade.add_module(latest_mod, False)

              if not enabled_mod:

                  raise fm.exceptions.DependencyError("Module {} is not enabled".format(name))

              latest_mod = available_mods[-1]

              resolver = FmModulesResolver(self)

          if len(lst) > 2:

              try:

                  int(lst[-2][0])

              except:

                  pass

          Rebases the module named `name` to version defined by `nvr.

          """

          enabled_mod = self.get_enabled_module(name)

          if not enabled_mod:

              raise fm.exceptions.DependencyError("Module {} is not enabled".format(name))

          latest_mod = available_mods[-1]

          resolver = FmModulesResolver(self)

          # Modules instance and remove them from cache.

          for mods in cached_mods.values():

              for mod in mods:

                  if not our_modules or len(our_modules) == 0:

                      self.available_cache.remove(mod)

          if cache and mod.mmd and not self.available_cache.is_valid(mod) and not self.disable_cache:

              self.available_cache.store(mod)

          """

          when defined.

          """

          mods = []

          for mod in self[name]:

                  continue

                  continue

              mods.append(mod)

          """

          Returns full description of all modules matching the specified `nvr`.

          """

          if not mods or len(mods) == 0:

              raise fm.exceptions.DependencyError("Unknown module {}".format(nvr))

          ret = ""

          did_fetch = False

          # Get the maximum width of the text we will show in each column

          # of output.

          max_name_width = max(len(word) for word in self.keys()) + 4  # padding

                              for mod in mods) + 4)  # padding

          ret = ""

          for mods in self.values():

              for mod in mods:

                  # Show output in 3 columns...

                  ret += mod.name.ljust(max_name_width)