Retrieve a named propagator

    Args:
        name (str): Name of the desired propagator
    Return:
        Propagator class
330449
def get_propagator(name):
    

    from .sgp4 import Sgp4
    from .sgp4beta import Sgp4Beta

    scope = locals().copy()
    scope.update(globals())

    if name not in scope:
        raise UnknownPropagatorError(name)

    return scope[name]
946599
def get_logger_by_name(name=None, rand_name=False, charset=Charset.HEX):
    
    if rand_name:
        name = rand_str(charset)
    logger = logging.getLogger(name)
    return logger
851948
def get_by_name(self, name):
        
        scopes = self._client.get_all()
        result = [x for x in scopes if x['name'] == name]
        return result[0] if result else None
1310376
def get_by_name(self, name): # pylint: disable=invalid-name,redefined-builtin
        
        rs, _ = self.list(filter=field('name').eq(name), limit=1)
        if len(rs) is 0:
            raise CDRouterError('no such device')
        return rs[0]
929141
def get(self, name):
        
        # read the attribute
        attr = getattr(self.context, name, None)
        if callable(attr):
            return attr()
        return attr
7640
def _get_column(cls, name):
        
        if name == 'pk':
            return cls._meta.get_field(cls._meta.pk.name)
        return cls._columns[name]
413916
def instantiate_by_name(self, object_name):
        
        if object_name not in self.instances:
            instance = self.instantiate_from_data(self.environment[object_name])

            self.instances[object_name] = instance
            return instance
        else:
            return self.instances[object_name]
194337
def getParameter(self, name):
        
        return lock_and_call(
            lambda: Parameter(self._impl.getParameter(name)),
            self._lock
        )
723596
def get_methods_by_name(self, name):
        

        return (m for m in self.methods if m.get_name() == name)
494234
def find(cls, name):
        
        try:
            return cls._member_map_[name]
        except KeyError:
            for ctype in cls._member_map_.values():
                if ctype.name == name:
                    return ctype
            raise ValueError('%s is not a valid %s' % (name, cls.__name__))
540821
def get(self, name=None):
        
        if name is None:
            return self._classes
        else:
            if name not in self._classes.keys():
                return None
            else:
                return self._classes[name]
638982
def load_class_by_name(name: str):
    """"""
    mod_path, _, cls_name = name.rpartition('.')
    mod = importlib.import_module(mod_path)
    cls = getattr(mod, cls_name)
    return cls
518767
def GetValueByName(self, name):
    
    if not self._registry_key and self._registry:
      self._GetKeyFromRegistry()

    if not self._registry_key:
      return None

    return self._registry_key.GetValueByName(name)
168905
def lpop(self, name):
        
        with self.pipe as pipe:
            f = Future()
            res = pipe.lpop(self.redis_key(name))

            def cb():
                f.set(self.valueparse.decode(res.result))

            pipe.on_execute(cb)
            return f
891290
def get_variable(self, name):
        
        name = get_op_tensor_name(name)[1]
        if len(self.vs_name):
            name_with_vs = self.vs_name + "/" + name
        else:
            name_with_vs = name
        return get_op_or_tensor_by_name(name_with_vs)
514035
def get_value(self, name):
        
        # first clean up the name
        name = self._clean_up_name(name)

        # now get the parameter object
        x = self._find_parameter(name.split('/'))

        # quit if it pooped.
        if x == None: return None

        # get the value and test the bounds
        value  = x.value()
        
        # handles the two versions of pyqtgraph
        bounds = None
    
        # For lists, just make sure it's a valid value
        if x.opts['type'] == 'list':

            # If it's not one from the master list, choose
            # and return the default value.            
            if not value in x.opts['values']:
                
                # Only choose a default if there exists one                
                if len(x.opts('values')):                              
                    self.set_value(name, x.opts['values'][0])                
                    return x.opts['values'][0]
                
                # Otherwise, just return None and do nothing                
                else: return None

        # For strings, make sure the returned value is always a string.
        elif x.opts['type'] in ['str']: return str(value)
                
        # Otherwise assume it is a value with bounds or limits (depending on 
        # the version of pyqtgraph)    
        else:        
            if   'limits' in x.opts: bounds = x.opts['limits']
            elif 'bounds' in x.opts: bounds = x.opts['bounds']
            if not bounds == None:
                if not bounds[1]==None and value > bounds[1]: value = bounds[1]
                if not bounds[0]==None and value < bounds[0]: value = bounds[0]
            
        # return it        
        return value
782778
def get_argument(self, name):
        """"""
        val = self.arguments.get(name)
        if val:
            return val[0]
        return None