Apply ruff unsafe fixes

Author: oschwald

examples/benchmark.py

@@ -2,6 +2,7 @@
 
 
 import argparse
+import contextlib
 import random
 import socket
 import struct
@@ -19,12 +20,10 @@
 reader = geoip2.database.Reader(args.file, mode=args.mode)
 
 
-def lookup_ip_address():
+def lookup_ip_address() -> None:
     ip = socket.inet_ntoa(struct.pack("!L", random.getrandbits(32)))
-    try:
-        record = reader.city(str(ip))
-    except geoip2.errors.AddressNotFoundError:
-        pass
+    with contextlib.suppress(geoip2.errors.AddressNotFoundError):
+        reader.city(str(ip))
 
 
 elapsed = timeit.timeit(

geoip2/_internal.py

@@ -1,11 +1,11 @@
-"""This package contains internal utilities"""
+"""This package contains internal utilities."""
 
 # pylint: disable=too-few-public-methods
 from abc import ABCMeta
 
 
 class Model(metaclass=ABCMeta):
-    """Shared methods for MaxMind model classes"""
+    """Shared methods for MaxMind model classes."""
 
     def __eq__(self, other: object) -> bool:
         return isinstance(other, self.__class__) and self.to_dict() == other.to_dict()
@@ -15,7 +15,7 @@ def __ne__(self, other):
 
     # pylint: disable=too-many-branches
     def to_dict(self):
-        """Returns a dict of the object suitable for serialization"""
+        """Returns a dict of the object suitable for serialization."""
         result = {}
         for key, value in self.__dict__.items():
             if key.startswith("_"):

geoip2/database.py

@@ -8,7 +8,7 @@
 import inspect
 import os
 from collections.abc import Sequence
-from typing import IO, Any, AnyStr, Optional, Type, Union, cast
+from typing import IO, Any, AnyStr, Optional, Union, cast
 
 import maxminddb
 from maxminddb import (
@@ -253,7 +253,7 @@ def _get(self, database_type: str, ip_address: IPAddress) -> Any:
 
     def _model_for(
         self,
-        model_class: Union[Type[Country], Type[Enterprise], Type[City]],
+        model_class: Union[type[Country], type[Enterprise], type[City]],
         types: str,
         ip_address: IPAddress,
     ) -> Union[Country, Enterprise, City]:
@@ -268,11 +268,11 @@ def _model_for(
     def _flat_model_for(
         self,
         model_class: Union[
-            Type[Domain],
-            Type[ISP],
-            Type[ConnectionType],
-            Type[ASN],
-            Type[AnonymousIP],
+            type[Domain],
+            type[ISP],
+            type[ConnectionType],
+            type[ASN],
+            type[AnonymousIP],
         ],
         types: str,
         ip_address: IPAddress,

geoip2/errors.py

@@ -53,7 +53,7 @@ def __init__(
 
     @property
     def network(self) -> Optional[Union[ipaddress.IPv4Network, ipaddress.IPv6Network]]:
-        """The network for the error"""
+        """The network for the error."""
         if self.ip_address is None or self._prefix_len is None:
             return None
         return ipaddress.ip_network(f"{self.ip_address}/{self._prefix_len}", False)

geoip2/models.py

@@ -15,7 +15,7 @@
 import ipaddress
 from abc import ABCMeta
 from collections.abc import Sequence
-from typing import Dict, List, Optional, Union
+from typing import Optional, Union
 
 import geoip2.records
 from geoip2._internal import Model
@@ -81,14 +81,14 @@ def __init__(
         self,
         locales: Optional[Sequence[str]],
         *,
-        continent: Optional[Dict] = None,
-        country: Optional[Dict] = None,
+        continent: Optional[dict] = None,
+        country: Optional[dict] = None,
         ip_address: Optional[IPAddress] = None,
-        maxmind: Optional[Dict] = None,
+        maxmind: Optional[dict] = None,
         prefix_len: Optional[int] = None,
-        registered_country: Optional[Dict] = None,
-        represented_country: Optional[Dict] = None,
-        traits: Optional[Dict] = None,
+        registered_country: Optional[dict] = None,
+        represented_country: Optional[dict] = None,
+        traits: Optional[dict] = None,
         **_,
     ) -> None:
         self._locales = locales
@@ -200,18 +200,18 @@ def __init__(
         self,
         locales: Optional[Sequence[str]],
         *,
-        city: Optional[Dict] = None,
-        continent: Optional[Dict] = None,
-        country: Optional[Dict] = None,
-        location: Optional[Dict] = None,
+        city: Optional[dict] = None,
+        continent: Optional[dict] = None,
+        country: Optional[dict] = None,
+        location: Optional[dict] = None,
         ip_address: Optional[IPAddress] = None,
-        maxmind: Optional[Dict] = None,
-        postal: Optional[Dict] = None,
+        maxmind: Optional[dict] = None,
+        postal: Optional[dict] = None,
         prefix_len: Optional[int] = None,
-        registered_country: Optional[Dict] = None,
-        represented_country: Optional[Dict] = None,
-        subdivisions: Optional[List[Dict]] = None,
-        traits: Optional[Dict] = None,
+        registered_country: Optional[dict] = None,
+        represented_country: Optional[dict] = None,
+        subdivisions: Optional[list[dict]] = None,
+        traits: Optional[dict] = None,
         **_,
     ) -> None:
         super().__init__(
@@ -360,7 +360,7 @@ class Enterprise(City):
 
 
 class SimpleModel(Model, metaclass=ABCMeta):
-    """Provides basic methods for non-location models"""
+    """Provides basic methods for non-location models."""
 
     _ip_address: IPAddress
     _network: Optional[Union[ipaddress.IPv4Network, ipaddress.IPv6Network]]
@@ -396,7 +396,7 @@ def __repr__(self) -> str:
 
     @property
     def ip_address(self):
-        """The IP address for the record"""
+        """The IP address for the record."""
         if not isinstance(
             self._ip_address,
             (ipaddress.IPv4Address, ipaddress.IPv6Address),
@@ -406,7 +406,7 @@ def ip_address(self):
 
     @property
     def network(self) -> Optional[Union[ipaddress.IPv4Network, ipaddress.IPv6Network]]:
-        """The network for the record"""
+        """The network for the record."""
         # This code is duplicated for performance reasons
         network = self._network
         if network is not None:

geoip2/records.py

@@ -12,7 +12,7 @@
 # pylint:disable=R0903
 from abc import ABCMeta
 from collections.abc import Sequence
-from typing import Dict, Optional, Type, Union
+from typing import Optional, Union
 
 from geoip2._internal import Model
 
@@ -28,13 +28,13 @@ def __repr__(self) -> str:
 class PlaceRecord(Record, metaclass=ABCMeta):
     """All records with :py:attr:`names` subclass :py:class:`PlaceRecord`."""
 
-    names: Dict[str, str]
+    names: dict[str, str]
     _locales: Sequence[str]
 
     def __init__(
         self,
         locales: Optional[Sequence[str]],
-        names: Optional[Dict[str, str]],
+        names: Optional[dict[str, str]],
     ) -> None:
         if locales is None:
             locales = ["en"]
@@ -98,7 +98,7 @@ def __init__(
         *,
         confidence: Optional[int] = None,
         geoname_id: Optional[int] = None,
-        names: Optional[Dict[str, str]] = None,
+        names: Optional[dict[str, str]] = None,
         **_,
     ) -> None:
         self.confidence = confidence
@@ -152,7 +152,7 @@ def __init__(
         *,
         code: Optional[str] = None,
         geoname_id: Optional[int] = None,
-        names: Optional[Dict[str, str]] = None,
+        names: Optional[dict[str, str]] = None,
         **_,
     ) -> None:
         self.code = code
@@ -224,7 +224,7 @@ def __init__(
         geoname_id: Optional[int] = None,
         is_in_european_union: bool = False,
         iso_code: Optional[str] = None,
-        names: Optional[Dict[str, str]] = None,
+        names: Optional[dict[str, str]] = None,
         **_,
     ) -> None:
         self.confidence = confidence
@@ -305,7 +305,7 @@ def __init__(
         geoname_id: Optional[int] = None,
         is_in_european_union: bool = False,
         iso_code: Optional[str] = None,
-        names: Optional[Dict[str, str]] = None,
+        names: Optional[dict[str, str]] = None,
         # pylint:disable=redefined-builtin
         type: Optional[str] = None,
         **_,
@@ -536,7 +536,7 @@ def __init__(
         confidence: Optional[int] = None,
         geoname_id: Optional[int] = None,
         iso_code: Optional[str] = None,
-        names: Optional[Dict[str, str]] = None,
+        names: Optional[dict[str, str]] = None,
         **_,
     ) -> None:
         self.confidence = confidence
@@ -558,13 +558,12 @@ class Subdivisions(tuple):
     """
 
     def __new__(
-        cls: Type["Subdivisions"],
+        cls: type["Subdivisions"],
         locales: Optional[Sequence[str]],
         *subdivisions,
     ) -> "Subdivisions":
         subobjs = tuple(Subdivision(locales, **x) for x in subdivisions)
-        obj = super().__new__(cls, subobjs)  # type: ignore
-        return obj
+        return super().__new__(cls, subobjs)  # type: ignore
 
     def __init__(
         self,
@@ -925,7 +924,7 @@ def __init__(
 
     @property
     def ip_address(self):
-        """The IP address for the record"""
+        """The IP address for the record."""
         if not isinstance(
             self._ip_address,
             (ipaddress.IPv4Address, ipaddress.IPv6Address),
@@ -935,7 +934,7 @@ def ip_address(self):
 
     @property
     def network(self) -> Optional[Union[ipaddress.IPv4Network, ipaddress.IPv6Network]]:
-        """The network for the record"""
+        """The network for the record."""
         # This code is duplicated for performance reasons
         network = self._network
         if network is not None:

geoip2/types.py

@@ -1,4 +1,4 @@
-"""Provides types used internally"""
+"""Provides types used internally."""
 
 from ipaddress import IPv4Address, IPv6Address
 from typing import Union

geoip2/webservice.py

@@ -28,7 +28,7 @@
 import ipaddress
 import json
 from collections.abc import Sequence
-from typing import Any, Dict, Optional, Type, Union, cast
+from typing import Any, Optional, Union, cast
 
 import aiohttp
 import aiohttp.http
@@ -358,7 +358,7 @@ async def _session(self) -> aiohttp.ClientSession:
     async def _response_for(
         self,
         path: str,
-        model_class: Union[Type[Insights], Type[City], Type[Country]],
+        model_class: Union[type[Insights], type[City], type[Country]],
         ip_address: IPAddress,
     ) -> Union[Country, City, Insights]:
         uri = self._uri(path, ip_address)
@@ -372,8 +372,8 @@ async def _response_for(
             decoded_body = self._handle_success(body, uri)
             return model_class(self._locales, **decoded_body)
 
-    async def close(self):
-        """Close underlying session
+    async def close(self) -> None:
+        """Close underlying session.
 
         This will close the session and any associated connections.
         """
@@ -441,7 +441,7 @@ class Client(BaseClient):
     """
 
     _session: requests.Session
-    _proxies: Optional[Dict[str, str]]
+    _proxies: Optional[dict[str, str]]
 
     def __init__(  # pylint: disable=too-many-arguments,too-many-positional-arguments
         self,
@@ -510,7 +510,7 @@ def insights(self, ip_address: IPAddress = "me") -> Insights:
     def _response_for(
         self,
         path: str,
-        model_class: Union[Type[Insights], Type[City], Type[Country]],
+        model_class: Union[type[Insights], type[City], type[Country]],
         ip_address: IPAddress,
     ) -> Union[Country, City, Insights]:
         uri = self._uri(path, ip_address)
@@ -523,8 +523,8 @@ def _response_for(
         decoded_body = self._handle_success(body, uri)
         return model_class(self._locales, **decoded_body)
 
-    def close(self):
-        """Close underlying session
+    def close(self) -> None:
+        """Close underlying session.
 
         This will close the session and any associated connections.
         """

tests/database_test.py

@@ -283,5 +283,5 @@ def test_modes(self, mock_open) -> None:
         with geoip2.database.Reader(
             path,
             mode=geoip2.database.MODE_MMAP_EXT,
-        ) as reader:
+        ):
             mock_open.assert_called_once_with(path, geoip2.database.MODE_MMAP_EXT)

tests/models_test.py

@@ -4,15 +4,14 @@
 import ipaddress
 import sys
 import unittest
-from typing import Dict
 
 sys.path.append("..")
 
 import geoip2.models
 
 
 class TestModels(unittest.TestCase):
-    def setUp(self):
+    def setUp(self) -> None:
         self.maxDiff = 20_000
 
     def test_insights_full(self) -> None:
@@ -447,7 +446,7 @@ def test_unknown_keys(self) -> None:
 
 
 class TestNames(unittest.TestCase):
-    raw: Dict = {
+    raw: dict = {
         "continent": {
             "code": "NA",
             "geoname_id": 42,