dataiter 0.99__tar.gz → 0.9999__tar.gz

{dataiter-0.99 → dataiter-0.9999}/.gitignore

@@ -4,10 +4,10 @@
 .envrc
 .pytest_cache
 __pycache__
-benchmark*.csv
 benchmark-head.py
+benchmark-versions.csv
+benchmark-versions.ods
 build
-data/orig
 dataiter.egg-info
 dist
 doc/_build

{dataiter-0.99 → dataiter-0.9999}/COPYING

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2019-2024 Osmo Salomaa
+Copyright (c) 2019-2025 Osmo Salomaa
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

dataiter-0.9999/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.1
+Name: dataiter
+Version: 0.9999
+Summary: Simple, light-weight data frames for Python
+Project-URL: Homepage, https://github.com/otsaloma/dataiter
+Author-email: Osmo Salomaa <otsaloma@iki.fi>
+License-Expression: MIT
+License-File: AUTHORS.md
+License-File: COPYING
+Requires-Python: >=3.9.0
+Requires-Dist: attd>=0.3
+Requires-Dist: numpy<3.0,>=2.0
+Requires-Dist: pyarrow>=2.0
+Requires-Dist: wcwidth>=0.1
+Description-Content-Type: text/markdown
+
+Simple, Light-Weight Data Frames for Python
+===========================================
+
+[![PyPI](https://img.shields.io/pypi/v/dataiter.svg)](https://pypi.org/project/dataiter)
+[![Downloads](https://pepy.tech/badge/dataiter/month)](https://pepy.tech/project/dataiter)
+
+Dataiter's **`DataFrame`** is a class for tabular data similar to R's
+`data.frame`, implementing all common operations to manipulate data. It
+is under the hood a dictionary of NumPy arrays and thus capable of fast
+vectorized operations. You can consider it to be a light-weight
+alternative to Pandas with a simple and consistent API. Performance-wise
+Dataiter relies on NumPy and Numba and is likely to be at best
+comparable to Pandas.
+
+## Installation
+
+```bash
+# Latest stable version
+pip install -U dataiter
+
+# Latest development version
+pip install -U git+https://github.com/otsaloma/dataiter
+
+# Numba (optional)
+pip install -U numba
+```
+
+Dataiter optionally uses **Numba** to speed up certain operations. If
+you have Numba installed, Dataiter will use it automatically. It's
+currently not a hard dependency, so you need to install it separately.
+
+## Quick Start
+
+```python
+>>> import dataiter as di
+>>> data = di.read_csv("data/listings.csv")
+>>> data.filter(hood="Manhattan", guests=2).sort(price=1).head()
+.
+        id      hood zipcode guests    sqft price
+     int64    string  string  int64 float64 int64
+  ──────── ───────── ─────── ────── ─────── ─────
+0 42279170 Manhattan   10013      2     nan     0
+1 42384530 Manhattan   10036      2     nan     0
+2 18835820 Manhattan   10021      2     nan    10
+3 20171179 Manhattan   10027      2     nan    10
+4 14858544 Manhattan              2     nan    15
+5 31397084 Manhattan   10002      2     nan    19
+6 22289683 Manhattan   10031      2     nan    20
+7  7760204 Manhattan   10040      2     nan    22
+8 43292527 Manhattan   10033      2     nan    22
+9 43268040 Manhattan   10033      2     nan    23
+.
+```
+
+## Documentation
+
+https://dataiter.readthedocs.io/
+
+If you're familiar with either dplyr (R) or Pandas (Python), the
+comparison table in the documentation will give you a quick overview of
+the differences and similarities in common operations.
+
+https://dataiter.readthedocs.io/en/stable/comparison.html
+
+## Development
+
+To install a virtualenv for development, use
+
+    make venv
+
+or, for a specific Python version
+
+    make PYTHON=python3.X venv

dataiter-0.9999/README.md

@@ -0,0 +1,73 @@
+Simple, Light-Weight Data Frames for Python
+===========================================
+
+[![PyPI](https://img.shields.io/pypi/v/dataiter.svg)](https://pypi.org/project/dataiter)
+[![Downloads](https://pepy.tech/badge/dataiter/month)](https://pepy.tech/project/dataiter)
+
+Dataiter's **`DataFrame`** is a class for tabular data similar to R's
+`data.frame`, implementing all common operations to manipulate data. It
+is under the hood a dictionary of NumPy arrays and thus capable of fast
+vectorized operations. You can consider it to be a light-weight
+alternative to Pandas with a simple and consistent API. Performance-wise
+Dataiter relies on NumPy and Numba and is likely to be at best
+comparable to Pandas.
+
+## Installation
+
+```bash
+# Latest stable version
+pip install -U dataiter
+
+# Latest development version
+pip install -U git+https://github.com/otsaloma/dataiter
+
+# Numba (optional)
+pip install -U numba
+```
+
+Dataiter optionally uses **Numba** to speed up certain operations. If
+you have Numba installed, Dataiter will use it automatically. It's
+currently not a hard dependency, so you need to install it separately.
+
+## Quick Start
+
+```python
+>>> import dataiter as di
+>>> data = di.read_csv("data/listings.csv")
+>>> data.filter(hood="Manhattan", guests=2).sort(price=1).head()
+.
+        id      hood zipcode guests    sqft price
+     int64    string  string  int64 float64 int64
+  ──────── ───────── ─────── ────── ─────── ─────
+0 42279170 Manhattan   10013      2     nan     0
+1 42384530 Manhattan   10036      2     nan     0
+2 18835820 Manhattan   10021      2     nan    10
+3 20171179 Manhattan   10027      2     nan    10
+4 14858544 Manhattan              2     nan    15
+5 31397084 Manhattan   10002      2     nan    19
+6 22289683 Manhattan   10031      2     nan    20
+7  7760204 Manhattan   10040      2     nan    22
+8 43292527 Manhattan   10033      2     nan    22
+9 43268040 Manhattan   10033      2     nan    23
+.
+```
+
+## Documentation
+
+https://dataiter.readthedocs.io/
+
+If you're familiar with either dplyr (R) or Pandas (Python), the
+comparison table in the documentation will give you a quick overview of
+the differences and similarities in common operations.
+
+https://dataiter.readthedocs.io/en/stable/comparison.html
+
+## Development
+
+To install a virtualenv for development, use
+
+    make venv
+
+or, for a specific Python version
+
+    make PYTHON=python3.X venv

{dataiter-0.99 → dataiter-0.9999}/dataiter/__init__.py

@@ -25,7 +25,7 @@ import numpy as np
 
 from dataiter import util
 
-__version__ = "0.99"
+__version__ = "0.9999"
 
 DEFAULT_PEEK_ELEMENTS = 10
 DEFAULT_PEEK_ITEMS = 3
@@ -34,10 +34,28 @@ PRINT_FLOAT_PRECISION = 6
 PRINT_MAX_ELEMENTS = 100
 PRINT_MAX_ITEMS = 10
 PRINT_MAX_ROWS = 100
+
+#: Maximum amount of columns to wrap print output to. This is only a fallback
+#: in case Python's ``shutil.get_terminal_size`` fails to detect the width of
+#: your terminal. By default the detected full width is used.
 PRINT_MAX_WIDTH = 80
+
+#: Thousand separator to use when printing numbers. By default this is blank,
+#: meaning no thousand separators are rendered.
 PRINT_THOUSAND_SEPARATOR = ""
+
+#: Maximum width to truncate string columns to in :class:`DataFrame` print
+#: output. When this is exceeded, strings will be cut and an ellipsis (``…``)
+#: rendered at the cut point.
 PRINT_TRUNCATE_WIDTH = 36
+
+#: ``True`` to use Numba, if available, to speed up :doc:`aggregations
+#: </aggregation>`, ``False`` to only use pure Python code.
 USE_NUMBA = False
+
+#: ``True`` to use Numba cache for JIT-compiled :doc:`aggregations
+#: </aggregation>`, ``False`` to only keep compiled code in memory for the
+#: duration of the session.
 USE_NUMBA_CACHE = True
 
 if not np.__version__.startswith("2."):
@@ -69,12 +87,14 @@ globals().pop("np", None)
 globals().pop("numba", None)
 globals().pop("util", None)
 
+from dataiter import dtypes # noqa
 from dataiter.vector import Vector # noqa
 from dataiter.data_frame import DataFrame # noqa
 from dataiter.data_frame import DataFrameColumn # noqa
 from dataiter.geojson import GeoJSON # noqa
 from dataiter.list_of_dicts import ListOfDicts # noqa
 from dataiter import dt # noqa
+from dataiter import regex # noqa
 
 from dataiter.aggregate import all # noqa
 from dataiter.aggregate import any # noqa

{dataiter-0.99 → dataiter-0.9999}/dataiter/data_frame.py

@@ -20,7 +20,7 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-import contextlib
+import codecs
 import dataiter
 import functools
 import itertools
@@ -475,24 +475,29 @@ class DataFrame(dict):
             yield colname, np.delete(column, rows)
 
     @classmethod
-    def from_arrow(cls, data, *, strings_as_object=inf, dtypes={}):
+    @deco.new_from_generator
+    def from_arrow(cls, data, *, dtypes={}):
         """
         Return a new data frame from ``pyarrow.Table`` `data`.
 
-        `strings_as_object` is a cutoff point. If any row has more characters
-        than that, the whole column will use the object data type. This is
-        intended to help limit memory use as NumPy strings are fixed-length and
-        can take a huge amount of memory if even a single row is long. If set,
-        `dtypes` overrides this.
-
         `dtypes` is an optional dict mapping column names to NumPy datatypes.
         """
-        # Arrow's 'to_numpy' is "limited to primitive types for which NumPy has
-        # the same physical representation as Arrow, and assuming the Arrow
-        # data has no nulls." Using Pandas is easier and probably good enough.
-        return cls.from_pandas(data.to_pandas(),
-                               strings_as_object=strings_as_object,
-                               dtypes=dtypes)
+        for name, column in zip(data.column_names, data.columns):
+            req_dtype = dtypes.get(name, None)
+            na = column.is_null(nan_is_null=True).to_numpy()
+            column = column.to_numpy()
+            if np.issubdtype(column.dtype, np.object_):
+                if req_dtype is None or np.dtype(req_dtype) != np.dtype(object):
+                    # Likely to be strings, but not necessarily.
+                    # Force type-guessing in Vector.fast.
+                    column = column.tolist()
+            column = DataFrameColumn.fast(column, req_dtype)
+            if na.any():
+                if column.dtype != column.na_dtype:
+                    # Upcast integer to float if needed.
+                    column = column.astype(column.na_dtype)
+                column[na] = column.na_value
+            yield name, column
 
     @classmethod
     def from_json(cls, string, *, columns=[], dtypes={}, **kwargs):
@@ -517,38 +522,29 @@ class DataFrame(dict):
         return cls(**data)
 
     @classmethod
-    def from_pandas(cls, data, *, strings_as_object=inf, dtypes={}):
+    @deco.new_from_generator
+    def from_pandas(cls, data, *, dtypes={}):
         """
         Return a new data frame from ``pandas.DataFrame`` `data`.
 
-        `strings_as_object` is a cutoff point. If any row has more characters
-        than that, the whole column will use the object data type. This is
-        intended to help limit memory use as NumPy strings are fixed-length and
-        can take a huge amount of memory if even a single row is long. If set,
-        `dtypes` overrides this.
-
         `dtypes` is an optional dict mapping column names to NumPy datatypes.
         """
-        if (not isinstance(strings_as_object, (int, float)) or
-            isinstance(strings_as_object, bool)):
-            raise TypeError("Expected a number for strings_as_object")
-        dtypes = dtypes.copy()
-        from pandas.api.types import is_object_dtype
-        if strings_as_object < inf:
-            for name in data.columns:
-                if name not in dtypes and is_object_dtype(data[name]):
-                    with contextlib.suppress(AttributeError):
-                        if data[name].str.len().max() > strings_as_object:
-                            dtypes[name] = object
-        data = {x: data[x].to_numpy(copy=True) for x in data.columns}
-        for name, value in data.items():
-            # Pandas object columns are likely to be strings,
-            # convert to list to force type guessing in Vector.__init__.
-            if np.issubdtype(value.dtype, np.object_):
-                data[name] = data[name].tolist()
-        for name, dtype in dtypes.items():
-            data[name] = DataFrameColumn(data[name], dtype)
-        return cls(**data)
+        for name in data.columns:
+            req_dtype = dtypes.get(name, None)
+            na = data[name].isna().to_numpy(copy=True)
+            column = data[name].to_numpy(copy=True)
+            if np.issubdtype(column.dtype, np.object_):
+                if req_dtype is None or np.dtype(req_dtype) != np.dtype(object):
+                    # Likely to be strings, but not necessarily.
+                    # Force type-guessing in Vector.fast.
+                    column = column.tolist()
+            column = DataFrameColumn.fast(column, req_dtype)
+            if na.any():
+                if column.dtype != column.na_dtype:
+                    # Upcast integer to float if needed.
+                    column = column.astype(column.na_dtype)
+                column[na] = column.na_value
+            yield name, column
 
     def full_join(self, other, *by):
         """
@@ -746,8 +742,9 @@ class DataFrame(dict):
         self._check_dimensions()
         return len(self)
 
-    def _new(self, *args, **kwargs):
-        return self.__class__(*args, **kwargs)
+    @classmethod
+    def _new(cls, *args, **kwargs):
+        return cls(*args, **kwargs)
 
     @property
     def nrow(self):
@@ -875,35 +872,25 @@ class DataFrame(dict):
             yield colname, total
 
     @classmethod
-    def read_csv(cls, path, *, encoding="utf-8", sep=",", header=True, columns=[], strings_as_object=inf, dtypes={}):
+    def read_csv(cls, path, *, encoding="utf-8", sep=",", header=True, columns=[], dtypes={}):
         """
         Return a new data frame from CSV file `path`.
 
         Will automatically decompress if `path` ends in ``.bz2|.gz|.xz``.
-
-        `columns` is an optional list of columns to limit to.
-
-        `strings_as_object` is a cutoff point. If any row has more characters
-        than that, the whole column will use the object data type. This is
-        intended to help limit memory use as NumPy strings are fixed-length and
-        can take a huge amount of memory if even a single row is long. If set,
-        `dtypes` overrides this.
-
-        `dtypes` is an optional dict mapping column names to NumPy datatypes.
+        `columns` is an optional list of columns to limit to. `dtypes` is an
+        optional dict mapping column names to NumPy datatypes.
         """
-        import pandas as pd
-        data = pd.read_csv(path,
-                           sep=sep,
-                           header=0 if header else None,
-                           usecols=columns or None,
-                           dtype=dtypes,
-                           parse_dates=False,
-                           encoding=encoding,
-                           low_memory=False)
+        from pyarrow import csv
+        table = csv.read_csv(
+            path,
+            read_options=csv.ReadOptions(encoding=encoding, autogenerate_column_names=not header),
+            parse_options=csv.ParseOptions(delimiter=sep, newlines_in_values=True),
+            convert_options=csv.ConvertOptions(include_columns=columns))
 
         if not header:
-            data.columns = util.generate_colnames(len(data.columns))
-        return cls.from_pandas(data, strings_as_object=strings_as_object, dtypes=dtypes)
+            names = util.generate_colnames(table.shape[1])
+            table = table.rename_columns(names)
+        return cls.from_arrow(table, dtypes=dtypes)
 
     @classmethod
     def read_json(cls, path, *, encoding="utf-8", columns=[], dtypes={}, **kwargs):
@@ -911,7 +898,6 @@ class DataFrame(dict):
         Return a new data frame from JSON file `path`.
 
         Will automatically decompress if `path` ends in ``.bz2|.gz|.xz``.
-
         `columns` is an optional list of columns to limit to. `dtypes` is an
         optional dict mapping column names to NumPy datatypes. `kwargs` are
         passed to ``json.load``.
@@ -931,24 +917,17 @@ class DataFrame(dict):
             return cls(**data)
 
     @classmethod
-    def read_parquet(cls, path, *, columns=[], strings_as_object=inf, dtypes={}):
+    def read_parquet(cls, path, *, columns=[], dtypes={}):
         """
         Return a new data frame from Parquet file `path`.
 
-        `columns` is an optional list of columns to limit to.
-
-        `strings_as_object` is a cutoff point. If any row has more characters
-        than that, the whole column will use the object data type. This is
-        intended to help limit memory use as NumPy strings are fixed-length and
-        can take a huge amount of memory if even a single row is long. If set,
-        `dtypes` overrides this.
-
-        `dtypes` is an optional dict mapping column names to NumPy datatypes.
+        `columns` is an optional list of columns to limit to. `dtypes` is an
+        optional dict mapping column names to NumPy datatypes.
         """
         import pyarrow.parquet as pq
         columns = columns or None
         data = pq.read_table(path, columns=columns)
-        return cls.from_arrow(data, strings_as_object=strings_as_object, dtypes=dtypes)
+        return cls.from_arrow(data, dtypes=dtypes)
 
     @classmethod
     def read_pickle(cls, path):
@@ -1076,23 +1055,30 @@ class DataFrame(dict):
         >>> data = di.read_csv("data/listings.csv")
         >>> data.sort(hood=1, zipcode=1)
         """
-        @deco.tuplefy
-        def sort_key():
-            pairs = colname_dir_pairs.items()
-            for colname, dir in reversed(list(pairs)):
-                if dir not in [1, -1]:
-                    raise ValueError("dir should be 1 or -1")
-                column = self[colname]
-                if column.is_object():
-                    # See Vector.sort for comparison.
-                    column = column.as_string()
-                if column.is_string():
-                    column[column.is_na()] = "\uffff"
-                if dir < 0 and not (column.is_boolean() or column.is_number()):
-                    # Use rank for non-numeric so that we can sort descending.
-                    column = column.rank(method="min")
-                yield column if dir > 0 else -column
-        indices = np.lexsort(sort_key())
+        def sort_key(colname, dir):
+            if dir not in [1, -1]:
+                raise ValueError("dir should be 1 or -1")
+            column = self[colname]
+            column = column._optimize_for_argsort()
+            if column._is_string_fixed():
+                column[column.is_na()] = "\uffff"
+            if dir > 0 and any((
+                # No strings here due to lexsort segfault.
+                # Need to require NumPy >= 2.2.1 to fix this.
+                # https://github.com/numpy/numpy/issues/27984
+                column._is_string_fixed(),
+                column.is_boolean(),
+                column.is_bytes(),
+                column.is_datetime(),
+                column.is_float(),
+                column.is_integer(),
+                column.is_timedelta(),
+            )): return column
+            if not column.is_number():
+                column = column.rank(method="min")
+            return column if dir > 0 else -column
+        indices = np.lexsort(tuple(
+            sort_key(*x) for x in reversed(colname_dir_pairs.items())))
         for colname, column in self.items():
             yield colname, column[indices].copy()
 
@@ -1187,7 +1173,7 @@ class DataFrame(dict):
         n = min(self.nrow, max_rows)
         columns = {colname: util.upad(
             [colname] +
-            [str(column.dtype)] +
+            [str(column.dtype_label)] +
             [str(x) for x in column[:n].to_strings(
                 quote=False, pad=True, truncate_width=truncate_width)]
         ) for colname, column in self.items()}
@@ -1224,21 +1210,31 @@ class DataFrame(dict):
         >>> data = di.read_csv("data/listings.csv")
         >>> data.unique("hood")
         """
+        # Strangely, standard Python is a lot faster here than np.unique
+        # with all the extra needed across columns of different type.
+        # We just need to avoid NaN and NaT for the 'in' checks to work.
         colnames = colnames or self.colnames
-        if (len(colnames) == 1 and
-            not self[colnames[0]].is_object()):
-            # Use a single column directly.
-            by = self[colnames[0]]
-        elif (len(set(self[x].dtype for x in colnames)) == 1 and
-              not self[colnames[0]].is_object()):
-            # Stack matching dtypes directly in a new array.
-            by = np.column_stack([self[x] for x in colnames])
-        else:
-            # Use rank for differing dtypes.
-            by = np.column_stack([self[x].rank(method="min") for x in colnames])
-        indices = np.sort(np.unique(by, return_index=True, axis=0)[1])
+        columns = [self[x] for x in colnames]
+        for i, column in enumerate(columns):
+            if column.is_datetime():
+                flag = np.nanmin(column) - np.timedelta64(1, "D")
+                if np.isnat(flag):
+                    flag = np.datetime64("-001-01-01")
+                columns[i] = column.replace_na(flag)
+            if column.is_float():
+                flag = np.nanmin(column) - 1
+                if np.isnan(flag):
+                    flag = -1
+                columns[i] = column.replace_na(flag)
+        rows = list(zip(*columns))
+        seen = set()
+        keep = []
+        for i in range(self.nrow):
+            if rows[i] not in seen:
+                seen.add(rows[i])
+                keep.append(i)
         for colname, column in self.items():
-            yield colname, column[indices].copy()
+            yield colname, column[keep].copy()
 
     @deco.new_from_generator
     def unselect(self, *colnames):
@@ -1280,16 +1276,24 @@ class DataFrame(dict):
 
         Will automatically compress if `path` ends in ``.bz2|.gz|.xz``.
         """
-        data = self.to_pandas()
+        from pyarrow import csv
+        table = self.to_arrow()
         util.makedirs_for_file(path)
-        data.to_csv(path, sep=sep, header=header, index=False, encoding=encoding)
+        csv.write_csv(table, path, write_options=csv.WriteOptions(include_header=header,
+                                                                  delimiter=sep,
+                                                                  quoting_style="needed"))
+
+        # XXX: Arrow's WriteOptions doesn't include encoding.
+        # If user requested something else than UTF-8, we need to rewrite!
+        if codecs.lookup(encoding) != codecs.lookup("utf-8"):
+            with util.xopen(path, "rt", encoding="utf-8") as f: text = f.read()
+            with util.xopen(path, "wt", encoding=encoding) as f: f.write(text)
 
     def write_json(self, path, *, encoding="utf-8", **kwargs):
         """
         Write data frame to JSON file `path`.
 
         Will automatically compress if `path` ends in ``.bz2|.gz|.xz``.
-
         `kwargs` are passed to ``json.JSONEncoder``.
         """
         return self.to_list_of_dicts().write_json(path, encoding=encoding, **kwargs)

{dataiter-0.99 → dataiter-0.9999}/dataiter/dt.py

@@ -23,8 +23,10 @@
 import datetime
 import numpy as np
 
+from dataiter import dtypes
 from dataiter import util
 from dataiter import Vector
+from numpy.dtypes import StringDType
 
 def day(x):
     """
@@ -46,22 +48,21 @@ def from_string(x, format):
     >>> dt.from_string(x, "%d.%m.%Y")
     """
     if util.is_scalar(x):
-        x = np.array([x], str)
+        x = Vector([x], str)
         return from_string(x, format)[0]
-    x = util.sequencify(x)
     assert isinstance(x, np.ndarray)
-    assert np.issubdtype(x.dtype, np.str_)
+    assert isinstance(x.dtype, StringDType)
     out = np.full_like(x, None, object)
     out = Vector.fast(out, object)
-    na = x == ""
+    na = x == dtypes.string.na_object
     f = np.vectorize(lambda x: datetime.datetime.strptime(x, format))
     out[~na] = f(x[~na].astype(object))
     out = out.as_datetime()
-    if len(out[~na]) > 0:
-        if (hour(out[~na]) == 0).all():
-            if (minute(out[~na]) == 0).all():
-                if (second(out[~na]) == 0).all():
-                    out = out.as_date()
+    if (len(out[~na]) > 0 and
+        (hour(out[~na])   == 0).all() and
+        (minute(out[~na]) == 0).all() and
+        (second(out[~na]) == 0).all()):
+        out = out.as_date()
     return out
 
 def hour(x):
@@ -146,9 +147,8 @@ def now():
 
 def _pull_datetime(x, function):
     if util.is_scalar(x):
-        x = np.array([x], np.datetime64)
+        x = Vector([x], np.datetime64)
         return _pull_datetime(x, function)[0]
-    x = util.sequencify(x)
     assert isinstance(x, np.ndarray)
     assert np.issubdtype(x.dtype, np.datetime64)
     out = np.full_like(x, np.nan)
@@ -161,9 +161,8 @@ def _pull_datetime(x, function):
 
 def _pull_int(x, function):
     if util.is_scalar(x):
-        x = np.array([x], np.datetime64)
+        x = Vector([x], np.datetime64)
         return _pull_int(x, function)[0]
-    x = util.sequencify(x)
     assert isinstance(x, np.ndarray)
     assert np.issubdtype(x.dtype, np.datetime64)
     out = np.full_like(x, np.nan, float)
@@ -176,12 +175,11 @@ def _pull_int(x, function):
 
 def _pull_str(x, function):
     if util.is_scalar(x):
-        x = np.array([x], np.datetime64)
+        x = Vector([x], np.datetime64)
         return _pull_str(x, function)[0]
-    x = util.sequencify(x)
     assert isinstance(x, np.ndarray)
     assert np.issubdtype(x.dtype, np.datetime64)
-    out = np.full_like(x, "", object)
+    out = np.full_like(x, dtypes.string.na_object, object)
     out = Vector.fast(out, object)
     na = np.isnat(x)
     if na.all(): return out
@@ -214,7 +212,6 @@ def replace(x, year=None, month=None, day=None, hour=None, minute=None, second=N
     scalar_keys = [x for x in kwargs if util.is_scalar(kwargs[x])]
     vector_keys = [x for x in kwargs if x not in scalar_keys]
     # Like _pull_datetime, but no vectorized function.
-    x = util.sequencify(x)
     assert isinstance(x, np.ndarray)
     assert np.issubdtype(x.dtype, np.datetime64)
     out = np.full_like(x, np.nan)