def getFlatObject(self, schema=None): ''' return flat object with static properties and last existing value of dyn props ''' data = {} hybrid_properties = list(get_hybrid_properties(self.__class__).keys()) # if self.ID is not None: max_iter = max(len(self.__table__.columns), len( self.__properties__), len(hybrid_properties)) for i in range(max_iter): # Get static Properties try: curStatProp = list(self.__table__.columns)[i] data[curStatProp.key] = self.getProperty( curStatProp.key) except: pass # Get dynamic Properties try: curDynPropName = list(self.__properties__)[i] data[curDynPropName] = self.getProperty(curDynPropName) except Exception as e: pass try: PropName = hybrid_properties[i] data[PropName] = self.getProperty(PropName) except Exception as e: pass # if not schema and hasattr(self, 'getForm'): # schema = self.getForm()['schema'] if schema: data = formatValue(data, schema) return data
def to_json(inst, cls): """ Jsonify the sql alchemy query result. """ convert = dict() # add your coversions for things like datetime's # and what-not that aren't serializable. d = dict() for c in cls.__table__.columns: v = getattr(inst, c.name) if c.type in convert.keys() and v is not None: try: d[c.name] = convert[c.type](v) except: d[c.name] = "Error: Failed to covert using ", str( convert[c.type]) elif v is None: d[c.name] = str() else: d[c.name] = v for c in get_hybrid_properties(cls): v = getattr(inst, c) d[c] = v return d
def info(ctx, table, filter_): """ Print table summary information """ import sqlalchemy_utils as sau from ..db import construct_filter db = _db_from_ctx(ctx) echoer = cliutils.Echoer(logging.getLogger("tilez")) echoer.info("Information about: {}".format(table)) query = construct_filter(db.session.query(table), filter_) echoer.process("Number of entries: {}".format(query.count())) # Diagnostic info about table template = "{idx: <10} {name: <20}{type: <15}" echoer.process("Enumerating columns in table: {}".format(table)) echoer.item( "{idx: <10} {name: <20}{type: <30}".format(idx="COLUMN #", name="NAME", type="TYPE"), bold=True, underline=True ) for idx, col in enumerate(sau.get_columns(table).values()): echoer.item( template.format( **{ "idx": "Col {0:02d}".format(idx), "name": '"{}"'.format(col.name), "type": "{type} {pk}".format(type=col.type, pk="(PRIMARY KEY)" if col.primary_key else ""), } ) ) for idx, (name, col) in enumerate(six.iteritems(sau.get_hybrid_properties(table))): echoer.item(template.format(**{"idx": "HYBRID {0:02d}".format(idx), "name": '"{}"'.format(name), "type": "?"}))
def is_hybrid(self): if self._in_form(): model = self.parent._marvinform._param_form_lookup[ self.full].Meta.model hybrids = get_hybrid_properties(model).keys() return self.db_column in hybrids return None
def getFlatObject(self, schema=None): ''' return flat object with static properties and last existing value of dyn props ''' data = {} hybrid_properties = list(get_hybrid_properties(self.__class__).keys()) if self.ID is not None: max_iter = max(len(self.__table__.columns), len( self.__properties__), len(hybrid_properties)) for i in range(max_iter): # Get static Properties try: curStatProp = list(self.__table__.columns)[i] data[curStatProp.key] = self.getProperty( curStatProp.key) except: pass # Get dynamic Properties try: curDynPropName = list(self.__properties__)[i] data[curDynPropName] = self.getProperty(curDynPropName) except Exception as e: pass try: PropName = hybrid_properties[i] data[PropName] = self.getProperty(PropName) except Exception as e: pass if not schema and hasattr(self, 'getForm'): schema = self.getForm()['schema'] if schema: data = formatValue(data, schema) return data
def adapt_attribute(self, attr_name): cols = get_attrs(self.from_obj) hybrids = get_hybrid_properties(self.model).keys() if attr_name in hybrids: return ClauseAdapter(self.from_obj).traverse( getattr(self.model, attr_name)) else: return getattr(cols, attr_name)
def as_dict(self): hybrid_properties = list(get_hybrid_properties(self.__class__).keys()) values = {c.key: getattr(self, c.key) for c in inspect(self).mapper.column_attrs} for propName in hybrid_properties: values[propName] = getattr(self, propName) return values
def adapt_attribute(self, attr_name): cols = get_attrs(self.from_obj) hybrids = get_hybrid_properties(self.model).keys() if attr_name in hybrids: return ClauseAdapter(self.from_obj).traverse( getattr(self.model, attr_name) ) else: return getattr(cols, attr_name)
def validate_fields(self, fields): descriptors = get_all_descriptors(self.from_obj) hybrids = get_hybrid_properties(self.model) expressions = self.column_property_expressions for field in fields: if field in hybrids or field in expressions: continue self.validate_field(field, descriptors)
def adapt_attribute(self, attr_name): cols = get_attrs(self.from_obj) hybrids = get_hybrid_properties(self.model).keys() if (attr_name in hybrids or attr_name in self.column_property_expressions): column = adapt(self.from_obj, getattr(self.model, attr_name)) else: column = getattr(cols, attr_name) return self.format_column(column)
def adapted_descriptors(self): return ( get_all_descriptors(self.from_obj).items() + [ ( key, ClauseAdapter(self.from_obj).traverse( getattr(self.model, key) ) ) for key in get_hybrid_properties(self.model).keys() ] )
def adapt_attribute(self, attr_name): cols = get_attrs(self.from_obj) hybrids = get_hybrid_properties(self.model).keys() if ( attr_name in hybrids or attr_name in self.column_property_expressions ): column = ClauseAdapter(self.from_obj).traverse( getattr(self.model, attr_name) ) else: column = getattr(cols, attr_name) return self.format_column(column)
def GetFlatObject(self, schema=None): ''' return flat object with static properties and last existing value of dyn props ''' resultat = {} hybrid_properties = list(get_hybrid_properties(self.__class__).keys()) if self.ID is not None: max_iter = max(len(self.__table__.columns), len(self.PropDynValuesOfNow), len(hybrid_properties)) for i in range(max_iter): #### Get static Properties #### try: curStatProp = list(self.__table__.columns)[i] resultat[curStatProp.key] = self.GetProperty( curStatProp.key) except: pass #### Get dynamic Properties #### try: curDynPropName = list(self.PropDynValuesOfNow)[i] resultat[curDynPropName] = self.GetProperty(curDynPropName) except Exception as e: pass try: PropName = hybrid_properties[i] resultat[PropName] = self.GetProperty(PropName) except Exception as e: pass else: max_iter = len(self.__table__.columns) for i in range(max_iter): #### Get static Properties #### try: curStatProp = list(self.__table__.columns)[i] curVal = self.GetProperty(curStatProp.key) if curVal is not None: resultat[curStatProp.key] = self.GetProperty( curStatProp.key) except: pass # Add TypeName in JSON # resultat['TypeName'] = self.GetType().Name return resultat
def test_declarative_model(self): assert (list(get_hybrid_properties( self.Category).keys()) == ['lowercase_name'])
def test_aliased_class(self): assert (list( get_hybrid_properties(sa.orm.aliased( self.Category)).keys()) == ['lowercase_name'])
def test_aliased_class(self, Category): props = get_hybrid_properties(sa.orm.aliased(Category)) assert list(props.keys()) == ['lowercase_name']
def test_declarative_model(self, Category): assert ( list(get_hybrid_properties(Category).keys()) == ['lowercase_name'] )
def as_dict(self): d = {c.name: getattr(self, c.name) for c in self.__table__.columns} d.update({col: getattr(self, col) for col in get_hybrid_properties(Indicator).keys()}) return d
def validate_fields(self, fields): descriptors = get_all_descriptors(self.from_obj) for field in fields: if field in get_hybrid_properties(self.model): continue self.validate_field(field, descriptors)
def test_aliased_class(self): assert ( list(get_hybrid_properties(sa.orm.aliased(self.Category)).keys()) == ['lowercase_name'] )
def test_mapper(self): assert (list(get_hybrid_properties(sa.inspect( self.Category)).keys()) == ['lowercase_name'])
def test_mapper(self, Category): assert ( list(get_hybrid_properties(sa.inspect(Category)).keys()) == ['lowercase_name'] )