macro-lib/pythonpath/libre_macros_global_settings_lib.py - new_source_processing - kuzant24/libre-macros

macro-lib/pythonpath/libre_macros_global_settings_lib.py
344 строки10 KB
direct-dev.ru
fixed for home work
04 авг 2026, 16:06
04 авг 2026, 16:06eb53100
# -*- coding: utf-8 -*-
from __future__ import print_function, unicode_literals
MACRO_VERSION = "3.10.359"
"""
Глобальные настройки collect_workbooks (JSON рядом с пресетами).

Файл: ~/.config/libre-macros/collect_workbooks/merge_global_settings.json
"""

import json
import os
import re
import sys

try:
    unicode
except NameError:
    unicode = str

GLOBAL_SETTINGS_FILE = u"merge_global_settings.json"
GLOBAL_SETTINGS_SUBDIR = u"collect_workbooks"
GLOBAL_SETTINGS_JSON_VER = 1

DEFAULT_DATE_FORMAT = u"DD.MM.YYYY"
DEFAULT_NUMBER_FORMAT = u"# ##0,00"
DEFAULT_FONT_NAME = u"PT Sans"
DEFAULT_FONT_SIZE = 11.0
DEFAULT_PARAM_SHEET_PREFIX = u"Параметры_Объединения"
CUSTOM_NUMBER_FORMAT_LABEL = u"— свой формат —"

DATE_FORMAT_CHOICES = (
    u"DD.MM.YYYY",
    u"DD.MM.YYYY NNN",
    u"DD.MM.YYYY DDD",
    u"DD.MM.YY",
    u"DD.MM.YYYY HH:MM",
    u"DD.MM.YYYY HH:MM:SS",
    u"YYYY-MM-DD",
    u"YY-MM-DD",
    u"YYYY-MM-DD HH:MM",
    u"YYYY-MM-DD HH:MM:SS",
    u"DD/MM/YYYY",
    u"DD/MM/YY",
    u"MM/DD/YYYY",
    u"MM/DD/YY",
    u"DD.MMM.YYYY",
    u"D MMMM YYYY",
    u"ДД.ММ.ГГГГ",
    u"ДД.ММ.ГГ",
    u"ДД.ММ.ГГГГ ЧЧ:ММ",
    u"ДД.ММ.ГГГГ ЧЧ:ММ:СС",
    u"ГГГГ-ММ-ДД",
)

NUMBER_FORMAT_CHOICES = (
    u"# ##0,00",
    u"# ##0",
    u"0,00",
    u"0",
    u"0%",
    u"0,00%",
    CUSTOM_NUMBER_FORMAT_LABEL,
)

# Excel-стиль (#,##0.00 / 0.00) — не предлагать в combo: в Calc ru/RU запятая = десятичный.
# Ручной ввод всё ещё допускается; UNO нормализует при применении.


def is_calc_friendly_number_format(fmt):
    """True, если пресет годится для Calc/ods (без Excel-тысячных/десятичной точки)."""
    s = unicode(fmt or u"").strip()
    if s == u"" or s == CUSTOM_NUMBER_FORMAT_LABEL:
        return True
    low = s.casefold()
    if low == u"general":
        return False
    if u"#,##" in s:
        return False
    # 0.00 / #0.00 — Excel decimal point (не E-научный и не дата)
    if re.match(r"^[#0\s,]*\.\d+%?$", s):
        return False
    return True


def calc_number_format_choices(extra=None):
    """Пресеты числовых форматов для визардов (без Excel-стиля)."""
    out = []
    seen = set()
    for item in NUMBER_FORMAT_CHOICES:
        s = unicode(item or u"").strip()
        if s == u"":
            continue
        if not is_calc_friendly_number_format(s) and s != CUSTOM_NUMBER_FORMAT_LABEL:
            continue
        k = s.casefold()
        if k in seen:
            continue
        seen.add(k)
        out.append(s)
    for item in extra or ():
        s = unicode(item or u"").strip()
        if s == u"":
            continue
        k = s.casefold()
        if k in seen:
            continue
        seen.add(k)
        out.append(s)
    return tuple(out)


def _config_base():
    if sys.platform == "win32":
        base = os.environ.get("APPDATA", os.path.expanduser("~"))
    else:
        base = os.environ.get(
            "XDG_CONFIG_HOME", os.path.join(os.path.expanduser("~"), ".config")
        )
    return os.path.join(base, "libre-macros")


def global_settings_dir():
    path = os.path.join(_config_base(), GLOBAL_SETTINGS_SUBDIR)
    try:
        os.makedirs(path, exist_ok=True)
    except TypeError:
        if not os.path.isdir(path):
            try:
                os.makedirs(path)
            except OSError:
                pass
    except OSError:
        pass
    return path


def global_settings_path():
    return os.path.join(global_settings_dir(), GLOBAL_SETTINGS_FILE)


def default_global_settings():
    return {
        "version": GLOBAL_SETTINGS_JSON_VER,
        "default_date_format": DEFAULT_DATE_FORMAT,
        "number_format": DEFAULT_NUMBER_FORMAT,
        "font_name": DEFAULT_FONT_NAME,
        "font_size": DEFAULT_FONT_SIZE,
        "param_sheet_prefix": DEFAULT_PARAM_SHEET_PREFIX,
        "suppress_param_action_messages": False,
        "merge_flags": {},
    }


def normalize_param_sheet_prefix(raw, default=None):
    """
    Префикс имени листа параметров (по умолч. Параметры_Объединения).
    Пустое / недопустимое → default.
    """
    if default is None:
        default = DEFAULT_PARAM_SHEET_PREFIX
    s = unicode(raw or u"").strip()
    if s == u"":
        return unicode(default)
    # Calc: имя листа без []:*/?\ и не длиннее 31
    bad = u"[]:*/?\\"
    cleaned = []
    for ch in s:
        if ch in bad or ord(ch) < 32:
            continue
        cleaned.append(ch)
    s = u"".join(cleaned).strip()
    if s == u"":
        return unicode(default)
    if len(s) > 31:
        s = s[:31]
    return s


def normalize_global_settings(obj):
    defaults = default_global_settings()
    if obj is None or not isinstance(obj, dict):
        return dict(defaults)
    out = dict(defaults)
    dt = unicode(obj.get("default_date_format", u"") or u"").strip()
    if dt != u"":
        out["default_date_format"] = dt
    num = unicode(obj.get("number_format", u"") or u"").strip()
    if num != u"":
        out["number_format"] = num
    font = unicode(obj.get("font_name", u"") or u"").strip()
    if font != u"":
        out["font_name"] = font
    raw_size = obj.get("font_size", None)
    if raw_size is not None and unicode(raw_size).strip() != u"":
        try:
            size = float(unicode(raw_size).replace(u",", u"."))
            if size >= 1.0:
                out["font_size"] = size
        except (TypeError, ValueError):
            pass
    if "param_sheet_prefix" in obj:
        out["param_sheet_prefix"] = normalize_param_sheet_prefix(
            obj.get("param_sheet_prefix"), DEFAULT_PARAM_SHEET_PREFIX
        )
    if "suppress_param_action_messages" in obj:
        out["suppress_param_action_messages"] = bool(obj.get("suppress_param_action_messages"))
    raw_flags = obj.get("merge_flags")
    if isinstance(raw_flags, dict):
        flags = {}
        for key, val in raw_flags.items():
            k = unicode(key or u"").strip()
            if k == u"":
                continue
            flags[k] = bool(val)
        out["merge_flags"] = flags
    return out


def merge_flags_from_settings(settings=None):
    """Словарь merge_flags из глобальных настроек (только явно заданные ключи)."""
    gs = normalize_global_settings(settings or load_global_settings())
    raw = gs.get("merge_flags")
    if not isinstance(raw, dict):
        return {}
    out = {}
    for key, val in raw.items():
        k = unicode(key or u"").strip()
        if k == u"":
            continue
        out[k] = bool(val)
    return out


def load_global_settings():
    path = global_settings_path()
    if not os.path.isfile(path):
        return default_global_settings()
    try:
        with open(path, "rb") as f:
            raw = f.read()
        if not raw:
            return default_global_settings()
        data = json.loads(raw.decode("utf-8"))
    except Exception as err:
        print(u"global_settings: read %s: %s" % (path, err))
        return default_global_settings()
    return normalize_global_settings(data)


def save_global_settings(settings):
    payload = normalize_global_settings(settings)
    path = global_settings_path()
    try:
        global_settings_dir()
        with open(path, "wb") as f:
            f.write(
                json.dumps(payload, ensure_ascii=False, indent=2).encode("utf-8")
            )
    except Exception as err:
        return u"Не удалось сохранить глобальные настройки:\n%s" % err
    try:
        apply_runtime_font_settings(payload)
    except Exception:
        pass
    try:
        apply_runtime_param_sheet_prefix(payload)
    except Exception:
        pass
    return None


def resolve_number_format_choice(text):
    """Текст из combo → строка формата Calc (пустая метка «свой» → пусто)."""
    s = unicode(text or u"").strip()
    if s == u"" or s == CUSTOM_NUMBER_FORMAT_LABEL:
        return u""
    return s


def apply_runtime_param_sheet_prefix(settings=None):
    """
    Подставить param_sheet_prefix в MERGE_PARAM_SHEET_NAME (collect + wizard cfg).

    Возвращает актуальный префикс.
    """
    gs = normalize_global_settings(settings or load_global_settings())
    prefix = normalize_param_sheet_prefix(
        gs.get("param_sheet_prefix"), DEFAULT_PARAM_SHEET_PREFIX
    )
    try:
        import libre_macros_collect_cfg as ccfg

        ccfg.MERGE_PARAM_SHEET_NAME = prefix
    except Exception:
        pass
    try:
        import libre_macros_param_wizard_cfg as pwcfg

        pwcfg.MERGE_PARAM_SHEET_NAME = prefix
    except Exception:
        pass
    return prefix


def apply_runtime_font_settings(settings=None):
    """
    Подставить font_name / font_size в runtime libre_macros_lib и direct.

    Возвращает (font_name, font_size).
    """
    gs = normalize_global_settings(settings or load_global_settings())
    name = unicode(gs.get("font_name") or DEFAULT_FONT_NAME).strip() or DEFAULT_FONT_NAME
    try:
        size = float(gs.get("font_size") or DEFAULT_FONT_SIZE)
    except (TypeError, ValueError):
        size = float(DEFAULT_FONT_SIZE)
    if size < 1.0:
        size = float(DEFAULT_FONT_SIZE)
    try:
        import libre_macros_lib as lm

        lm._LM_PP_FONT_NAME = name
        lm._LM_PP_DEFAULT_FONT_SIZE = float(size)
    except Exception:
        pass
    try:
        import libre_macros_direct_lib as direct

        direct._DIRECT_PP_DEFAULT_FONT_NAME = name
        direct._DIRECT_PP_DEFAULT_FONT_SIZE = float(size)
    except Exception:
        pass
    return name, size


def direct_options_from_global_settings(settings=None):
    """Поля для direct_bind_options из глобальных настроек."""
    gs = normalize_global_settings(settings or load_global_settings())
    return {
        "default_date_format": gs.get("default_date_format", DEFAULT_DATE_FORMAT),
        "number_format": gs.get("number_format", DEFAULT_NUMBER_FORMAT),
        "font_name": gs.get("font_name", DEFAULT_FONT_NAME),
        "font_size": gs.get("font_size", DEFAULT_FONT_SIZE),
    }