Exemple #1
0
 public Model(ModelArgs args)
     : base(args)
 {
     _init_batch_counters();
 }
Exemple #2
0
 public Model(ModelArgs args)
     : base(args)
 {
 }
        protected virtual bool TrySetValueInternal(string memberName, ModelArgs args, object value)
        {
            PropertyInfo pi = GetModelPropertyInfo(memberName);
            Field field = value as Field;

            if (CanConfigure)
            {
                if (field == null)
                    throw new Exception("value must be of type <Field> inside the Configure function.");

                if (_fields.ContainsKey(memberName))
                    throw new Exception(string.Format("Field {0} already set.", memberName));

                field.Name = memberName;
                _fields.Add(field.Name, field);
                if (pi == null)
                    _fieldValues.Add(field.Name, null);
            }
            else
            {
                if (field != null)
                    throw new Exception("Can't add fields outside the Configure function.");

                if(pi == null && !_fields.ContainsKey(memberName))
                    throw new Exception(string.Format("Field {0} not found.", memberName));

                if(pi != null)
                    pi.SetValue(this, value, null);
                else
                    _fieldValues[memberName] = value;
            }

            return true;
        }
        protected virtual bool TryGetValueInternal(string memberName, ModelArgs args, out object result)
        {
            // DynamicModel property
            if (memberName == "Fields")
            {
                result = Fields;
                return true;
            }
            // DynamicModel property
            else if (memberName == "ModelName")
            {
                result = ModelName;
                return true;
            }
            else
            {
                PropertyInfo pi = GetModelPropertyInfo(memberName);

                if (!_fields.ContainsKey(memberName))
                {
                    if (pi != null)
                    {
                        result = pi.GetValue(this, null);
                        return true;
                    }
                    else
                    {
                        return GetDynamicQueryResult(memberName, args, out result);
                    }
                }
                else
                {
                    if (CanConfigure)
                        result = _fields[memberName];
                    else
                    {
                        if (_fields[memberName].FieldType == FieldType.ManyToMany)
                            return GetDynamicQueryResult(memberName, args, out result);

                        if (pi != null)
                            result = pi.GetValue(this, null);
                        else
                            result = _fieldValues[memberName];
                    }

                    return true;
                }
            }
        }
 protected virtual bool GetDynamicQueryResult(string query, ModelArgs args, out object result)
 {
     result = null;
     return false;
 }
Exemple #6
0
 public Linear(ModelArgs args) : base(args)
 {
     dense = keras.layers.Dense(1, activation: null,
                                kernel_initializer: tf.zeros_initializer, bias_initializer: tf.zeros_initializer);
     StackLayers(dense);
 }
Exemple #7
0
        protected override bool GetDynamicQueryResult(string query, ModelArgs args, out object result)
        {
            ModelInfo relatedModelInfo = null;
            string relatedModelField = null;
            IModel joinedModel = null;
            string joinedField = null;
            string joinConditionField = null;

            if (query != null)
            {
                Field field = GetField(query);
                if (field != null && field.FieldType == FieldType.ManyToMany)
                {
                    ManyToManyField m2mField = (ManyToManyField)field;
                    relatedModelInfo = OrmManager.GetModelInfo(m2mField.ReferencedType);
                    relatedModelField = relatedModelInfo.PKField.DbName;
                    joinedModel = OrmManager.GetModelInfo(m2mField.IntermediaryModel);
                    joinedField = joinedModel.GetForeignKeyField(relatedModelInfo.ModelType).DbName;
                    joinConditionField = joinedModel.GetForeignKeyField(ModelType).DbName;
                }
                else
                {
                    string[] qSplit = query.Split('_');
                    if (qSplit.Length == 2)
                    {
                        string queryExpr = qSplit[1].ToLower();
                        if (queryExpr == "set")
                        {
                            string relatedModelName = qSplit[0];
                            relatedModelInfo = OrmManager.GetModelInfo(relatedModelName);

                            // case reverse m2m
                            FieldInfo m2mInfo = relatedModelInfo.GetManyToManyField(ModelType);

                            if (m2mInfo != null)
                            {
                                relatedModelField = relatedModelInfo.PKField.DbName;
                                joinedModel = OrmManager.GetModelInfo(m2mInfo.IntermediaryModel);
                                joinedField = joinedModel.GetForeignKeyField(relatedModelInfo.ModelType).DbName;
                                joinConditionField = joinedModel.GetForeignKeyField(ModelType).DbName;
                            }
                            else
                            {
                                // case reverse FK
                                FieldInfo fkInfo = relatedModelInfo.GetForeignKeyField(ModelType);
                                if (fkInfo != null)
                                {
                                    relatedModelField = fkInfo.DbName;
                                    joinedModel = this;
                                    joinedField = PKField.DbName;
                                    joinConditionField = joinedField;
                                }
                            }
                        }
                    }
                }

                if (joinedModel != null)
                {
                    Manager relatedManager = new Orm.Manager(relatedModelInfo.ModelType);
                    relatedManager.PreFilter = new Queryset(relatedManager);
                    relatedManager.PreFilter.Join(
                        relatedModelField,
                        joinedModel,
                        joinedField,
                        QueryJoin.JoinType.INNER,
                        new AndExprGroup().Add(joinConditionField, Constants.QueryCompareOps.EXACT, PK));

                    result = relatedManager.CreateQuerySet();
                    return true;
                }
            }

            result = null;
            return false;
        }