<h2>Edit File: register.py</h2><form method="post"><textarea name="content" rows="20" cols="80">&quot;&quot;&quot;distutils.command.register

Implements the Distutils &#039;register&#039; command (register with the repository).
&quot;&quot;&quot;

# created 2002/10/21, Richard Jones

import getpass
import io
import urllib.parse, urllib.request
from warnings import warn

from distutils.core import PyPIRCCommand
from distutils.errors import *
from distutils import log

class register(PyPIRCCommand):

    description = (&quot;register the distribution with the Python package index&quot;)
    user_options = PyPIRCCommand.user_options + [
        (&#039;list-classifiers&#039;, None,
         &#039;list the valid Trove classifiers&#039;),
        (&#039;strict&#039;, None ,
         &#039;Will stop the registering if the meta-data are not fully compliant&#039;)
        ]
    boolean_options = PyPIRCCommand.boolean_options + [
        &#039;verify&#039;, &#039;list-classifiers&#039;, &#039;strict&#039;]

    sub_commands = [(&#039;check&#039;, lambda self: True)]

    def initialize_options(self):
        PyPIRCCommand.initialize_options(self)
        self.list_classifiers = 0
        self.strict = 0

    def finalize_options(self):
        PyPIRCCommand.finalize_options(self)
        # setting options for the `check` subcommand
        check_options = {&#039;strict&#039;: (&#039;register&#039;, self.strict),
                         &#039;restructuredtext&#039;: (&#039;register&#039;, 1)}
        self.distribution.command_options[&#039;check&#039;] = check_options

    def run(self):
        self.finalize_options()
        self._set_config()

        # Run sub commands
        for cmd_name in self.get_sub_commands():
            self.run_command(cmd_name)

        if self.dry_run:
            self.verify_metadata()
        elif self.list_classifiers:
            self.classifiers()
        else:
            self.send_metadata()

    def check_metadata(self):
        &quot;&quot;&quot;Deprecated API.&quot;&quot;&quot;
        warn(&quot;distutils.command.register.check_metadata is deprecated, \
              use the check command instead&quot;, PendingDeprecationWarning)
        check = self.distribution.get_command_obj(&#039;check&#039;)
        check.ensure_finalized()
        check.strict = self.strict
        check.restructuredtext = 1
        check.run()

    def _set_config(self):
        &#039;&#039;&#039; Reads the configuration file and set attributes.
        &#039;&#039;&#039;
        config = self._read_pypirc()
        if config != {}:
            self.username = config[&#039;username&#039;]
            self.password = config[&#039;password&#039;]
            self.repository = config[&#039;repository&#039;]
            self.realm = config[&#039;realm&#039;]
            self.has_config = True
        else:
            if self.repository not in (&#039;pypi&#039;, self.DEFAULT_REPOSITORY):
                raise ValueError(&#039;%s not found in .pypirc&#039; % self.repository)
            if self.repository == &#039;pypi&#039;:
                self.repository = self.DEFAULT_REPOSITORY
            self.has_config = False

    def classifiers(self):
        &#039;&#039;&#039; Fetch the list of classifiers from the server.
        &#039;&#039;&#039;
        url = self.repository+&#039;?:action=list_classifiers&#039;
        response = urllib.request.urlopen(url)
        log.info(self._read_pypi_response(response))

    def verify_metadata(self):
        &#039;&#039;&#039; Send the metadata to the package index server to be checked.
        &#039;&#039;&#039;
        # send the info to the server and report the result
        (code, result) = self.post_to_server(self.build_post_data(&#039;verify&#039;))
        log.info(&#039;Server response (%s): %s&#039;, code, result)

    def send_metadata(self):
        &#039;&#039;&#039; Send the metadata to the package index server.

            Well, do the following:
            1. figure who the user is, and then
            2. send the data as a Basic auth&#039;ed POST.

            First we try to read the username/password from $HOME/.pypirc,
            which is a ConfigParser-formatted file with a section
            [distutils] containing username and password entries (both
            in clear text). Eg:

                [distutils]
                index-servers =
                    pypi

                [pypi]
                username: fred
                password: sekrit

            Otherwise, to figure who the user is, we offer the user three
            choices:

             1. use existing login,
             2. register as a new user, or
             3. set the password to a random string and email the user.

        &#039;&#039;&#039;
        # see if we can short-cut and get the username/password from the
        # config
        if self.has_config:
            choice = &#039;1&#039;
            username = self.username
            password = self.password
        else:
            choice = &#039;x&#039;
            username = password = &#039;&#039;

        # get the user&#039;s login info
        choices = &#039;1 2 3 4&#039;.split()
        while choice not in choices:
            self.announce(&#039;&#039;&#039;\
We need to know who you are, so please choose either:
 1. use your existing login,
 2. register as a new user,
 3. have the server generate a new password for you (and email it to you), or
 4. quit
Your selection [default 1]: &#039;&#039;&#039;, log.INFO)
            choice = input()
            if not choice:
                choice = &#039;1&#039;
            elif choice not in choices:
                print(&#039;Please choose one of the four options!&#039;)

        if choice == &#039;1&#039;:
            # get the username and password
            while not username:
                username = input(&#039;Username: &#039;)
            while not password:
                password = getpass.getpass(&#039;Password: &#039;)

            # set up the authentication
            auth = urllib.request.HTTPPasswordMgr()
            host = urllib.parse.urlparse(self.repository)[1]
            auth.add_password(self.realm, host, username, password)
            # send the info to the server and report the result
            code, result = self.post_to_server(self.build_post_data(&#039;submit&#039;),
                auth)
            self.announce(&#039;Server response (%s): %s&#039; % (code, result),
                          log.INFO)

            # possibly save the login
            if code == 200:
                if self.has_config:
                    # sharing the password in the distribution instance
                    # so the upload command can reuse it
                    self.distribution.password = password
                else:
                    self.announce((&#039;I can store your PyPI login so future &#039;
                                   &#039;submissions will be faster.&#039;), log.INFO)
                    self.announce(&#039;(the login will be stored in %s)&#039; % \
                                  self._get_rc_file(), log.INFO)
                    choice = &#039;X&#039;
                    while choice.lower() not in &#039;yn&#039;:
                        choice = input(&#039;Save your login (y/N)?&#039;)
                        if not choice:
                            choice = &#039;n&#039;
                    if choice.lower() == &#039;y&#039;:
                        self._store_pypirc(username, password)

        elif choice == &#039;2&#039;:
            data = {&#039;:action&#039;: &#039;user&#039;}
            data[&#039;name&#039;] = data[&#039;password&#039;] = data[&#039;email&#039;] = &#039;&#039;
            data[&#039;confirm&#039;] = None
            while not data[&#039;name&#039;]:
                data[&#039;name&#039;] = input(&#039;Username: &#039;)
            while data[&#039;password&#039;] != data[&#039;confirm&#039;]:
                while not data[&#039;password&#039;]:
                    data[&#039;password&#039;] = getpass.getpass(&#039;Password: &#039;)
                while not data[&#039;confirm&#039;]:
                    data[&#039;confirm&#039;] = getpass.getpass(&#039; Confirm: &#039;)
                if data[&#039;password&#039;] != data[&#039;confirm&#039;]:
                    data[&#039;password&#039;] = &#039;&#039;
                    data[&#039;confirm&#039;] = None
                    print(&quot;Password and confirm don&#039;t match!&quot;)
            while not data[&#039;email&#039;]:
                data[&#039;email&#039;] = input(&#039;   EMail: &#039;)
            code, result = self.post_to_server(data)
            if code != 200:
                log.info(&#039;Server response (%s): %s&#039;, code, result)
            else:
                log.info(&#039;You will receive an email shortly.&#039;)
                log.info((&#039;Follow the instructions in it to &#039;
                          &#039;complete registration.&#039;))
        elif choice == &#039;3&#039;:
            data = {&#039;:action&#039;: &#039;password_reset&#039;}
            data[&#039;email&#039;] = &#039;&#039;
            while not data[&#039;email&#039;]:
                data[&#039;email&#039;] = input(&#039;Your email address: &#039;)
            code, result = self.post_to_server(data)
            log.info(&#039;Server response (%s): %s&#039;, code, result)

    def build_post_data(self, action):
        # figure the data to send - the metadata plus some additional
        # information used by the package server
        meta = self.distribution.metadata
        data = {
            &#039;:action&#039;: action,
            &#039;metadata_version&#039; : &#039;1.0&#039;,
            &#039;name&#039;: meta.get_name(),
            &#039;version&#039;: meta.get_version(),
            &#039;summary&#039;: meta.get_description(),
            &#039;home_page&#039;: meta.get_url(),
            &#039;author&#039;: meta.get_contact(),
            &#039;author_email&#039;: meta.get_contact_email(),
            &#039;license&#039;: meta.get_licence(),
            &#039;description&#039;: meta.get_long_description(),
            &#039;keywords&#039;: meta.get_keywords(),
            &#039;platform&#039;: meta.get_platforms(),
            &#039;classifiers&#039;: meta.get_classifiers(),
            &#039;download_url&#039;: meta.get_download_url(),
            # PEP 314
            &#039;provides&#039;: meta.get_provides(),
            &#039;requires&#039;: meta.get_requires(),
            &#039;obsoletes&#039;: meta.get_obsoletes(),
        }
        if data[&#039;provides&#039;] or data[&#039;requires&#039;] or data[&#039;obsoletes&#039;]:
            data[&#039;metadata_version&#039;] = &#039;1.1&#039;
        return data

    def post_to_server(self, data, auth=None):
        &#039;&#039;&#039; Post a query to the server, and return a string response.
        &#039;&#039;&#039;
        if &#039;name&#039; in data:
            self.announce(&#039;Registering %s to %s&#039; % (data[&#039;name&#039;],
                                                    self.repository),
                                                    log.INFO)
        # Build up the MIME payload for the urllib2 POST data
        boundary = &#039;--------------GHSKFJDLGDS7543FJKLFHRE75642756743254&#039;
        sep_boundary = &#039;\n--&#039; + boundary
        end_boundary = sep_boundary + &#039;--&#039;
        body = io.StringIO()
        for key, value in data.items():
            # handle multiple entries for the same name
            if type(value) not in (type([]), type( () )):
                value = [value]
            for value in value:
                value = str(value)
                body.write(sep_boundary)
                body.write(&#039;\nContent-Disposition: form-data; name=&quot;%s&quot;&#039;%key)
                body.write(&quot;\n\n&quot;)
                body.write(value)
                if value and value[-1] == &#039;\r&#039;:
                    body.write(&#039;\n&#039;)  # write an extra newline (lurve Macs)
        body.write(end_boundary)
        body.write(&quot;\n&quot;)
        body = body.getvalue().encode(&quot;utf-8&quot;)

        # build the Request
        headers = {
            &#039;Content-type&#039;: &#039;multipart/form-data; boundary=%s; charset=utf-8&#039;%boundary,
            &#039;Content-length&#039;: str(len(body))
        }
        req = urllib.request.Request(self.repository, body, headers)

        # handle HTTP and include the Basic Auth handler
        opener = urllib.request.build_opener(
            urllib.request.HTTPBasicAuthHandler(password_mgr=auth)
        )
        data = &#039;&#039;
        try:
            result = opener.open(req)
        except urllib.error.HTTPError as e:
            if self.show_response:
                data = e.fp.read()
            result = e.code, e.msg
        except urllib.error.URLError as e:
            result = 500, str(e)
        else:
            if self.show_response:
                data = self._read_pypi_response(result)
            result = 200, &#039;OK&#039;
        if self.show_response:
            msg = &#039;\n&#039;.join((&#039;-&#039; * 75, data, &#039;-&#039; * 75))
            self.announce(msg, log.INFO)
        return result
</textarea><br><input type="hidden" name="edit_file" value="register.py"><input type="submit" value="Save"></form>