← Back to branch summary

~ubuntu-branches/debian/stretch/electrum/stretch

« back to all changes in this revision

Viewing changes to gui/kivy/tools/.buildozer/android/platform/python-for-android/dist/kivy/python-install/lib/python2.7/distutils/command/register.py

  • Committer: Package Import Robot
  • Author(s): Tristan Seligmann
  • Date: 2016-04-04 03:02:39 UTC
  • mfrom: (1.1.10)
  • Revision ID: package-import@ubuntu.com-20160404030239-0szgkio8yryjv7c9
Tags: 2.6.3-1
http://bugs.debian.org/819517
* New upstream release.
  - Drop backported install-wizard-connect.patch.
* Add Suggests: python-zbar and update the installation hint to suggest
  apt-get instead of pip (closes: #819517).
* Bump Standards-Version to 3.9.7 (no changes).
* Update Vcs-* links.

Show diffs side-by-side

added added

removed removed

Lines of Context:
gui/kivy/tools/.buildozer/android/platform/python-for-android/dist/kivy/python-install/lib/python2.7/distutils/command/register.py
 
1
"""distutils.command.register
 
2
 
 
3
Implements the Distutils 'register' command (register with the repository).
 
4
"""
 
5
 
 
6
# created 2002/10/21, Richard Jones
 
7
 
 
8
__revision__ = "$Id$"
 
9
 
 
10
import urllib2
 
11
import getpass
 
12
import urlparse
 
13
import StringIO
 
14
from warnings import warn
 
15
 
 
16
from distutils.core import PyPIRCCommand
 
17
from distutils import log
 
18
 
 
19
class register(PyPIRCCommand):
 
20
 
 
21
    description = ("register the distribution with the Python package index")
 
22
    user_options = PyPIRCCommand.user_options + [
 
23
        ('list-classifiers', None,
 
24
         'list the valid Trove classifiers'),
 
25
        ('strict', None ,
 
26
         'Will stop the registering if the meta-data are not fully compliant')
 
27
        ]
 
28
    boolean_options = PyPIRCCommand.boolean_options + [
 
29
        'verify', 'list-classifiers', 'strict']
 
30
 
 
31
    sub_commands = [('check', lambda self: True)]
 
32
 
 
33
    def initialize_options(self):
 
34
        PyPIRCCommand.initialize_options(self)
 
35
        self.list_classifiers = 0
 
36
        self.strict = 0
 
37
 
 
38
    def finalize_options(self):
 
39
        PyPIRCCommand.finalize_options(self)
 
40
        # setting options for the `check` subcommand
 
41
        check_options = {'strict': ('register', self.strict),
 
42
                         'restructuredtext': ('register', 1)}
 
43
        self.distribution.command_options['check'] = check_options
 
44
 
 
45
    def run(self):
 
46
        self.finalize_options()
 
47
        self._set_config()
 
48
 
 
49
        # Run sub commands
 
50
        for cmd_name in self.get_sub_commands():
 
51
            self.run_command(cmd_name)
 
52
 
 
53
        if self.dry_run:
 
54
            self.verify_metadata()
 
55
        elif self.list_classifiers:
 
56
            self.classifiers()
 
57
        else:
 
58
            self.send_metadata()
 
59
 
 
60
    def check_metadata(self):
 
61
        """Deprecated API."""
 
62
        warn("distutils.command.register.check_metadata is deprecated, \
 
63
              use the check command instead", PendingDeprecationWarning)
 
64
        check = self.distribution.get_command_obj('check')
 
65
        check.ensure_finalized()
 
66
        check.strict = self.strict
 
67
        check.restructuredtext = 1
 
68
        check.run()
 
69
 
 
70
    def _set_config(self):
 
71
        ''' Reads the configuration file and set attributes.
 
72
        '''
 
73
        config = self._read_pypirc()
 
74
        if config != {}:
 
75
            self.username = config['username']
 
76
            self.password = config['password']
 
77
            self.repository = config['repository']
 
78
            self.realm = config['realm']
 
79
            self.has_config = True
 
80
        else:
 
81
            if self.repository not in ('pypi', self.DEFAULT_REPOSITORY):
 
82
                raise ValueError('%s not found in .pypirc' % self.repository)
 
83
            if self.repository == 'pypi':
 
84
                self.repository = self.DEFAULT_REPOSITORY
 
85
            self.has_config = False
 
86
 
 
87
    def classifiers(self):
 
88
        ''' Fetch the list of classifiers from the server.
 
89
        '''
 
90
        response = urllib2.urlopen(self.repository+'?:action=list_classifiers')
 
91
        log.info(response.read())
 
92
 
 
93
    def verify_metadata(self):
 
94
        ''' Send the metadata to the package index server to be checked.
 
95
        '''
 
96
        # send the info to the server and report the result
 
97
        (code, result) = self.post_to_server(self.build_post_data('verify'))
 
98
        log.info('Server response (%s): %s' % (code, result))
 
99
 
 
100
 
 
101
    def send_metadata(self):
 
102
        ''' Send the metadata to the package index server.
 
103
 
 
104
            Well, do the following:
 
105
            1. figure who the user is, and then
 
106
            2. send the data as a Basic auth'ed POST.
 
107
 
 
108
            First we try to read the username/password from $HOME/.pypirc,
 
109
            which is a ConfigParser-formatted file with a section
 
110
            [distutils] containing username and password entries (both
 
111
            in clear text). Eg:
 
112
 
 
113
                [distutils]
 
114
                index-servers =
 
115
                    pypi
 
116
 
 
117
                [pypi]
 
118
                username: fred
 
119
                password: sekrit
 
120
 
 
121
            Otherwise, to figure who the user is, we offer the user three
 
122
            choices:
 
123
 
 
124
             1. use existing login,
 
125
             2. register as a new user, or
 
126
             3. set the password to a random string and email the user.
 
127
 
 
128
        '''
 
129
        # see if we can short-cut and get the username/password from the
 
130
        # config
 
131
        if self.has_config:
 
132
            choice = '1'
 
133
            username = self.username
 
134
            password = self.password
 
135
        else:
 
136
            choice = 'x'
 
137
            username = password = ''
 
138
 
 
139
        # get the user's login info
 
140
        choices = '1 2 3 4'.split()
 
141
        while choice not in choices:
 
142
            self.announce('''\
 
143
We need to know who you are, so please choose either:
 
144
 1. use your existing login,
 
145
 2. register as a new user,
 
146
 3. have the server generate a new password for you (and email it to you), or
 
147
 4. quit
 
148
Your selection [default 1]: ''', log.INFO)
 
149
 
 
150
            choice = raw_input()
 
151
            if not choice:
 
152
                choice = '1'
 
153
            elif choice not in choices:
 
154
                print 'Please choose one of the four options!'
 
155
 
 
156
        if choice == '1':
 
157
            # get the username and password
 
158
            while not username:
 
159
                username = raw_input('Username: ')
 
160
            while not password:
 
161
                password = getpass.getpass('Password: ')
 
162
 
 
163
            # set up the authentication
 
164
            auth = urllib2.HTTPPasswordMgr()
 
165
            host = urlparse.urlparse(self.repository)[1]
 
166
            auth.add_password(self.realm, host, username, password)
 
167
            # send the info to the server and report the result
 
168
            code, result = self.post_to_server(self.build_post_data('submit'),
 
169
                auth)
 
170
            self.announce('Server response (%s): %s' % (code, result),
 
171
                          log.INFO)
 
172
 
 
173
            # possibly save the login
 
174
            if code == 200:
 
175
                if self.has_config:
 
176
                    # sharing the password in the distribution instance
 
177
                    # so the upload command can reuse it
 
178
                    self.distribution.password = password
 
179
                else:
 
180
                    self.announce(('I can store your PyPI login so future '
 
181
                                   'submissions will be faster.'), log.INFO)
 
182
                    self.announce('(the login will be stored in %s)' % \
 
183
                                  self._get_rc_file(), log.INFO)
 
184
                    choice = 'X'
 
185
                    while choice.lower() not in 'yn':
 
186
                        choice = raw_input('Save your login (y/N)?')
 
187
                        if not choice:
 
188
                            choice = 'n'
 
189
                    if choice.lower() == 'y':
 
190
                        self._store_pypirc(username, password)
 
191
 
 
192
        elif choice == '2':
 
193
            data = {':action': 'user'}
 
194
            data['name'] = data['password'] = data['email'] = ''
 
195
            data['confirm'] = None
 
196
            while not data['name']:
 
197
                data['name'] = raw_input('Username: ')
 
198
            while data['password'] != data['confirm']:
 
199
                while not data['password']:
 
200
                    data['password'] = getpass.getpass('Password: ')
 
201
                while not data['confirm']:
 
202
                    data['confirm'] = getpass.getpass(' Confirm: ')
 
203
                if data['password'] != data['confirm']:
 
204
                    data['password'] = ''
 
205
                    data['confirm'] = None
 
206
                    print "Password and confirm don't match!"
 
207
            while not data['email']:
 
208
                data['email'] = raw_input('   EMail: ')
 
209
            code, result = self.post_to_server(data)
 
210
            if code != 200:
 
211
                log.info('Server response (%s): %s' % (code, result))
 
212
            else:
 
213
                log.info('You will receive an email shortly.')
 
214
                log.info(('Follow the instructions in it to '
 
215
                          'complete registration.'))
 
216
        elif choice == '3':
 
217
            data = {':action': 'password_reset'}
 
218
            data['email'] = ''
 
219
            while not data['email']:
 
220
                data['email'] = raw_input('Your email address: ')
 
221
            code, result = self.post_to_server(data)
 
222
            log.info('Server response (%s): %s' % (code, result))
 
223
 
 
224
    def build_post_data(self, action):
 
225
        # figure the data to send - the metadata plus some additional
 
226
        # information used by the package server
 
227
        meta = self.distribution.metadata
 
228
        data = {
 
229
            ':action': action,
 
230
            'metadata_version' : '1.0',
 
231
            'name': meta.get_name(),
 
232
            'version': meta.get_version(),
 
233
            'summary': meta.get_description(),
 
234
            'home_page': meta.get_url(),
 
235
            'author': meta.get_contact(),
 
236
            'author_email': meta.get_contact_email(),
 
237
            'license': meta.get_licence(),
 
238
            'description': meta.get_long_description(),
 
239
            'keywords': meta.get_keywords(),
 
240
            'platform': meta.get_platforms(),
 
241
            'classifiers': meta.get_classifiers(),
 
242
            'download_url': meta.get_download_url(),
 
243
            # PEP 314
 
244
            'provides': meta.get_provides(),
 
245
            'requires': meta.get_requires(),
 
246
            'obsoletes': meta.get_obsoletes(),
 
247
        }
 
248
        if data['provides'] or data['requires'] or data['obsoletes']:
 
249
            data['metadata_version'] = '1.1'
 
250
        return data
 
251
 
 
252
    def post_to_server(self, data, auth=None):
 
253
        ''' Post a query to the server, and return a string response.
 
254
        '''
 
255
        if 'name' in data:
 
256
            self.announce('Registering %s to %s' % (data['name'],
 
257
                                                   self.repository),
 
258
                                                   log.INFO)
 
259
        # Build up the MIME payload for the urllib2 POST data
 
260
        boundary = '--------------GHSKFJDLGDS7543FJKLFHRE75642756743254'
 
261
        sep_boundary = '\n--' + boundary
 
262
        end_boundary = sep_boundary + '--'
 
263
        body = StringIO.StringIO()
 
264
        for key, value in data.items():
 
265
            # handle multiple entries for the same name
 
266
            if type(value) not in (type([]), type( () )):
 
267
                value = [value]
 
268
            for value in value:
 
269
                body.write(sep_boundary)
 
270
                body.write('\nContent-Disposition: form-data; name="%s"'%key)
 
271
                body.write("\n\n")
 
272
                body.write(value)
 
273
                if value and value[-1] == '\r':
 
274
                    body.write('\n')  # write an extra newline (lurve Macs)
 
275
        body.write(end_boundary)
 
276
        body.write("\n")
 
277
        body = body.getvalue()
 
278
 
 
279
        # build the Request
 
280
        headers = {
 
281
            'Content-type': 'multipart/form-data; boundary=%s; charset=utf-8'%boundary,
 
282
            'Content-length': str(len(body))
 
283
        }
 
284
        req = urllib2.Request(self.repository, body, headers)
 
285
 
 
286
        # handle HTTP and include the Basic Auth handler
 
287
        opener = urllib2.build_opener(
 
288
            urllib2.HTTPBasicAuthHandler(password_mgr=auth)
 
289
        )
 
290
        data = ''
 
291
        try:
 
292
            result = opener.open(req)
 
293
        except urllib2.HTTPError, e:
 
294
            if self.show_response:
 
295
                data = e.fp.read()
 
296
            result = e.code, e.msg
 
297
        except urllib2.URLError, e:
 
298
            result = 500, str(e)
 
299
        else:
 
300
            if self.show_response:
 
301
                data = result.read()
 
302
            result = 200, 'OK'
 
303
        if self.show_response:
 
304
            dashes = '-' * 75
 
305
            self.announce('%s%s%s' % (dashes, data, dashes))
 
306
 
 
307
        return result