Add comprehensive tests for main functionality and utility functions

- Implemented tests for the main execution flow, including success and exception handling scenarios.
- Added tests for parsing input from files, strings, and stdin, ensuring proper error handling.
- Created tests for utility functions, covering edge cases and expected behaviors for string handling, header parsing, and received headers.
- Removed dependency on 'six' from the project as it is no longer required.
- Introduced a new test suite for utility functions to ensure robustness and reliability.

Author: fedelemantuano

.github/copilot-instructions.md

@@ -88,6 +88,8 @@ make format   # ruff formatting
 make check    # lint + test
 make pre-commit  # runs pre-commit hooks
 ```
+For all unittest use `pytest` framework and mock external dependencies as needed.
+When you modify code, ensure all tests pass and coverage remains high.
 
 ### Build & Release
 ```bash
@@ -161,4 +163,4 @@ When working with this codebase:
 - Use factory functions, not direct MailParser() instantiation
 - Test with various malformed emails from `tests/mails/`
 - Remember header property naming (underscores for hyphens)
-- Consider security implications of email parsing edge cases
+- Consider security implications of email parsing edge cases

.github/instructions/python.instructions.md

@@ -44,10 +44,10 @@ applyTo: '**/*.py'
 def calculate_area(radius: float) -> float:
     """
     Calculate the area of a circle given the radius.
-    
+
     Parameters:
     radius (float): The radius of the circle.
-    
+
     Returns:
     float: The area of the circle, calculated as π * radius^2.
     """

pyproject.toml

@@ -25,9 +25,7 @@ authors = [
 maintainers = [
   { name = "Fedele Mantuano", email = "mantuano.fedele@gmail.com" }
 ]
-dependencies = [
-    "six>=1.17.0",
-]
+dependencies = []
 
 [dependency-groups]
 dev = [

src/mailparser/const.py

@@ -24,41 +24,46 @@
 
 # Patterns for receiveds
 RECEIVED_PATTERNS = [
-    # each pattern handles matching a single clause
-    # need to exclude withs followed by cipher (e.g., google); (?! cipher)
-    # TODO: ideally would do negative matching for with in parens
-    # need the beginning or space to differentiate from envelope-from
+    # FIXED: More restrictive 'from' clause
+    # Only matches 'from' at the beginning of the header (^) or after
+    # newline/whitespace to avoid matching within "for <email> from <email>"
+    # constructs which caused duplicate matches in IBM gateway headers
     (
-        r"(?:(?:^|\s)from\s+(?P<from>.+?)(?:\s*[(]?"
+        r"(?:(?:^|\n\s*)from\s+(?P<from>.+?)(?:\s*[(]?"
         r"envelope-from|\s*[(]?envelope-sender|\s+"
-        r"by|\s+with(?! cipher)|\s+id|\s+for|\s+via|;))"
+        r"by|\s+with(?! cipher)|\s+id|\s+via|;))"
     ),
-    # need to make sure envelope-from comes before from to prevent mismatches
-    # envelope-from and -sender seem to optionally have space and/or
-    # ( before them other clauses must have whitespace before
+    # IMPROVED: More precise 'by' clause
+    # Modified to not consume 'with' clause, allowing proper separation
+    # of 'by' (server name) and 'with' (protocol) fields
     (
-        r"(?:[^-\.]by\s+(?P<by>.+?)(?:\s*[(]?envelope-from|\s*"
-        r"[(]?envelope-sender|\s+from|\s+with"
-        r"(?! cipher)|\s+id|\s+for|\s+via|;))"
+        r"(?:(?:^|\s)by\s+(?P<by>[^\s]+(?:\s+[^\s]+)*?)"
+        r"(?:\s+with(?! cipher)|\s*[(]?envelope-from|\s*"
+        r"[(]?envelope-sender|\s+id|\s+for|\s+via|;))"
     ),
+    # IMPROVED: 'with' clause with better boundary detection
     (
-        r"(?:with(?! cipher)\s+(?P<with>.+?)(?:\s*[(]?envelope-from|\s*[(]?"
-        r"envelope-sender|\s+from|\s+by|\s+id|\s+for|\s+via|;))"
+        r"(?:(?:^|\s)with(?! cipher)\s+(?P<with>.+?)"
+        r"(?:\s*[(]?envelope-from|\s*[(]?"
+        r"envelope-sender|\s+id|\s+for|\s+via|;))"
     ),
+    # IMPROVED: 'id' clause with cleaner boundaries
     (
-        r"[^\w\.](?:id\s+(?P<id>.+?)(?:\s*[(]?envelope-from|\s*"
-        r"[(]?envelope-sender|\s+from|\s+by|\s+with"
-        r"(?! cipher)|\s+for|\s+via|;))"
+        r"(?:(?:^|\s)id\s+(?P<id>.+?)(?:\s*[(]?envelope-from|\s*"
+        r"[(]?envelope-sender|\s+for|\s+via|;))"
     ),
+    # IMPROVED: 'for' clause - handles "for <email> from <email>" pattern
+    # Stops before 'from' keyword to prevent the 'from' pattern from
+    # matching the sender email in this construct
     (
-        r"(?:for\s+(?P<for>.+?)(?:\s*[(]?envelope-from|\s*[(]?"
-        r"envelope-sender|\s+from|\s+by|\s+with"
-        r"(?! cipher)|\s+id|\s+via|;))"
+        r"(?:(?:^|\s)for\s+(?P<for><[^>]+>|[^\s]+)"
+        r"(?:\s+from|\s*[(]?envelope-from|\s*[(]?"
+        r"envelope-sender|\s+via|;))"
     ),
+    # IMPROVED: 'via' clause with better termination
     (
-        r"(?:via\s+(?P<via>.+?)(?:\s*[(]?"
-        r"envelope-from|\s*[(]?envelope-sender|\s+"
-        r"from|\s+by|\s+id|\s+for|\s+with(?! cipher)|;))"
+        r"(?:(?:^|\s)via\s+(?P<via>.+?)(?:\s*[(]?"
+        r"envelope-from|\s*[(]?envelope-sender|;))"
     ),
     # assumes emails are always inside <>
     r"(?:envelope-from\s+<(?P<envelope_from>.+?)>)",

src/mailparser/core.py

@@ -23,10 +23,7 @@
 import logging
 import os
 
-import six
-
 from mailparser.const import ADDRESSES_HEADERS, EPILOGUE_DEFECTS, REGXIP
-from mailparser.exceptions import MailParserEnvironmentError
 from mailparser.utils import (
     convert_mail_date,
     decode_header_part,
@@ -132,7 +129,7 @@ def __str__(self):
         if self.message:
             return self.subject
         else:
-            return six.text_type()
+            return str()
 
     @classmethod
     def from_file_obj(cls, fp):
@@ -225,10 +222,6 @@ def from_bytes(cls, bt):
             Instance of MailParser
         """
         log.debug("Parsing email from bytes")
-        if six.PY2:
-            raise MailParserEnvironmentError(
-                "Parsing from bytes is valid only for Python 3.x version"
-            )
         message = email.message_from_bytes(bt)
         return cls(message)
 
@@ -527,7 +520,7 @@ def _extract_ip(self, received_header):
         check = REGXIP.findall(received_header[0 : received_header.find("by")])
         if check:
             try:
-                ip_str = six.text_type(check[-1])
+                ip_str = str(check[-1])
                 log.debug(f"Found sender IP {ip_str!r} in {received_header!r}")
                 ip = ipaddress.ip_address(ip_str)
             except ValueError:
@@ -563,7 +556,7 @@ def __getattr__(self, name):
 
         # object headers
         elif name_header in ADDRESSES_HEADERS:
-            h = decode_header_part(self.message.get(name_header, six.text_type()))
+            h = decode_header_part(self.message.get(name_header, str()))
             h_parsed = email.utils.getaddresses([h], strict=True)
             return (
                 h_parsed

src/mailparser/utils.py

@@ -35,8 +35,6 @@
 from email.header import decode_header
 from unicodedata import normalize
 
-import six
-
 from mailparser.const import (
     ADDRESSES_HEADERS,
     JUNK_PATTERN,
@@ -90,52 +88,45 @@ def wrapper(*args, **kwargs):
 @sanitize
 def ported_string(raw_data, encoding="utf-8", errors="ignore"):
     """
-    Give as input raw data and output a str in Python 3
-    and unicode in Python 2.
+    Give as input raw data and output a str in Python 3.
 
     Args:
-        raw_data: Python 2 str, Python 3 bytes or str to porting
+        raw_data: bytes or str to convert to str
         encoding: string giving the name of an encoding
-        errors: his specifies the treatment of characters
+        errors: specifies the treatment of characters
             which are invalid in the input encoding
 
     Returns:
-        str (Python 3) or unicode (Python 2)
+        str
     """
 
     if not raw_data:
-        return six.text_type()
+        return str()
 
-    if isinstance(raw_data, six.text_type):
+    if isinstance(raw_data, str):
         return raw_data
 
-    if six.PY2:
-        try:
-            return six.text_type(raw_data, encoding, errors)
-        except LookupError:
-            return six.text_type(raw_data, "utf-8", errors)
-
-    if six.PY3:
-        try:
-            return six.text_type(raw_data, encoding)
-        except (LookupError, UnicodeDecodeError):
-            return six.text_type(raw_data, "utf-8", errors)
+    # raw_data is bytes, decode it
+    try:
+        return str(raw_data, encoding)
+    except (LookupError, UnicodeDecodeError):
+        return str(raw_data, "utf-8", errors)
 
 
 def decode_header_part(header):
     """
-    Given an raw header returns an decoded header
+    Given a raw header returns a decoded header
 
     Args:
         header (string): header to decode
 
     Returns:
-        str (Python 3) or unicode (Python 2)
+        str
     """
     if not header:
-        return six.text_type()
+        return str()
 
-    output = six.text_type()
+    output = str()
 
     try:
         for d, c in decode_header(header):
@@ -151,10 +142,15 @@ def decode_header_part(header):
 
 
 def ported_open(file_):
-    if six.PY2:
-        return open(file_)
-    elif six.PY3:
-        return open(file_, encoding="utf-8", errors="ignore")
+    """Open a file with UTF-8 encoding and ignore errors.
+
+    Args:
+        file_: path to the file to open
+
+    Returns:
+        file object
+    """
+    return open(file_, encoding="utf-8", errors="ignore")
 
 
 def find_between(text, first_token, last_token):
@@ -179,7 +175,7 @@ def fingerprints(data):
 
     hashes = namedtuple("Hashes", "md5 sha1 sha256 sha512")
 
-    if not isinstance(data, six.binary_type):
+    if not isinstance(data, bytes):
         data = data.encode("utf-8")
 
     # md5
@@ -215,28 +211,19 @@ def msgconvert(email):
 
     Returns:
         tuple with file path of mail converted and
-        standard output data (unicode Python 2, str Python 3)
+        standard output data (str)
     """
     log.debug("Started converting Outlook email")
     temph, temp = tempfile.mkstemp(prefix="outlook_")
     command = ["msgconvert", "--outfile", temp, email]
 
     try:
-        if six.PY2:
-            with open(os.devnull, "w") as devnull:
-                out = subprocess.Popen(
-                    command,
-                    stdin=subprocess.PIPE,
-                    stdout=subprocess.PIPE,
-                    stderr=devnull,
-                )
-        elif six.PY3:
-            out = subprocess.Popen(
-                command,
-                stdin=subprocess.PIPE,
-                stdout=subprocess.PIPE,
-                stderr=subprocess.DEVNULL,
-            )
+        out = subprocess.Popen(
+            command,
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.DEVNULL,
+        )
 
     except OSError as e:
         message = f"Check if 'msgconvert' tool is installed / {e!r}"
@@ -284,12 +271,9 @@ def parse_received(received):
             # otherwise we have one matching clause!
             log.debug("Found one match for %s in %s" % (pattern.pattern, received))
             match = matches[0].groupdict()
-            if six.PY2:
-                values_by_clause[match.keys()[0]] = match.values()[0]
-            elif six.PY3:
-                key = list(match.keys())[0]
-                value = list(match.values())[0]
-                values_by_clause[key] = value
+            key = list(match.keys())[0]
+            value = list(match.values())[0]
+            values_by_clause[key] = value
 
     if len(values_by_clause) == 0:
         # we weren't able to match anything...
@@ -466,7 +450,7 @@ def get_to_domains(to=[], reply_to=[]):
     for i in to + reply_to:
         try:
             domains.add(i[1].split("@")[-1].lower().strip())
-        except KeyError:
+        except (KeyError, IndexError):
             pass
 
     return list(domains)
@@ -495,7 +479,7 @@ def get_header(message, name):
             return headers[0].strip()
         # in this case return a list
         return headers
-    return six.text_type()
+    return str()
 
 
 def get_mail_keys(message, complete=True):