naeural-client 2.0.0__py3-none-any.whl

naeural_client/logging/small_logger.py

@@ -0,0 +1,93 @@
+from .base_logger import BaseLogger
+from .logger_mixins import (_ClassInstanceMixin,
+                            _ComputerVisionMixin,
+                            _DateTimeMixin,
+                            _DownloadMixin,
+                            _GeneralSerializationMixin,
+                            _JSONSerializationMixin,
+                            _PickleSerializationMixin,
+                            _ProcessMixin,
+                            _ResourceSizeMixin,
+                            _TimersMixin,
+                            _UploadMixin,
+                            _UtilsMixin
+                            )
+
+
+class Logger(
+  BaseLogger,
+  _ClassInstanceMixin,
+  _ComputerVisionMixin,
+  _DateTimeMixin,
+  _DownloadMixin,
+  _GeneralSerializationMixin,
+  _JSONSerializationMixin,
+  _PickleSerializationMixin,
+  _ProcessMixin,
+  _ResourceSizeMixin,
+  _TimersMixin,
+  _UploadMixin,
+  _UtilsMixin):
+
+  def __init__(self, lib_name="",
+               lib_ver="",
+               config_file="",
+               config_data={},
+               base_folder=None,
+               app_folder=None,
+               show_time=True,
+               config_file_encoding=None,
+               no_folders_no_save=False,
+               max_lines=None,
+               HTML=False,
+               DEBUG=True,
+               data_config_subfolder=None,
+               check_additional_configs=False,
+               default_color='n',
+               ):
+
+    super(Logger, self).__init__(
+      lib_name=lib_name, lib_ver=lib_ver,
+      config_file=config_file,
+      base_folder=base_folder,
+      app_folder=app_folder,
+      show_time=show_time,
+      config_data=config_data,
+      config_file_encoding=config_file_encoding,
+      no_folders_no_save=no_folders_no_save,
+      max_lines=max_lines,
+      HTML=HTML,
+      DEBUG=DEBUG,
+      data_config_subfolder=data_config_subfolder,
+      check_additional_configs=check_additional_configs,
+      default_color=default_color,
+    )
+    self.cleanup_logs(archive_older_than_days=2)
+
+    return
+
+  def iP(self, str_msg, results=False, show_time=False, noprefix=False, color=None):
+    if self.runs_from_ipython():
+      return self._logger(
+        str_msg,
+        show=True, results=results, show_time=show_time,
+        noprefix=noprefix, color=color
+      )
+    return
+
+  def __repr__(self):
+    # Get the name of the class
+    class_name = self.__class__.__name__
+
+    # Get public properties (those not starting with "_")
+    public_properties = {k: v for k, v in self.__dict__.items() if not k.startswith("_")}
+
+    # Convert properties to a string representation
+    properties_str = ", ".join(f"{k}={v!r}" for k, v in public_properties.items())
+
+    return f"{class_name}({properties_str})"
+
+
+if __name__ == '__main__':
+  l = Logger('TEST', base_folder='Dropbox', app_folder='_libraries_testdata')
+  l.P("All check", color='green')

naeural_client/logging/tzlocal/__init__.py

@@ -0,0 +1,20 @@
+import sys
+
+if sys.platform == "win32":
+  from .win32 import (
+      get_localzone,
+      get_localzone_name,
+      reload_localzone,
+  )  # pragma: no cover
+else:
+  from .unix import get_localzone, get_localzone_name, reload_localzone
+
+from .utils import assert_tz_offset
+
+
+__all__ = [
+    "get_localzone",
+    "get_localzone_name",
+    "reload_localzone",
+    "assert_tz_offset",
+]

naeural_client/logging/tzlocal/unix.py

@@ -0,0 +1,231 @@
+import logging
+import os
+import re
+import sys
+import warnings
+from datetime import timezone
+
+from . import utils
+
+if sys.version_info >= (3, 9):
+  import zoneinfo  # pragma: no cover
+else:
+  from backports import zoneinfo  # pragma: no cover
+
+_cache_tz = None
+_cache_tz_name = None
+
+log = logging.getLogger("tzlocal")
+
+
+def _get_localzone_name(_root="/"):
+  """Tries to find the local timezone configuration.
+
+  This method finds the timezone name, if it can, or it returns None.
+
+  The parameter _root makes the function look for files like /etc/localtime
+  beneath the _root directory. This is primarily used by the tests.
+  In normal usage you call the function without parameters."""
+
+  # First try the ENV setting.
+  tzenv = utils._tz_name_from_env()
+  if tzenv:
+    return tzenv
+
+  # Are we under Termux on Android?
+  if os.path.exists(os.path.join(_root, "system/bin/getprop")):
+    log.debug("This looks like Termux")
+
+    import subprocess
+
+    try:
+      androidtz = (
+          subprocess.check_output(["getprop", "persist.sys.timezone"])
+          .strip()
+          .decode()
+      )
+      return androidtz
+    except (OSError, subprocess.CalledProcessError):
+      # proot environment or failed to getprop
+      log.debug("It's not termux?")
+      pass
+
+  # Now look for distribution specific configuration files
+  # that contain the timezone name.
+
+  # Stick all of them in a dict, to compare later.
+  found_configs = {}
+
+  for configfile in ("etc/timezone", "var/db/zoneinfo"):
+    tzpath = os.path.join(_root, configfile)
+    try:
+      with open(tzpath) as tzfile:
+        data = tzfile.read()
+        log.debug(f"{tzpath} found, contents:\n {data}")
+
+        etctz = data.strip("/ \t\r\n")
+        if not etctz:
+          # Empty file, skip
+          continue
+        for etctz in etctz.splitlines():
+          # Get rid of host definitions and comments:
+          if " " in etctz:
+            etctz, dummy = etctz.split(" ", 1)
+          if "#" in etctz:
+            etctz, dummy = etctz.split("#", 1)
+          if not etctz:
+            continue
+
+          found_configs[tzpath] = etctz.replace(" ", "_")
+
+    except (OSError, UnicodeDecodeError):
+      # File doesn't exist or is a directory, or it's a binary file.
+      continue
+
+  # CentOS has a ZONE setting in /etc/sysconfig/clock,
+  # OpenSUSE has a TIMEZONE setting in /etc/sysconfig/clock and
+  # Gentoo has a TIMEZONE setting in /etc/conf.d/clock
+  # We look through these files for a timezone:
+
+  zone_re = re.compile(r"\s*ZONE\s*=\s*\"")
+  timezone_re = re.compile(r"\s*TIMEZONE\s*=\s*\"")
+  end_re = re.compile('"')
+
+  for filename in ("etc/sysconfig/clock", "etc/conf.d/clock"):
+    tzpath = os.path.join(_root, filename)
+    try:
+      with open(tzpath, "rt") as tzfile:
+        data = tzfile.readlines()
+        log.debug(f"{tzpath} found, contents:\n {data}")
+
+      for line in data:
+        # Look for the ZONE= setting.
+        match = zone_re.match(line)
+        if match is None:
+          # No ZONE= setting. Look for the TIMEZONE= setting.
+          match = timezone_re.match(line)
+        if match is not None:
+          # Some setting existed
+          line = line[match.end():]
+          etctz = line[: end_re.search(line).start()]
+
+          # We found a timezone
+          found_configs[tzpath] = etctz.replace(" ", "_")
+
+    except (OSError, UnicodeDecodeError):
+      # UnicodeDecode handles when clock is symlink to /etc/localtime
+      continue
+
+  # systemd distributions use symlinks that include the zone name,
+  # see manpage of localtime(5) and timedatectl(1)
+  tzpath = os.path.join(_root, "etc/localtime")
+  if os.path.exists(tzpath) and os.path.islink(tzpath):
+    log.debug(f"{tzpath} found")
+    etctz = os.path.realpath(tzpath)
+    start = etctz.find("/") + 1
+    while start != 0:
+      etctz = etctz[start:]
+      try:
+        zoneinfo.ZoneInfo(etctz)
+        tzinfo = f"{tzpath} is a symlink to"
+        found_configs[tzinfo] = etctz.replace(" ", "_")
+        # Only need first valid relative path in simlink.
+        break
+      except zoneinfo.ZoneInfoNotFoundError:
+        pass
+      start = etctz.find("/") + 1
+
+  if len(found_configs) > 0:
+    log.debug(f"{len(found_configs)} found:\n {found_configs}")
+    # We found some explicit config of some sort!
+    if len(found_configs) > 1:
+      # Uh-oh, multiple configs. See if they match:
+      unique_tzs = set()
+      zoneinfopath = os.path.join(_root, "usr", "share", "zoneinfo")
+      directory_depth = len(zoneinfopath.split(os.path.sep))
+
+      for tzname in found_configs.values():
+        # Look them up in /usr/share/zoneinfo, and find what they
+        # really point to:
+        path = os.path.realpath(os.path.join(zoneinfopath, *tzname.split("/")))
+        real_zone_name = "/".join(path.split(os.path.sep)[directory_depth:])
+        unique_tzs.add(real_zone_name)
+
+      if len(unique_tzs) != 1:
+        message = "Multiple conflicting time zone configurations found:\n"
+        for key, value in found_configs.items():
+          message += f"{key}: {value}\n"
+        message += "Fix the configuration, or set the time zone in a TZ environment variable.\n"
+        raise zoneinfo.ZoneInfoNotFoundError(message)
+
+    # We found exactly one config! Use it.
+    return list(found_configs.values())[0]
+
+
+def _get_localzone(_root="/"):
+  """Creates a timezone object from the timezone name.
+
+  If there is no timezone config, it will try to create a file from the
+  localtime timezone, and if there isn't one, it will default to UTC.
+
+  The parameter _root makes the function look for files like /etc/localtime
+  beneath the _root directory. This is primarily used by the tests.
+  In normal usage you call the function without parameters."""
+
+  # First try the ENV setting.
+  tzenv = utils._tz_from_env()
+  if tzenv:
+    return tzenv
+
+  tzname = _get_localzone_name(_root)
+  if tzname is None:
+    # No explicit setting existed. Use localtime
+    log.debug("No explicit setting existed. Use localtime")
+    for filename in ("etc/localtime", "usr/local/etc/localtime"):
+      tzpath = os.path.join(_root, filename)
+
+      if not os.path.exists(tzpath):
+        continue
+      with open(tzpath, "rb") as tzfile:
+        tz = zoneinfo.ZoneInfo.from_file(tzfile, key="local")
+        break
+    else:
+      warnings.warn("Can not find any timezone configuration, defaulting to UTC.")
+      tz = timezone.utc
+  else:
+    tz = zoneinfo.ZoneInfo(tzname)
+
+  if _root == "/":
+    # We are using a file in etc to name the timezone.
+    # Verify that the timezone specified there is actually used:
+    utils.assert_tz_offset(tz, error=False)
+  return tz
+
+
+def get_localzone_name():
+  """Get the computers configured local timezone name, if any."""
+  global _cache_tz_name
+  if _cache_tz_name is None:
+    _cache_tz_name = _get_localzone_name()
+
+  return _cache_tz_name
+
+
+def get_localzone():
+  """Get the computers configured local timezone, if any."""
+
+  global _cache_tz
+  if _cache_tz is None:
+    _cache_tz = _get_localzone()
+
+  return _cache_tz
+
+
+def reload_localzone():
+  """Reload the cached localzone. You need to call this if the timezone has changed."""
+  global _cache_tz_name
+  global _cache_tz
+  _cache_tz_name = _get_localzone_name()
+  _cache_tz = _get_localzone()
+
+  return _cache_tz

naeural_client/logging/tzlocal/utils.py

@@ -0,0 +1,113 @@
+import logging
+import os
+import time
+import datetime
+import calendar
+import warnings
+
+
+try:
+  import zoneinfo  # pragma: no cover
+except ImportError:
+  from backports import zoneinfo  # pragma: no cover
+
+from . import windows_tz
+
+log = logging.getLogger("tzlocal")
+
+
+def get_tz_offset(tz):
+  """Get timezone's offset using built-in function datetime.utcoffset()."""
+  return int(datetime.datetime.now(tz).utcoffset().total_seconds())
+
+
+def assert_tz_offset(tz, error=True):
+  """Assert that system's timezone offset equals to the timezone offset found.
+
+  If they don't match, we probably have a misconfiguration, for example, an
+  incorrect timezone set in /etc/timezone file in systemd distributions.
+
+  If error is True, this method will raise a ValueError, otherwise it will
+  emit a warning.
+  """
+
+  tz_offset = get_tz_offset(tz)
+  system_offset = calendar.timegm(time.localtime()) - calendar.timegm(time.gmtime())
+  # No one has timezone offsets less than a minute, so this should be close enough:
+  if abs(tz_offset - system_offset) > 60:
+    msg = (
+        "Timezone offset does not match system offset: {} != {}. "
+        "Please, check your config files."
+    ).format(tz_offset, system_offset)
+    if error:
+      raise ValueError(msg)
+    warnings.warn(msg)
+
+
+def _tz_name_from_env(tzenv=None):
+  if tzenv is None:
+    tzenv = os.environ.get("TZ")
+
+  if not tzenv:
+    return None
+
+  log.debug(f"Found a TZ environment: {tzenv}")
+
+  if tzenv[0] == ":":
+    tzenv = tzenv[1:]
+
+  if tzenv in windows_tz.tz_win:
+    # Yup, it's a timezone
+    return tzenv
+
+  if os.path.isabs(tzenv) and os.path.exists(tzenv):
+    # It's a file specification, expand it, if possible
+    parts = os.path.realpath(tzenv).split(os.sep)
+
+    # Is it a zone info zone?
+    possible_tz = "/".join(parts[-2:])
+    if possible_tz in windows_tz.tz_win:
+      # Yup, it is
+      return possible_tz
+
+    # Maybe it's a short one, like UTC?
+    if parts[-1] in windows_tz.tz_win:
+      # Indeed
+      return parts[-1]
+
+  log.debug("TZ does not contain a time zone name")
+  return None
+
+
+def _tz_from_env(tzenv=None):
+  if tzenv is None:
+    tzenv = os.environ.get("TZ")
+
+  if not tzenv:
+    return None
+
+  # Some weird format that exists:
+  if tzenv[0] == ":":
+    tzenv = tzenv[1:]
+
+  # TZ specifies a file
+  if os.path.isabs(tzenv) and os.path.exists(tzenv):
+    # Try to see if we can figure out the name
+    tzname = _tz_name_from_env(tzenv)
+    if not tzname:
+      # Nope, not a standard timezone name, just take the filename
+      tzname = tzenv.split(os.sep)[-1]
+    with open(tzenv, "rb") as tzfile:
+      return zoneinfo.ZoneInfo.from_file(tzfile, key=tzname)
+
+  # TZ must specify a zoneinfo zone.
+  try:
+    tz = zoneinfo.ZoneInfo(tzenv)
+    # That worked, so we return this:
+    return tz
+  except zoneinfo.ZoneInfoNotFoundError:
+    # Nope, it's something like "PST4DST" etc, we can't handle that.
+    raise zoneinfo.ZoneInfoNotFoundError(
+        "tzlocal() does not support non-zoneinfo timezones like %s. \n"
+        "Please use a timezone in the form of Continent/City" % tzenv
+    ) from None

naeural_client/logging/tzlocal/win32.py

@@ -0,0 +1,151 @@
+import logging
+from datetime import datetime
+
+try:
+  import _winreg as winreg
+except ImportError:
+  import winreg
+
+try:
+  import zoneinfo  # pragma: no cover
+except ImportError:
+  from backports import zoneinfo  # pragma: no cover
+
+from .windows_tz import win_tz
+from . import utils
+
+_cache_tz = None
+_cache_tz_name = None
+
+log = logging.getLogger("tzlocal")
+
+
+def valuestodict(key):
+  """Convert a registry key's values to a dictionary."""
+  result = {}
+  size = winreg.QueryInfoKey(key)[1]
+  for i in range(size):
+    data = winreg.EnumValue(key, i)
+    result[data[0]] = data[1]
+  return result
+
+
+def _get_dst_info(tz):
+  # Find the offset for when it doesn't have DST:
+  dst_offset = std_offset = None
+  has_dst = False
+  year = datetime.now().year
+  for dt in (datetime(year, 1, 1), datetime(year, 6, 1)):
+    if tz.dst(dt).total_seconds() == 0.0:
+      # OK, no DST during winter, get this offset
+      std_offset = tz.utcoffset(dt).total_seconds()
+    else:
+      has_dst = True
+
+  return has_dst, std_offset, dst_offset
+
+
+def _get_localzone_name():
+  # Windows is special. It has unique time zone names (in several
+  # meanings of the word) available, but unfortunately, they can be
+  # translated to the language of the operating system, so we need to
+  # do a backwards lookup, by going through all time zones and see which
+  # one matches.
+  tzenv = utils._tz_name_from_env()
+  if tzenv:
+    return tzenv
+
+  log.debug("Looking up time zone info from registry")
+  handle = winreg.ConnectRegistry(None, winreg.HKEY_LOCAL_MACHINE)
+
+  TZLOCALKEYNAME = r"SYSTEM\CurrentControlSet\Control\TimeZoneInformation"
+  localtz = winreg.OpenKey(handle, TZLOCALKEYNAME)
+  keyvalues = valuestodict(localtz)
+  localtz.Close()
+
+  if "TimeZoneKeyName" in keyvalues:
+    # Windows 7 and later
+
+    # For some reason this returns a string with loads of NUL bytes at
+    # least on some systems. I don't know if this is a bug somewhere, I
+    # just work around it.
+    tzkeyname = keyvalues["TimeZoneKeyName"].split("\x00", 1)[0]
+  else:
+    # Don't support XP any longer
+    raise LookupError("Can not find Windows timezone configuration")
+
+  timezone = win_tz.get(tzkeyname)
+  if timezone is None:
+    # Nope, that didn't work. Try adding "Standard Time",
+    # it seems to work a lot of times:
+    timezone = win_tz.get(tzkeyname + " Standard Time")
+
+  # Return what we have.
+  if timezone is None:
+    raise zoneinfo.ZoneInfoNotFoundError(tzkeyname)
+
+  if keyvalues.get("DynamicDaylightTimeDisabled", 0) == 1:
+    # DST is disabled, so don't return the timezone name,
+    # instead return Etc/GMT+offset
+
+    tz = zoneinfo.ZoneInfo(timezone)
+    has_dst, std_offset, dst_offset = _get_dst_info(tz)
+    if not has_dst:
+      # The DST is turned off in the windows configuration,
+      # but this timezone doesn't have DST so it doesn't matter
+      return timezone
+
+    if std_offset is None:
+      raise zoneinfo.ZoneInfoNotFoundError(
+          f"{tzkeyname} claims to not have a non-DST time!?"
+      )
+
+    if std_offset % 3600:
+      # I can't convert this to an hourly offset
+      raise zoneinfo.ZoneInfoNotFoundError(
+          f"tzlocal can't support disabling DST in the {timezone} zone."
+      )
+
+    # This has whole hours as offset, return it as Etc/GMT
+    return f"Etc/GMT{-std_offset//3600:+.0f}"
+
+  return timezone
+
+
+def get_localzone_name():
+  """Get the zoneinfo timezone name that matches the Windows-configured timezone."""
+  global _cache_tz_name
+  if _cache_tz_name is None:
+    _cache_tz_name = _get_localzone_name()
+
+  return _cache_tz_name
+
+
+def get_localzone():
+  """Returns the zoneinfo-based tzinfo object that matches the Windows-configured timezone."""
+
+  global _cache_tz
+  if _cache_tz is None:
+    _cache_tz = zoneinfo.ZoneInfo(get_localzone_name())
+
+  if not utils._tz_name_from_env():
+    # If the timezone does NOT come from a TZ environment variable,
+    # verify that it's correct. If it's from the environment,
+    # we accept it, this is so you can run tests with different timezones.
+    utils.assert_tz_offset(_cache_tz, error=False)
+
+  return _cache_tz
+
+
+def reload_localzone():
+  """Reload the cached localzone. You need to call this if the timezone has changed."""
+  global _cache_tz
+  global _cache_tz_name
+  _cache_tz_name = _get_localzone_name()
+  _cache_tz = zoneinfo.ZoneInfo(_cache_tz_name)
+  utils.assert_tz_offset(_cache_tz, error=False)
+  return _cache_tz
+
+
+if __name__ == '__main__':
+  res = get_localzone_name()