Add epoch_unit to analyzer

And store the offset and scale directly rather than the datetime-based
epoch. It's a little more efficient this way as the offset and scale are
used directly and we only really need the epoch and unit (which offset
and scale are derived from) for display purposes, which is basically a
one-off in structa's runtime

Author: waveform80

structa/analyzer.py

@@ -161,7 +161,12 @@ class Analyzer:
     :type epoch: datetime.datetime or None
     :param epoch:
         The epoch to use when converting numbers to datetime values. Defaults
-        to the UNIX epoch (1st January, 1970)
+        to the UNIX epoch (1st January, 1970).
+
+    :type epoch_unit: datetime.timedelta or None
+    :param epoch_unit:
+        The unit of time used in numeric representations of datetime values.
+        Defaults to 1 second.
 
     :type progress: object or None
     :param progress:
@@ -173,8 +178,11 @@ def __init__(self, *, bad_threshold=Fraction(2, 100),
                  empty_threshold=Fraction(98, 100),
                  null_threshold=Fraction(98, 100), field_threshold=20,
                  merge_threshold=Fraction(50, 100), max_numeric_len=30,
-                 strip_whitespace=False, min_timestamp=None,
-                 max_timestamp=None, epoch=None, progress=None):
+                 strip_whitespace=False,
+                 min_timestamp=None, max_timestamp=None,
+                 epoch=datetime.utcfromtimestamp(0),
+                 epoch_unit=timedelta(seconds=1),
+                 progress=None):
         self.bad_threshold = bad_threshold
         self.empty_threshold = empty_threshold
         self.null_threshold = null_threshold
@@ -183,15 +191,19 @@ def __init__(self, *, bad_threshold=Fraction(2, 100),
         self.max_numeric_len = max_numeric_len
         self.strip_whitespace = strip_whitespace
         unix_epoch = datetime.utcfromtimestamp(0)
-        self.epoch = unix_epoch if epoch is None else epoch
-        offset = (unix_epoch - self.epoch).total_seconds() / 86400
+        self.timestamp_offset = (epoch - unix_epoch).total_seconds()
+        self.timestamp_scale = epoch_unit.total_seconds()
         now = datetime.now()
         if min_timestamp is None:
             min_timestamp = now - relativedelta(years=20)
         if max_timestamp is None:
             max_timestamp = now + relativedelta(years=10)
-        self.min_timestamp = min_timestamp.timestamp() + offset
-        self.max_timestamp = max_timestamp.timestamp() + offset
+        self.min_timestamp = (
+            min_timestamp.timestamp() - self.timestamp_offset
+        ) / self.timestamp_scale
+        self.max_timestamp = (
+            max_timestamp.timestamp() - self.timestamp_offset
+        ) / self.timestamp_scale
         self._progress = progress
 
     @property
@@ -740,7 +752,8 @@ def _match_possible_datetime(self, pattern):
                 isinstance(pattern, (Int, Float)) and
                 in_range(pattern.values.min) and
                 in_range(pattern.values.max)):
-            return DateTime.from_numbers(pattern, epoch=self.epoch)
+            return DateTime.from_numbers(pattern, offset=self.timestamp_offset,
+                                         scale=self.timestamp_scale)
         elif (
                 isinstance(pattern, StrRepr) and (
                     (
@@ -751,6 +764,7 @@ def _match_possible_datetime(self, pattern):
                 ) and
                 in_range(pattern.content.values.min) and
                 in_range(pattern.content.values.max)):
-            return DateTime.from_numbers(pattern, epoch=self.epoch)
+            return DateTime.from_numbers(pattern, offset=self.timestamp_offset,
+                                         scale=self.timestamp_scale)
         else:
             return pattern

structa/types.py

@@ -7,16 +7,21 @@
 import math
 from copy import copy
 from numbers import Real
+from datetime import datetime
 from textwrap import indent, shorten
-from datetime import datetime, timedelta
 from functools import partial, total_ordering
 from collections.abc import Mapping
 from operator import attrgetter
 
 from .collections import Counter, FrozenCounter
 from .conversions import try_conversion, parse_bool
-from .format import format_int, format_repr, format_sample
 from .xml import ElementFactory, xml, merge_siblings
+from .format import (
+    format_int,
+    format_repr,
+    format_sample,
+    format_timestamp_numrepr,
+)
 
 
 tag = ElementFactory()
@@ -905,14 +910,15 @@ def from_strings(cls, iterable, pattern, bad_threshold=0):
             pattern=pattern)
 
     @classmethod
-    def from_numbers(cls, pattern, epoch=datetime.utcfromtimestamp(0),
-                     unit=timedelta(seconds=1)):
+    def from_numbers(cls, pattern, offset=0, scale=1):
         """
         Class method for constructing an instance wrapped in a :class:`NumRepr`
         to indicate a numeric representation of a set of timestamps (e.g. day
-        offset from the UNIX epoch; a different *epoch* may be specified as
-        a :class:`~datetime.datetime`, and a different *unit* as a
-        :class:`~datetime.timedelta`, which defaults to 1 second).
+        offset from the UNIX epoch). A different epoch may be specified as a
+        numeric *offset*, and a different epoch *scale* as a numeric number of
+        seconds). The default offset and scale are 0 and 1 which is equivalent
+        to a seconds offset from the UNIX epoch (i.e. a traditional UNIX
+        timestamp).
 
         Constructed with an *sample* of number, a *pattern* (which can be a
         :class:`StrRepr` instance if the numbers are themselves represented as
@@ -925,9 +931,6 @@ def from_numbers(cls, pattern, epoch=datetime.utcfromtimestamp(0),
         else:
             num_pattern = pattern
         dt_counter = Counter()
-        unix_epoch = datetime.utcfromtimestamp(0)
-        offset = (epoch - unix_epoch).total_seconds()
-        scale = unit.total_seconds()
         for value, count in num_pattern.values.sample.items():
             dt_value = datetime.utcfromtimestamp((value * scale) + offset)
             dt_counter[dt_value] = count
@@ -1208,27 +1211,13 @@ class NumRepr(Repr):
 
     def __str__(self):
         type_, scale, offset = self.pattern
-        delta = timedelta(seconds=scale)
-        unit = ', '.join(
-            '{count}{prop}'.format(
-                count='{value}*'.format(value=value) if value != 1 else '',
-                prop=prop)
-            for prop in ('days', 'seconds', 'microseconds')
-            for value in (getattr(delta, prop),)
-            if value
-        )
-        if not offset % 86400:
-            epoch = datetime.utcfromtimestamp(offset).date().isoformat()
-        else:
-            epoch = datetime.utcfromtimestamp(offset).isoformat()
-        if type_ is Int:
-            template = 'int {unit} after {epoch} of {self.content}'
-        elif type_ is Float:
-            template = 'float {unit} after {epoch} of {self.content}'
-        else:
-            assert False, 'str(num-repr) of {self.content!r}'.format(
-                self=self, unit=unit, epoch=epoch)
-        return template.format(self=self, unit=unit, epoch=epoch)
+        try:
+            type_name = {Int: 'int', Float: 'float'}[type_]
+        except KeyError:
+            assert False, 'str(num-repr) of {self.content!r}'.format(self=self)
+        return '{type_name} {numrepr} of {self.content}'.format(
+            self=self, type_name=type_name,
+            numrepr=format_timestamp_numrepr(offset, scale))
 
     def __xml__(self):
         type_, scale, offset = self.pattern