refactorign

Author: latentvector

commune/key/app.py

@@ -5,6 +5,7 @@ class KeyDashboard(c.Module):
 
     def __init__(self, state: dict=None):
 
+
         self.keys = c.keys()
         self.key2index = {k:i for i,k in enumerate(self.keys)}
 
@@ -45,16 +46,21 @@ def remove_key(self):
                 c.rm_keys(rm_keys)
 
     @classmethod
-    def dashboard(cls, *args, **kwargs):
+    def app(cls, *args, **kwargs):
         self = cls(*args, **kwargs)
 
         for k in ['select', 'create', 'rename', 'remove']:
             fn_name = k + '_key'
             with st.expander(fn_name.capitalize().replace('_',' ')):
                 getattr(self, fn_name)()
-
         return self.key
 
 
-KeyDashboard.run(__name__)
+
+    def ticket(self, *args, **kwargs):
+        data = st.text_input('Data', 'None')
+        return self.key.ticket(data)
+
+
+b = KeyDashboard.run(__name__)
 

commune/key/key.py

@@ -116,9 +116,10 @@ def __init__(self,
 
         self.crypto_type = crypto_type
         self.seed_hex = seed_hex
-        self.derive_path = None
+        self.derive_path = derive_path
         self.path = path 
         self.ss58_format = ss58_format
+    
 
 
         if crypto_type != KeypairType.ECDSA and ss58_address and not public_key:
@@ -276,10 +277,6 @@ def load_key(cls, path=None):
         return {'status': 'success', 'message': f'key loaded from {path}'}
 
 
-    @classmethod
-    def load_keys(cls, path=keys_path, verbose:bool = False, refresh:bool = False,  **kwargs):
-        return cls.load_mems(path, verbose=verbose, refresh=refresh, **kwargs)
-
     @classmethod
     def save_keys(cls, path='saved_keys.json', **kwargs):
         path = cls.resolve_path(path)

commune/module/module.py

@@ -279,13 +279,11 @@ def load_yaml(cls, path:str=None, default={}, **kwargs) -> Dict:
         '''
         import yaml
         path = cls.resolve_path(path)
-
         try:
             with open(path, 'r') as file:
                 data = yaml.safe_load(file)
         except:
             data = default
-
         return data
 
     get_yaml = load_yaml
@@ -372,23 +370,16 @@ def load_config(cls, path:str=None, to_munch:bool = False) -> Union[Munch, Dict]
             path: The path to the config file
             to_munch: If true, then convert the config to a munch
         '''
-
         if path == None: 
             path = cls.config_path()
         else:
-            module_tree = c.tree()
-            path = module_tree[path].replace('.py', '.yaml')
-            
+            path = c.tree().get(path, path).replace('.py', '.yaml')
         config = cls.load_yaml(path)
 
-        # convert to munch
-        if config == None:
-            config = {}
-
+        config = config or {} 
         # convert to munch
         if to_munch:
             config =  cls.dict2munch(config)
-        
         return config
 
 
@@ -775,12 +766,18 @@ def sys_path(cls, *args, **kwargs):
     @classmethod
     def import_module(cls, import_path:str) -> 'Object':
         from importlib import import_module
+        pwd = c.pwd()
         try:
             return import_module(import_path)
         except Exception as e:
             import sys
-            sys.path.append(c.pwd())
-            return import_module(import_path)
+            sys.path.append(pwd)
+            sys.path = list(set(sys.path))
+            try:
+                return import_module(import_path)
+            except Exception as e:
+                print(f'Error: {e}')
+                raise e
 
     def can_import_module(self, module:str) -> bool:
         '''
@@ -1322,7 +1319,6 @@ def get_module(cls,
         try:
             module = c.simple2object(path)
         except Exception as e:
-            raise e
             if trials == 0:
                 raise Exception(f'Could not find {path} in {c.modules(path)} modules')
             c.print(f'Could not find {path} in {c.modules(path)} modules, so we are updating the tree', color='red')
@@ -1450,19 +1446,17 @@ def repo2module(self, repo:str, name=None, template_module='demo', **kwargs):
     def simple2path(cls, path:str, **kwargs) -> str:
         return c.module('tree').simple2path(path, **kwargs)
 
+
     @classmethod
-    def simple2objectpath(cls, path:str,path2objectpath = {'tree': 'commune.tree.tree.Tree'}, **kwargs) -> str:
+    def simple2object(cls, path:str,  path2objectpath = {'tree': 'commune.tree.tree.Tree'}, **kwargs) -> str:
 
 
         if path in path2objectpath:
-            object_path =  path2objectpath[path]
+            path =  path2objectpath[path]
         else:
-            object_path =  c.module('tree').simple2objectpath(path, **kwargs)
+            path =  c.module('tree').simple2objectpath(path, **kwargs)
 
-        return object_path
-    @classmethod
-    def simple2object(cls, path:str, **kwargs) -> str:
-        path = c.simple2objectpath(path, **kwargs)
+        
         try:
             return c.import_object(path)
         except Exception as e:

commune/server/access.py

@@ -9,8 +9,8 @@ class Access(c.Module):
 
     def __init__(self, 
                 module : Union[c.Module, str] = None, # the module or any python object
-                network: str =  'subspace:main', # mainnet
-                netuid: int = 0, # subnet id
+                network: str =  'subspace', # mainnet
+                netuid: int = 'all', # subnet id
                 timescale:str =  'min', # 'sec', 'min', 'hour', 'day'
                 stake2rate: int =  100.0,  # 1 call per every N tokens staked per timescale
                 max_rate: int =  1000.0, # 1 call per every N tokens staked per timescale
@@ -25,84 +25,79 @@ def __init__(self,
 
         self.set_config(locals())
         self.user_module = c.module("user")()
-        self.address2key = c.address2key()
-        self.set_module(module)
         self.state_path = state_path
         if refresh:
             self.rm_state()
-
         self.last_time_synced = c.time()
         self.state = {'sync_time': 0, 
                       'stake_from': {}, 
                       'role2rate': role2rate, 
                       'fn_info': {}}
+        
+        self.set_module(module)
 
         c.thread(self.run_loop)
 
-        
-    def set_module(self, module: c.Module):
-        module = module or c.module('module')()
+    def set_module(self, module):
         if isinstance(module, str):
             module = c.module(module)()
         self.module = module
-        c.print(f'🚀 Access module set to {module} 🚀\033', color='yellow')
-        self.whitelist =  list(set(self.module.whitelist + c.whitelist))
-        self.blacklist =  list(set(self.module.blacklist + c.blacklist))
+        return module
 
-        return {'success': True, 'msg': f'set module to {module}'}
 
     def run_loop(self):
         while True:
             try:
                 r = self.sync_network()
             except Exception as e:
                 r = c.detailed_error(e)
+            c.print(r)
             c.sleep(self.config.sync_interval)
 
+
     def sync_network(self, update=False, max_age=None):
         state = self.get(self.state_path, {}, max_age=self.config.sync_interval)
         time_since_sync = c.time() - state.get('sync_time', 0)
         self.key2address = c.key2address()
         self.address2key = c.address2key()
-        if time_since_sync > self.config.sync_interval:
-            if 'subspace:' in self.config.network:
-                self.config.network = self.config.network.replace('subspace:', '')
-            self.subspace = c.module('subspace')(network=self.config.network)
-            max_age = max_age or self.config.max_age
-            state['stakes'] = self.subspace.stakes(fmt='j', netuid='all', update=False, max_age=max_age)
-            self.state = state
-            self.put(self.state_path, self.state)
-            c.print(f'🔄 Synced {self.state_path} 🔄\033', color='yellow')
-
-        response = {'success': True, 
-                    'msg': f'synced {self.state_path}', 
+        response = {'msg': f'synced {self.state_path}', 
                     'until_sync': int(self.config.sync_interval - time_since_sync),
                     'time_since_sync': int(time_since_sync)}
+        
+        if time_since_sync < self.config.sync_interval:
+            response['msg'] = 'synced too earlly'
+            return response
+        
+        self.subspace = c.module('subspace')(network=self.config.network)
+        max_age = max_age or self.config.max_age
+        state['stakes'] = self.subspace.stakes(fmt='j', netuid=self.config.netuid, update=update, max_age=max_age)
+        self.state = state
+        self.put(self.state_path, self.state)
+        c.print(f'🔄 Synced {self.state_path} at {c.datetime()} 🔄\033', color='yellow')
+
+
         return response
 
-    def verify(self, 
-               address='5FNBuR2yVf4A1v5nt3w5oi4ScorraGRjiSVzkXBVEsPHaGq1', 
-               fn: str = 'info' ,
-              input:dict = None) -> dict:
+    def forward(self, fn: str = 'info' , input:dict = None, address=None) -> dict:
         """
         input : dict 
             fn : str
             address : str
 
         returns : dict
         """
-        if input is not None:
-            address = input.get('address', address)
-            fn = input.get('fn', fn)
+        input = input or {}
+        address = input.get('address', address)
+        assert address, f'address not in input or as an argument'
+        fn = input.get('fn', fn)
 
         # ONLY THE ADMIN CAN CALL ANY FUNCTION, THIS IS A SECURITY FEATURE
         # THE ADMIN KEYS ARE STORED IN THE CONFIG
         if c.is_admin(address):
             return {'success': True, 'msg': f'is verified admin'}
-
 
-        assert fn in self.whitelist , f"Function {fn} not in whitelist={self.whitelist}"
-        assert fn not in self.blacklist, f"Function {fn} is blacklisted={self.blacklist}" 
+        assert fn in self.module.whitelist , f"Function {fn} not in whitelist={self.module.whitelist}"
+        assert fn not in self.module.blacklist, f"Function {fn} is blacklisted={self.module.blacklist}" 
 
         if address in self.address2key:
             return {'success': True, 'msg': f'address {address} is a local key'}
@@ -142,7 +137,6 @@ def verify(self,
 
         rate_limit = (total_stake_score / stake2rate) # convert the stake to a rate
 
-
         # STEP 3: CHECK THE MAX RATE
         max_rate = fn2info.get('max_rate', self.config.max_rate)
         rate_limit = min(rate_limit, max_rate) # cap the rate limit at the max rate
@@ -181,11 +175,7 @@ def verify(self,
         self.state['user_info'][address] = user_info
         # check the rate limit
         return user_info
-
-    @classmethod
-    def get_access_state(cls, module):
-        access_state = cls.get(module)
-        return access_state
+    verify = forward
 
     @classmethod
     def test_whitelist(cls, key='vali::fam', base_rate=2, fn='info'):
@@ -194,7 +184,7 @@ def test_whitelist(cls, key='vali::fam', base_rate=2, fn='info'):
 
         for i in range(base_rate*3):    
             t1 = c.time()
-            result = module.verify(**{'address': key.ss58_address, 'fn': 'info'})
+            result = module.forward(**{'address': key.ss58_address, 'fn': 'info'})
             t2 = c.time()
             c.print(f'🚨 {t2-t1} seconds... 🚨\033', color='yellow')