fix lint

Author: Yunnglin

cookbook/client/tinker/sample.py

@@ -14,25 +14,25 @@
 from twinkle.template import Template
 
 # Step 1: Define the base model and connect to the server
-base_model = "Qwen/Qwen2.5-7B-Instruct"
+base_model = 'Qwen/Qwen2.5-7B-Instruct'
 service_client = init_tinker_compat_client(base_url='http://localhost:8000')
 
 # Step 2: Create a sampling client by loading weights from a saved checkpoint.
 # The model_path is a twinkle:// URI pointing to a previously saved LoRA checkpoint.
 # The server will load the base model and apply the LoRA adapter weights.
 sampling_client = service_client.create_sampling_client(
-    model_path="twinkle://20260212_174205-Qwen_Qwen2_5-7B-Instruct-51edc9ed/weights/twinkle-lora-2",
+    model_path='twinkle://20260212_174205-Qwen_Qwen2_5-7B-Instruct-51edc9ed/weights/twinkle-lora-2',
     base_model=base_model)
 
 # Step 3: Load the tokenizer locally to encode the prompt and decode the results
-print(f"Using model {base_model}")
+print(f'Using model {base_model}')
 
 template = Template(model_id=f'ms://{base_model}')
 
 trajectory = Trajectory(
     messages=[
         Message(role='system', content='You are a helpful assistant'),
-        Message(role='user', content="你是谁？"),
+        Message(role='user', content='你是谁？'),
     ]
 )
 
@@ -44,8 +44,8 @@
 prompt = types.ModelInput.from_ints(input_ids)
 params = types.SamplingParams(
     max_tokens=128,       # Maximum number of tokens to generate
-    temperature=0.7,     
-    stop=["\n"]          # Stop generation when a newline character is produced
+    temperature=0.7,
+    stop=['\n']          # Stop generation when a newline character is produced
 )
 
 # Step 5: Send the sampling request to the server.
@@ -57,4 +57,4 @@
 # Step 6: Decode and print the generated responses
 print('Responses:')
 for i, seq in enumerate(result.sequences):
-    print(f"{i}: {repr(template.decode(seq.tokens))}")
+    print(f'{i}: {repr(template.decode(seq.tokens))}')

cookbook/client/tinker/self_congnition.py

@@ -82,7 +82,7 @@ def eval():
     # Step 1: Load the trained LoRA checkpoint for inference
 
     # Path to a previously saved LoRA checkpoint (twinkle:// URI)
-    weight_path = "twinkle://20260212_174205-Qwen_Qwen2_5-7B-Instruct-51edc9ed/weights/twinkle-lora-2"
+    weight_path = 'twinkle://20260212_174205-Qwen_Qwen2_5-7B-Instruct-51edc9ed/weights/twinkle-lora-2'
 
     # Connect to the server and create a sampling client with the trained weights
     service_client = init_tinker_compat_client(base_url='http://localhost:8000')
@@ -96,7 +96,7 @@ def eval():
     trajectory = Trajectory(
         messages=[
             Message(role='system', content='You are a helpful assistant'),
-            Message(role='user', content="你是谁？"),
+            Message(role='user', content='你是谁？'),
         ]
     )
 
@@ -121,9 +121,9 @@ def eval():
     # Decode and print each response
     print('Responses:')
     for i, seq in enumerate(result.sequences):
-        print(f"{i}: {repr(template.decode(seq.tokens))}")
+        print(f'{i}: {repr(template.decode(seq.tokens))}')
 
 
-if __name__ == "__main__":
+if __name__ == '__main__':
     # train()   # Uncomment to run training
     eval()      # Run evaluation / inference

cookbook/client/tinker/short_math_grpo.py

@@ -208,8 +208,8 @@ def main():
     dataset = create_Math_dataset()
     dataloader = DataLoader(dataset=dataset, batch_size=BATCH_SIZE)
     template = Template(model_id=f'ms://{BASE_MODEL}')
-    
-    logger.info("Dataset and template initialized")
+
+    logger.info('Dataset and template initialized')
 
     # Step 2: Initialize the Tinker-compatible client
     logger.info('Connecting to Tinker server...')

src/twinkle/server/tinker/common/compat_base.py

@@ -101,7 +101,7 @@ def _to_float(v):
                     head, unit = s.split()  # ignore unit/tail
                     cleaned[f'{key}/{unit}'] = float(head)
                 except Exception:
-                    m = re.match(r"^([+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?)", s)
+                    m = re.match(r'^([+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?)', s)
                     if m:
                         cleaned[key] = float(m.group(1))
 

src/twinkle/server/tinker/model.py

@@ -120,25 +120,25 @@ def __init__(self,
 
         def _cleanup_adapter(self, adapter_name: str) -> None:
             """Common adapter cleanup logic used by both manual unload and automatic expiration.
-            
+
             This method handles:
             1. Clearing adapter state
             2. Removing adapter from model
             3. Unregistering from adapter manager
             4. Removing from server state
-            
+
             Args:
                 adapter_name: Name of the adapter to clean up
             """
             # Remove from model if it exists
             if self.get_adapter_info(adapter_name):
                 # Clear adapter state
                 self.clear_adapter_state(adapter_name)
-                
+
                 self.model.remove_adapter(adapter_name)
                 # Unregister from adapter manager
                 self.unregister_adapter(adapter_name)
-                
+
                 # Remove from server state
                 self.state.unload_model(adapter_name)
 
@@ -175,16 +175,13 @@ async def _create_adapter():
                         # TODO: support more lora config parameters, train_unembed, etc.
                         lora_cfg = LoraConfig(r=body.lora_config.rank, target_modules='all-linear')
 
-                        adapter_name = self.get_adapter_name(
-                            adapter_name=model_id)
-                        
+                        adapter_name = self.get_adapter_name(adapter_name=model_id)
+
                         # Register adapter FIRST (limit check happens inside register_adapter)
-                        self.register_adapter(
-                            adapter_name, request.state.token, session_id=body.session_id)
-                        
+                        self.register_adapter(adapter_name, request.state.token, session_id=body.session_id)
+
                         # Create adapter AFTER successful registration
-                        self.model.add_adapter_to_model(
-                            adapter_name=adapter_name, config_or_dir=lora_cfg)
+                        self.model.add_adapter_to_model(adapter_name=adapter_name, config_or_dir=lora_cfg)
 
                         self.model.set_template('Template', adapter_name=adapter_name, model_id=self.base_model)
                         self.model.set_processor('InputProcessor', adapter_name=adapter_name)
@@ -193,8 +190,7 @@ async def _create_adapter():
                         # Fresh adapter has no accumulated gradients.
                         self.set_adapter_state(adapter_name, 'grad_ready', False)
 
-                    training_run_manager = create_training_run_manager(
-                        request.state.token)
+                    training_run_manager = create_training_run_manager(request.state.token)
                     training_run_manager.save(model_id, body)
 
                     return types.CreateModelResponse(model_id=model_id)
@@ -261,8 +257,7 @@ async def unload_model(self, request: Request, body: types.UnloadModelRequest) -
 
             async def _do_unload():
                 # Only remove adapter, not the base model
-                adapter_name = self.get_adapter_name(
-                    adapter_name=body.model_id)
+                adapter_name = self.get_adapter_name(adapter_name=body.model_id)
                 # Use common cleanup logic
                 self._cleanup_adapter(adapter_name)
                 return types.UnloadModelResponse(model_id=body.model_id)
@@ -315,9 +310,7 @@ async def _do_forward():
 
             # Calculate input tokens and batch size for validation
             datum_list = body.forward_input.data
-            input_tokens = sum(
-                len(d.model_input.to_ints()) for d in datum_list
-            )
+            input_tokens = sum(len(d.model_input.to_ints()) for d in datum_list)
             batch_size = len(datum_list)
             return await self.schedule_task(
                 _do_forward,
@@ -360,11 +353,12 @@ async def _do_forward_backward():
                     loss_fn_config = body.forward_backward_input.loss_fn_config or {}
 
                     # Unified forward_backward for both Megatron and Transformers
-                    output, loss = self.model.forward_backward(inputs=datum_list,
-                                                                adapter_name=adapter_name,
-                                                                loss_fn=loss_fn,
-                                                                **loss_fn_config)
-                    output_type = 'ImportanceSamplingLossReturn' if loss_fn == 'importance_sampling' else 'CrossEntropyLossReturn'
+                    output, loss = self.model.forward_backward(
+                        inputs=datum_list, adapter_name=adapter_name, loss_fn=loss_fn, **loss_fn_config)
+                    if loss_fn == 'importance_sampling':
+                        output_type = 'ImportanceSamplingLossReturn'
+                    else:
+                        output_type = 'CrossEntropyLossReturn'
                     # Mark gradients as ready after a successful forward_backward.
                     self.set_adapter_state(adapter_name, 'grad_ready', True)
                     return types.ForwardBackwardOutput(
@@ -381,9 +375,7 @@ async def _do_forward_backward():
 
             # Calculate input tokens and batch size for validation
             datum_list = body.forward_backward_input.data
-            input_tokens = sum(
-                len(d.model_input.to_ints()) for d in datum_list
-            )
+            input_tokens = sum(len(d.model_input.to_ints()) for d in datum_list)
             batch_size = len(datum_list)
             return await self.schedule_task(
                 _do_forward_backward,
@@ -417,14 +409,13 @@ async def _do_optim():
                     # Disallow empty step (must have at least one forward_backward since last step)
                     if not self.get_adapter_state(adapter_name, 'grad_ready', False):
                         raise RuntimeError(
-                            f"No accumulated gradients for adapter={adapter_name}; call forward_backward before optim_step"
+                            f'No accumulated gradients for adapter={adapter_name}; call forward_backward before optim_step'  # noqa: E501
                         )
 
                     # Touch adapter to reset inactivity counter
                     self.touch_adapter(adapter_name)
 
-                    self.model.step(adam_params=body.adam_params,
-                                    adapter_name=adapter_name)
+                    self.model.step(adam_params=body.adam_params, adapter_name=adapter_name)
                     # Clear grad-ready after a successful step.
                     self.set_adapter_state(adapter_name, 'grad_ready', False)
                     metrics = self.model.calculate_metric(is_training=True, adapter_name=adapter_name)
@@ -590,15 +581,15 @@ async def _do_load():
                     weight_path = body.path
                     load_optimizer = body.optimizer
 
-                    self.model.load(checkpoint_dir=weight_path,
-                                    load_optimizer=load_optimizer,
-                                    adapter_name=adapter_name,
-                                    token=token)
+                    self.model.load(
+                        checkpoint_dir=weight_path,
+                        load_optimizer=load_optimizer,
+                        adapter_name=adapter_name,
+                        token=token)
 
                     # Loading a checkpoint should reset step readiness.
                     self.set_adapter_state(adapter_name, 'grad_ready', False)
-                    return types.LoadWeightsResponse(path=body.path,
-                                                     type='load_weights')
+                    return types.LoadWeightsResponse(path=body.path, type='load_weights')
                 except Exception:
                     logger.error(traceback.format_exc())
                     return types.RequestFailedResponse(

src/twinkle/server/tinker/sampler.py

@@ -160,14 +160,14 @@ async def _do_sample():
                         token = request.state.token
                         checkpoint_manager = create_checkpoint_manager(token)
                         adapter_name, adapter_uri = checkpoint_manager.parse_adapter_uri(model_path)
-                    
+
                     # Validate adapter URI existence if provided
                     if not adapter_uri or not os.path.exists(adapter_uri):
                         return types.RequestFailedResponse(
-                            error=f"Adapter URI {model_path} does not exist. Please check the model_path.",
+                            error=f'Adapter URI {model_path} does not exist. Please check the model_path.',
                             category=types.RequestErrorCategory.User,
                         )
-                    
+
                     # Convert tinker SamplingParams to twinkle SamplingParams if needed
                     sampling_params = None
                     if body.sampling_params:

src/twinkle/server/tinker/server.py

@@ -28,12 +28,11 @@
 
 logger = logging.getLogger(__name__)
 
-def build_server_app(
-    deploy_options: Dict[str, Any],
-    supported_models: Optional[List[types.SupportedModel]] = None,
-    server_config: Dict[str, Any] = {},
-    **kwargs
-):
+
+def build_server_app(deploy_options: dict[str, Any],
+                     supported_models: list[types.SupportedModel] | None = None,
+                     server_config: dict[str, Any] = {},
+                     **kwargs):
     """Build and configure the Tinker-compatible server application.
 
     This factory function creates a FastAPI application with Ray Serve deployment
@@ -66,8 +65,11 @@ class TinkerCompatServer:
         - Proxying to model/sampler deployments
         - Training run and checkpoint CRUD operations
         """
-        
-        def __init__(self, supported_models: Optional[List[types.SupportedModel]] = None, server_config: Dict[str, Any] = {}, **kwargs) -> None:
+
+        def __init__(self,
+                     supported_models: list[types.SupportedModel] | None = None,
+                     server_config: dict[str, Any] = {},
+                     **kwargs) -> None:
             """Initialize the Tinker-compatible server.
 
             Args:
@@ -78,13 +80,13 @@ def __init__(self, supported_models: Optional[List[types.SupportedModel]] = None
             self.state = get_server_state(**server_config)
             # Disable proxy for internal requests to avoid routing through external proxies
             self.client = httpx.AsyncClient(timeout=None, trust_env=False)
-            self.route_prefix = kwargs.get("route_prefix", "/api/v1")
+            self.route_prefix = kwargs.get('route_prefix', '/api/v1')
             self.supported_models = self.normalize_models(supported_models) or [
-                types.SupportedModel(model_name="Qwen/Qwen2.5-0.5B-Instruct"),
-                types.SupportedModel(model_name="Qwen/Qwen2.5-3B-Instruct"),
-                types.SupportedModel(model_name="Qwen/Qwen2.5-7B-Instruct"),
-                types.SupportedModel(model_name="Qwen/Qwen2.5-72B-Instruct"),
-                types.SupportedModel(model_name="Qwen/Qwen3-30B-A3B-Instruct-2507"),
+                types.SupportedModel(model_name='Qwen/Qwen2.5-0.5B-Instruct'),
+                types.SupportedModel(model_name='Qwen/Qwen2.5-3B-Instruct'),
+                types.SupportedModel(model_name='Qwen/Qwen2.5-7B-Instruct'),
+                types.SupportedModel(model_name='Qwen/Qwen2.5-72B-Instruct'),
+                types.SupportedModel(model_name='Qwen/Qwen3-30B-A3B-Instruct-2507'),
             ]
             # Lock for ModelScope config file operations (login writes, get_user_info reads)
             self._modelscope_config_lock = asyncio.Lock()
@@ -682,7 +684,4 @@ async def save_weights_for_sampler(self, request: Request, body: types.SaveWeigh
             return await self._proxy_to_model(request, 'save_weights_for_sampler', base_model)
 
     return TinkerCompatServer.options(**deploy_options).bind(
-        supported_models=supported_models,
-        server_config=server_config,
-        **kwargs
-    )
+        supported_models=supported_models, server_config=server_config, **kwargs)

src/twinkle/server/twinkle/model.py

@@ -200,18 +200,17 @@ def _on_adapter_expired(self, adapter_name: str) -> None:
             if self.get_adapter_info(adapter_name):
                 # Clear adapter state
                 self.clear_adapter_state(adapter_name)
-                
+
                 self.model.remove_adapter(adapter_name)
                 # Unregister from adapter manager
                 self.unregister_adapter(adapter_name)
-                
+
                 # Remove from server state
                 self.state.unload_model(adapter_name)
                 # Remove adapter from model
                 self.model.remove_adapter(adapter_name)
 
-
-        @app.post("/create")
+        @app.post('/create')
         def create(self, request: Request, body: CreateRequest):
             return {'status': 'ok'}
 
@@ -508,13 +507,13 @@ def add_adapter_to_model(self, request: Request, body: AddAdapterRequest):
             # Extract token for metadata storage
             token = request.state.token
             training_run_manager = create_training_run_manager(token)
-            
+
             # Register adapter FIRST (limit check happens inside register_adapter)
             self.register_adapter(adapter_name, token)
-            
+
             # Create adapter AFTER successful registration
             self.model.add_adapter_to_model(adapter_name, config, **extra_kwargs)
-            
+
             # Save training run metadata (similar to tinker's create_model)
             # Create a training run config from the adapter configuration
             lora_config = None