def map(self, name, properties, connection_type='input', verbose=False):
# connection properties
max_connections = properties.pop('max_connections', 1)
attr_type = None
#print('- Mapping: "%s.%s": ' % (self.name, name)
#print(json.dumps(properties, indent=5)
pdict = dict()
# attribute properties (ie 'label', 'desc', 'connection_type')
for property_name in properties:
#print(' - updating property: "%s.%s:%s' % (self.name, name, property_name)
pattrs = properties.get(property_name)
#print('# DEBUG: pattrs: ', pattrs
if not util.is_dict(pattrs):
continue
property_value = pattrs.get('value')
property_type = pattrs.get('type')
if property_name == 'default':
attr_type = property_type.lower()
#print('# DEBUG: "%s.%s" default: "%s"' % (self.name, name, attr_type.upper())
# {'label': 'Name'}
pdict[property_name] = property_value
pdict['attr_type'] = attr_type
return self.add_attr(name,
connectable=True,
connection_type=connection_type,
max_connections=max_connections,
user=False,
**pdict)
def testIsDict(self):
self.assertFalse(util.is_dict([]))
self.assertTrue(util.is_dict({}))
self.assertFalse(util.is_dict(set()))
self.assertFalse(util.is_dict(()))
self.assertFalse(util.is_dict(42))
self.assertFalse(util.is_dict('dict?'))
self.assertFalse(util.is_dict(object))
def testIsDict(self):
self.assertFalse(util.is_dict([]))
self.assertTrue(util.is_dict({}))
self.assertFalse(util.is_dict(set()))
self.assertFalse(util.is_dict(()))
self.assertFalse(util.is_dict(42))
self.assertFalse(util.is_dict('dict?'))
self.assertFalse(util.is_dict(object))
def sentence_get_from_result_oop(Prg,
Result,
ReturnType="separated_subsentences",
ColorBefore=None,
ColorAfter=None,
ColorDetected=None,
ColorResultNum=None,
RowNumDisplayed=None,
WordsDetected=set()):
Url, Txt, Source = sentence_text_from_obj(Prg,
Result,
ReturnType=ReturnType)
if util.is_dict(Txt):
Sentence = SentenceObj(ColorBasic=ColorBefore,
ColorAfter=ColorAfter,
ColorDetected=ColorDetected,
ColorResultNum=ColorResultNum,
RowNumDisplayed=RowNumDisplayed,
WordsDetected=WordsDetected,
Url=Url,
Source=Source,
Prg=Prg)
Sentence.add_big_string(Txt["subsentences_before"])
Sentence.add_big_string(Txt["subsentence_result"])
Sentence.add_big_string(Txt["subsentences_after"])
return Sentence
else:
return SentenceObj(Txt,
ColorBasic=ColorBefore,
ColorAfter=ColorAfter,
ColorDetected=ColorDetected,
ColorResultNum=ColorResultNum,
RowNumDisplayed=RowNumDisplayed,
WordsDetected=WordsDetected,
Url=Url,
Source=Source,
Prg=Prg)
def buildConnections(self, verbose=False):
if verbose:
print('\n# %s:"%s":' % (self.Class(), self.name))
for section in self._metadata.data:
if verbose:
print(' Section: "%s":' % (section))
attributes = self._metadata.data.get(section)
for attr_name in attributes:
# parse connections
properties = attributes.get(attr_name)
attr_label = 'Attribute'
is_connection = False
conn_type = None
required = False
attr_type = None
if 'connectable' in properties:
if 'connection_type' in properties:
if properties.get('connectable'):
is_connection = True
conn_type = properties.get('connection_type')
#print(' -> connection "%s" type: %s' % (attr_name, conn_type)
if conn_type == 'input':
attr_label = "Input"
if conn_type == 'output':
attr_label = "Output"
# parse defaults (type, value)
if 'default' in properties:
defaults = properties.get('default')
attr_type = defaults.get('type')
# parse required
if 'required' in properties:
required = properties.get('required', False)
if required:
attr_label = '*%s' % attr_label
if verbose:
print(' "%s: %s"' % (attr_label, attr_name))
print(' "attr_type": "%s"' % attr_type)
# build connections
if is_connection:
attr_node = self.map(attr_name,
properties,
connection_type=conn_type)
if not attr_node:
if verbose:
print('no node...')
continue
# parse properties of attribute/connection
# MAPPING:
# name -> name
# type -> attr_type (lower)
# default -> default_value
# label -> label
mapping = dict()
for pname in properties:
if verbose:
print(' "%s:"' % pname)
pvalue = properties.get(pname)
if not util.is_dict(pvalue):
#print(' bool attribute: "%s.%s"' % (attr_name, pname)
continue
for pattr in pvalue:
pval = pvalue.get(pattr)
if verbose:
if pval:
print(' "%s": %s' % (pattr, pval))
if verbose:
print('\n')
def test_neg_dicts( self ):
self.assertFalse( util.is_dict( ["foo","bar"] ) )
def test_positive_types( self ):
self.assertTrue( util.is_string( "abcd" ) )
self.assertTrue( util.is_boolean( True ) )
self.assertTrue( util.is_integer( 1234 ) )
self.assertTrue( util.is_list( [1,2,3,4]) )
self.assertTrue( util.is_dict( {"foo":"bar"} ) )