Bump requests from 2.27.1 to 2.28.1 (#1781)

* Bump requests from 2.27.1 to 2.28.1

Bumps [requests](https://github.com/psf/requests) from 2.27.1 to 2.28.1.
- [Release notes](https://github.com/psf/requests/releases)
- [Changelog](https://github.com/psf/requests/blob/main/HISTORY.md)
- [Commits](https://github.com/psf/requests/compare/v2.27.1...v2.28.1)

---
updated-dependencies:
- dependency-name: requests
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>

* Update requests==2.28.1

* Update urllib3==1.26.12

* Update certifi==2022.9.24

* Update idna==3.4

* Update charset-normalizer==2.1.1

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: JonnyWong16 <9099342+JonnyWong16@users.noreply.github.com>

[skip ci]

lib/charset_normalizer/models.py

@@ -4,7 +4,16 @@ from encodings.aliases import aliases
 from hashlib import sha256
 from json import dumps
 from re import sub
-from typing import Any, Dict, Iterator, List, Optional, Tuple, Union
+from typing import (
+    Any,
+    Counter as TypeCounter,
+    Dict,
+    Iterator,
+    List,
+    Optional,
+    Tuple,
+    Union,
+)
 
 from .constant import NOT_PRINTABLE_PATTERN, TOO_BIG_SEQUENCE
 from .md import mess_ratio
@@ -21,21 +30,21 @@ class CharsetMatch:
         languages: "CoherenceMatches",
         decoded_payload: Optional[str] = None,
     ):
-        self._payload = payload  # type: bytes
+        self._payload: bytes = payload
 
-        self._encoding = guessed_encoding  # type: str
-        self._mean_mess_ratio = mean_mess_ratio  # type: float
-        self._languages = languages  # type: CoherenceMatches
-        self._has_sig_or_bom = has_sig_or_bom  # type: bool
-        self._unicode_ranges = None  # type: Optional[List[str]]
+        self._encoding: str = guessed_encoding
+        self._mean_mess_ratio: float = mean_mess_ratio
+        self._languages: CoherenceMatches = languages
+        self._has_sig_or_bom: bool = has_sig_or_bom
+        self._unicode_ranges: Optional[List[str]] = None
 
-        self._leaves = []  # type: List[CharsetMatch]
-        self._mean_coherence_ratio = 0.0  # type: float
+        self._leaves: List[CharsetMatch] = []
+        self._mean_coherence_ratio: float = 0.0
 
-        self._output_payload = None  # type: Optional[bytes]
-        self._output_encoding = None  # type: Optional[str]
+        self._output_payload: Optional[bytes] = None
+        self._output_encoding: Optional[str] = None
 
-        self._string = decoded_payload  # type: Optional[str]
+        self._string: Optional[str] = decoded_payload
 
     def __eq__(self, other: object) -> bool:
         if not isinstance(other, CharsetMatch):
@@ -53,8 +62,8 @@ class CharsetMatch:
         if not isinstance(other, CharsetMatch):
             raise ValueError
 
-        chaos_difference = abs(self.chaos - other.chaos)  # type: float
-        coherence_difference = abs(self.coherence - other.coherence)  # type: float
+        chaos_difference: float = abs(self.chaos - other.chaos)
+        coherence_difference: float = abs(self.coherence - other.coherence)
 
         # Bellow 1% difference --> Use Coherence
         if chaos_difference < 0.01 and coherence_difference > 0.02:
@@ -95,7 +104,7 @@ class CharsetMatch:
         return 0.0
 
     @property
-    def w_counter(self) -> Counter:
+    def w_counter(self) -> TypeCounter[str]:
         """
         Word counter instance on decoded text.
         Notice: Will be removed in 3.0
@@ -137,7 +146,7 @@ class CharsetMatch:
         """
         Encoding name are known by many name, using this could help when searching for IBM855 when it's listed as CP855.
         """
-        also_known_as = []  # type: List[str]
+        also_known_as: List[str] = []
         for u, p in aliases.items():
             if self.encoding == u:
                 also_known_as.append(p)
@@ -227,9 +236,9 @@ class CharsetMatch:
         if self._unicode_ranges is not None:
             return self._unicode_ranges
         # list detected ranges
-        detected_ranges = [
+        detected_ranges: List[Optional[str]] = [
             unicode_range(char) for char in str(self)
-        ]  # type: List[Optional[str]]
+        ]
         # filter and sort
         self._unicode_ranges = sorted(list({r for r in detected_ranges if r}))
         return self._unicode_ranges
@@ -280,8 +289,8 @@ class CharsetMatches:
     Act like a list(iterable) but does not implements all related methods.
     """
 
-    def __init__(self, results: List[CharsetMatch] = None):
-        self._results = sorted(results) if results else []  # type: List[CharsetMatch]
+    def __init__(self, results: Optional[List[CharsetMatch]] = None):
+        self._results: List[CharsetMatch] = sorted(results) if results else []
 
     def __iter__(self) -> Iterator[CharsetMatch]:
         yield from self._results
@@ -360,17 +369,17 @@ class CliDetectionResult:
         unicode_path: Optional[str],
         is_preferred: bool,
     ):
-        self.path = path  # type: str
-        self.unicode_path = unicode_path  # type: Optional[str]
-        self.encoding = encoding  # type: Optional[str]
-        self.encoding_aliases = encoding_aliases  # type: List[str]
-        self.alternative_encodings = alternative_encodings  # type: List[str]
-        self.language = language  # type: str
-        self.alphabets = alphabets  # type: List[str]
-        self.has_sig_or_bom = has_sig_or_bom  # type: bool
-        self.chaos = chaos  # type: float
-        self.coherence = coherence  # type: float
-        self.is_preferred = is_preferred  # type: bool
+        self.path: str = path
+        self.unicode_path: Optional[str] = unicode_path
+        self.encoding: Optional[str] = encoding
+        self.encoding_aliases: List[str] = encoding_aliases
+        self.alternative_encodings: List[str] = alternative_encodings
+        self.language: str = language
+        self.alphabets: List[str] = alphabets
+        self.has_sig_or_bom: bool = has_sig_or_bom
+        self.chaos: float = chaos
+        self.coherence: float = coherence
+        self.is_preferred: bool = is_preferred
 
     @property
     def __dict__(self) -> Dict[str, Any]:  # type: ignore