Ignore pylint warnings

Author: mattt

Diff for: python/cog/code_xforms.py

@@ -12,7 +12,7 @@ def load_module_from_string(
     if not source or not name:
         return None
     module = types.ModuleType(name)
-    exec(source, module.__dict__)  # noqa: S102
+    exec(source, module.__dict__)  # noqa: S102 # pylint: disable=exec-used
     return module
 
 

Diff for: python/cog/command/ast_openapi_schema.py

@@ -490,8 +490,8 @@ def predict(
     name = resolve_name(annotation)
     if isinstance(annotation, ast.Subscript):
         # forget about other subscripts like Optional, and assume otherlib.File will still be an uri
-        slice = resolve_name(annotation.slice)
-        format = {"format": "uri"} if slice in ("Path", "File") else {}
+        slice = resolve_name(annotation.slice)  # pylint: disable=redefined-builtin
+        format = {"format": "uri"} if slice in ("Path", "File") else {}  # pylint: disable=redefined-builtin
         array_type = {"x-cog-array-type": "iterator"} if "Iterator" in name else {}
         display_type = (
             {"x-cog-array-display": "concatenate"} if "Concatenate" in name else {}
@@ -544,7 +544,7 @@ def extract_info(code: str) -> "JSONDict":
             kws = {}
         else:
             raise ValueError("Unexpected default value", default)
-        input: JSONDict = {"x-order": len(properties)}
+        input: JSONDict = {"x-order": len(properties)}  # pylint: disable=redefined-builtin
         # need to handle other types?
         arg_type = OPENAPI_TYPES.get(get_annotation(arg.annotation), "string")
         if get_annotation(arg.annotation) in ("Path", "File"):

Diff for: python/cog/predictor.py

@@ -57,7 +57,8 @@
 
 class BasePredictor(ABC):
     def setup(
-        self, weights: Optional[Union[CogFile, CogPath, str]] = None
+        self,
+        weights: Optional[Union[CogFile, CogPath, str]] = None,  # pylint: disable=unused-argument
     ) -> Optional[Awaitable[None]]:
         """
         An optional method to prepare the model so multiple predictions run efficiently.
@@ -142,12 +143,12 @@ def get_weights_type(
     signature = inspect.signature(setup_function)
     if "weights" not in signature.parameters:
         return None
-    Type = signature.parameters["weights"].annotation
+    Type = signature.parameters["weights"].annotation  # pylint: disable=invalid-name,redefined-outer-name
     # Handle Optional. It is Union[Type, None]
     if get_origin(Type) == Union:
         args = get_args(Type)
         if len(args) == 2 and args[1] is type(None):
-            Type = get_args(Type)[0]
+            Type = get_args(Type)[0]  # pylint: disable=invalid-name
     return Type
 
 
@@ -248,7 +249,7 @@ def load_slim_predictor_from_ref(ref: str, method_name: str) -> BasePredictor:
                 log.debug(f"[{module_name}] fast loader returned None")
         else:
             log.debug(f"[{module_name}] cannot use fast loader as current Python <3.9")
-    except Exception as e:
+    except Exception as e:  # pylint: disable=broad-exception-caught
         log.debug(f"[{module_name}] fast loader failed: {e}")
     finally:
         if not module:
@@ -294,7 +295,10 @@ def cleanup(self) -> None:
     # and do it that way. convert is supposed to mutate though, so it's tricky
 
 
-def validate_input_type(type: Type[Any], name: str) -> None:
+def validate_input_type(
+    type: Type[Any],  # pylint: disable=redefined-builtin
+    name: str,
+) -> None:
     if type is inspect.Signature.empty:
         raise TypeError(
             f"No input type provided for parameter `{name}`. Supported input types are: {readable_types_list(ALLOWED_INPUT_TYPES)}, or a Union or List of those types."
@@ -411,8 +415,8 @@ def get_output_type(predictor: BasePredictor) -> Type[BaseModel]:
 
     input_types = get_type_hints(predict)
 
-    OutputType = input_types.pop("return", None)
-    if OutputType is None:
+    OutputType = input_types.pop("return", None)  # pylint: disable=invalid-name
+    if not OutputType:
         raise TypeError(
             """You must set an output type. If your model can return multiple output types, you can explicitly set `Any` as the output type.
 

Diff for: python/cog/server/clients.py

@@ -272,7 +272,7 @@ async def upload_files(
         When a file is encountered, it will be passed to upload_file. Any paths will be opened and converted to files.
         """
         # skip four isinstance checks for fast text models
-        if type(obj) == str:  # noqa: E721
+        if type(obj) == str:  # noqa: E721 # pylint: disable=unidiomatic-typecheck
             return obj
         # # it would be kind of cleaner to make the default file_url
         # # instead of skipping entirely, we need to convert to datauri

Diff for: python/cog/server/connection.py

@@ -8,7 +8,7 @@
 from typing import Any, Generic, TypeVar
 
 X = TypeVar("X")
-_ForkingPickler = connection._ForkingPickler  # type: ignore
+_ForkingPickler = connection._ForkingPickler  # type: ignore # pylint: disable=protected-access
 
 # based on https://github.com/python/cpython/blob/main/Lib/multiprocessing/connection.py#L364
 
@@ -28,7 +28,7 @@ async def async_init(self) -> None:
         sz = 65536
         sock.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, sz)
         sock.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, sz)
-        self._reader, self._writer = await asyncio.open_connection(sock=sock)
+        self._reader, self._writer = await asyncio.open_connection(sock=sock)  # pylint: disable=attribute-defined-outside-init
         self.started = True
 
     async def _recv(self, size: int) -> io.BytesIO:

Diff for: python/cog/server/eventtypes.py

@@ -9,7 +9,7 @@
 # From worker parent process
 #
 @define
-class PredictionInput:
+class PredictionInput:  # pylint: disable=too-few-public-methods
     payload: Dict[str, Any]
     id: str = field(factory=lambda: secrets.token_hex(4))
 
@@ -21,31 +21,31 @@ def from_request(cls, request: schema.PredictionRequest) -> "PredictionInput":
 
 
 @define
-class Cancel:
+class Cancel:  # pylint: disable=too-few-public-methods
     id: str
 
 
 @define
-class Shutdown:
+class Shutdown:  # pylint: disable=too-few-public-methods
     pass
 
 
 # From predictor child process
 #
 @define
-class Log:
+class Log:  # pylint: disable=too-few-public-methods
     message: str
     source: str = field(validator=validators.in_(["stdout", "stderr"]))
 
 
 @define
-class PredictionMetric:
+class PredictionMetric:  # pylint: disable=too-few-public-methods
     name: str
     value: "float | int"
 
 
 @define
-class PredictionOutput:
+class PredictionOutput:  # pylint: disable=too-few-public-methods
     payload: Any
 
 
@@ -55,7 +55,7 @@ class PredictionOutputType:
 
 
 @define
-class Done:
+class Done:  # pylint: disable=too-few-public-methods
     canceled: bool = False
     error: bool = False
     error_detail: str = ""

Diff for: python/cog/server/http.py

@@ -80,7 +80,11 @@ class MyFastAPI(FastAPI):
     state: MyState  # type: ignore
 
 
-def add_setup_failed_routes(app: MyFastAPI, started_at: datetime, msg: str) -> None:
+def add_setup_failed_routes(
+    app: MyFastAPI,  # pylint: disable=redefined-outer-name
+    started_at: datetime,
+    msg: str,
+) -> None:
     print(msg)
     result = SetupResult(
         started_at=started_at,
@@ -128,7 +132,7 @@ async def start_shutdown() -> Any:
         predictor = load_slim_predictor_from_ref(predictor_ref, "predict")
         InputType = get_input_type(predictor)
         OutputType = get_output_type(predictor)
-    except Exception:
+    except Exception:  # pylint: disable=broad-exception-caught
         msg = "Error while loading predictor:\n\n" + traceback.format_exc()
         add_setup_failed_routes(app, started_at, msg)
         return app
@@ -145,15 +149,15 @@ async def start_shutdown() -> Any:
     class PredictionRequest(schema.PredictionRequest.with_types(input_type=InputType)):
         pass
 
-    PredictionResponse = schema.PredictionResponse.with_types(
+    PredictionResponse = schema.PredictionResponse.with_types(  # pylint: disable=invalid-name
         input_type=InputType, output_type=OutputType
     )
 
     http_semaphore = asyncio.Semaphore(threads)
 
     if TYPE_CHECKING:
-        P = ParamSpec("P")
-        T = TypeVar("T")
+        P = ParamSpec("P")  # pylint: disable=invalid-name
+        T = TypeVar("T")  # pylint: disable=invalid-name
 
     def limited(f: "Callable[P, Awaitable[T]]") -> "Callable[P, Awaitable[T]]":
         @functools.wraps(f)
@@ -167,15 +171,15 @@ async def wrapped(*args: "P.args", **kwargs: "P.kwargs") -> "T":
         try:
             trainer_ref = get_predictor_ref(config, "train")
             trainer = load_slim_predictor_from_ref(trainer_ref, "train")
-            TrainingInputType = get_training_input_type(trainer)
-            TrainingOutputType = get_training_output_type(trainer)
+            TrainingInputType = get_training_input_type(trainer)  # pylint: disable=invalid-name
+            TrainingOutputType = get_training_output_type(trainer)  # pylint: disable=invalid-name
 
-            class TrainingRequest(
+            class TrainingRequest(  # pylint: disable=too-few-public-methods
                 schema.TrainingRequest.with_types(input_type=TrainingInputType)
             ):
                 pass
 
-            TrainingResponse = schema.TrainingResponse.with_types(
+            TrainingResponse = schema.TrainingResponse.with_types(  # pylint: disable=invalid-name
                 input_type=TrainingInputType, output_type=TrainingOutputType
             )
 
@@ -222,7 +226,7 @@ def cancel_training(
             ) -> Any:
                 return cancel(training_id)
 
-        except Exception as e:
+        except Exception as e:  # pylint: disable=broad-exception-caught
             if isinstance(e, (PredictorNotSet, FileNotFoundError)) and not is_build:
                 pass  # ignore missing train.py for backward compatibility with existing "bad" models in use
             else:
@@ -354,7 +358,7 @@ async def shared_predict(
         # [compat] If body is supplied but input is None, set it to an empty
         # dictionary so that later code can be simpler.
         if request.input is None:
-            request.input = {}
+            request.input = {}  # pylint: disable=attribute-defined-outside-init
 
         try:
             # Previously, we only asked PredictionRunner to handle file uploads for
@@ -444,19 +448,19 @@ def predict(...) -> output_type:
 
 class Server(uvicorn.Server):
     def start(self) -> None:
-        self._thread = threading.Thread(target=self.run)
+        self._thread = threading.Thread(target=self.run)  # pylint: disable=attribute-defined-outside-init
         self._thread.start()
 
     def stop(self) -> None:
         log.info("stopping server")
-        self.should_exit = True
+        self.should_exit = True  # pylint: disable=attribute-defined-outside-init
 
         self._thread.join(timeout=5)
         if not self._thread.is_alive():
             return
 
         log.warn("failed to exit after 5 seconds, setting force_exit")
-        self.force_exit = True
+        self.force_exit = True  # pylint: disable=attribute-defined-outside-init
         self._thread.join(timeout=5)
         if not self._thread.is_alive():
             return
@@ -470,12 +474,12 @@ def is_port_in_use(port: int) -> bool:
         return s.connect_ex(("localhost", port)) == 0
 
 
-def signal_ignore(signum: Any, frame: Any) -> None:
+def signal_ignore(signum: Any, frame: Any) -> None:  # pylint: disable=unused-argument
     log.warn("Got a signal to exit, ignoring it...", signal=signal.Signals(signum).name)
 
 
 def signal_set_event(event: threading.Event) -> Callable[[Any, Any], None]:
-    def _signal_set_event(signum: Any, frame: Any) -> None:
+    def _signal_set_event(signum: Any, frame: Any) -> None:  # pylint: disable=unused-argument
         event.set()
 
     return _signal_set_event

Diff for: python/cog/server/runner.py

@@ -100,11 +100,17 @@ def update_time_shares(self) -> None:
                 self._time_shares_per_prediction[prediction_id] += incurred_cost
         self._last_updated_time_shares = now
 
-    def start_tracking(self, id: str) -> None:
+    def start_tracking(
+        self,
+        id: str,  # pylint: disable=redefined-builtin
+    ) -> None:
         self.update_time_shares()
         self._time_shares_per_prediction[id] = 0.0
 
-    def end_tracking(self, id: str) -> float:
+    def end_tracking(
+        self,
+        id: str,  # pylint: disable=redefined-builtin
+    ) -> float:
         self.update_time_shares()
         return self._time_shares_per_prediction.pop(id)
 
@@ -193,7 +199,7 @@ async def inner() -> SetupResult:
                         else:
                             status = schema.Status.SUCCEEDED
                         self._state = WorkerState.IDLE
-            except Exception:
+            except Exception:  # pylint: disable=broad-exception-caught
                 logs.append(traceback.format_exc())
                 status = schema.Status.FAILED
 
@@ -224,7 +230,7 @@ def handle_error(task: RunnerTask) -> None:
             # worker state if an exception was thrown.
             try:
                 raise exc
-            except Exception:
+            except Exception:  # pylint: disable=broad-exception-caught
                 self.log.error("caught exception while running setup", exc_info=True)
                 if self._shutdown_event is not None:
                     self._shutdown_event.set()
@@ -248,7 +254,10 @@ def state_from_predictions_in_flight(self) -> WorkerState:
     def is_busy(self) -> bool:
         return self._state not in {WorkerState.PROCESSING, WorkerState.IDLE}
 
-    def enter_predict(self, id: str) -> None:
+    def enter_predict(
+        self,
+        id: str,  # pylint: disable=redefined-builtin
+    ) -> None:
         if self.is_busy():
             raise InvalidStateException(
                 f"Invalid operation: state is {self._state} (must be processing or idle)"
@@ -263,12 +272,18 @@ def enter_predict(self, id: str) -> None:
         self._predictions_in_flight.add(id)
         self._state = self.state_from_predictions_in_flight()
 
-    def exit_predict(self, id: str) -> None:
+    def exit_predict(
+        self,
+        id: str,  # pylint: disable=redefined-builtin
+    ) -> None:
         self._predictions_in_flight.remove(id)
         self._state = self.state_from_predictions_in_flight()
 
     @contextlib.contextmanager
-    def prediction_ctx(self, id: str) -> Iterator[None]:
+    def prediction_ctx(
+        self,
+        id: str,  # pylint: disable=redefined-builtin
+    ) -> Iterator[None]:
         self.enter_predict(id)
         try:
             yield
@@ -420,7 +435,7 @@ async def _read_events(self) -> None:
         while self._child.is_alive() and not self._terminating.is_set():
             # in tests this can still be running when the task is destroyed
             result = await self._events.recv()
-            id, event = result
+            id, event = result  # pylint: disable=redefined-builtin
             if id == "LOG" and self._state == WorkerState.STARTING:
                 id = "SETUP"
             if id == "LOG" and len(self._predictions_in_flight) == 1: