#! /usr/bin/python -tt
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU Library General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
# Copyright 2005 Duke University

import types
import sys
from yum.constants import *
from yum.Errors import CompsException
#FIXME - compsexception isn't caught ANYWHERE so it's pointless to raise it
# switch all compsexceptions to grouperrors after api break
import fnmatch
import re
from yum.i18n import to_unicode
from yum.misc import get_my_lang_code
from yum.misc import cElementTree_iterparse as iterparse 

lang_attr = '{http://www.w3.org/XML/1998/namespace}lang'

def parse_boolean(strng):
    return BOOLEAN_STATES.get(strng.lower(), False)

def parse_number(strng):
    return int(strng)

class CompsObj(object):
    """ Group/Category helper object. """

    # Could be the same as ui_name?
    def __str__(self):
        """ Return the "name" of the object for the C locale. """
        return self.name

    @property
    def compsid(self):
        """ Return the "id": categoryid, groupid, environmentid. """

        for idT in ('categoryid', 'groupid', 'environmentid'):
            if hasattr(self, idT):
                return getattr(self, idT)

        return None

    @property
    def ui_name(self):
        """ Return the "name" of the object for the current locale. """
        return self.nameByLang(get_my_lang_code())
    
    @property
    def ui_description(self):
        """ Return the "description" of the object for the current locale. """
        return self.descriptionByLang(get_my_lang_code())

    def __cmp__(self, other):
        if other is None:
            return 1

        if self.display_order > other.display_order:
            return 1
        if self.display_order < other.display_order:
            return -1

        return cmp(self.ui_name, other.ui_name)

    def _expand_languages(self, lang):
        import gettext
        languages = [lang]

        if 'C' not in languages:
            languages.append('C')
         
        # now normalize and expand the languages
        nelangs = []
        for lang in languages:
            for nelang in gettext._expand_lang(lang):
                if nelang not in nelangs:
                    nelangs.append(nelang)
        return nelangs
        
    def nameByLang(self, lang):

        for langcode in self._expand_languages(lang):
            if langcode in self.translated_name:
                return to_unicode(self.translated_name[langcode])

        return to_unicode(self.name)

    def descriptionByLang(self, lang):
        for langcode in self._expand_languages(lang):
            if langcode in self.translated_description:
                return to_unicode(self.translated_description[langcode])
        return to_unicode(self.description)


class Group(CompsObj):
    """ Group object parsed from group data in each repo. and merged. """

    def __init__(self, elem=None):
        self.user_visible = True
        self.default = False
        self.selected = False
        self.name = ""
        self.description = ""
        self.translated_name = {}
        self.translated_description = {}
        self.mandatory_packages = {}
        self.optional_packages = {}
        self.default_packages = {}
        self.conditional_packages = {}
        self.langonly = None
        self.groupid = None
        self.display_order = 1024
        self.installed = False
        self.toremove = False

        self._weak = False

        if elem:
            self.parse(elem)

    def _packageiter(self):
        # Gah, FIXME: real iterator/class
        lst = self.mandatory_packages.keys() + \
              self.optional_packages.keys() + \
              self.default_packages.keys() + \
              self.conditional_packages.keys()

        return lst

    packages = property(_packageiter)

    def parse(self, elem):
        for child in elem:

            if child.tag == 'id':
                myid = child.text
                if self.groupid is not None:
                    raise CompsException
                self.groupid = myid
            
            elif child.tag == 'name':
                text = child.text
                if text:
                    text = text.encode('utf8')
                
                lang = child.attrib.get(lang_attr)
                if lang:
                    self.translated_name[lang] = text
                else:
                    self.name = text
    
    
            elif child.tag == 'description':
                text = child.text
                if text:
                    text = text.encode('utf8')
                    
                lang = child.attrib.get(lang_attr)
                if lang:
                    self.translated_description[lang] = text
                else:
                    if text:
                        self.description = text
    
            elif child.tag == 'uservisible':
                self.user_visible = parse_boolean(child.text)
    
            elif child.tag == 'display_order':
                self.display_order = parse_number(child.text)

            elif child.tag == 'default':
                self.default = parse_boolean(child.text)
    
            elif child.tag in ['langonly', 'lang_only']: 
                text = child.text
                if self.langonly is not None:
                    raise CompsException
                self.langonly = text
    
            elif child.tag == 'packagelist':
                self.parse_package_list(child)
    
    def parse_package_list(self, packagelist_elem):
        for child in packagelist_elem:
            if child.tag == 'packagereq':
                genre = child.attrib.get('type')
                if not genre:
                    genre = u'mandatory'

                if genre not in ('mandatory', 'default', 'optional', 'conditional'):
                    # just ignore bad package lines
                    continue

                package = child.text
                if not package:
                    #  Ignore this too, or we end up doing:
                    # .searchNevra(name=None)
                    continue
                if genre == 'mandatory':
                    self.mandatory_packages[package] = 1
                elif genre == 'default':
                    self.default_packages[package] = 1
                elif genre == 'optional':
                    self.optional_packages[package] = 1
                elif genre == 'conditional':
                    self.conditional_packages[package] = child.attrib.get('requires')



    def add(self, obj):
        """Add another group object to this object"""
    
        # we only need package lists and any translation that we don't already
        # have
        
        for pkg in obj.mandatory_packages:
            self.mandatory_packages[pkg] = 1
        for pkg in obj.default_packages:
            self.default_packages[pkg] = 1
        for pkg in obj.optional_packages:
            self.optional_packages[pkg] = 1
        for pkg in obj.conditional_packages:
            self.conditional_packages[pkg] = obj.conditional_packages[pkg]
        
        # Handle cases where a comps.xml without name & decription tags
        # has been setup first, so the name & decription for this object is blank.
            
        
        if self.name == '' and obj.name != '':
            self.name = obj.name

        if self.description == '' and obj.description != '':
            self.description = obj.description
            
        # name and description translations
        for lang in obj.translated_name:
            if lang not in self.translated_name:
                self.translated_name[lang] = obj.translated_name[lang]
        
        for lang in obj.translated_description:
            if lang not in self.translated_description:
                self.translated_description[lang] = obj.translated_description[lang]
        
    def xml(self):
        """write out an xml stanza for the group object"""
        msg ="""        
  <group>
   <id>%s</id>
   <default>%s</default>
   <uservisible>%s</uservisible>
   <display_order>%s</display_order>\n""" % (self.groupid, str(self.default).lower(), 
                                  str(self.user_visible).lower(), self.display_order)
   
        if self.langonly:
            msg += """   <langonly>%s</langonly>""" % self.langonly
            
        msg +="""   <name>%s</name>\n""" % self.name
        for (lang, val) in sorted(self.translated_name.items()):
            msg += """   <name xml:lang="%s">%s</name>\n""" % (lang, val)
        
        msg += """   <description>%s</description>\n""" % self.description
        for (lang, val) in sorted(self.translated_description.items()):
            msg += """   <description xml:lang="%s">%s</description>\n""" % (lang, val)

        msg += """    <packagelist>\n"""
        for pkg in sorted(self.mandatory_packages):
            msg += """      <packagereq type="mandatory">%s</packagereq>\n""" % pkg
        for pkg in sorted(self.default_packages):
            msg += """      <packagereq type="default">%s</packagereq>\n""" % pkg
        for pkg in sorted(self.optional_packages):
            msg += """      <packagereq type="optional">%s</packagereq>\n""" % pkg
        for (pkg, req) in sorted(self.conditional_packages.items()):
            msg += """      <packagereq type="conditional" requires="%s">%s</packagereq>\n""" % (req, pkg)
        msg += """    </packagelist>\n"""
        msg += """  </group>"""

        return msg      

class Environment(CompsObj):
    """ Environment object parsed from group data in each repo, and merged """

    def __init__(self, elem=None):
        self.name = ""
        self.environmentid = None
        self.description = ""
        self.translated_name = {}
        self.translated_description = {}
        self.display_order = 1024
        self.langonly = None
        self.installed = False
        self._groups = {}
        self._options = {}
        self._defaultoptions = {}

        self._weak = False

        if elem:
            self.parse(elem)

    def _allgroupiter(self):
        lst = self._groups.keys() + \
              self._options.keys()
        return lst

    allgroups = property(_allgroupiter)

    def _groupiter(self):
        return self._groups.keys()

    groups = property(_groupiter)

    def _optioniter(self):
        return self._options.keys()

    options = property(_optioniter)

    def _defaultoptioniter(self):
        return self._defaultoptions.keys()

    defaultoptions = property(_defaultoptioniter)

    def parse(self, elem):
        for child in elem:
            if child.tag == 'id':
                myid = child.text
                if self.environmentid is not None:
                    raise CompsException
                self.environmentid = myid

            elif child.tag == 'name':
                text = child.text
                if text:
                    text = text.encode('utf8')

                lang = child.attrib.get(lang_attr)
                if lang:
                    self.translated_name[lang] = text
                else:
                    self.name = text

            elif child.tag == 'description':
                text = child.text
                if text:
                    text = text.encode('utf8')

                lang = child.attrib.get(lang_attr)
                if lang:
                    self.translated_description[lang] = text
                else:
                    self.description = text

            elif child.tag == 'grouplist':
                self.parse_group_list(child)

            elif child.tag == 'optionlist':
                self.parse_option_list(child)

            elif child.tag == 'display_order':
                self.display_order = parse_number(child.text)

    def parse_group_list(self, grouplist_elem):
        for child in grouplist_elem:
            if child.tag == 'groupid':
                groupid = child.text
                self._groups[groupid] = 1

    def parse_option_list(self, optionlist_elem):
        for child in optionlist_elem:
            if child.tag == 'groupid':
                optionid = child.text
                self._options[optionid] = 1
                defopt = child.attrib.get('default')
                if defopt:
                    default = parse_boolean(defopt)
                else:
                    default = False
                if default:
                    self._defaultoptions[optionid] = 1

    def add(self, obj):
        """Add another environment object to this object"""

        for grp in obj.groups:
            self._groups[grp] = 1

        for grp in obj.defaultoptions:
            self._defaultoptions[grp] = 1

        for grp in obj.options:
            self._options[grp] = 1

        # name and description translations
        for lang in obj.translated_name:
            if lang not in self.translated_name:
                self.translated_name[lang] = obj.translated_name[lang]

        for lang in obj.translated_description:
            if lang not in self.translated_description:
                self.translated_description[lang] = obj.translated_description[lang]

    def xml(self):
        """write out an xml stanza for the environment object"""
        msg ="""
  <environment>
   <id>%s</id>
   <display_order>%s</display_order>\n""" % (self.environmentid, self.display_order)

        msg +="""   <name>%s</name>\n""" % self.name
        for (lang, val) in self.translated_name.items():
            msg += """   <name xml:lang="%s">%s</name>\n""" % (lang, val)

        msg += """   <description>%s</description>\n""" % self.description
        for (lang, val) in self.translated_description.items():
            msg += """    <description xml:lang="%s">%s</description>\n""" % (lang, val)

        msg += """    <grouplist>\n"""
        for grp in self.groups:
            msg += """     <groupid>%s</groupid>\n""" % grp
        msg += """    </grouplist>\n"""
        msg += """    <optionlist>\n"""
        for grp in self.options:
            if grp in self.defaultoptions:
                msg += """     <groupid default="true">%s</groupid>\n""" % grp
            else:
                msg += """     <groupid>%s</groupid>\n""" % grp
        msg += """    </optionlist>\n"""
        msg += """  </environment>\n"""

        return msg

class Category(CompsObj):
    """ Category object parsed from group data in each repo. and merged. """

    def __init__(self, elem=None):
        self.name = ""
        self.categoryid = None
        self.description = ""
        self.translated_name = {}
        self.translated_description = {}
        self.display_order = 1024
        self._groups = {}        

        if elem:
            self.parse(elem)
            
    def _groupiter(self):
        return self._groups.keys()
    
    groups = property(_groupiter)
    
    def parse(self, elem):
        for child in elem:
            if child.tag == 'id':
                myid = child.text
                if self.categoryid is not None:
                    raise CompsException
                self.categoryid = myid

            elif child.tag == 'name':
                text = child.text
                if text:
                    text = text.encode('utf8')
                    
                lang = child.attrib.get(lang_attr)
                if lang:
                    self.translated_name[lang] = text
                else:
                    self.name = text
    
            elif child.tag == 'description':
                text = child.text
                if text:
                    text = text.encode('utf8')
                    
                lang = child.attrib.get(lang_attr)
                if lang:
                    self.translated_description[lang] = text
                else:
                    self.description = text
            
            elif child.tag == 'grouplist':
                self.parse_group_list(child)

            elif child.tag == 'display_order':
                self.display_order = parse_number(child.text)

    def parse_group_list(self, grouplist_elem):
        for child in grouplist_elem:
            if child.tag == 'groupid':
                groupid = child.text
                self._groups[groupid] = 1

    def add(self, obj):
        """Add another category object to this object"""
    
        for grp in obj.groups:
            self._groups[grp] = 1
        
        # name and description translations
        for lang in obj.translated_name:
            if lang not in self.translated_name:
                self.translated_name[lang] = obj.translated_name[lang]
        
        for lang in obj.translated_description:
            if lang not in self.translated_description:
                self.translated_description[lang] = obj.translated_description[lang]

    def xml(self):
        """write out an xml stanza for the category object"""
        msg ="""        
  <category>
   <id>%s</id>
   <display_order>%s</display_order>\n""" % (self.categoryid, self.display_order)
   
        msg +="""   <name>%s</name>\n""" % self.name
        for (lang, val) in self.translated_name.items():
            msg += """   <name xml:lang="%s">%s</name>\n""" % (lang, val)
        
        msg += """   <description>%s</description>\n""" % self.description
        for (lang, val) in self.translated_description.items():
            msg += """    <description xml:lang="%s">%s</description>\n""" % (lang, val)

        msg += """    <grouplist>\n"""
        for grp in self.groups:
            msg += """     <groupid>%s</groupid>\n""" % grp
        msg += """    </grouplist>\n"""
        msg += """  </category>\n"""

        return msg                

class Langpacks(CompsObj):
    def __init__(self, elem=None):
        self.langpacks = []
        self.name = "" # prevent CompsObj.__str__() throwing an AttributeError
        if elem is not None:
            self.parse(elem)

    def __getitem__(self, indx):
        return self.langpacks[indx]

    def __iter__(self):
        for i in self.langpacks:
            yield i

    def __len__(self):
        return len(self.langpacks)

    def add(self, name, install):
        langpack = {
            "name": name,
            "install": install,
        }
        self.langpacks.append(langpack)

    def parse(self, elem):
        for child in elem:
            if child.tag == "match":
                langpack = {
                    "name": child.attrib.get("name"),
                    "install": child.attrib.get("install"),
                }
                self.langpacks.append(langpack)
            else:
                raise CompsException("Unexpected element in <langpacks>: %s" % child.tag)

        self.name = elem.attrib.get("name")
        self.install = elem.attrib.get("install")

    def xml(self):
        """write out an xml stanza for the Langpacks object"""
        if not self.langpacks:
            return ''
        msg  = '  <langpacks>\n'
        for i in self:
            msg += '    <match name="%s" install="%s"/>\n' % (i["name"], i["install"])
        msg += '  </langpacks>\n'
        return msg

class Comps(object):
    def __init__(self, overwrite_groups=False):
        self._groups = {}
        self._environments = {}
        self._categories = {}
        self._langpacks = Langpacks()
        self.compscount = 0
        self.overwrite_groups = overwrite_groups
        self.compiled = False # have groups been compiled into avail/installed 
                              # lists, yet.


    def get_groups(self):
        grps = self._groups.values()
        grps.sort(key=lambda x: (x.display_order, x.name))
        return grps

    def get_environments(self):
        environments = self._environments.values()
        environments.sort(key=lambda x: (x.display_order, x.name))
        return environments

    def get_categories(self):
        cats = self._categories.values()
        cats.sort(key=lambda x: (x.display_order, x.name))
        return cats

    def get_langpacks(self):
        return self._langpacks
    
    groups = property(get_groups)
    environments = property(get_environments)
    categories = property(get_categories)
    langpacks = property(get_langpacks)
    
    def has_group(self, grpid):
        exists = self.return_groups(grpid)
            
        if exists:
            return True
            
        return False
    
    def return_group(self, grpid):
        """Return the first group which matches"""
        grps = self.return_groups(grpid)
        if grps:
            return grps[0]

        return None

    def return_groups(self, group_pattern, case_sensitive=False):
        """return all groups which match either by glob or exact match"""
        returns = {}

        if not group_pattern:
            return []

        for item in group_pattern.split(','):
            item = item.strip()
            if item in self._groups:
                thisgroup = self._groups[item]
                returns[thisgroup.groupid] = thisgroup
                continue
            
            if case_sensitive:
                match = re.compile(fnmatch.translate(item)).match
            else:
                match = re.compile(fnmatch.translate(item), flags=re.I).match

            done = False
            for group in self.groups:
                for name in group.name, group.groupid, group.ui_name:
                    if match(name):
                        done = True
                        returns[group.groupid] = group
                        break
            if done:
                continue

            # If we didn't match to anything in the current locale, try others
            for group in self.groups:
                for name in group.translated_name.values():
                    if match(name):
                        returns[group.groupid] = group
                        break

        return returns.values()

    def has_environment(self, environmentid):
        exists = self.return_environments(environmentid)

        if exists:
            return True

        return False

    def return_environment(self, environmentid):
        """Return the first group which matches"""
        environments = self.return_environments(environmentid)
        if environments:
            return environments[0]

        return None

    def return_environments(self, env_pattern, case_sensitive=False):
        """return all environments which match either by glob or exact match"""
        returns = {}

        if not env_pattern:
            return []

        for item in env_pattern.split(','):
            item = item.strip()
            if item in self._environments:
                env = self._environments[item]
                returns[env.environmentid] = env
                continue

            if case_sensitive:
                match = re.compile(fnmatch.translate(item)).match
            else:
                match = re.compile(fnmatch.translate(item), flags=re.I).match

            done = False
            for env in self.environments:
                for name in env.name, env.environmentid, env.ui_name:
                    if match(name):
                        done = True
                        returns[env.environmentid] = env
                        break
            if done:
                continue

            # If we didn't match to anything in the current locale, try others
            for env in self.environments:
                for name in env.translated_name.values():
                    if match(name):
                        returns[env.environmentid] = env
                        break

        return returns.values()

    #  This is close to returnPackages() etc. API ... need to std. these names
    # the above return_groups uses different, but equal, API.
    def return_categories(self, pattern, ignore_case=True):
        """return all categories which match either by glob or exact match"""
        returns = {}

        for item in pattern.split(','):
            item = item.strip()
            if item in self._categories:
                cat = self._categories[item]
                returns[cat.categoryid] = cat
                continue

            if not ignore_case:
                match = re.compile(fnmatch.translate(item)).match
            else:
                match = re.compile(fnmatch.translate(item), flags=re.I).match

            done = False
            for cat in self.categories:
                for name in cat.name, cat.categoryid, cat.ui_name:
                    if match(name):
                        done = True
                        returns[cat.categoryid] = cat
                        break
            if done:
                continue

            for cat in self.categories:
                for name in cat.translated_name.values():
                    if match(name):
                        returns[cat.categoryid] = cat
                        break

        return returns.values()

    def add_group(self, group):
        if group.groupid in self._groups:
            thatgroup = self._groups[group.groupid]
            if thatgroup._weak:
                # If what we had was weak, use this one and merge the weak one.
                tmp = group
                group = thatgroup
                thatgroup = self._groups[group.groupid] = tmp
            thatgroup.add(group)
        else:
            self._groups[group.groupid] = group

    def add_environment(self, environment):
        if environment.environmentid in self._environments:
            env = self._environments[environment.environmentid]
            if env._weak:
                # If what we had was weak, use this one and merge the weak one.
                tmp = environment
                environment = env
                env = self._environments[environment.environmentid] = tmp
            env.add(environment)
        else:
            self._environments[environment.environmentid] = environment

    def add_category(self, category):
        if category.categoryid in self._categories:
            thatcat = self._categories[category.categoryid]
            thatcat.add(category)
        else:
            self._categories[category.categoryid] = category

    def add_langpack(self, name, install):
        self._langpacks.add(name, install)

    def add(self, srcfile = None):
        if not srcfile:
            raise CompsException
            
        if type(srcfile) in types.StringTypes:
            # srcfile is a filename string
            try:
                infile = open(srcfile, 'rt')
            except IOError, e:
                raise CompsException, 'open(%s): #%u %s' % (srcfile, e.errno, e.strerror)
        else:
            # srcfile is a file object
            infile = srcfile
        
        self.compscount += 1
        self.compiled = False
        
        parser = iterparse(infile)
        try:
            for event, elem in parser:
                if elem.tag == "group":
                    group = Group(elem)
                    self.add_group(group)
                if elem.tag == "environment":
                    environment = Environment(elem)
                    self.add_environment(environment)
                if elem.tag == "category":
                    category = Category(elem)
                    self.add_category(category)
                if elem.tag == "langpacks":
                    self._langpacks.parse(elem)
        except SyntaxError, e:
            raise CompsException, "comps file is empty/damaged"
            
        del parser
        
    def compile(self, pkgtuplist):
        """ compile the groups into installed/available groups """
        
        # convert the tuple list to a simple dict of pkgnames
        inst_pkg_names = {}
        for (n,a,e,v,r) in pkgtuplist:
            inst_pkg_names[n] = 1
        

        for group in self.groups:
            # if there are mandatory packages in the group, then make sure
            # they're all installed.  if any are missing, then the group
            # isn't installed.
            if len(group.mandatory_packages) > 0:
                group.installed = True
                for pkgname in group.mandatory_packages:
                    if pkgname not in inst_pkg_names:
                        group.installed = False
                        break
            # if it doesn't have any of those then see if it has ANY of the
            # optional/default packages installed.
            # If so - then the group is installed
            else:
                check_pkgs = group.optional_packages.keys() + group.default_packages.keys() + group.conditional_packages.keys()
                group.installed = False
                for pkgname in check_pkgs:
                    if pkgname in inst_pkg_names:
                        group.installed = True
                        break

        # Now do basically the same thing for evgroups.
        inst_grp_names = {}
        for group in self.groups:
            inst_grp_names[group.groupid] = group.installed
        for evgroup in self.environments:
            if evgroup.groups:
                evgroup.installed = True
                for grpname in evgroup.groups:
                    if not inst_grp_names.get(grpname):
                        evgroup.installed = False
                        break
            else:
                evgroup.installed = False
                for grpname in evgroup.options:
                    if grpname in inst_grp_names:
                        evgroup.installed = True
                        break
        
        self.compiled = True
    
    def xml(self):
        """returns the xml of the comps files in this class, merged"""

        if not self._groups and not self._categories and \
            not self._environments and not len(self._langpacks):
            return ""
            
        msg = """<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE comps PUBLIC "-//Red Hat, Inc.//DTD Comps info//EN" "comps.dtd">
<comps>
""" 
 
        for g in self.get_groups():
            msg += g.xml()
        for c in self.get_categories():
            msg += c.xml()
        for e in self.get_environments():
            msg += e.xml()
        msg += self.get_langpacks().xml()
        msg += """\n</comps>\n"""
        
        return msg
            
        
        
def main():

    try:
        print sys.argv[1]
        p = Comps()
        for srcfile in sys.argv[1:]:
            p.add(srcfile)

        print
        print "===== GROUPS ====="
        for group in p.groups:
            print "%s (id: %s)" % (group, group.groupid)
            for pkg in group.packages:
                print '  ' + pkg

        print
        print "===== ENVIRONMENTS ====="
        for environment in p.environments:
            print "%s (id: %s)" % (environment.name, environment.environmentid)
            for group in environment.groups:
                print '  ' + group
            for group in environment.options:
                print '  *' + group

        print
        print "===== CATEGORIES ====="
        for category in p.categories:
            print "%s (id: %s)" % (category.name, category.categoryid)
            for group in category.groups:
                print '  ' + group

        print
        print "===== LANGPACKS ====="
        for langpack in p.langpacks:
            print '  %s (%s)' % (langpack["name"], langpack["install"])

    except IOError:
        print >> sys.stderr, "newcomps.py: No such file:\'%s\'" % sys.argv[1]
        sys.exit(1)
        
if __name__ == '__main__':
    main()