test fixes

Author: latentvector

commune/aes.py

@@ -41,11 +41,9 @@ def decrypt(self, enc):
     def _pad(self, s):
         return s + (self.bs - len(s) % self.bs) * chr(self.bs - len(s) % self.bs)
 
-    @staticmethod
-    def _unpad(s):
+    def _unpad(self, s):
         return s[:-ord(s[len(s)-1:])]
-
-
+    
     @classmethod
     def test(cls, data=None, key='dummy'):
         import torch

commune/key.py

@@ -227,7 +227,6 @@ def rm_key_address(cls, key):
         key2address.pop(key, None)
         cls.put('key2address', key2address)
 
-    
     @classmethod
     def update(cls, **kwargs):
         return cls.key2address(update=True,**kwargs)
@@ -502,13 +501,11 @@ def key_exists(cls, key, **kwargs):
             if key in addresses:
                 key_exists = True
         return key_exists
-    
 
     @classmethod
     def get_key_address(cls, key): 
         return cls.get_key(key).ss58_address
 
-    
     @classmethod
     def rm_key(cls, key=None):
 
@@ -517,7 +514,6 @@ def rm_key(cls, key=None):
         if key not in keys:
             raise Exception(f'key {key} not found, available keys: {keys}')
         c.rm(key2path[key])
-        cls.rm_key_address(key)
         return {'deleted':[key]}
 
     @property
@@ -537,10 +533,7 @@ def rm_keys(cls, rm_keys, verbose:bool=False):
             cls.rm_key(rm_key)
 
         return {'removed_keys':rm_keys}
-    
-    @classmethod
-    def rm_all_keys(cls):
-        return cls.rm_keys(cls.keys())
+
 
     crypto_types = ['ED25519', 'SR25519', 'ECDSA']
 
@@ -566,13 +559,11 @@ def crypto_type2name(cls, crypto_type:str):
 
     @classmethod
     def resolve_crypto_type(cls, crypto_type):
-            
         if isinstance(crypto_type, str):
             crypto_type = crypto_type.upper()
             crypto_type = cls.crypto_name2type(crypto_type)
         elif isinstance(crypto_type, int):
             assert crypto_type in list(KeypairType.__dict__.values()), f'crypto_type {crypto_type} not supported'
-            
         assert crypto_type in list(KeypairType.__dict__.values()), f'crypto_type {crypto_type} not supported'
         return crypto_type
 
@@ -588,8 +579,6 @@ def new_key(cls,
         '''
         yo rody, this is a class method you can gen keys whenever fam
         '''
-        mnemonic = kwargs.pop('m', mnemonic)
-
         if verbose:
             c.print(f'generating {crypto_type} keypair, {suri}', color='green')
 
@@ -610,8 +599,6 @@ def new_key(cls,
         return key
 
     create = gen = new_key
-
-    
 
     def to_json(self, password: str = None ) -> dict:
         state_dict =  self.copy(self.__dict__)
@@ -1275,12 +1262,6 @@ def save(self, path=None):
         c.put_json(path, self.to_json())
         return {'saved':path}
 
-    def diplicate(self, new_path):
-        c.print(f'copying key from {self.path} to {new_path}')
-        c.cp(self.path, new_path)
-        return {'copied':new_path}
-    
-    
 
     def __repr__(self):
         return self.__str__()
@@ -1350,17 +1331,6 @@ def duplicate_keys(cls) -> dict:
 
         return {k:v for k,v in duplicate_keys.items() if len(v) > 1}
 
-    @classmethod
-    def clean_all_keys(cls):
-        key2adress = c.key2address()
-        for k,a in key2adress.items():
-            if c.key_exists(a):
-                c.print(f'removing {a}', color='red')
-                c.rm_key(a)
-            c.print('cleaning', k, a,  c.key_exists(a))
-
-        
-
     @classmethod
     def from_private_key(cls, private_key:str):
         return cls(private_key=private_key)

commune/namespace.py

@@ -36,19 +36,13 @@ def namespace(cls, search=None,
             cls.put(path,namespace)
         if search != None:
             namespace = {k:v for k,v in namespace.items() if search in k} 
-
-        namespace = cls.clean_namespace(namespace)
-
-        return namespace
-    
-    @classmethod
-    def clean_namespace(cls, namespace):
         namespace = {k:':'.join(v.split(':')[:-1]) + ':'+ str(v.split(':')[-1]) for k,v in namespace.items()}
         namespace = dict(sorted(namespace.items(), key=lambda x: x[0]))
         ip  = c.ip()
         namespace = {k: v.replace(ip, '0.0.0.0') for k,v in namespace.items() }
         namespace = { k.replace('"', ''): v for k,v in namespace.items() }
         return namespace
+    
     @classmethod
     def update_namespace(cls, network, netuid=None, timeout=1, search=None, verbose=False):
         c.print(f'UPDATING --> NETWORK(network={network} netuid={netuid})', color='blue')
@@ -152,11 +146,6 @@ def modules(cls, network:List=network) -> List[str]:
     def addresses(cls, network:str=network, **kwargs) -> List[str]:
         return list(cls.namespace(network=network, **kwargs).values())
 
-    @classmethod
-    def module_exists(cls, module:str, network:str=network) -> bool:
-        namespace = cls.namespace(network=network)
-        return bool(module in namespace)
-
     @classmethod
     def check_servers(self, *args, **kwargs):
         servers = c.pm2ls()
@@ -191,44 +180,6 @@ def add_server(cls, address:str, name=None, network:str = 'local',timeout:int=4,
 
         return {'success': True, 'msg': f'Added {address} to {network} modules', 'remote_modules': cls.servers(network=network), 'network': network}
 
-    @classmethod
-    def remote_servers(cls, network:str = 'remote', **kwargs):
-        return cls.namespace(network=network)
-    
-    @classmethod
-    def infos(cls, search=None, network=network, servers=None, features=['key', 'address', 'name'],   update:str=True, batch_size = 10, timeout=20, hardware=True, namespace=True, schema=True) -> List[str]:
-        path = f'infos/{network}'
-        if not update:
-            infos = cls.get(path, [])
-        if update or len(infos) == 0:
-            infos = []
-            servers = cls.servers(search=search, network=network) if servers == None else servers
-            futures = []
-            infos = []
-            for s in servers:
-                kwargs = {'module':s, 'fn':'info', 'network': network, 'hardware': hardware, 'namespace': namespace, 'schema': schema}
-                future = c.submit(c.call, kwargs=kwargs, return_future=True, timeout=timeout)
-                futures.append(future)
-                if len(futures) >= batch_size:
-                    for f in c.as_completed(futures):
-                        
-                        result = f.result()
-                        futures.remove(f)
-
-                        if isinstance(result, dict) and 'error' not in result:
-                            infos.append(result)
-                        
-                        break
-            infos += c.wait(futures, timeout=timeout)
-            cls.put(path, infos)
-        infos = [s for s in infos if s != None]
-        if search != None:
-            infos = [s for s in infos if 'name' in s and search in s['name']]
-
-        if features != None:
-            infos = [{k:v for k,v in s.items() if k in features} for s in infos]
-        return infos
-    
     @classmethod
     def rm_server(cls,  name, network:str = 'local', **kwargs):
         namespace = cls.namespace(network=network)
@@ -237,7 +188,6 @@ def rm_server(cls,  name, network:str = 'local', **kwargs):
                 if v == name:
                     name = k
                     break
-            
         if name in namespace:
             # reregister
             address = cls.get_address(name, network=network)
@@ -253,13 +203,6 @@ def servers(cls, search=None, network:str = 'local',  **kwargs):
         namespace = cls.namespace(search=search, network=network, **kwargs)
         return list(namespace.keys())
 
-    @classmethod
-    def refresh_namespace(cls, network:str):
-        return cls.put_namespace(network, {})
-    @classmethod
-    def network2namespace(self):
-        return {network: self.namespace(network=network) for network in self.networks()}
-    all = network2namespace
     @classmethod
     def server_exists(cls, name:str, network:str = None,  prefix_match:bool=False, **kwargs) -> bool:
         servers = cls.servers(network=network, **kwargs)
@@ -299,22 +242,7 @@ def server_exists(cls, name:str, network:str = None,  prefix_match:bool=False, *
         else:
             server_exists =  bool(name in servers)
 
-        return server_exists
-
-    @classmethod
-    def clean(cls, network='local'):
-        namespace = cls.namespace(network=network)
-        address2name = {}
-        
-        for name, address in address2name.items():
-            if address in address2name.values():
-                if len(address2name[address]) < len(name):
-                    namespace[address] = name
-            else:
-                address2name[address] = name
-
-        namespace = {v:k for k,v in address2name.items()}
-        return namespace     
+        return server_exists  
 
 Namespace.run(__name__)