cengal.bulk_pip_actions.bulk_install.versions.v_0.bulk_install

View Source

  1#!/usr/bin/env python
  2# coding=utf-8
  3
  4# Copyright © 2012-2024 ButenkoMS. All rights reserved. Contacts: <gtalk@butenkoms.space>
  5# 
  6# Licensed under the Apache License, Version 2.0 (the "License");
  7# you may not use this file except in compliance with the License.
  8# You may obtain a copy of the License at
  9# 
 10#     http://www.apache.org/licenses/LICENSE-2.0
 11# 
 12# Unless required by applicable law or agreed to in writing, software
 13# distributed under the License is distributed on an "AS IS" BASIS,
 14# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 15# See the License for the specific language governing permissions and
 16# limitations under the License.
 17
 18from typing import Dict, List, Union, Set
 19from cengal.bulk_pip_actions.install import *
 20from cengal.system import IS_INSIDE_OR_FOR_WEB_BROWSER, OS_TYPE, KIVY_PLATFORM, KIVY_TARGET_PLATFORM
 21from cengal.hardware.info.cpu import cpu_info
 22
 23
 24"""
 25Module Docstring
 26Docstrings: http://www.python.org/dev/peps/pep-0257/
 27"""
 28
 29__author__ = "ButenkoMS <gtalk@butenkoms.space>"
 30__copyright__ = "Copyright © 2012-2024 ButenkoMS. All rights reserved. Contacts: <gtalk@butenkoms.space>"
 31__credits__ = ["ButenkoMS <gtalk@butenkoms.space>", ]
 32__license__ = "Apache License, Version 2.0"
 33__version__ = "4.4.1"
 34__maintainer__ = "ButenkoMS <gtalk@butenkoms.space>"
 35__email__ = "gtalk@butenkoms.space"
 36# __status__ = "Prototype"
 37__status__ = "Development"
 38# __status__ = "Production"
 39
 40
 41class ModulesLists(object):
 42    def __init__(self):
 43        self.list_type = None
 44
 45        self.python2 = list()
 46        self.python3 = list()
 47        self.cpython2 = list()
 48        self.cpython3 = list()
 49        self.pypy2 = list()
 50        self.pypy3 = list()
 51        self.universal = list()
 52
 53        self.linux_allowed: Set[str] = set()
 54        self.linux_forbidden: Set[str] = set()
 55        self.windows_allowed: Set[str] = set()
 56        self.windows_forbidden: Set[str] = set()
 57        self.osx_allowed: Set[str] = set()
 58        self.osx_forbidden: Set[str] = set()
 59        self.emscripten_allowed: Set[str] = set()
 60        self.emscripten_forbidden: Set[str] = set()
 61
 62        self.kivy_linux_allowed: Set[str] = set()
 63        self.kivy_linux_forbidden: Set[str] = set()
 64        self.kivy_win_allowed: Set[str] = set()
 65        self.kivy_win_forbidden: Set[str] = set()
 66        self.kivy_macosx_allowed: Set[str] = set()
 67        self.kivy_macosx_forbidden: Set[str] = set()
 68        self.kivy_ios_allowed: Set[str] = set()
 69        self.kivy_ios_forbidden: Set[str] = set()
 70        self.kivy_android_allowed: Set[str] = set()
 71        self.kivy_android_forbidden: Set[str] = set()
 72        self.kivy_unknown_allowed: Set[str] = set()
 73        self.kivy_unknown_forbidden: Set[str] = set()
 74
 75        self.kivy_target_linux_allowed: Set[str] = set()
 76        self.kivy_target_linux_forbidden: Set[str] = set()
 77        self.kivy_target_win_allowed: Set[str] = set()
 78        self.kivy_target_win_forbidden: Set[str] = set()
 79        self.kivy_target_macosx_allowed: Set[str] = set()
 80        self.kivy_target_macosx_forbidden: Set[str] = set()
 81        self.kivy_target_ios_allowed: Set[str] = set()
 82        self.kivy_target_ios_forbidden: Set[str] = set()
 83        self.kivy_target_android_allowed: Set[str] = set()
 84        self.kivy_target_android_forbidden: Set[str] = set()
 85        self.kivy_target_unknown_allowed: Set[str] = set()
 86        self.kivy_target_unknown_forbidden: Set[str] = set()
 87
 88        self.arch__x86__allowed: Set[str] = set()
 89        self.arch__x86__forbidden: Set[str] = set()
 90        self.arch__x86_64__allowed: Set[str] = set()
 91        self.arch__x86_64__forbidden: Set[str] = set()
 92        self.arch__x86_32__allowed: Set[str] = set()
 93        self.arch__x86_32__forbidden: Set[str] = set()
 94        self.arch__ARM__allowed: Set[str] = set()
 95        self.arch__ARM__forbidden: Set[str] = set()
 96        self.arch__ARM_8__allowed: Set[str] = set()
 97        self.arch__ARM_8__forbidden: Set[str] = set()
 98        self.arch__ARM_8_64__allowed: Set[str] = set()
 99        self.arch__ARM_8_64__forbidden: Set[str] = set()
100        self.arch__ARM_8_32__allowed: Set[str] = set()
101        self.arch__ARM_8_32__forbidden: Set[str] = set()
102        self.arch__ARM_7__allowed: Set[str] = set()
103        self.arch__ARM_7__forbidden: Set[str] = set()
104
105        self._allowed: Set[str] = set()
106        self._forbidden: Set[str] = set()
107
108    def chosen_packages(self):
109        if IS_INSIDE_OR_FOR_WEB_BROWSER:
110            # Must be before other systems!
111            self._allowed.update(self.emscripten_allowed)
112            self._forbidden.update(self.emscripten_forbidden)
113        elif 'Linux' == OS_TYPE:
114            self._allowed.update(self.linux_allowed)
115            self._forbidden.update(self.linux_forbidden)
116        elif 'Windows' == OS_TYPE:
117            self._allowed.update(self.windows_allowed)
118            self._forbidden.update(self.windows_forbidden)
119        elif 'Darwin' == OS_TYPE:
120            self._allowed.update(self.osx_allowed)
121            self._forbidden.update(self.osx_forbidden)
122
123        if 'linux' == KIVY_PLATFORM:
124            self._allowed.update(self.kivy_linux_allowed)
125            self._forbidden.update(self.kivy_linux_forbidden)
126        elif 'win' == KIVY_PLATFORM:
127            self._allowed.update(self.kivy_win_allowed)
128            self._forbidden.update(self.kivy_win_forbidden)
129        elif 'macosx' == KIVY_PLATFORM:
130            self._allowed.update(self.kivy_macosx_allowed)
131            self._forbidden.update(self.kivy_macosx_forbidden)
132        elif 'ios' == KIVY_PLATFORM:
133            self._allowed.update(self.kivy_ios_allowed)
134            self._forbidden.update(self.kivy_ios_forbidden)
135        elif 'android' == KIVY_PLATFORM:
136            self._allowed.update(self.kivy_android_allowed)
137            self._forbidden.update(self.kivy_android_forbidden)
138        elif 'unknown' == KIVY_PLATFORM:
139            self._allowed.update(self.kivy_unknown_allowed)
140            self._forbidden.update(self.kivy_unknown_forbidden)
141
142        if 'linux' == KIVY_TARGET_PLATFORM:
143            self._allowed.update(self.kivy_target_linux_allowed)
144            self._forbidden.update(self.kivy_target_linux_forbidden)
145        elif 'win' == KIVY_TARGET_PLATFORM:
146            self._allowed.update(self.kivy_target_win_allowed)
147            self._forbidden.update(self.kivy_target_win_forbidden)
148        elif 'macosx' == KIVY_TARGET_PLATFORM:
149            self._allowed.update(self.kivy_target_macosx_allowed)
150            self._forbidden.update(self.kivy_target_macosx_forbidden)
151        elif 'ios' == KIVY_TARGET_PLATFORM:
152            self._allowed.update(self.kivy_target_ios_allowed)
153            self._forbidden.update(self.kivy_target_ios_forbidden)
154        elif 'android' == KIVY_TARGET_PLATFORM:
155            self._allowed.update(self.kivy_target_android_allowed)
156            self._forbidden.update(self.kivy_target_android_forbidden)
157        elif 'unknown' == KIVY_TARGET_PLATFORM:
158            self._allowed.update(self.kivy_target_unknown_allowed)
159            self._forbidden.update(self.kivy_target_unknown_forbidden)
160
161        arch = cpu_info().arch.casefold()
162        if cpu_info().is_x86:
163            self._allowed.update(self.arch__x86__allowed)
164            self._forbidden.update(self.arch__x86__forbidden)
165            if 'x86_64'.casefold() == arch:
166                self._allowed.update(self.arch__x86_64__allowed)
167                self._forbidden.update(self.arch__x86_64__forbidden)
168            elif 'x86_32'.casefold() == arch:
169                self._allowed.update(self.arch__x86_32__allowed)
170                self._forbidden.update(self.arch__x86_32__forbidden)
171        
172        if cpu_info().is_arm:
173            self._allowed.update(self.arch__ARM__allowed)
174            self._forbidden.update(self.arch__ARM__forbidden)
175            if 'ARM_8'.casefold() == arch:
176                self._allowed.update(self.arch__ARM_8__allowed)
177                self._forbidden.update(self.arch__ARM_8__forbidden)
178            elif ('ARM_8'.casefold() == arch) and (64 == cpu_info().bits):
179                self._allowed.update(self.arch__ARM_8_64__allowed)
180                self._forbidden.update(self.arch__ARM_8_64__forbidden)
181            elif ('ARM_8'.casefold() == arch) and (32 == cpu_info().bits):
182                self._allowed.update(self.arch__ARM_8_32__allowed)
183                self._forbidden.update(self.arch__ARM_8_32__forbidden)
184            elif 'ARM_7'.casefold() == arch:
185                self._allowed.update(self.arch__ARM_7__allowed)
186                self._forbidden.update(self.arch__ARM_7__forbidden)
187
188        modules = list()
189        modules += self.universal
190        if '2' == PYTHON_VERSION[0]:
191            if 'CPython' == PLATFORM_NAME:
192                modules += self.cpython2
193            elif 'PyPy' == PLATFORM_NAME:
194                modules += self.pypy2
195            modules += self.python2
196        if '3' == PYTHON_VERSION[0]:
197            if 'CPython' == PLATFORM_NAME:
198                modules += self.cpython3
199            elif 'PyPy' == PLATFORM_NAME:
200                modules += self.pypy3
201            modules += self.python3
202
203        modules.extend(self._allowed)
204
205        if self._forbidden:
206            new_modules = list()
207            for item in modules:
208                if item not in self._forbidden:
209                    new_modules.append(item)
210            modules = new_modules
211
212        return modules
213
214    def bulk_install(self):
215        modules = self.chosen_packages()
216        if modules:
217            print('INSTALLING: {}'.format(modules))
218            print()
219
220            for item in modules:
221                install(item, self.list_type)

class ModulesLists: View Source

 42class ModulesLists(object):
 43    def __init__(self):
 44        self.list_type = None
 45
 46        self.python2 = list()
 47        self.python3 = list()
 48        self.cpython2 = list()
 49        self.cpython3 = list()
 50        self.pypy2 = list()
 51        self.pypy3 = list()
 52        self.universal = list()
 53
 54        self.linux_allowed: Set[str] = set()
 55        self.linux_forbidden: Set[str] = set()
 56        self.windows_allowed: Set[str] = set()
 57        self.windows_forbidden: Set[str] = set()
 58        self.osx_allowed: Set[str] = set()
 59        self.osx_forbidden: Set[str] = set()
 60        self.emscripten_allowed: Set[str] = set()
 61        self.emscripten_forbidden: Set[str] = set()
 62
 63        self.kivy_linux_allowed: Set[str] = set()
 64        self.kivy_linux_forbidden: Set[str] = set()
 65        self.kivy_win_allowed: Set[str] = set()
 66        self.kivy_win_forbidden: Set[str] = set()
 67        self.kivy_macosx_allowed: Set[str] = set()
 68        self.kivy_macosx_forbidden: Set[str] = set()
 69        self.kivy_ios_allowed: Set[str] = set()
 70        self.kivy_ios_forbidden: Set[str] = set()
 71        self.kivy_android_allowed: Set[str] = set()
 72        self.kivy_android_forbidden: Set[str] = set()
 73        self.kivy_unknown_allowed: Set[str] = set()
 74        self.kivy_unknown_forbidden: Set[str] = set()
 75
 76        self.kivy_target_linux_allowed: Set[str] = set()
 77        self.kivy_target_linux_forbidden: Set[str] = set()
 78        self.kivy_target_win_allowed: Set[str] = set()
 79        self.kivy_target_win_forbidden: Set[str] = set()
 80        self.kivy_target_macosx_allowed: Set[str] = set()
 81        self.kivy_target_macosx_forbidden: Set[str] = set()
 82        self.kivy_target_ios_allowed: Set[str] = set()
 83        self.kivy_target_ios_forbidden: Set[str] = set()
 84        self.kivy_target_android_allowed: Set[str] = set()
 85        self.kivy_target_android_forbidden: Set[str] = set()
 86        self.kivy_target_unknown_allowed: Set[str] = set()
 87        self.kivy_target_unknown_forbidden: Set[str] = set()
 88
 89        self.arch__x86__allowed: Set[str] = set()
 90        self.arch__x86__forbidden: Set[str] = set()
 91        self.arch__x86_64__allowed: Set[str] = set()
 92        self.arch__x86_64__forbidden: Set[str] = set()
 93        self.arch__x86_32__allowed: Set[str] = set()
 94        self.arch__x86_32__forbidden: Set[str] = set()
 95        self.arch__ARM__allowed: Set[str] = set()
 96        self.arch__ARM__forbidden: Set[str] = set()
 97        self.arch__ARM_8__allowed: Set[str] = set()
 98        self.arch__ARM_8__forbidden: Set[str] = set()
 99        self.arch__ARM_8_64__allowed: Set[str] = set()
100        self.arch__ARM_8_64__forbidden: Set[str] = set()
101        self.arch__ARM_8_32__allowed: Set[str] = set()
102        self.arch__ARM_8_32__forbidden: Set[str] = set()
103        self.arch__ARM_7__allowed: Set[str] = set()
104        self.arch__ARM_7__forbidden: Set[str] = set()
105
106        self._allowed: Set[str] = set()
107        self._forbidden: Set[str] = set()
108
109    def chosen_packages(self):
110        if IS_INSIDE_OR_FOR_WEB_BROWSER:
111            # Must be before other systems!
112            self._allowed.update(self.emscripten_allowed)
113            self._forbidden.update(self.emscripten_forbidden)
114        elif 'Linux' == OS_TYPE:
115            self._allowed.update(self.linux_allowed)
116            self._forbidden.update(self.linux_forbidden)
117        elif 'Windows' == OS_TYPE:
118            self._allowed.update(self.windows_allowed)
119            self._forbidden.update(self.windows_forbidden)
120        elif 'Darwin' == OS_TYPE:
121            self._allowed.update(self.osx_allowed)
122            self._forbidden.update(self.osx_forbidden)
123
124        if 'linux' == KIVY_PLATFORM:
125            self._allowed.update(self.kivy_linux_allowed)
126            self._forbidden.update(self.kivy_linux_forbidden)
127        elif 'win' == KIVY_PLATFORM:
128            self._allowed.update(self.kivy_win_allowed)
129            self._forbidden.update(self.kivy_win_forbidden)
130        elif 'macosx' == KIVY_PLATFORM:
131            self._allowed.update(self.kivy_macosx_allowed)
132            self._forbidden.update(self.kivy_macosx_forbidden)
133        elif 'ios' == KIVY_PLATFORM:
134            self._allowed.update(self.kivy_ios_allowed)
135            self._forbidden.update(self.kivy_ios_forbidden)
136        elif 'android' == KIVY_PLATFORM:
137            self._allowed.update(self.kivy_android_allowed)
138            self._forbidden.update(self.kivy_android_forbidden)
139        elif 'unknown' == KIVY_PLATFORM:
140            self._allowed.update(self.kivy_unknown_allowed)
141            self._forbidden.update(self.kivy_unknown_forbidden)
142
143        if 'linux' == KIVY_TARGET_PLATFORM:
144            self._allowed.update(self.kivy_target_linux_allowed)
145            self._forbidden.update(self.kivy_target_linux_forbidden)
146        elif 'win' == KIVY_TARGET_PLATFORM:
147            self._allowed.update(self.kivy_target_win_allowed)
148            self._forbidden.update(self.kivy_target_win_forbidden)
149        elif 'macosx' == KIVY_TARGET_PLATFORM:
150            self._allowed.update(self.kivy_target_macosx_allowed)
151            self._forbidden.update(self.kivy_target_macosx_forbidden)
152        elif 'ios' == KIVY_TARGET_PLATFORM:
153            self._allowed.update(self.kivy_target_ios_allowed)
154            self._forbidden.update(self.kivy_target_ios_forbidden)
155        elif 'android' == KIVY_TARGET_PLATFORM:
156            self._allowed.update(self.kivy_target_android_allowed)
157            self._forbidden.update(self.kivy_target_android_forbidden)
158        elif 'unknown' == KIVY_TARGET_PLATFORM:
159            self._allowed.update(self.kivy_target_unknown_allowed)
160            self._forbidden.update(self.kivy_target_unknown_forbidden)
161
162        arch = cpu_info().arch.casefold()
163        if cpu_info().is_x86:
164            self._allowed.update(self.arch__x86__allowed)
165            self._forbidden.update(self.arch__x86__forbidden)
166            if 'x86_64'.casefold() == arch:
167                self._allowed.update(self.arch__x86_64__allowed)
168                self._forbidden.update(self.arch__x86_64__forbidden)
169            elif 'x86_32'.casefold() == arch:
170                self._allowed.update(self.arch__x86_32__allowed)
171                self._forbidden.update(self.arch__x86_32__forbidden)
172        
173        if cpu_info().is_arm:
174            self._allowed.update(self.arch__ARM__allowed)
175            self._forbidden.update(self.arch__ARM__forbidden)
176            if 'ARM_8'.casefold() == arch:
177                self._allowed.update(self.arch__ARM_8__allowed)
178                self._forbidden.update(self.arch__ARM_8__forbidden)
179            elif ('ARM_8'.casefold() == arch) and (64 == cpu_info().bits):
180                self._allowed.update(self.arch__ARM_8_64__allowed)
181                self._forbidden.update(self.arch__ARM_8_64__forbidden)
182            elif ('ARM_8'.casefold() == arch) and (32 == cpu_info().bits):
183                self._allowed.update(self.arch__ARM_8_32__allowed)
184                self._forbidden.update(self.arch__ARM_8_32__forbidden)
185            elif 'ARM_7'.casefold() == arch:
186                self._allowed.update(self.arch__ARM_7__allowed)
187                self._forbidden.update(self.arch__ARM_7__forbidden)
188
189        modules = list()
190        modules += self.universal
191        if '2' == PYTHON_VERSION[0]:
192            if 'CPython' == PLATFORM_NAME:
193                modules += self.cpython2
194            elif 'PyPy' == PLATFORM_NAME:
195                modules += self.pypy2
196            modules += self.python2
197        if '3' == PYTHON_VERSION[0]:
198            if 'CPython' == PLATFORM_NAME:
199                modules += self.cpython3
200            elif 'PyPy' == PLATFORM_NAME:
201                modules += self.pypy3
202            modules += self.python3
203
204        modules.extend(self._allowed)
205
206        if self._forbidden:
207            new_modules = list()
208            for item in modules:
209                if item not in self._forbidden:
210                    new_modules.append(item)
211            modules = new_modules
212
213        return modules
214
215    def bulk_install(self):
216        modules = self.chosen_packages()
217        if modules:
218            print('INSTALLING: {}'.format(modules))
219            print()
220
221            for item in modules:
222                install(item, self.list_type)

list_type

python2

python3

cpython2

cpython3

pypy2

pypy3

universal

linux_allowed: Set[str]

linux_forbidden: Set[str]

windows_allowed: Set[str]

windows_forbidden: Set[str]

osx_allowed: Set[str]

osx_forbidden: Set[str]

emscripten_allowed: Set[str]

emscripten_forbidden: Set[str]

kivy_linux_allowed: Set[str]

kivy_linux_forbidden: Set[str]

kivy_win_allowed: Set[str]

kivy_win_forbidden: Set[str]

kivy_macosx_allowed: Set[str]

kivy_macosx_forbidden: Set[str]

kivy_ios_allowed: Set[str]

kivy_ios_forbidden: Set[str]

kivy_android_allowed: Set[str]

kivy_android_forbidden: Set[str]

kivy_unknown_allowed: Set[str]

kivy_unknown_forbidden: Set[str]

kivy_target_linux_allowed: Set[str]

kivy_target_linux_forbidden: Set[str]

kivy_target_win_allowed: Set[str]

kivy_target_win_forbidden: Set[str]

kivy_target_macosx_allowed: Set[str]

kivy_target_macosx_forbidden: Set[str]

kivy_target_ios_allowed: Set[str]

kivy_target_ios_forbidden: Set[str]

kivy_target_android_allowed: Set[str]

kivy_target_android_forbidden: Set[str]

kivy_target_unknown_allowed: Set[str]

kivy_target_unknown_forbidden: Set[str]

arch__x86__allowed: Set[str]

arch__x86__forbidden: Set[str]

arch__x86_64__allowed: Set[str]

arch__x86_64__forbidden: Set[str]

arch__x86_32__allowed: Set[str]

arch__x86_32__forbidden: Set[str]

arch__ARM__allowed: Set[str]

arch__ARM__forbidden: Set[str]

arch__ARM_8__allowed: Set[str]

arch__ARM_8__forbidden: Set[str]

arch__ARM_8_64__allowed: Set[str]

arch__ARM_8_64__forbidden: Set[str]

arch__ARM_8_32__allowed: Set[str]

arch__ARM_8_32__forbidden: Set[str]

arch__ARM_7__allowed: Set[str]

arch__ARM_7__forbidden: Set[str]

def chosen_packages(self): View Source

109    def chosen_packages(self):
110        if IS_INSIDE_OR_FOR_WEB_BROWSER:
111            # Must be before other systems!
112            self._allowed.update(self.emscripten_allowed)
113            self._forbidden.update(self.emscripten_forbidden)
114        elif 'Linux' == OS_TYPE:
115            self._allowed.update(self.linux_allowed)
116            self._forbidden.update(self.linux_forbidden)
117        elif 'Windows' == OS_TYPE:
118            self._allowed.update(self.windows_allowed)
119            self._forbidden.update(self.windows_forbidden)
120        elif 'Darwin' == OS_TYPE:
121            self._allowed.update(self.osx_allowed)
122            self._forbidden.update(self.osx_forbidden)
123
124        if 'linux' == KIVY_PLATFORM:
125            self._allowed.update(self.kivy_linux_allowed)
126            self._forbidden.update(self.kivy_linux_forbidden)
127        elif 'win' == KIVY_PLATFORM:
128            self._allowed.update(self.kivy_win_allowed)
129            self._forbidden.update(self.kivy_win_forbidden)
130        elif 'macosx' == KIVY_PLATFORM:
131            self._allowed.update(self.kivy_macosx_allowed)
132            self._forbidden.update(self.kivy_macosx_forbidden)
133        elif 'ios' == KIVY_PLATFORM:
134            self._allowed.update(self.kivy_ios_allowed)
135            self._forbidden.update(self.kivy_ios_forbidden)
136        elif 'android' == KIVY_PLATFORM:
137            self._allowed.update(self.kivy_android_allowed)
138            self._forbidden.update(self.kivy_android_forbidden)
139        elif 'unknown' == KIVY_PLATFORM:
140            self._allowed.update(self.kivy_unknown_allowed)
141            self._forbidden.update(self.kivy_unknown_forbidden)
142
143        if 'linux' == KIVY_TARGET_PLATFORM:
144            self._allowed.update(self.kivy_target_linux_allowed)
145            self._forbidden.update(self.kivy_target_linux_forbidden)
146        elif 'win' == KIVY_TARGET_PLATFORM:
147            self._allowed.update(self.kivy_target_win_allowed)
148            self._forbidden.update(self.kivy_target_win_forbidden)
149        elif 'macosx' == KIVY_TARGET_PLATFORM:
150            self._allowed.update(self.kivy_target_macosx_allowed)
151            self._forbidden.update(self.kivy_target_macosx_forbidden)
152        elif 'ios' == KIVY_TARGET_PLATFORM:
153            self._allowed.update(self.kivy_target_ios_allowed)
154            self._forbidden.update(self.kivy_target_ios_forbidden)
155        elif 'android' == KIVY_TARGET_PLATFORM:
156            self._allowed.update(self.kivy_target_android_allowed)
157            self._forbidden.update(self.kivy_target_android_forbidden)
158        elif 'unknown' == KIVY_TARGET_PLATFORM:
159            self._allowed.update(self.kivy_target_unknown_allowed)
160            self._forbidden.update(self.kivy_target_unknown_forbidden)
161
162        arch = cpu_info().arch.casefold()
163        if cpu_info().is_x86:
164            self._allowed.update(self.arch__x86__allowed)
165            self._forbidden.update(self.arch__x86__forbidden)
166            if 'x86_64'.casefold() == arch:
167                self._allowed.update(self.arch__x86_64__allowed)
168                self._forbidden.update(self.arch__x86_64__forbidden)
169            elif 'x86_32'.casefold() == arch:
170                self._allowed.update(self.arch__x86_32__allowed)
171                self._forbidden.update(self.arch__x86_32__forbidden)
172        
173        if cpu_info().is_arm:
174            self._allowed.update(self.arch__ARM__allowed)
175            self._forbidden.update(self.arch__ARM__forbidden)
176            if 'ARM_8'.casefold() == arch:
177                self._allowed.update(self.arch__ARM_8__allowed)
178                self._forbidden.update(self.arch__ARM_8__forbidden)
179            elif ('ARM_8'.casefold() == arch) and (64 == cpu_info().bits):
180                self._allowed.update(self.arch__ARM_8_64__allowed)
181                self._forbidden.update(self.arch__ARM_8_64__forbidden)
182            elif ('ARM_8'.casefold() == arch) and (32 == cpu_info().bits):
183                self._allowed.update(self.arch__ARM_8_32__allowed)
184                self._forbidden.update(self.arch__ARM_8_32__forbidden)
185            elif 'ARM_7'.casefold() == arch:
186                self._allowed.update(self.arch__ARM_7__allowed)
187                self._forbidden.update(self.arch__ARM_7__forbidden)
188
189        modules = list()
190        modules += self.universal
191        if '2' == PYTHON_VERSION[0]:
192            if 'CPython' == PLATFORM_NAME:
193                modules += self.cpython2
194            elif 'PyPy' == PLATFORM_NAME:
195                modules += self.pypy2
196            modules += self.python2
197        if '3' == PYTHON_VERSION[0]:
198            if 'CPython' == PLATFORM_NAME:
199                modules += self.cpython3
200            elif 'PyPy' == PLATFORM_NAME:
201                modules += self.pypy3
202            modules += self.python3
203
204        modules.extend(self._allowed)
205
206        if self._forbidden:
207            new_modules = list()
208            for item in modules:
209                if item not in self._forbidden:
210                    new_modules.append(item)
211            modules = new_modules
212
213        return modules

def bulk_install(self): View Source

215    def bulk_install(self):
216        modules = self.chosen_packages()
217        if modules:
218            print('INSTALLING: {}'.format(modules))
219            print()
220
221            for item in modules:
222                install(item, self.list_type)