Gets the model from a given key.
557977
def get_model_from_key(key):
    """"""
    _known_models = {}
    model_name = key.split(':', 2)[0]
    # populate
    for klass in Model.__subclasses__():
        _known_models[klass.__name__] = klass
    return _known_models.get(model_name, None)
242464
def get(self, key):
    '''
    '''
    path = self.object_path(key)
    return self._read_object(path)
250025
def get(self, key):
        """"""
        doc = self._collection.find_one({'_id': key})
        if doc:
            doc.pop('_id')
            return doc
232999
def get_model(obj):
    
    p = obj
    while hasattr(p, 'parent'):
        p = p.parent
    return p
936288
def from_dict(cls: typing.Type[T], dikt) -> T:
        """"""
        return util.deserialize_model(dikt, cls)
690898
function getModel(model) {
  const schemaPaths = model.schema.paths;
  const name = model.modelName;

  const fields = extractPaths(schemaPaths, { name });

  return {
    name,
    fields,
    model
  };
}
660453
def _get(self, key):
        """"""
        self._populate_cache()
        if key not in self._cache:
            raise AttributeError("DataField has no member {}".format(key))

        return self._cache[key]
61967
public Object get(Object key) {
        Object value = mCacheMap.get(key);
        if (value != null || mCacheMap.containsKey(key)) {
            return value;
        }
        value = mBackingMap.get(key);
        if (value != null || mBackingMap.containsKey(key)) {
            mCacheMap.put(key, value);
        }
        return value;
    }
1274213
def get_one(self, key):
        
        query = build_db_query(self.primary_key, key)
        collection = self.ds.connection(self.collection_name)

        document = collection.find_one(query)
        if document is None:
            raise LookupError('{0} with key {1} was not found'.format(self.model_klass.__name__, query))
        return self.model_klass.from_json(document)
479626
def get_model(name):
    

    model = MODELS.get(name.lower(), None)

    assert model, "Could not locate model by name '%s'" % name

    return model
948035
def getattr(self, key):
		
		if key in _MethodFactoryMeta[self.classId]:
			""" property exists """
			return self.__dict__[key]
		else:
			""" property does not exist """
			return None
1100589
def get(self, key, failobj=None, exact=0):
        """"""
        if not exact:
            key = self.getfullkey(key,new=1)
        return self.data.get(key,failobj)
516142
public static function find($key)
    {
        $instance = new static;

        $model = $instance->newQuery()->id($key)->take(1)->first();

        if ($model) {
            $model->exists = true;
        }

        return $model;
    }
975664
@SuppressWarnings("unchecked")
  @Nullable
  public <T> T get(Key<T> key) {
    return (T) data.get(key);
  }
1369843
def get(self, key: Any, default: Any=None) -> Any:
        ''''''

        return self.data.get(key, default)
1041787
def get_model(method):
    """"""

    @wraps(method)
    def wrapper(migrator, model, *args, **kwargs):
        if isinstance(model, str):
            return method(migrator, migrator.orm[model], *args, **kwargs)
        return method(migrator, model, *args, **kwargs)
    return wrapper
927078
def get(self, key, key_length=0):
        
        if key_length < 1:
            key_length = len(key)
        return self.get_method(self, key, key_length)