def test_operator03(self):
"- operator"
s3 = OrderedSet('Groening') | OrderedSet('Simpsons')
self.assertIsInstance(s3, OrderedSet)
self.assertEqual(['G', 'r', 'o', 'e', 'n', 'i', 'g', 'S', 'm', 'p', 's'],
list(s3)
)
def test_pop02(self):
s = OrderedSet('Futurama')
self.assertEqual('m', s.pop())
self.assertListEqual(['F', 'u', 't', 'r', 'a'], [*s])
self.assertEqual('F', s.pop(last=False))
self.assertListEqual(['u', 't', 'r', 'a'], [*s])
def test_operator01(self):
"| operator and __eq__."
s3 = OrderedSet('Futurama') | OrderedSet('Simpsons')
self.assertIsInstance(s3, OrderedSet)
content = ['F', 'u', 't', 'r', 'a', 'm', 'S', 'i', 'p', 's', 'o', 'n']
self.assertListEqual(content, [*s3])
self.assertEqual(OrderedSet(content), s3)
new_content = [*content]
new_content[3], new_content[4] = new_content[4], new_content[3]
self.assertNotEqual(OrderedSet(new_content), s3)
self.assertNotEqual(OrderedSet(content[:-1]), s3)
def _mapper(self, header):
columns = self.columns
defaults = self.defaults
# column_keys = frozenset(h.lower() for h in columns)
column_keys = OrderedSet(h.lower()
for h in columns) # TODO: OrderedFrozenSet
row_keys = frozenset(k.lower() for k in header)
missings = []
constants = {}
indices = [(key, index) for index, key in enumerate(header)
if key in column_keys]
for key in column_keys:
if key not in row_keys:
try:
constants[key] = defaults[key]
except KeyError:
missings.append(key)
if missings:
raise self.ParseError(
"Following columns are missing and haven't got any default value : {}"
.format(missings))
def _aux(row):
data = {
key: row[index] or defaults.get(key)
for key, index in indices
}
data.update(constants)
return data
return _aux
def __init__(self, allowed_variables=(), message=None, code=None):
self.allowed_variables = OrderedSet(allowed_variables)
if message is not None:
self.message = message
if code is not None:
self.code = code
self._help_text = lazy(
(lambda: gettext('You can use variables: {}').format(
' '.join('{{%s}}' % var
for var in self._allowed_variables), )), str)()
def test_discard(self):
s = OrderedSet('Futurama')
with self.assertNoException():
s.discard('z')
s.discard('a')
self.assertListEqual(['F', 'u', 't', 'r', 'm'], [*s])
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
instance = self.instance
selected_fnames = [sf.name for sf in instance.searchfields]
# TODO: work with Fields instead of Field names + split()...
not_hiddable_fnames = OrderedSet(
fname.split('__', 1)[0] for fname in selected_fnames)
is_hidden = FieldsConfig.get_4_model(
instance.content_type.model_class()).is_fieldname_hidden
def keep_field(name):
root_name = name.split('__', 1)[0]
return not is_hidden(root_name) or root_name in not_hiddable_fnames
fields_f = self.fields['fields']
fields_f.choices = [
choice for choice in self.instance.get_modelfields_choices()
if keep_field(choice[0])
]
fields_f.initial = selected_fnames
def test_repr(self):
self.assertEqual('OrderedSet()', repr(OrderedSet()))
self.assertEqual("OrderedSet(['F', 'r', 'y'])",
repr(OrderedSet('Fry')))
def test_pop01(self):
with self.assertRaises(KeyError):
OrderedSet().pop()
def test_reversed(self):
s = OrderedSet('Futurama')
self.assertListEqual(['m', 'a', 'r', 't', 'u', 'F'], [*reversed(s)])
def test_eq(self):
"__eq__ with a list"
s = OrderedSet('Futurama')
self.assertEqual(s, ['F', 'u', 't', 'r', 'a', 'm'])
self.assertEqual(s, ['u', 't', 'r', 'a', 'm', 'F'])
self.assertNotEqual(s, ['u', 't', 'r', 'a', 'm'])
def test_operator02(self):
"& operator."
s3 = OrderedSet('Groening') & OrderedSet('Simpsons')
self.assertIsInstance(s3, OrderedSet)
self.assertListEqual(['i', 'o', 'n'], [*s3])
def test_main(self):
s1 = OrderedSet('Futurama')
self.assertListEqual(['F', 'u', 't', 'r', 'a', 'm'], [*s1])
s2 = OrderedSet([2, 1, 6, 5, 4, 6, 5, 4, 2, 1])
self.assertListEqual([2, 1, 6, 5, 4], [*s2])
def handle(self, *app_labels, **options):
verbosity = options.get('verbosity')
# eg: 'persons', 'creme_core'...
all_apps = OrderedSet(app_config.label
for app_config in creme_app_configs())
apps_2_populate = all_apps if not app_labels else \
[_checked_app_label(app, all_apps) for app in app_labels]
# ----------------------------------------------------------------------
populators = []
populators_names = set() # Names of populators that will be run
total_deps = set(
) # Populators names that are needed by our populators
total_missing_deps = set() # All populators names that are added by
# this script because of dependencies
while True:
changed = False
for app_label in apps_2_populate:
populator = self._get_populator(app_label=app_label,
verbosity=verbosity,
all_apps=all_apps,
options=options)
if populator is not None:
populators.append(populator)
populators_names.add(app_label)
total_deps.update(populator.dependencies)
changed = True
if not changed: break
apps_2_populate = total_deps - populators_names
total_missing_deps |= apps_2_populate
if total_missing_deps and verbosity >= 1:
self.stdout.write(
'Additional dependencies will be populated: {}'.format(
', '.join(total_missing_deps)), self.style.NOTICE)
# Clean the dependencies (avoid dependencies that do not exist in
# 'populators', which would cause Exception raising)
for populator in populators:
populator.build_dependencies(populators_names)
populators = dependence_sort(
populators,
BasePopulator.get_app,
BasePopulator.get_dependencies,
)
# ----------------------------------------------------------------------
self.models = set()
dispatch_uid = 'creme_core-populate_command'
pre_save.connect(self._signal_handler, dispatch_uid=dispatch_uid)
for populator in populators:
if verbosity >= 1:
self.stdout.write('Populate "{}" ...'.format(populator.app),
ending='')
self.stdout.flush()
try:
populator.populate()
except Exception as e:
self.stderr.write(' Populate "{}" failed ({})'.format(
populator.app, e))
if verbosity >= 1:
exc_type, exc_value, exc_traceback = sys.exc_info()
self.stderr.write(''.join(
format_exception(exc_type, exc_value, exc_traceback)))
if verbosity >= 1:
self.stdout.write(' OK', self.style.SUCCESS)
pre_save.disconnect(dispatch_uid=dispatch_uid)
# ----------------------------------------------------------------------
if self.models:
if verbosity >= 1:
self.stdout.write(
'Update sequences for models : {}'.format(
[model.__name__ for model in self.models]),
ending='',
)
self.stdout.flush()
connection = connections[options.get('database', DEFAULT_DB_ALIAS)]
cursor = connection.cursor()
for line in connection.ops.sequence_reset_sql(
no_style(), self.models):
cursor.execute(line)
# connection.close() #seems useless (& does not work with mysql)
if verbosity >= 1:
self.stdout.write(self.style.SUCCESS(' OK'))
elif verbosity >= 1:
self.stdout.write('No sequence to update.')
if verbosity >= 1:
self.stdout.write(self.style.SUCCESS('Populate is OK.'))
################################################################################
from collections import defaultdict
from copy import deepcopy
import logging # warnings
from django.conf import settings
from django.core.exceptions import ImproperlyConfigured
from django.core.serializers.base import DeserializationError
from django.core.serializers.python import _get_model
from creme.creme_core.utils.collections import OrderedSet
from creme.creme_core.utils.imports import import_apps_sub_modules
logger = logging.getLogger(__name__)
ALLOWED_ID_CHARS = OrderedSet('abcdefghijklmnopqrstuvwxyz'
'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_.')
class FetcherInterface:
"""Multiple fetchers of the same "type" (i.e: pop email, imap email...) could
be registered with the same key in CRUDityRegistry.
FetcherInterface abstract those to act like one fetcher.
"""
def __init__(self, fetchers):
self.fetchers = list(fetchers)
self._inputs = defaultdict(dict)
self._default_backend = None
def add_fetchers(self, fetchers):
self.fetchers.extend(fetchers)
def allowed_variables(self, variables):
self._allowed_variables = OrderedSet(variables)
