Make tzinfo kwarg clear in get() factory conditions

arrow/factory.py

@@ -205,14 +205,14 @@ def get(self, *args: Any, **kwargs: Any) -> Arrow:
         if len(kwargs) == 1 and tz is None:
             arg_count = 3
 
-        # () -> now, @ utc.
+        # () -> now, @ tzinfo or utc
         if arg_count == 0:
             if isinstance(tz, str):
                 tz = parser.TzinfoParser.parse(tz)
-                return self.type.now(tz)
+                return self.type.now(tzinfo=tz)
 
             if isinstance(tz, dt_tzinfo):
-                return self.type.now(tz)
+                return self.type.now(tzinfo=tz)
 
             return self.type.utcnow()
 
@@ -223,39 +223,39 @@ def get(self, *args: Any, **kwargs: Any) -> Arrow:
             if arg is None:
                 raise TypeError("Cannot parse argument of type None.")
 
-            # try (int, float) -> from timestamp with tz
+            # try (int, float) -> from timestamp @ tzinfo
             elif not isinstance(arg, str) and is_timestamp(arg):
                 if tz is None:
                     # set to UTC by default
                     tz = dateutil_tz.tzutc()
                 return self.type.fromtimestamp(arg, tzinfo=tz)
 
-            # (Arrow) -> from the object's datetime.
+            # (Arrow) -> from the object's datetime @ tzinfo
             elif isinstance(arg, Arrow):
                 return self.type.fromdatetime(arg.datetime, tzinfo=tz)
 
-            # (datetime) -> from datetime.
+            # (datetime) -> from datetime @ tzinfo
             elif isinstance(arg, datetime):
                 return self.type.fromdatetime(arg, tzinfo=tz)
 
-            # (date) -> from date.
+            # (date) -> from date @ tzinfo
             elif isinstance(arg, date):
                 return self.type.fromdate(arg, tzinfo=tz)
 
-            # (tzinfo) -> now, @ tzinfo.
+            # (tzinfo) -> now @ tzinfo
             elif isinstance(arg, dt_tzinfo):
-                return self.type.now(arg)
+                return self.type.now(tzinfo=arg)
 
-            # (str) -> parse.
+            # (str) -> parse @ tzinfo
             elif isinstance(arg, str):
                 dt = parser.DateTimeParser(locale).parse_iso(arg, normalize_whitespace)
-                return self.type.fromdatetime(dt, tz)
+                return self.type.fromdatetime(dt, tzinfo=tz)
 
             # (struct_time) -> from struct_time
             elif isinstance(arg, struct_time):
                 return self.type.utcfromtimestamp(calendar.timegm(arg))
 
-            # (iso calendar) -> convert then from date
+            # (iso calendar) -> convert then from date @ tzinfo
             elif isinstance(arg, tuple) and len(arg) == 3:
                 d = iso_to_gregorian(*arg)
                 return self.type.fromdate(d, tzinfo=tz)
@@ -269,25 +269,25 @@ def get(self, *args: Any, **kwargs: Any) -> Arrow:
 
             if isinstance(arg_1, datetime):
 
-                # (datetime, tzinfo/str) -> fromdatetime replace tzinfo.
+                # (datetime, tzinfo/str) -> fromdatetime @ tzinfo
                 if isinstance(arg_2, (dt_tzinfo, str)):
-                    return self.type.fromdatetime(arg_1, arg_2)
+                    return self.type.fromdatetime(arg_1, tzinfo=arg_2)
                 else:
                     raise TypeError(
                         f"Cannot parse two arguments of types 'datetime', {type(arg_2)!r}."
                     )
 
             elif isinstance(arg_1, date):
 
-                # (date, tzinfo/str) -> fromdate replace tzinfo.
+                # (date, tzinfo/str) -> fromdate @ tzinfo
                 if isinstance(arg_2, (dt_tzinfo, str)):
                     return self.type.fromdate(arg_1, tzinfo=arg_2)
                 else:
                     raise TypeError(
                         f"Cannot parse two arguments of types 'date', {type(arg_2)!r}."
                     )
 
-            # (str, format) -> parse.
+            # (str, format) -> parse @ tzinfo
             elif isinstance(arg_1, str) and isinstance(arg_2, (str, list)):
                 dt = parser.DateTimeParser(locale).parse(
                     args[0], args[1], normalize_whitespace
@@ -299,7 +299,7 @@ def get(self, *args: Any, **kwargs: Any) -> Arrow:
                     f"Cannot parse two arguments of types {type(arg_1)!r} and {type(arg_2)!r}."
                 )
 
-        # 3+ args -> datetime-like via constructor.
+        # 3+ args -> datetime-like via constructor
         else:
             return self.type(*args, **kwargs)