openmodule 13.6.0__tar.gz → 14.0.1__tar.gz

{openmodule-13.6.0 → openmodule-14.0.1}/ChangeLog

@@ -1,6 +1,18 @@
 CHANGES
 =======
 
+v14.0.1
+-------
+
+* fixed sentry release name
+
+v14.0.0
+-------
+
+* Add breaking changes to docs
+* OM-693 Openmodule sentry v2
+* Update known\_issues.md [skip ci]
+
 v13.6.0
 -------
 
@@ -151,9 +163,6 @@ v12.0.0.rc0
 * schedule exports utility
 * SettingsProvider docs
 * SettingsProvider docs
-* added settings\_models requirement, marking Test\* classes that are not tests with \_\_test\_\_ = False
-* AAAAAAAABBBBBBBBBBBBBBMerge branch 'master' into DEV-5415
-* [skip ci] Broken until settings\_model pip package is fixed. Removed deprecated features for v12. Using settings\_models in SettingsProvider
 
 v11.1.1
 -------
@@ -199,14 +208,3 @@ v10.0.3
 -------
 
 * added freezegun and fakeredis to openmodule requirements
-
-v10.0.2
--------
-
-* touching a filer, since the tag's job is skipped because the commit mentioned 'sk\_ip ci'
-
-v10.0.2.rc2
------------
-
-* added more documentation [skip ci]
-* fixes an issue in the multiprocessing\_logging package in testcases

{openmodule-13.6.0/openmodule.egg-info → openmodule-14.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: openmodule
-Version: 13.6.0
+Version: 14.0.1
 Summary: Libraries for developing the arivo openmodule
 Home-page: https://gitlab.com/arivo-public/device-python/openmodule.git
 Author: ARIVO

{openmodule-13.6.0 → openmodule-14.0.1}/docs/getting_started.md

@@ -12,7 +12,7 @@ All device services connect to the broker. Device services use the `SUB` port of
 and the `PUB` port to receive messages.
 
 We are send [multipart messages](https://zguide.zeromq.org/docs/chapter2/#Multipart-Messages) to the broker.
-The multipart message consists of a `topic` and a `payload`. The `topic` is used to route the message to possible 
+The multipart message consists of a `topic` and a `payload`. The `topic` is used to route the message to possible
 multiple device services (Broadcast). The `payload` is a JSON string containing the actual data.
 
 ![Broker](./images/broker.drawio.png)
@@ -75,6 +75,7 @@ The Openmodule will raise an `AssertionError` if the validator is missing.
 ### Project Structure
 
 The Openmodule is structured in the following way:
+
 ```
 openmodule/
 ├── openmodule/
@@ -97,6 +98,7 @@ The `openmodule_commands` folder contains some utility commands like for example
 ### Project Structure of a Device Service
 
 A typical device service has the following structure:
+
 ```
 device-service/
 ├── docker/
@@ -121,7 +123,7 @@ The YAML file `default.yml` is an optional additional config file if you need a
 
 The `src` folder contains the actual source code of the device service. The `app.py` file contains the main function
 of the device service. An example of the `app.py` is shown in the section
-[Create a Openmodule Instance](getting_started.md#create-a-openmodule-instance). 
+[Create a Openmodule Instance](getting_started.md#create-a-openmodule-instance).
 This example of the `app.py` file was copied from our template project.
 The `config.py` file contains the configuration of the device service. The `models.py` file
 should hold all models that are used in the device service.
@@ -184,7 +186,7 @@ To solve this migrate your model definition and the YAML initialization
 
 The first step that are you have to do is to create an instance of the Openmodule class.
 Below you see an example of the main Python file `app.py`. This file was copied from our template project and
-you do not have to manually create it.
+you do not have to manually create it. You also need to provide a Sentry DSN to the Openmodule.
 
 ```python
 import logging
@@ -204,7 +206,7 @@ def main_wrapper():
 
 
 def main():
-    core = init_openmodule(settings)
+    core = init_openmodule(settings, dsn="https://<key>@debug.acc.si/<project>")
     try:
         while True:
             time.sleep(1)

{openmodule-13.6.0 → openmodule-14.0.1}/docs/known_issues.md

@@ -5,6 +5,9 @@ version. The changelog may contain many other notes aswell.
 
 The version numbers below always note the _version through which the issue was fixed_.
 
+## 13.6.0
+* fixed message dispatcher trying to handle messages after shutdown was called
+
 ## 13.1.2
 
 * fixed error output on RPCs not sent by this RPCClient

{openmodule-13.6.0 → openmodule-14.0.1}/docs/migrations.md

@@ -1,5 +1,16 @@
 # Breaking Version Changes
 
+## 14.0.0
+* sentry_sdk version was updated
+* redis was removed
+* The `RPCServer` does no longer call `os._exit` if `"status"` is in the handler return value.
+It raises a `ValueError` instead.
+* The `init_openmodule` now takes a sentry `dsn` as an argument. This is required if sentry is enabled 
+(is enabled by default if not `TESTING` and not `DEBUG`).
+* The `receive_message_from_socket` is now a context manager and should be used with a `with` statement.
+This was done, so that any received zmq message automatically continues an existing sentry trace.
+  * Example: `with receive_message_from_socket(socket) as (topic, message):`
+
 ## 13.6.0
 * messaging:
   * the `get_pub_socket` now raises an AssertionError because we no longer support multiple publishers. 

openmodule-14.0.1/docs/sentry.md

@@ -0,0 +1,93 @@
+from openmodule.core import init_openmodule
+
+# Sentry
+
+[TOC]
+
+## Introduction
+
+Sentry is a service that helps us monitor and fix errors in our applications. It provides real-time error tracking and
+notifications.
+
+The Python Sentry SDK automatically creates events from uncaught exceptions and logs of level `error` and above.
+All error logs and exceptions are part of a transaction, even if no trace is created. So adding additional context to a
+transaction will also apply to the error logs and exceptions.
+
+It also provides tools for tracing process flows and diagnosing performance issues.
+
+## Initialization
+
+To use Sentry, you need to provide the DSN to the OpenModuleCore initialization function. The DSN is a unique identifier
+for your project that tells the SDK where to send the events. You can find the DSN in the Sentry project settings.
+
+* During Testing and Development, sentry will not be initialized, and no events will be sent.
+* You can provide additional [sentry options](https://docs.sentry.io/platforms/python/configuration/options/) as keyword
+  arguments to the `init_openmodule` function (`server_name` and `environment` cannot be overriden).
+* the `extras` keyword argument can be used to provide additional data to the Sentry SDK
+
+```python
+def main():
+    core = init_openmodule(settings, dsn="https://<key>@debug.acc.si/<project>")
+```
+
+## Errors & Exceptions
+
+Uncaught exceptions and `logging.exception(...)` calls are automatically captured by Sentry and turned into issues with
+a stack trace. `logging.error(...)` calls are also captured, but without a stack trace, so it's better to use
+`logging.exception(...)` when possible.
+
+### requests raise_for_status
+
+When using the `requests` library, you can use the `raise_for_status` method to raise an exception if the request was
+unsuccessful. This will cause sentry to automatically add the response body to the current transaction.
+
+## Tracing
+
+Openmodule provides the `sentry.trace` function that can be used as a decorator to trace a function or as a context
+manager to trace a block of code. This will create a new span for the function or block of code and record its duration.
+If no transaction is active, a new transaction will be created before the span.
+
+* When using the decorator, the span will have the (qual)name of the function (if none is provided).
+* When using the context manager, you **should** provide a name for the span.
+* In addition to name, the op parameter can be used to specify the operation type of the span.
+  (default is `function` and should be sufficient for most cases, others can be found
+  [here](https://develop.sentry.dev/sdk/telemetry/traces/span-operations/).)
+
+```python
+from openmodule import sentry
+
+
+@sentry.trace
+def my_function():
+    pass
+
+
+@sentry.trace(name="other_function")
+def my_function2():
+    pass
+
+
+with sentry.trace("my_block"):
+    pass
+```
+
+## Adding Additional Information
+
+You can add context to the current transaction using one of the following methods:
+
+* `sentry_sdk.set_tag(key: str, value: str)`: Adds
+  a [tag](https://docs.sentry.io/platforms/python/enriching-events/tags/) to the current transaction.
+* `sentry_sdk.set_tags(**key_value_pairs: str)`:
+  Adds [tags](https://docs.sentry.io/platforms/python/enriching-events/tags/) to the current transaction.
+* `sentry_sdk.set_context(key: str, value: Any)`: Adds
+  a [context](https://docs.sentry.io/platforms/python/enriching-events/context/) to the current transaction.
+* `sentry_sdk.set_extra(key: str, value: Any)`: Adds extra data to the current transaction. (similar to tags, but not
+  indexed for searching and more free-form)
+
+```python
+with sentry.trace("my_block"):
+    sentry_sdk.set_tag("key", "value")
+    sentry_sdk.set_tags({"key1": "value1", "key2": "value2"})
+    sentry_sdk.set_context("key", {"whatever": "you want"})
+    sentry_sdk.set_extra("key", "value")
+```

{openmodule-13.6.0 → openmodule-14.0.1}/docs/settings.md

@@ -47,14 +47,14 @@ class GlobalSettings:
     BROKER_SUB = broker_sub()
     BROKER_PUB = broker_pub()
 
-    LOCAL_DEVELOPMENT = bool("LOCAL_DEVELOPMENT", False)
     is_bridged_slave = is_bridged_slave()
     DIST_FOLDER = dist_folder()
     DEV_DEVICE = dev_device()
 
-    # redis
-    REDIS_HOST = string("REDIS_HOST", "localhost")
-    REDIS_PASSWORD = string("REDIS_PASSWORD", "") or None
-    REDIS_PORT = int("REDIS_PORT", 6379)
-    REDIS_DB = int("REDIS_DB", 0)
+    # translation
+    LOCALE_DIR = locale_dir()
+    LANGUAGE = "" if testing() else string("LANGUAGE", "de").lower()
+
+    # databox
+    DATABOX_UPLOAD_DIR = string("DATABOX_UPLOAD_DIR", "/upload")
 ```

{openmodule-13.6.0 → openmodule-14.0.1}/docs/testing.md

@@ -154,8 +154,8 @@ Mixin for testing alembic migrations. Tests start with a clean database without
 
 You can also provide your own sqlite3 database that will be copied for each test.
 
-**⚠ Do not use the database models defined in your app for these tests.** 
-Instead use the `AlembicMigrationTestMixin.get_model`method to get the model from the database schema. 
+**⚠ Do not use the database models defined in your app for these tests.**
+Instead use the `AlembicMigrationTestMixin.get_model`method to get the model from the database schema.
 Your Source code will not work with models from a different database revision. Do not call any functions that rely on
 the database models in your tests.
 
@@ -326,7 +326,8 @@ shut down within 3 seconds and print that it hase received a KeyboardInterrupt.
 
 Since main tests are somewhat complex, we provide some examples for different use cases.
 
-**Wait for an RPC server to be started, and send a test RPC. Also ensure that the service sends a specific message on start and stop (basic backend test case).**
+**Wait for an RPC server to be started, and send a test RPC. Also ensure that the service sends a specific message on
+start and stop (basic backend test case).**
 
 ```python 
 class MainTest(RPCServerTestMixin, MainTestMixin):
@@ -340,12 +341,16 @@ class MainTest(RPCServerTestMixin, MainTestMixin):
                 self.assertEqual("register", register_request.get("type"))
 
                 # wait for the rpc server to become responsive
-                self.wait_for_rpc_response("backend", "auth", AccessRequest(name=settings.NAME, medium_id="GARIVO1", medium_type="lpr"), AccessResponse)
+                self.wait_for_rpc_response("backend", "auth",
+                                           AccessRequest(name=settings.NAME, medium_id="GARIVO1", medium_type="lpr"),
+                                           AccessResponse)
 
                 # make a test request
-                response = self.rpc("backend", "auth", AccessRequest(name=settings.NAME, medium_id="GARIVO1", medium_type="lpr"), AccessResponse)
+                response = self.rpc("backend", "auth",
+                                    AccessRequest(name=settings.NAME, medium_id="GARIVO1", medium_type="lpr"),
+                                    AccessResponse)
                 self.assertEqual("GARIVO1", response.medium_id)
-                
+
             finally:
                 self.send_signal_to_process(process, signal.SIGTERM)
                 self.assertCleanShutdown(process)
@@ -445,8 +450,49 @@ finally:
 Another fix is setting the `log_config` to `None`, but with this setting the Uvicorn log output is disabled
 for `python -m tox` command.
 
+## Utils
+
+### DeveloperError
+
+Can be used to raise an error in the test code (e.g. when mocking a function and wanting an unimplemented error)
+
+```python
+def test():
+    def mocker():
+        raise DeveloperError("This function should not be called")
+
+    with mock.patch("module.func", mocker):
+        with self.assertRaises(DeveloperError):
+            module.function_that_calls_func()
+```
+
+### wait_for_value
+
+This function waits until the given `getter` function returns the expected value or the timeout is reached.
+That is useful when you want to wait for a value to change in another thread.
+
+If no `target` is given, it waits until the `getter` function returns a value that is different from the initial value.
+**warning**: The getter function might return the 'changed' value in the initial call, which would lead to no change
+happening.
+
+`invert_target` can be set to True to wait for the getter function to return a value that is different from the target.
+
+```python
+class Test(TestCase):
+    def get_value(self):
+        return self.whatever
+
+    def change_value(self):
+        time.sleep(1)
+        self.whatever = 2
+
+    def test(self):
+        self.whatever = 1
+        threading.Thread(target=self.change_value).start()
+        self.whatever = wait_for_value(self.get_value, 2)
+```
+
 ## Exit with Error 112
 
 Whenever the RPCServer finds a RPCResponse model containing a `status` field, a log line is printed and the process is
 terminated with error code 112. The log line might not be printed in some cases, so watch out for 112
-

{openmodule-13.6.0 → openmodule-14.0.1}/openmodule/config.py

@@ -483,19 +483,11 @@ class GlobalSettings:
     BROKER_SUB = broker_sub()
     BROKER_PUB = broker_pub()
 
-    LOCAL_DEVELOPMENT = bool("LOCAL_DEVELOPMENT", False)
     COMPUTE_ID = compute_id()
     DAEMON = bool("DAEMON", False)
     DIST_FOLDER = dist_folder()
     DEV_DEVICE = dev_device()
 
-    # redis
-    REDIS_HOST = string("REDIS_HOST", "localhost")
-    REDIS_PASSWORD = string("REDIS_PASSWORD", "") or None
-    REDIS_PORT = int("REDIS_PORT", 6379)
-    REDIS_DB = int("REDIS_DB", 0)
-    REDIS_CONNECTION_STATUS_KEY = string("REDIS_CONNECTION_STATUS_KEY", "device_connection_status")
-
     # translation
     LOCALE_DIR = locale_dir()
     LANGUAGE = "" if testing() else string("LANGUAGE", "de").lower()

{openmodule-13.6.0 → openmodule-14.0.1}/openmodule/connection_status.py

@@ -4,6 +4,7 @@ import time
 from enum import Enum
 from typing import Optional, Set
 
+from openmodule import sentry
 from openmodule.dispatcher import MessageDispatcher
 from openmodule.models.base import ZMQMessage, OpenModuleModel
 
@@ -98,6 +99,7 @@ class ConnectionStatusListener:
                 self._log.debug("Connection status message timeout")
                 self._set(ConnectionStatus.shutdown)
 
+    @sentry.trace
     def get_current_status(self) -> ConnectionRPCResponse:
         """Checks the current_status by sending an RPC to om_rpc_client"""
         try:

{openmodule-13.6.0 → openmodule-14.0.1}/openmodule/core.py

@@ -9,6 +9,7 @@ from concurrent.futures.thread import ThreadPoolExecutor
 import zmq
 from typing import Optional
 
+from openmodule import sentry
 from openmodule.alert import AlertHandler
 from openmodule.config import validate_config_module
 from openmodule.dispatcher import ZMQMessageDispatcher
@@ -71,9 +72,9 @@ class OpenModuleCore(threading.Thread):
     def _run(self):
         try:
             while True:
-                topic, message = receive_message_from_socket(self.sub_socket)
-                if topic is not None:
-                    self.messages.dispatch(topic, message)
+                with receive_message_from_socket(self.sub_socket) as (topic, message):
+                    if topic is not None:
+                        self.messages.dispatch(topic, message)
         except zmq.ContextTerminated:
             self.log.debug("context terminated, core shutting down")
         finally:
@@ -84,15 +85,16 @@ class OpenModuleCore(threading.Thread):
     def _run_internal(self):
         try:
             while True:
-                topic, message = receive_message_from_socket(self.sub_socket_internal)
-                if topic is not None:
-                    self._messages_internal.dispatch(topic, message)
-                    self.connection_listener.check_timeout()
+                with receive_message_from_socket(self.sub_socket_internal) as (topic, message):
+                    if topic is not None:
+                        self._messages_internal.dispatch(topic, message)
+                        self.connection_listener.check_timeout()
         except zmq.ContextTerminated:
             pass
         finally:
             self.sub_socket_internal.close()
 
+    @sentry.trace(op="topic.send")
     def publish(self, message: ZMQMessage, topic: str):
         assert isinstance(topic, str), "topic must be a string"
 
@@ -134,10 +136,10 @@ def print_environment(core: OpenModuleCore):
         )
 
 
-def init_openmodule(config, sentry=None, logging=True, dsgvo=True,
+def init_openmodule(config, *, dsn: str = None, sentry=None, logging=True, dsgvo=True,
                     health_handler: Optional[HealthHandlerType] = None,
                     context=None, database=False, catch_sigterm=True,
-                    dispatcher_max_threads=1, wait_for_broker=True) -> OpenModuleCore:
+                    dispatcher_max_threads=1, wait_for_broker=True, **sentry_kwargs) -> OpenModuleCore:
     if health_handler:
         warnings.warn(
             "health_handler is deprecated, and will simply be ignored. Please use metrics "
@@ -172,18 +174,16 @@ def init_openmodule(config, sentry=None, logging=True, dsgvo=True,
     # we activate sentry if
     # -> sentry=None (default) -> then we only activate in production
     # -> sentry=True/False this overrides and we activate/deactivate as desired
-    activate_sentry = False
     if sentry is None:
-        if should_activate_sentry(config):
-            activate_sentry = True
-        else:
+        sentry = should_activate_sentry()
+        if not sentry:
             _core_thread.log.info("not activating sentry in debug or test mode")
-    else:
-        activate_sentry = sentry
 
-    if activate_sentry:
+    if sentry:
+        if dsn is None:
+            raise ValueError("sentry DSN is required")
+        init_sentry(dsn, **sentry_kwargs)
         _core_thread.sentry_was_initialized = True
-        init_sentry(_core_thread)
 
     if dsgvo:
         init_dsgvo_config()

{openmodule-13.6.0 → openmodule-14.0.1}/openmodule/dispatcher.py

@@ -12,7 +12,9 @@ from typing import Union, Optional, Callable, DefaultDict, List, Dict, TypeVar,
 
 import zmq
 from pydantic import ValidationError, BaseModel, parse_obj_as
+from sentry_sdk.utils import qualname_from_function
 
+from openmodule import sentry
 from openmodule.config import settings
 from openmodule.models.base import ZMQMessage
 from openmodule.utils.schema import Schema
@@ -199,26 +201,28 @@ class MessageDispatcher:
             listeners = self.listeners.get(topic, [])
             for listener in listeners:
                 if listener.matches(message):
-                    self.executor.submit(self.execute, listener, message)
+                    self.executor.submit(self.execute, topic, listener, message)
 
-    def execute(self, listener: Listener, message: Dict):
-        try:
-            parsed_message = parse_obj_as(listener.message_class, message)
-        except ValidationError as e:
-            if self.raise_validation_errors:
-                raise e from None
-            else:
-                self.log.exception("Invalid message received")
-        else:
+    def execute(self, topic: str, listener: Listener, message: Dict):
+        with sentry.continue_trace_zmq_message_process(topic, message):
             try:
-                listener.handler(parsed_message)
-            except zmq.ContextTerminated:
-                raise
-            except Exception as e:
-                if self.raise_handler_errors:
+                parsed_message = parse_obj_as(listener.message_class, message)
+            except ValidationError as e:
+                if self.raise_validation_errors:
                     raise e from None
                 else:
-                    self.log.exception("Error in message handler")
+                    self.log.exception("Invalid message received")
+            else:
+                try:
+                    with sentry.trace(f"message_handler.{qualname_from_function(listener.handler)}"):
+                        listener.handler(parsed_message)
+                except zmq.ContextTerminated:
+                    raise
+                except Exception as e:
+                    if self.raise_handler_errors:
+                        raise e from None
+                    else:
+                        self.log.exception("Error in message handler")
 
 
 class SubscribingMessageDispatcher(MessageDispatcher):

openmodule-14.0.1/openmodule/logging.py

@@ -0,0 +1,34 @@
+import logging
+import sys
+
+import requests
+
+_patched_exceptions = set()
+
+
+def _patch_requests_library():
+    """Adds the response text to the string representation of a requests.RequestException"""
+    if requests.RequestException in _patched_exceptions:
+        return
+    _patched_exceptions.add(requests.RequestException)
+
+    original_exception_string = requests.RequestException.__str__
+
+    def new_exception_string(self: requests.RequestException):
+        ret_str = original_exception_string(self)
+        if self.response is not None:
+            ret_str = f"{ret_str}: {self.response.text[:1000]}"
+        return ret_str
+
+    setattr(requests.RequestException, "__str__", new_exception_string)
+
+
+def init_logging(core):
+    assert hasattr(core.config, "LOG_LEVEL"), (
+        "LOG_LEVEL setting not found in your config. In order to use logging please add \n"
+        "> LOG_LEVEL = config.log_level()\n"
+        "to your config.py"
+    )
+    _patch_requests_library()
+    logging.basicConfig(level=core.config.LOG_LEVEL, stream=sys.stdout)
+    logging.captureWarnings(True)

{openmodule-13.6.0 → openmodule-14.0.1}/openmodule/messaging.py

@@ -3,11 +3,13 @@ import logging
 import random
 import string
 import time
+from contextlib import contextmanager
 from typing import Optional, Tuple, Dict
 
 import orjson
 import zmq
 
+from openmodule import sentry
 from openmodule.dispatcher import MessageDispatcher
 from openmodule.models.base import ZMQMessage
 
@@ -80,16 +82,19 @@ def wait_for_connection(dispatcher: MessageDispatcher, pub_socket=None, pub_lock
         raise TimeoutError("could not connect to the message broker in time")
 
 
+@contextmanager
 def receive_message_from_socket(sub_socket: zmq.Socket) -> Tuple[Optional[str], Optional[Dict]]:
     """
     :param sub_socket: zmq socket to receive
-    :return: returns None if an invalid message was received
-             otherwise returns a tuple containing (topic: str, message: dict)
+    Enters a sentry trace for the received message. For this reason, the function should be used as a context manager.
+    :yields: a tuple containing (None, None) if an invalid message was received
+             otherwise yields a tuple containing (topic: str, message: dict)
     """
     parts = sub_socket.recv_multipart()
     if len(parts) != 2:
         logging.error(f"received a zmq message with an invalid number of parts: {len(parts)}")
-        return None, None
+        yield None, None
+        return
 
     topic, message = parts
 
@@ -97,10 +102,12 @@ def receive_message_from_socket(sub_socket: zmq.Socket) -> Tuple[Optional[str],
         message_dict = orjson.loads(message)
     except orjson.JSONDecodeError as e:
         logging.error(f"received a zmq message with an invalid json. parsing error: {str(e)}")
-        return None, None
+        yield None, None
     else:
         if not isinstance(message_dict, dict):
             logging.error(f"received a zmq message which was not a dict but a {type(message)}")
-            return None, None
+            yield None, None
         else:
-            return topic.decode("utf8"), message_dict
+            decoded_topic = topic.decode("utf8")
+            with sentry.continue_trace_zmq_message_receive(decoded_topic, message_dict):
+                yield decoded_topic, message_dict

{openmodule-13.6.0 → openmodule-14.0.1}/openmodule/models/base.py

@@ -13,7 +13,7 @@ from dateutil.tz import UTC
 from pydantic import Field, BaseModel, validator, root_validator
 from pydantic.main import ROOT_KEY
 
-from openmodule import config
+from openmodule import config, sentry
 from openmodule.config import settings
 
 
@@ -139,6 +139,8 @@ class ZMQMessage(OpenModuleModel):
     timestamp: datetime = Field(default_factory=lambda: datetime.utcnow())
     name: str = Field(default_factory=lambda: settings.NAME)
     type: str
+    baggage: Optional[str] = Field(default_factory=sentry.get_baggage)
+    sentry_trace: Optional[str] = Field(default_factory=sentry.get_traceparent, alias="sentry-trace")
 
     _tz_timestamp = timezone_validator("timestamp")