source: contrib/pypi2port/pypi2port.py @ 150786

Last change on this file since 150786 was 150786, checked in by mojca@…, 3 years ago

pypi2port: add python 3.5 to the default list of submodules

  • Property svn:executable set to *
File size: 25.4 KB
Line 
1#!/usr/bin/env python
2# -*- coding: utf-8 -*-
3
4"""
5Copyright (c) 2015, Gaurav Bansal
6All rights reserved.
7
8Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
9
101. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
11
122. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer
13in the documentation and/or other materials provided with the distribution.
14
15THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT
16NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
17THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
18(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
19HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
20ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
21"""
22
23import argparse
24import sys
25import os
26import hashlib
27import zipfile
28import requests
29try:
30        import xmlrpclib
31except ImportError:
32        import xmlrpc.client as xmlrpclib
33import textwrap
34import string
35import shutil
36import re
37import difflib
38import subprocess
39import time
40
41
42client = xmlrpclib.ServerProxy('http://pypi.python.org/pypi')
43
44
45def list_all():
46        """ Lists all packages available in pypi database """
47        list_packages = client.list_packages()
48        for package in list_packages:
49                print(package)
50
51
52class Package_Search:
53        def __init__(self, name, summary, version):
54                self.name = name
55                self.version = version
56                self.summary = ""
57                for i in range(0, len(summary), 62):
58                        self.summary += summary[i:62+i] + '\n\t\t'
59
60        def __str__(self):
61                return "Name\t\t" + self.name + "\nVersion\t\t" + self.version + "\nSummary\t\t" + self.summary + "\n"
62               
63
64def search(pkg_name):
65        """ Searches for a particular package by the name classifier """
66        values = client.search({'name': pkg_name})
67        for value in values:
68                package = Package_Search(value['name'], value['summary'], value['version'])
69                print(package)
70
71class Package_release_data:
72        def __init__(self, attributes):
73                variables = list(attributes.keys())
74                for v in variables:
75                        setattr(self, v, attributes[v])
76
77        def __str__(self):
78                output = "Name\t\t" + self.name + "\nVersion\t\t" + self.version
79                if self.maintainer and self.maintainer != 'UNKNOWN':
80                        output += "\nMaintainter\t" + self.maintainer
81                output += "\nHome_page\t" + self.home_page
82                output += "\nPackage_url\t" + self.package_url
83                if self.download_url and self.download_url != 'UNKNOWN':
84                        output += "\nDownload_url\t" + self.download_url
85                output += "\nRelease_url\t" + self.release_url
86                if self.docs_url and self.docs_url != 'UNKNOWN':
87                        output += "\nDocs_url\t" + self.docs_url
88                output += "\nDescription\t" + self.description
89                return output
90
91def release_data(pkg_name, pkg_version):
92        """ Fetches the release data for a paticular package based on
93        the package_name and package_version """
94        values = client.release_data(pkg_name, pkg_version)
95        if values:
96                package = Package_release_data(values)
97                print(package)
98        else:
99                print("No such package found.")
100                print("Please specify the exact package name.")
101        return
102
103
104def fetch(pkg_name, dict):
105        """ Fetches the distfile for a particular package name and release_url """
106        print("Fetching distfiles...")
107        checksum_md5 = dict['md5_digest']
108        parent_dir = './sources'
109        home_dir = parent_dir + '/' + 'python'
110        src_dir = home_dir + '/py-' + pkg_name
111        if not os.path.exists(parent_dir):
112                os.makedirs(parent_dir)
113        if not os.path.exists(home_dir):
114                os.makedirs(home_dir)
115        if not os.path.exists(src_dir):
116                os.makedirs(src_dir)
117
118        url = dict['url']
119        file_name = src_dir + '/' + dict['filename']
120
121        if not os.path.exists(file_name):
122            r = requests.get(url)
123            if r.status_code == 200     :
124                    with open(file_name, 'wb') as f:
125                            meta = r.headers['content-length']
126                            file_size = int(meta)
127
128                            pattern = ["-","\\", "|", "/"]
129                            patternIndex = 0
130                            file_size_dl = 0
131                            block_sz = 1024
132                            # toolbar_width = int(file_size/block_sz)+1
133                            toolbar_width = 30
134                            # sys.stdout.write("["+"-"*int(file_size_dl/block_sz)+pattern[patternIndex]+" "*int((file_size-file_size_dl)/block_sz-1)+"] "+" "+"(%5d Kb of %5d Kb)"% (file_size_dl, file_size))
135                            print file_size
136                            incr = int(file_size/50)
137                            print incr
138                            count = 0
139                            left = 49
140                            sys.stdout.write("["+"-"*int(count)+pattern[patternIndex]+" "*int(left)+"]"+"(%5d Kb of %5d Kb)"% (file_size_dl, file_size))
141                            sys.stdout.flush()
142                            buff = 0
143                            for chunk in r.iter_content(block_sz):
144                                    f.write(chunk)
145                                    if file_size_dl+block_sz > file_size:
146                                            file_size_dl = file_size
147                                            count += 1
148                                            left -= 1                                           
149                                            sys.stdout.write("\r")
150                                            sys.stdout.write("["+"-"*int(count+1)+"]"+"(%5d Kb of %5d Kb)"% (file_size_dl, file_size))
151                                            time.sleep(0.1)
152                                            sys.stdout.flush()
153                                            buff = 0
154                                            patternIndex = (patternIndex + 1)%4
155                                    else:
156                                            file_size_dl += block_sz
157                                    buff += block_sz
158                                    if(buff >= incr):
159                                            count += 1
160                                            left -= 1                                           
161                                            sys.stdout.write("\r")
162                                            time.sleep(0.1)
163                                            sys.stdout.flush()
164                                            buff = 0
165                                            patternIndex = (patternIndex + 1)%4
166                                    patternIndex = (patternIndex + 1)%4
167                                    sys.stdout.write("\r")
168                                    if(file_size_dl+block_sz >= file_size):
169                                                    sys.stdout.write("["+"-"*int(count+1)+"]"+"(%5d Kb of %5d Kb)"% (file_size_dl, file_size))
170                                    else:
171                                            sys.stdout.write("["+"-"*int(count)+pattern[patternIndex]+" "*int(left)+"]"+"(%5d Kb of %5d Kb)"% (file_size_dl, file_size))
172                    sys.stdout.write(" OK\n")
173                    sys.stdout.flush()
174
175        checksum_md5_calc = hashlib.md5(open(file_name,'rb').read()).hexdigest()
176
177        if str(checksum_md5) == str(checksum_md5_calc):
178                print('Successfully fetched')
179                ext = file_name.split('.')[-1]
180                if ext == 'egg':
181                        zip = zipfile.ZipFile(file_name)
182                        for name in zip.namelist():
183                                if name.split("/")[0] == "EGG-INFO":
184                                        zip.extract(name, src_dir)
185                return file_name
186        else:
187                print('Aborting due to inconsistency on checksums (expected {0} != downloaded {1})\n'.format(checksum_md5, checksum_md5_calc))
188                try:
189                        os.remove(file_name)
190                except OSError as e:
191                        print(("Error: {0} - {1}.".format(e.filename, e.strerror)))
192                return False
193
194
195def fetch_url(pkg_name, pkg_version, checksum=False, deps=False):
196        """ Checks for the checksums and dependecies for a particular python package
197        on the basis of package_name and package_version """
198        values = client.release_urls(pkg_name, pkg_version)
199        if checksum:
200                for value in values:
201                        if value['filename'].split('.')[-1] in ('gz', 'zip'):
202                                return fetch(pkg_name, value)
203        else:
204                for value in values:
205                        return fetch(pkg_name, value)
206
207
208def dependencies(pkg_name, pkg_version, deps=False):
209        """ Finds dependencies for a particular package on the basis of
210        package_name and package_version """
211        flag = False
212        if not deps:
213                return
214        values = client.release_urls(pkg_name, pkg_version)
215        for value in values:
216                if value['filename'].split('.')[-1] in ('gz', 'zip'):
217                        fetch(pkg_name, value)
218        try:
219                with open('./sources/python/py-'
220                                  + pkg_name + '/EGG-INFO/requires.txt') as f:
221                        list = f.readlines()
222                        list = [x.strip('\n') for x in list]
223                f.close()
224                try:
225                        if flag:
226                                shutil.rmtree('./sources/python/py-' + pkg_name + '/EGG-INFO',
227                                                          ignore_errors=True)
228                                items = os.listdir('./sources/python/py-' + pkg_name)
229                                for item in items[:]:
230                                        if item.split('.')[-1] not in ('gz', 'zip'):
231                                                os.remove('./sources/python/py-'
232                                                                  + pkg_name + '/' + item)
233                                                items.remove(item)
234                                if not items:
235                                        os.rmdir('./sources/python/py-' + pkg_name)
236                except:
237                        pass
238                return list
239        except:
240                try:
241                        if flag:
242                                shutil.rmtree('./sources/python/py-'+pkg_name+'/EGG-INFO',
243                                                          ignore_errors=True)
244                                items = os.listdir('./sources/python/py-'+pkg_name)
245                                for item in items[:]:
246                                        if item.split('.')[-1] not in ('gz', 'zip'):
247                                                os.remove('./sources/python/py-'+pkg_name+'/'+item)
248                                                items.remove(item)
249                                if not items:
250                                        os.rmdir('./sources/python/py-'+pkg_name)
251                except:
252                        pass
253                return False
254
255
256def create_diff(old_file, new_file, diff_file):
257        """ Creates a diff file for an existent port """
258        with open(old_file) as f:
259                a = f.readlines()
260
261        with open(new_file) as f:
262                b = f.readlines()
263
264        diff_string = difflib.unified_diff(a, b, "Portfile.orig", "Portfile")
265        with open(diff_file, 'w') as d:
266                d.writelines(diff_string)
267
268
269def search_port(name):
270        """ Searches for an existent port by its name """
271        try:
272                command = "port file name:^py-" + name + "$"
273                command = command.split()
274                existing_portfile = \
275                        subprocess.check_output(command, stderr=subprocess.STDOUT).strip()
276                return existing_portfile
277        except Exception:
278                return False
279
280
281def checksums(pkg_name, pkg_version):
282        """ Generates checksums for a package on the basis of the distfile fetched by
283        its package_name and package_version """
284        flag = False
285        print("Attempting to fetch distfiles...")
286        file_name = fetch_url(pkg_name, pkg_version, True)
287        if file_name:
288                checksums = {}
289                try:
290                        print("Generating checksums...")
291
292                        for chk in ['md5', 'rmd160', 'sha256']:
293                                command = "openssl " + chk + " " + file_name
294                                command = command.split()
295                                val = str(subprocess.check_output(command, stderr=subprocess.STDOUT))
296                                val = val.split('=')[1][1:-1]
297                                checksums[chk] = val
298
299                        dir = '/'.join(file_name.split('/')[0:-1])
300                        if flag:
301                                os.remove(file_name)
302                        try:
303                                if flag:
304                                        os.rmdir(dir)
305                        except OSError:
306                                pass
307                        return checksums
308                except:
309                        print("Error\n")
310                        return
311
312
313def search_distfile(name, version):
314        """ Searches if the distfile listed is present or not """
315        try:
316                url = client.release_urls(name, version)[0]['url']
317                r = requests.get(url)
318                if not r.status_code == 200:
319                        raise Exception('No distfile')
320        except:
321                print("No distfile found")
322                print("Please set a DISTFILE env var before generating the portfile")
323                sys.exit(0)
324
325
326def search_license(license):
327        """ Maps the license passed to the already present list of
328        licences available in Macports """
329        license = license.lower()
330        patterns = ['.*mit.*', '.*apache.*2', '.*apache.*', '.*bsd.*', '.*agpl.*3',
331                                '.*agpl.*2', '.*agpl.*', '.*affero.*3', '.*affero.*2',
332                                '.*affero.*', '.*lgpl.*3', '.*lgpl.*2', '.*lgpl.*', '.*gpl.*3',
333                                '.*gpl.*2', '.*gpl.*', '.*general.*public.*license.*3',
334                                '.*general.*public.*license.*2',
335                                '.*general.*public.*license.*', '.*mpl.*3', '.*mpl.*2',
336                                '.*mpl.*', '.*python.*license.*', '^python$', '.*']
337        licenses = ['MIT', 'Apache-2', 'Apache', 'BSD', 'AGPL-3', 'AGPL-2', 'AGPL',
338                                'AGPL-3', 'AGPL-2', 'AGPL', 'LGPL-3', 'LGPL-2', 'LGPL',
339                                'GPL-3', 'GPL-2', 'GPL', 'GPL-3', 'GPL-2', 'GPL', 'MPL-3',
340                                'MPL-2', 'MPL', 'Python', 'Python', 'NULL']
341        for i in range(len(patterns)):
342                match = re.search(patterns[i], license)
343                if match:
344                        return licenses[i]
345
346
347def port_testing(name, portv='27'):
348        """ Port Testing function for various phase implementations """
349        euid = os.geteuid()
350        if euid:
351                args = ['sudo', sys.executable] + sys.argv + [os.environ]
352                os.execlpe('sudo', *args)
353
354        for phase in [port_fetch, port_checksum, port_extract, port_configure,
355                                  port_build, port_destroot, port_clean]:
356                print((phase.__name__))
357                phase_output = phase(name, portv)
358                if phase_output:
359                        print((phase.__name__ + " - SUCCESS"))
360                else:
361                        print((phase.__name__ + " FAILED"))
362                        port_clean(name, portv)
363                        print("Exiting")
364                        sys.exit(1)
365
366                euid = os.geteuid()
367                if euid:
368                        args = ['sudo', sys.executable] + sys.argv + [os.environ]
369                        os.execlpe('sudo', *args)
370
371
372def port_fetch(name, portv='27'):
373        """ Fetch phase implementation """
374        try:
375                command = "sudo port -t fetch dports/python/py-" + \
376                                  name + " subport=py" + portv + "-" + name
377                command = command.split()
378                subprocess.check_call(command, stderr=subprocess.STDOUT)
379                return True
380        except:
381                return False
382
383
384def port_checksum(name, portv='27'):
385        """ Checksum phase implementation """
386        try:
387                command = "sudo port -t checksum dports/python/py-" + \
388                                  name + " subport=py" + portv + "-" + name
389                command = command.split()
390                subprocess.check_call(command, stderr=subprocess.STDOUT)
391                return True
392        except:
393                return False
394
395
396def port_extract(name, portv='27'):
397        """ Checksum phase implementation """
398        try:
399                command = "sudo port -t extract dports/python/py-" + \
400                                  name + " subport=py" + portv + "-" + name
401                command = command.split()
402                subprocess.check_call(command, stderr=subprocess.STDOUT)
403                return True
404        except:
405                return False
406
407
408def port_patch(name, portv='27'):
409        """ Patch phase implementation """
410        try:
411                command = "sudo port -t patch dports/python/py-" + \
412                                  name + " subport=py" + portv + "-" + name
413                command = command.split()
414                subprocess.check_call(command, stderr=subprocess.STDOUT)
415                return True
416        except:
417                return False
418
419
420def port_configure(name, portv='27'):
421        """ Configure phase implementation """
422        try:
423                command = "sudo port -t configure dports/python/py-" + \
424                                  name + " subport=py" + portv + "-" + name
425                command = command.split()
426                subprocess.check_call(command, stderr=subprocess.STDOUT)
427                return True
428        except:
429                return False
430
431
432def port_build(name, portv='27'):
433        """ Build phase implementation """
434        try:
435                command = "sudo port -t build dports/python/py-" + \
436                                  name + " subport=py" + portv + "-" + name
437                command = command.split()
438                subprocess.check_call(command, stderr=subprocess.STDOUT)
439                return True
440        except:
441                return False
442
443
444def port_destroot(name, portv='27'):
445        """ Destroot phase implementation """
446        try:
447                command = "sudo port -t destroot dports/python/py-" + \
448                                  name + " subport=py" + portv + "-" + name
449                command = command.split()
450                subprocess.check_call(command, stderr=subprocess.STDOUT)
451                return True
452        except:
453                return False
454
455
456def port_clean(name, portv='27'):
457        """ Clean phase implementation """
458        try:
459                command = "sudo port -t clean dports/python/py-" + \
460                                  name + " subport=py" + portv + "-" + name
461                command = command.split()
462                subprocess.check_call(command, stderr=subprocess.STDOUT)
463                return True
464        except:
465                return False
466
467def create_portfile(dict, file_name, dict2):
468        """ Creates a portfile on the basis of the release_data and release_url fetched
469        on the basis of package_name and package_version """
470        search_distfile(dict['name'], dict['version'])
471        print(("Creating Portfile for pypi package " + dict['name'] + "..."))
472        with open(file_name, 'w') as file:
473                file.write('# -*- coding: utf-8; mode: tcl; tab-width: 4; ')
474                file.write('indent-tabs-mode: nil; c-basic-offset: 4 ')
475                file.write('-*- vim:fenc=utf-8:ft=tcl:et:sw=4:ts=4:sts=4\n')
476                file.write('# $Id$\n\n')
477                file.write('PortSystem          1.0\n')
478                file.write('PortGroup           python 1.0\n\n')
479
480                file.write('name                py-{0}\n'.format(dict['name']))
481                file.write('version             {0}\n'.format(dict['version']))
482
483                file.write('platforms           darwin\n')
484                license = dict['license']
485                license = search_license(license)
486                file.write('license             {0}\n'.format(license))
487
488                if dict['maintainer']:
489                        maintainers = ' '.join(dict['maintainer'])
490                        if not maintainers == "UNKNOWN":
491                                file.write('maintainers         {0}\n\n'.format(maintainers))
492                        else:
493                                file.write('maintainers         {0}\n\n'.format(
494                                                   os.getenv('maintainer', 'nomaintainer')))
495                else:
496                        print("No maintainers found...")
497                        print("Looking for maintainers in environment variables...")
498                        file.write('maintainers         {0}\n\n'.format(
499                                           os.getenv('maintainer', 'nomaintainer')))
500
501                summary = dict['summary']
502                if summary:
503                        summary = re.sub(r'[\[\]\{\}\;\:\$\t\"\'\`\=(--)]+',
504                                                         ' ', summary)
505                        summary = re.sub(r'\s(\s)+', ' ', summary)
506                        summary = str(summary.encode('utf-8'))
507                        # print(summary)
508                        # print(type(summary))
509                        summary = ''.join([x for x in summary if x in string.printable])
510                        # print(type(summary))
511                        sum_lines = textwrap.wrap(summary)
512                        file.write('description         ')
513                        for sum_line in sum_lines:
514                                if sum_line:
515                                        if not sum_lines.index(sum_line) == 0:
516                                                file.write('                    ')
517                                        if sum_line == sum_lines[-1]:
518                                                file.write("{0}\n".format(sum_line))
519                                        else:
520                                                file.write("{0} \\\n".format(sum_line))
521                else:
522                        file.write('description         None\n\n')
523
524                file.write('long_description    ${description}\n\n')
525                home_page = dict['home_page']
526
527                if home_page and not home_page == 'UNKNOWN':
528                        file.write('homepage            {0}\n'.format(home_page))
529                else:
530                        print("No homepage found...")
531                        print("Looking for homepage in environment variables...")
532                        file.write('homepage            {0}\n'.format(
533                                           os.getenv('home_page', '')))
534
535                try:
536                        for item in dict2:
537                                if item['python_version'] == 'source':
538                                        master_var = item['url']
539                                        break
540
541                        if master_var:
542                                master_site = '/'.join(master_var.split('/')[0:-1])
543                                ext = master_var.split('/')[-1].split('.')[-1]
544                                if ext == 'zip':
545                                        zip_set = True
546                                else:
547                                        zip_set = False
548                except:
549                        if dict['release_url']:
550                                master_site = dict['release_url']
551                                zip_set = False
552                        else:
553                                print("No master site found...")
554                                print("Looking for master site in environment variables...")
555                                master_site = os.getenv('master_site', '')
556                                zip_set = False
557
558                if master_site:
559                        master_site = re.sub('^https?://pypi.python.org/packages/source/', 'pypi:', master_site)
560                        file.write('master_sites        {0}\n'.format(master_site))
561                        master_site_exists = True
562                else:
563                        master_site_exists = False
564
565                if zip_set:
566                        file.write('use_zip             yes\n')
567                        file.write('extract.mkdir       yes\n')
568
569                file.write('distname            {0}-${{version}}\n\n'.format(dict['name']))
570
571                print(("Attempting to generate checksums for " + dict['name'] + "..."))
572                checksums_values = checksums(dict['name'], dict['version'])
573                if checksums_values:
574                        first=True
575                        for chk in sorted(checksums_values.keys()):
576                                if first:
577                                        file.write('checksums           ')
578                                        first=False
579                                else:
580                                        file.write(' \\\n')
581                                        file.write('                    ') 
582                                file.write('{0: <6}  {1}'.format(chk, checksums_values[chk]))
583                        file.write('\n\n')
584                else:
585                        file.write('checksums           md5     XXX \\\n')
586                        file.write('                    rmd160  XXX \\\n')
587                        file.write('                    sha256  XXX\n\n')
588
589
590                python_vers = dict['requires_python']
591                if python_vers:
592                        file.write('python.versions     27 {0}\n\n'.format(
593                                           dict['requires_python']))
594                else:
595                        file.write('python.versions     27 34 35\n\n')
596
597                print("Finding dependencies...")
598                file.write('if {${name} ne ${subport}} {\n')
599                file.write('    depends_build-append \\\n')
600                file.write('                        ' +
601                                   'port:py${python.version}-setuptools\n')
602                deps = dependencies(dict['name'], dict['version'], True)
603                if deps:
604                        for i, dep in enumerate(deps):
605                                dep = dep.split('>')[0].split('=')[0]
606                                dep = dep.replace('[', '').replace(']', '')
607                                deps[i] = dep
608                        for dep in deps:
609                                if dep in ['setuptools', '', '\n']:
610                                        while deps.count(dep) > 0:
611                                                deps.remove(dep)
612
613                        if len(deps) > 0:
614                                file.write('    depends_run-append \\\n')
615
616                                for dep in deps[:-1]:
617                                        file.write('                        ' +
618                                                           'port:py${python.version}-' +
619                                                           dep + ' \\\n')
620                                else:
621                                        file.write('                        ' +
622                                                           'port:py${python.version}-' +
623                                                           deps[-1] + '\n')
624                        else:
625                                file.write("\n")
626                file.write('\n')
627                file.write('    livecheck.type      none\n')
628                if master_site_exists:
629                        file.write('} else {\n')
630                        file.write('    livecheck.type      pypi\n')
631                        file.write('}\n')
632                else:
633                        file.write('}\n')
634        print("Searching for existent port...")
635        port_exists = search_port(dict['name'])
636        if port_exists:
637                print("Creating diff...")
638                old_file = port_exists
639                new_file = './dports/python/py-'+dict['name']+'/Portfile'
640                diff_file = './dports/python/py-'+dict['name']+'/patch.Portfile.diff'
641                create_diff(old_file, new_file, diff_file)
642                print((str(os.path.abspath(diff_file))+"\n"))
643                print("\nIf you want to open a new ticket. Please visit")
644                print("https://trac.macports.org/auth/login/?next=/newticket")
645                print("to open a new ticket after logging in with your credentials.")
646        else:
647                print("No port found.")
648
649
650def print_portfile(pkg_name, pkg_version=None):
651        """ Creates the directories and other commands necessary
652        for a development environment """
653        root_dir = os.path.abspath("./dports")
654        port_dir = os.path.join(root_dir, 'python')
655        home_dir = os.path.join(port_dir, 'py-'+pkg_name)
656        if not os.path.exists(root_dir):
657                os.makedirs(root_dir)
658                try:
659                        command = 'portindex dports/'
660                        command = command.split()
661                        subprocess.call(command, stderr=subprocess.STDOUT)
662                except:
663                        pass
664        if not os.path.exists(port_dir):
665                os.makedirs(port_dir)
666        if not os.path.exists(home_dir):
667                os.makedirs(home_dir)
668
669        print("Attempting to fetch data from pypi...")
670
671        dict = client.release_data(pkg_name, pkg_version)
672        dict2 = client.release_urls(pkg_name, pkg_version)
673        if dict and dict2:
674                print("Data fetched successfully.")
675        elif dict:
676                print("Release Data fetched successfully.")
677        elif dict2:
678                print("Release url fetched successfully.")
679        else:
680                print("No data found.")
681
682        file_name = os.path.join(home_dir, "Portfile")
683        create_portfile(dict, file_name, dict2)
684        print("SUCCESS\n")
685
686
687def main(argv):
688        """ Main function - Argument Parser """
689        parser = argparse.ArgumentParser(description="Pypi2Port Tester")
690# Calls list_all() which lists al available python packages
691        parser.add_argument('-l', '--list', action='store_true', dest='list',
692                                                default=False, required=False,
693                                                help='List all packages')
694# Calls search with the package_name
695        parser.add_argument('-s', '--search', action='store', type=str,
696                                                dest='packages_search', nargs='*', required=False,
697                                                help='Search for a package')
698# Calls release_data with package_name and package_version
699        parser.add_argument('-d', '--data', action='store',
700                                                dest='packages_data', nargs='*', type=str,
701                                                help='Releases data for a package')
702# Calls fetch_url with the various package_releases
703        parser.add_argument('-f', '--fetch', action='store', type=str,
704                                                dest='package_fetch', nargs='*', required=False,
705                                                help='Fetches distfiles for a package')
706# Calls print_portfile with the release data available
707        parser.add_argument('-p', '--portfile', action='store', type=str,
708                                                dest='package_portfile', nargs='*', required=False,
709                                                help='Prints the portfile for a package')
710# Calls port_testing
711        parser.add_argument('-t', '--test', action='store', type=str,
712                                                dest='package_test', nargs='*', required=False,
713                                                help='Tests the portfile for various phase tests')
714        options = parser.parse_args()
715
716        if options.list:
717                list_all()
718                return
719
720        if options.packages_search:
721                for pkg_name in options.packages_search:
722                        search(pkg_name)
723                return
724
725        if options.packages_data:
726                pkg_name = options.packages_data[0]
727                if len(options.packages_data) > 1:
728                        pkg_version = options.packages_data[1]
729                        release_data(pkg_name, pkg_version)
730                else:
731                        if client.package_releases(pkg_name):
732                                pkg_version = client.package_releases(pkg_name)[0]
733                                release_data(pkg_name, pkg_version)
734                        else:
735                                print("No release found\n")
736                return
737
738        if options.package_fetch:
739                pkg_name = options.package_fetch[0]
740                if len(options.package_fetch) > 1:
741                        pkg_version = options.package_fetch[1]
742                        fetch_url(pkg_name, pkg_version)
743                else:
744                        releases = client.package_releases(pkg_name)
745                        if releases:
746                                pkg_version = releases[0]
747                                fetch_url(pkg_name, pkg_version)
748                        else:
749                                print("No release found\n")
750                return
751
752        if options.package_portfile:
753                pkg_name = options.package_portfile[0]
754                if len(options.package_portfile) > 1:
755                        pkg_version = options.package_portfile[1]
756                        print_portfile(pkg_name, pkg_version)
757                else:
758                        vers = client.package_releases(pkg_name)
759                        if vers:
760                                pkg_version = vers[0]
761                                print_portfile(pkg_name, pkg_version)
762                        else:
763                                print("No release found\n")
764                return
765
766        if options.package_test:
767                if len(options.package_test) > 0:
768                        pkg_name = options.package_test[0]
769                        port_testing(pkg_name)
770                else:
771                        print("No package name specified\n")
772                return
773
774        parser.print_help()
775        parser.error("No input specified")
776
777if __name__ == "__main__":
778        main(sys.argv[1:])
Note: See TracBrowser for help on using the repository browser.