src/connect: typo compress

Makefile

@@ -0,0 +1,13 @@
+SOURCE_FILES = src
+
+.PHONY: format
+format:
+	uv run ruff check ${SOURCE_FILES} --fix --unsafe-fixes
+	uv run ruff format ${SOURCE_FILES}
+
+.PHONY: lint
+lint:
+	uv run mypy ${SOURCE_FILES}
+	uv run pyright ${SOURCE_FILES}
+	uv run ruff check ${SOURCE_FILES}
+	uv run ruff format --check ${SOURCE_FILES}

pyproject.toml

@@ -97,6 +97,9 @@ ignore = [
 "__init__.py" = ["D104"]
 "version.py" = ["D100"]
 
+[tool.ruff.lint.pydocstyle]
+convention = "google"
+
 [tool.ruff.format]
 preview = true
 

src/connect/__init__.py

@@ -0,0 +1,68 @@
+"""Connect-Python: A Python implementation of the Connect protocol."""
+
+from connect.call_options import CallOptions
+from connect.client import Client, ClientConfig
+from connect.code import Code
+from connect.codec import Codec, ProtoBinaryCodec, ProtoJSONCodec
+from connect.compression import Compression, GZipCompression
+from connect.connect import (
+    Peer,
+    Spec,
+    StreamingClientConn,
+    StreamingHandlerConn,
+    StreamRequest,
+    StreamResponse,
+    StreamType,
+    UnaryRequest,
+    UnaryResponse,
+)
+from connect.content_stream import AsyncByteStream
+from connect.error import ConnectError
+from connect.handler import Handler
+from connect.handler_context import HandlerContext
+from connect.headers import Headers
+from connect.idempotency_level import IdempotencyLevel
+from connect.middleware import ConnectMiddleware
+from connect.options import ClientOptions, ConnectOptions
+from connect.protocol import Protocol
+from connect.request import Request
+from connect.response import Response as HTTPResponse
+from connect.response import StreamingResponse
+from connect.response_writer import ServerResponseWriter
+from connect.version import __version__
+
+__all__ = [
+    "__version__",
+    "AsyncByteStream",
+    "CallOptions",
+    "Client",
+    "ClientConfig",
+    "ClientOptions",
+    "Code",
+    "Codec",
+    "Compression",
+    "ConnectError",
+    "ConnectMiddleware",
+    "ConnectOptions",
+    "GZipCompression",
+    "Handler",
+    "HandlerContext",
+    "Headers",
+    "HTTPResponse",
+    "IdempotencyLevel",
+    "Peer",
+    "Protocol",
+    "ProtoBinaryCodec",
+    "ProtoJSONCodec",
+    "Request",
+    "ServerResponseWriter",
+    "Spec",
+    "StreamingClientConn",
+    "StreamingHandlerConn",
+    "StreamingResponse",
+    "StreamRequest",
+    "StreamResponse",
+    "StreamType",
+    "UnaryRequest",
+    "UnaryResponse",
+]

src/connect/client.py

@@ -14,7 +14,7 @@
 from connect.client_interceptor import apply_interceptors
 from connect.code import Code
 from connect.codec import Codec, CodecNameType, ProtoBinaryCodec, ProtoJSONCodec
-from connect.compression import COMPRESSION_IDENTITY, Compression, GZipCompression, get_compresion_from_name
+from connect.compression import COMPRESSION_IDENTITY, Compression, GZipCompression, get_compression_from_name
 from connect.connect import (
     Spec,
     StreamRequest,
@@ -130,7 +130,7 @@ def __init__(self, raw_url: str, options: ClientOptions):
         self.request_compression_name = options.request_compression_name
         self.compressions = [GZipCompression()]
         if self.request_compression_name and self.request_compression_name != COMPRESSION_IDENTITY:
-            compression = get_compresion_from_name(self.request_compression_name, self.compressions)
+            compression = get_compression_from_name(self.request_compression_name, self.compressions)
             if not compression:
                 raise ConnectError(
                     f"unknown compression: {self.request_compression_name}",

src/connect/compression.py

@@ -29,7 +29,7 @@ def name(self) -> str:
 
     @abc.abstractmethod
     def compress(self, data: bytes) -> bytes:
-        """Compresse the given data using a specified compression algorithm.
+        """Compress the given data using a specified compression algorithm.
 
         Args:
             data (bytes): The data to be compressed.
@@ -42,7 +42,7 @@ def compress(self, data: bytes) -> bytes:
 
     @abc.abstractmethod
     def decompress(self, data: bytes, read_max_bytes: int) -> bytes:
-        """Decompresse the given data.
+        """Decompress the given data.
 
         Args:
             data (bytes): The compressed data to be decompressed.
@@ -75,7 +75,7 @@ def name(self) -> str:
         return self._name
 
     def compress(self, data: bytes) -> bytes:
-        """Compresse the given data using gzip compression.
+        """Compress the given data using gzip compression.
 
         Args:
             data (bytes): The data to be compressed.
@@ -91,7 +91,7 @@ def compress(self, data: bytes) -> bytes:
         return buf.getvalue()
 
     def decompress(self, data: bytes, read_max_bytes: int) -> bytes:
-        """Decompresse the given gzip-compressed data.
+        """Decompress the given gzip-compressed data.
 
         Args:
             data (bytes): The gzip-compressed data to decompress.
@@ -111,7 +111,7 @@ def decompress(self, data: bytes, read_max_bytes: int) -> bytes:
         return data
 
 
-def get_compresion_from_name(name: str | None, compressions: list[Compression]) -> Compression | None:
+def get_compression_from_name(name: str | None, compressions: list[Compression]) -> Compression | None:
     """Retrieve a Compression object from a list of compressions by its name.
 
     Args:
@@ -122,12 +122,12 @@ def get_compresion_from_name(name: str | None, compressions: list[Compression])
         Compression | None: The Compression object with the matching name, or None if not found.
 
     """
-    compresoin = (
+    compression = (
         next(
             (compression for compression in compressions if compression.name == name),
             None,
         )
         if name
         else None
     )
-    return compresoin
+    return compression

src/connect/content_stream.py

@@ -148,7 +148,7 @@ async def aclose(self) -> None:
         if self._closed:
             return
 
-        self.closed = True
+        self._closed = True
         if self._aclose_func:
             await self._aclose_func()
 

src/connect/protocol_connect/connect_client.py

@@ -17,7 +17,7 @@
 
 from connect.code import Code
 from connect.codec import Codec, StableCodec
-from connect.compression import COMPRESSION_IDENTITY, Compression, get_compresion_from_name
+from connect.compression import COMPRESSION_IDENTITY, Compression, get_compression_from_name
 from connect.connect import (
     Address,
     Peer,
@@ -155,7 +155,7 @@ def conn(self, spec: Spec, headers: Headers) -> StreamingClientConn:
                 request_headers=headers,
                 marshaler=ConnectUnaryRequestMarshaler(
                     codec=self.params.codec,
-                    compression=get_compresion_from_name(self.params.compression_name, self.params.compressions),
+                    compression=get_compression_from_name(self.params.compression_name, self.params.compressions),
                     compress_min_bytes=self.params.compress_min_bytes,
                     send_max_bytes=self.params.send_max_bytes,
                     headers=headers,
@@ -183,7 +183,7 @@ def conn(self, spec: Spec, headers: Headers) -> StreamingClientConn:
                     codec=self.params.codec,
                     compress_min_bytes=self.params.compress_min_bytes,
                     send_max_bytes=self.params.send_max_bytes,
-                    compression=get_compresion_from_name(self.params.compression_name, self.params.compressions),
+                    compression=get_compression_from_name(self.params.compression_name, self.params.compressions),
                 ),
                 unmarshaler=ConnectStreamingUnmarshaler(
                     codec=self.params.codec,
@@ -489,7 +489,7 @@ async def _validate_response(self, response: httpcore.Response) -> None:
                 Code.INTERNAL,
             )
 
-        self.unmarshaler.compression = get_compresion_from_name(compression, self.compressions)
+        self.unmarshaler.compression = get_compression_from_name(compression, self.compressions)
 
         if validate_error:
 
@@ -839,7 +839,7 @@ async def _validate_response(self, response: httpcore.Response) -> None:
                 Code.INTERNAL,
             )
 
-        self.unmarshaler.compression = get_compresion_from_name(compression, self.compressions)
+        self.unmarshaler.compression = get_compression_from_name(compression, self.compressions)
         self._response_headers.update(response_headers)
 
     async def aclose(self) -> None:

src/connect/protocol_grpc/grpc_client.py

@@ -12,7 +12,7 @@
 
 from connect.code import Code
 from connect.codec import Codec
-from connect.compression import COMPRESSION_IDENTITY, Compression, get_compresion_from_name
+from connect.compression import COMPRESSION_IDENTITY, Compression, get_compression_from_name
 from connect.connect import (
     Peer,
     Spec,
@@ -150,7 +150,7 @@ def conn(self, spec: Spec, headers: Headers) -> StreamingClientConn:
                 codec=self.params.codec,
                 compress_min_bytes=self.params.compress_min_bytes,
                 send_max_bytes=self.params.send_max_bytes,
-                compression=get_compresion_from_name(self.params.compression_name, self.params.compressions),
+                compression=get_compression_from_name(self.params.compression_name, self.params.compressions),
             ),
             unmarshaler=GRPCUnmarshaler(
                 web=self.web,
@@ -408,7 +408,7 @@ async def _validate_response(self, response: httpcore.Response) -> None:
 
         compression = response_headers.get(GRPC_HEADER_COMPRESSION, None)
         if compression and compression != COMPRESSION_IDENTITY:
-            self.unmarshaler.compression = get_compresion_from_name(compression, self.compressions)
+            self.unmarshaler.compression = get_compression_from_name(compression, self.compressions)
 
         self._response_headers.update(response_headers)