telegrinder 0.1.dev170__py3-none-any.whl → 0.1.dev171__py3-none-any.whl

telegrinder/node/event.py

@@ -0,0 +1,59 @@
+import typing
+
+import msgspec
+
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.msgspec_utils import DataclassInstance
+from telegrinder.node.base import BaseNode, ComposeError, DataNode
+from telegrinder.node.update import UpdateNode
+
+if typing.TYPE_CHECKING:
+    Dataclass = typing.TypeVar("Dataclass", bound="DataclassType")
+
+    DataclassType: typing.TypeAlias = DataclassInstance | DataNode | msgspec.Struct | dict[str, typing.Any]
+
+EVENT_NODE_KEY = "_event_node"
+
+
+if typing.TYPE_CHECKING:
+    EventNode: typing.TypeAlias = typing.Annotated["Dataclass", ...]
+
+else:
+    from telegrinder.msgspec_utils import decoder
+
+    class EventNode(BaseNode):
+        dataclass: type["DataclassType"]
+
+        def __new__(cls, dataclass: type["DataclassType"], /) -> type[typing.Self]:
+            namespace = dict(**cls.__dict__)
+            namespace.pop("__new__", None)
+            new_cls = type("EventNode", (cls,), {"dataclass": dataclass, **namespace})
+            return new_cls  # type: ignore
+
+        def __class_getitem__(cls, dataclass: type["DataclassType"], /) -> type[typing.Self]:
+            return cls(dataclass)
+
+        @classmethod
+        async def compose(cls, raw_update: UpdateNode, ctx: Context) -> "DataclassType":
+            dataclass_type = typing.get_origin(cls.dataclass) or cls.dataclass
+
+            try:
+                if issubclass(dataclass_type, dict):
+                    dataclass = cls.dataclass(**raw_update.incoming_update.to_full_dict())
+
+                elif issubclass(dataclass_type, msgspec.Struct | DataclassInstance):
+                    dataclass = decoder.convert(
+                        raw_update.incoming_update.to_full_dict(),
+                        type=cls.dataclass,
+                    )
+
+                else:
+                    dataclass = cls.dataclass(**raw_update.incoming_update.to_dict())
+
+                ctx[EVENT_NODE_KEY] = cls
+                return dataclass
+            except Exception:
+                raise ComposeError(f"Cannot parse update to {cls.dataclass.__name__!r}.")
+
+
+__all__ = ("EventNode",)

telegrinder/node/me.py

@@ -12,3 +12,6 @@ class Me(ScalarNode, User):
     async def compose(cls, api: API) -> User:
         me = await api.get_me()
         return me.expect(ComposeError("Can't complete get_me request"))
+
+
+__all__ = ("Me",)

telegrinder/node/message.py

@@ -1,18 +1,14 @@
-from telegrinder.bot.cute_types import MessageCute
-
-from .base import ComposeError, ScalarNode
-from .update import UpdateNode
+from telegrinder.bot.cute_types.message import MessageCute
+from telegrinder.node.base import ComposeError, ScalarNode
+from telegrinder.node.update import UpdateNode
 
 
 class MessageNode(ScalarNode, MessageCute):
     @classmethod
-    async def compose(cls, update: UpdateNode) -> "MessageNode":
+    async def compose(cls, update: UpdateNode) -> MessageCute:
         if not update.message:
-            raise ComposeError
-        return MessageNode(
-            **update.message.unwrap().to_dict(),
-            api=update.api,
-        )
+            raise ComposeError("Update is not a message.")
+        return update.message.unwrap()
 
 
 __all__ = ("MessageNode",)

telegrinder/node/polymorphic.py

@@ -2,38 +2,37 @@ import inspect
 import typing
 
 from telegrinder.bot.dispatch.context import Context
-from telegrinder.tools.magic import get_impls, impl
+from telegrinder.node.base import BaseNode, ComposeError
+from telegrinder.node.composer import CONTEXT_STORE_NODES_KEY, Composition, NodeSession
+from telegrinder.node.scope import NodeScope
+from telegrinder.node.update import UpdateNode
+from telegrinder.tools.magic import IMPL_MARK, get_impls_by_key, impl
 
-from .base import ComposeError
-from .composer import CONTEXT_STORE_NODES_KEY, Composition, NodeSession
-from .scope import NodeScope
-from .update import UpdateNode
 
-
-class Polymorphic:
+class Polymorphic(BaseNode):
     @classmethod
     async def compose(cls, update: UpdateNode, context: Context) -> typing.Any:
         scope = getattr(cls, "scope", None)
         node_ctx = context.get_or_set(CONTEXT_STORE_NODES_KEY, {})
 
-        for i, impl in enumerate(get_impls(cls)):
-            composition = Composition(impl, True)
+        for i, impl in enumerate(get_impls_by_key(cls, IMPL_MARK).values()):
+            composition = Composition(impl, True, node_class=cls)
             node_collection = await composition.compose_nodes(update, context)
             if node_collection is None:
                 continue
 
             # To determine whether this is a right morph, all subnodes must be resolved
             if scope is NodeScope.PER_EVENT and (cls, i) in node_ctx:
-                result: NodeSession = node_ctx[(cls, i)]
+                res: NodeSession = node_ctx[(cls, i)]
                 await node_collection.close_all()
-                return result.value
+                return res.value
 
             result = composition.func(cls, **node_collection.values())
             if inspect.isawaitable(result):
                 result = await result
 
             if scope is NodeScope.PER_EVENT:
-                node_ctx[(cls, i)] = NodeSession(cls, result, {})  # type: ignore
+                node_ctx[(cls, i)] = NodeSession(cls, result, {})
 
             await node_collection.close_all(with_value=result)
             return result

telegrinder/node/rule.py

@@ -1,4 +1,5 @@
 import dataclasses
+import importlib
 import typing
 
 from telegrinder.bot.dispatch.context import Context
@@ -6,6 +7,7 @@ from telegrinder.node.base import ComposeError, Node
 from telegrinder.node.update import UpdateNode
 
 if typing.TYPE_CHECKING:
+    from telegrinder.bot.dispatch.process import check_rule
     from telegrinder.bot.rules.abc import ABCRule
 
 
@@ -13,7 +15,9 @@ class RuleChain(dict[str, typing.Any]):
     dataclass = dict
     rules: tuple["ABCRule", ...] = ()
 
-    def __init_subclass__(cls) -> None:
+    def __init_subclass__(cls, *args: typing.Any, **kwargs: typing.Any) -> None:
+        super().__init_subclass__(*args, **kwargs)
+
         if cls.__name__ == "_RuleNode":
             return
         cls.dataclass = cls.generate_node_dataclass(cls)
@@ -21,7 +25,7 @@ class RuleChain(dict[str, typing.Any]):
     def __new__(cls, *rules: "ABCRule") -> type[Node]:
         return type("_RuleNode", (cls,), {"dataclass": dict, "rules": rules})  # type: ignore
 
-    def __class_getitem__(cls, items: typing.Union[tuple["ABCRule", ...], "ABCRule"]) -> typing.Self:
+    def __class_getitem__(cls, items: "ABCRule | tuple[ABCRule, ...]", /) -> typing.Self:
         if not isinstance(items, tuple):
             items = (items,)
         assert all(isinstance(rule, "ABCRule") for rule in items), "All items must be instances of 'ABCRule'."
@@ -32,13 +36,23 @@ class RuleChain(dict[str, typing.Any]):
         return dataclasses.dataclass(type(cls_.__name__, (object,), dict(cls_.__dict__)))
 
     @classmethod
-    async def compose(cls, update: UpdateNode):
-        from telegrinder.bot.dispatch.process import check_rule
+    async def compose(cls, update: UpdateNode) -> typing.Any:
+        globalns = globals()
+        if "check_rule" not in globalns:
+            globalns.update(
+                {
+                    "check_rule": getattr(
+                        importlib.import_module("telegrinder.bot.dispatch.process"),
+                        "check_rule",
+                    ),
+                },
+            )
 
         ctx = Context()
         for rule in cls.rules:
             if not await check_rule(update.api, rule, update, ctx):
-                raise ComposeError
+                raise ComposeError(f"Rule {rule!r} failed!")
+
         try:
             return cls.dataclass(**ctx)  # type: ignore
         except Exception as exc:
@@ -52,6 +66,14 @@ class RuleChain(dict[str, typing.Any]):
     def get_sub_nodes(cls) -> dict:
         return {"update": UpdateNode}
 
+    @classmethod
+    def get_compose_annotations(cls) -> dict[str, typing.Any]:
+        return {}
+
+    @classmethod
+    def get_node_impls(cls) -> dict[str, typing.Callable[..., typing.Any]]:
+        return {}
+
     @classmethod
     def is_generator(cls) -> typing.Literal[False]:
         return False

telegrinder/node/source.py

@@ -1,18 +1,17 @@
 import dataclasses
 import typing
 
-from fntypes import Nothing, Option
+from fntypes.option import Nothing, Option
 
-from telegrinder.api import API
-from telegrinder.types import Chat, Message, User
+from telegrinder.api.api import API
+from telegrinder.node.base import ComposeError, DataNode, ScalarNode
+from telegrinder.node.callback_query import CallbackQueryNode
+from telegrinder.node.message import MessageNode
+from telegrinder.node.polymorphic import Polymorphic, impl
+from telegrinder.types.objects import Chat, Message, User
 
-from .base import ComposeError, DataNode, ScalarNode
-from .callback_query import CallbackQueryNode
-from .message import MessageNode
-from .polymorphic import Polymorphic, impl
 
-
-@dataclasses.dataclass(kw_only=True)
+@dataclasses.dataclass(kw_only=True, slots=True)
 class Source(Polymorphic, DataNode):
     api: API
     chat: Chat
@@ -24,7 +23,7 @@ class Source(Polymorphic, DataNode):
         return cls(
             api=message.ctx_api,
             chat=message.chat,
-            from_user=message.from_user,
+            from_user=message.from_.expect(ComposeError("MessageNode has no from_user")),
             thread_id=message.message_thread_id,
         )
 
@@ -32,7 +31,7 @@ class Source(Polymorphic, DataNode):
     async def compose_callback_query(cls, callback_query: CallbackQueryNode) -> typing.Self:
         return cls(
             api=callback_query.ctx_api,
-            chat=callback_query.chat.expect(ComposeError),
+            chat=callback_query.chat.expect(ComposeError("CallbackQueryNode has no chat")),
             from_user=callback_query.from_user,
             thread_id=callback_query.message_thread_id,
         )

telegrinder/node/text.py

@@ -1,12 +1,12 @@
-from .base import ComposeError, ScalarNode
-from .message import MessageNode
+from telegrinder.node.base import ComposeError, ScalarNode
+from telegrinder.node.message import MessageNode
 
 
 class Text(ScalarNode, str):
     @classmethod
     async def compose(cls, message: MessageNode) -> str:
         if not message.text:
-            raise ComposeError("Message has no text")
+            raise ComposeError("Message has no text.")
         return message.text.unwrap()
 
 
@@ -14,7 +14,7 @@ class TextInteger(ScalarNode, int):
     @classmethod
     async def compose(cls, text: Text) -> int:
         if not text.isdigit():
-            raise ComposeError("Text is not digit")
+            raise ComposeError("Text is not digit.")
         return int(text)
 
 

telegrinder/node/update.py

@@ -1,6 +1,5 @@
 from telegrinder.bot.cute_types import UpdateCute
-
-from .base import ScalarNode
+from telegrinder.node.base import ScalarNode
 
 
 class UpdateNode(ScalarNode, UpdateCute):

telegrinder/tools/__init__.py

@@ -43,7 +43,7 @@ from .global_context import (
     CtxVar,
     GlobalContext,
     GlobalCtxVar,
-    TelegrinderCtx,
+    TelegrinderContext,
     ctx_var,
 )
 from .i18n import (
@@ -110,7 +110,7 @@ __all__ = (
     "SpecialFormat",
     "StartBotLink",
     "StartGroupLink",
-    "TelegrinderCtx",
+    "TelegrinderContext",
     "TgEmoji",
     "escape",
     "get_channel_boost_link",

telegrinder/tools/buttons.py

@@ -3,25 +3,20 @@ import typing
 
 import msgspec
 
-from telegrinder.model import encoder
-from telegrinder.types import (
+from telegrinder.msgspec_utils import DataclassInstance, encoder
+from telegrinder.types.objects import (
     CallbackGame,
     KeyboardButtonPollType,
     KeyboardButtonRequestChat,
     KeyboardButtonRequestUsers,
+    LoginUrl,
     SwitchInlineQueryChosenChat,
     WebAppInfo,
 )
-from telegrinder.types.objects import LoginUrl
 
 ButtonT = typing.TypeVar("ButtonT", bound="BaseButton")
 
 
-@typing.runtime_checkable
-class DataclassInstance(typing.Protocol):
-    __dataclass_fields__: typing.ClassVar[dict[str, dataclasses.Field[typing.Any]]]
-
-
 @dataclasses.dataclass
 class BaseButton:
     def get_data(self) -> dict[str, typing.Any]:
@@ -44,7 +39,7 @@ class RowButtons(typing.Generic[ButtonT]):
         return [b.get_data() for b in self.buttons]
 
 
-@dataclasses.dataclass
+@dataclasses.dataclass(slots=True)
 class Button(BaseButton):
     text: str
     request_contact: bool = dataclasses.field(default=False, kw_only=True)
@@ -61,7 +56,7 @@ class Button(BaseButton):
     web_app: dict[str, typing.Any] | WebAppInfo | None = dataclasses.field(default=None, kw_only=True)
 
 
-@dataclasses.dataclass
+@dataclasses.dataclass(slots=True)
 class InlineButton(BaseButton):
     text: str
     url: str | None = dataclasses.field(default=None, kw_only=True)

telegrinder/tools/error_handler/error.py

@@ -1,4 +1,6 @@
 class CatcherError(BaseException):
+    __slots__ = ("exc", "message")
+
     def __init__(self, exc: BaseException, message: str) -> None:
         self.exc = exc
         self.message = message

telegrinder/tools/error_handler/error_handler.py

@@ -16,7 +16,7 @@ ExceptionT = typing.TypeVar("ExceptionT", bound=BaseException, contravariant=Tru
 FuncCatcher = typing.Callable[typing.Concatenate[ExceptionT, ...], typing.Awaitable[typing.Any]]
 
 
-@dataclasses.dataclass(frozen=True, repr=False)
+@dataclasses.dataclass(frozen=True, repr=False, slots=True)
 class Catcher(typing.Generic[EventT]):
     func: FuncCatcher[BaseException]
     exceptions: list[type[BaseException] | BaseException] = dataclasses.field(

telegrinder/tools/formatting/spec_html_formats.py

@@ -24,7 +24,7 @@ def is_spec_format(obj: typing.Any) -> typing.TypeGuard[SpecialFormat]:
     )
 
 
-@dataclasses.dataclass(repr=False)
+@dataclasses.dataclass(repr=False, slots=True)
 class BaseSpecFormat:
     __formatter_name__: typing.ClassVar[str] = dataclasses.field(init=False, repr=False)
 
@@ -32,7 +32,7 @@ class BaseSpecFormat:
         return f"<Special formatter {self.__class__.__name__!r} -> {self.__formatter_name__!r}>"
 
 
-@dataclasses.dataclass(repr=False)
+@dataclasses.dataclass(repr=False, slots=True)
 class ChannelBoostLink(BaseSpecFormat):
     __formatter_name__ = "channel_boost_link"
 
@@ -40,7 +40,7 @@ class ChannelBoostLink(BaseSpecFormat):
     string: str | None = None
 
 
-@dataclasses.dataclass(repr=False)
+@dataclasses.dataclass(repr=False, slots=True)
 class InviteChatLink(BaseSpecFormat):
     __formatter_name__ = "invite_chat_link"
 
@@ -48,7 +48,7 @@ class InviteChatLink(BaseSpecFormat):
     string: str | None = None
 
 
-@dataclasses.dataclass(repr=False)
+@dataclasses.dataclass(repr=False, slots=True)
 class Mention(BaseSpecFormat):
     __formatter_name__ = "mention"
 
@@ -56,7 +56,7 @@ class Mention(BaseSpecFormat):
     user_id: int
 
 
-@dataclasses.dataclass(repr=False)
+@dataclasses.dataclass(repr=False, slots=True)
 class Link(BaseSpecFormat):
     __formatter_name__ = "link"
 
@@ -64,7 +64,7 @@ class Link(BaseSpecFormat):
     string: str | None = None
 
 
-@dataclasses.dataclass(repr=False)
+@dataclasses.dataclass(repr=False, slots=True)
 class PreCode(BaseSpecFormat):
     __formatter_name__ = "pre_code"
 
@@ -72,7 +72,7 @@ class PreCode(BaseSpecFormat):
     lang: str | ProgrammingLanguage | None = None
 
 
-@dataclasses.dataclass(repr=False)
+@dataclasses.dataclass(repr=False, slots=True)
 class TgEmoji(BaseSpecFormat):
     __formatter_name__ = "tg_emoji"
 
@@ -80,7 +80,7 @@ class TgEmoji(BaseSpecFormat):
     emoji_id: int
 
 
-@dataclasses.dataclass(repr=False)
+@dataclasses.dataclass(repr=False, slots=True)
 class StartBotLink(BaseSpecFormat):
     __formatter_name__ = "start_bot_link"
 
@@ -89,7 +89,7 @@ class StartBotLink(BaseSpecFormat):
     string: str | None
 
 
-@dataclasses.dataclass(repr=False)
+@dataclasses.dataclass(repr=False, slots=True)
 class StartGroupLink(BaseSpecFormat):
     __formatter_name__ = "start_group_link"
 
@@ -98,7 +98,7 @@ class StartGroupLink(BaseSpecFormat):
     string: str | None = None
 
 
-@dataclasses.dataclass(repr=False)
+@dataclasses.dataclass(repr=False, slots=True)
 class ResolveDomain(BaseSpecFormat):
     __formatter_name__ = "resolve_domain"
 

telegrinder/tools/global_context/__init__.py

@@ -1,12 +1,12 @@
 from .abc import ABCGlobalContext, CtxVar, GlobalCtxVar
 from .global_context import GlobalContext, ctx_var
-from .telegrinder_ctx import TelegrinderCtx
+from .telegrinder_ctx import TelegrinderContext
 
 __all__ = (
     "ABCGlobalContext",
     "CtxVar",
     "GlobalContext",
     "GlobalCtxVar",
-    "TelegrinderCtx",
+    "TelegrinderContext",
     "ctx_var",
 )

telegrinder/tools/global_context/global_context.py

@@ -81,7 +81,7 @@ def ctx_var(value: T, *, const: bool = False) -> T:
     return typing.cast(T, CtxVar(value, const=const))
 
 
-@dataclasses.dataclass(frozen=True, eq=False)
+@dataclasses.dataclass(frozen=True, eq=False, slots=True)
 class RootAttr:
     name: str
     can_be_read: bool = dataclasses.field(default=True, kw_only=True)
@@ -91,7 +91,7 @@ class RootAttr:
         return self.name == __value
 
 
-@dataclasses.dataclass(repr=False, frozen=True)
+@dataclasses.dataclass(repr=False, frozen=True, slots=True)
 class Storage:
     _storage: dict[str, "GlobalContext"] = dataclasses.field(
         default_factory=lambda: {},

telegrinder/tools/global_context/telegrinder_ctx.py

@@ -5,14 +5,14 @@ import vbml
 from telegrinder.tools.global_context import GlobalContext, ctx_var
 
 
-class TelegrinderCtx(GlobalContext):
+class TelegrinderContext(GlobalContext):
     """Basic type-hinted telegrinder context with context name `"telegrinder"`.
 
     You can use this class or GlobalContext:
     ```
-    from telegrinder.tools.global_context import GlobalContext, TelegrinderCtx
+    from telegrinder.tools.global_context import GlobalContext, TelegrinderContext
 
-    ctx1 = TelegrinderCtx()
+    ctx1 = TelegrinderContext()
     ctx2 = GlobalContext("telegrinder")  # same, but without the type-hints
     assert ctx1 == ctx2  # ok
     ```"""
@@ -22,4 +22,4 @@ class TelegrinderCtx(GlobalContext):
     vbml_patcher: typing.ClassVar[vbml.Patcher] = ctx_var(vbml.Patcher(), const=True)
 
 
-__all__ = ("TelegrinderCtx",)
+__all__ = ("TelegrinderContext",)

telegrinder/tools/keyboard.py

@@ -17,7 +17,7 @@ DictStrAny: typing.TypeAlias = dict[str, typing.Any]
 AnyMarkup: typing.TypeAlias = InlineKeyboardMarkup | ReplyKeyboardMarkup
 
 
-@dataclasses.dataclass(kw_only=True)
+@dataclasses.dataclass(kw_only=True, slots=True)
 class KeyboardModel:
     resize_keyboard: bool
     one_time_keyboard: bool
@@ -77,7 +77,7 @@ class ABCMarkup(ABC, typing.Generic[ButtonT]):
         return self
 
 
-@dataclasses.dataclass(kw_only=True)
+@dataclasses.dataclass(kw_only=True, slots=True)
 class Keyboard(ABCMarkup[Button], KeyboardModel):
     BUTTON = Button
 

telegrinder/tools/loop_wrapper/loop_wrapper.py

@@ -1,6 +1,7 @@
 import asyncio
 import contextlib
 import dataclasses
+import datetime
 import typing
 
 from telegrinder.modules import logger
@@ -32,7 +33,7 @@ def to_coroutine_task(task: Task) -> CoroutineTask[typing.Any]:
     return task
 
 
-@dataclasses.dataclass
+@dataclasses.dataclass(slots=True)
 class DelayedTask(typing.Generic[CoroFunc]):
     handler: CoroFunc
     seconds: float
@@ -60,7 +61,7 @@ class DelayedTask(typing.Generic[CoroFunc]):
             self._cancelled = True
 
 
-@dataclasses.dataclass(kw_only=True)
+@dataclasses.dataclass(kw_only=True, slots=True)
 class Lifespan:
     startup_tasks: list[CoroutineTask[typing.Any]] = dataclasses.field(default_factory=lambda: [])
     shutdown_tasks: list[CoroutineTask[typing.Any]] = dataclasses.field(default_factory=lambda: [])
@@ -86,10 +87,11 @@ class LoopWrapper(ABCLoopWrapper):
         *,
         tasks: list[CoroutineTask[typing.Any]] | None = None,
         lifespan: Lifespan | None = None,
+        event_loop: asyncio.AbstractEventLoop | None = None,
     ) -> None:
         self.tasks: list[CoroutineTask[typing.Any]] = tasks or []
         self.lifespan = lifespan or Lifespan()
-        self._loop = asyncio.new_event_loop()
+        self._loop = event_loop or asyncio.new_event_loop()
 
     def __repr__(self) -> str:
         return "<{}: loop={!r} with tasks={!r}, lifespan={!r}>".format(
@@ -143,6 +145,10 @@ class LoopWrapper(ABCLoopWrapper):
         with contextlib.suppress(asyncio.CancelledError):
             self._loop.run_until_complete(task_to_cancel)
 
+    @typing.overload
+    def timer(self, *, seconds: datetime.timedelta) -> typing.Callable[..., typing.Any]: ...
+
+    @typing.overload
     def timer(
         self,
         *,
@@ -150,7 +156,19 @@ class LoopWrapper(ABCLoopWrapper):
         hours: int = 0,
         minutes: int = 0,
         seconds: float = 0,
-    ):
+    ) -> typing.Callable[..., typing.Any]: ...
+
+    def timer(
+        self,
+        *,
+        days: int = 0,
+        hours: int = 0,
+        minutes: int = 0,
+        seconds: float | datetime.timedelta = 0,
+    ) -> typing.Callable[..., typing.Any]:
+        if isinstance(seconds, datetime.timedelta):
+            seconds = seconds.total_seconds()
+
         seconds += minutes * 60
         seconds += hours * 60 * 60
         seconds += days * 24 * 60 * 60
@@ -161,6 +179,10 @@ class LoopWrapper(ABCLoopWrapper):
 
         return decorator
 
+    @typing.overload
+    def interval(self, *, seconds: datetime.timedelta) -> typing.Callable[..., typing.Any]: ...
+
+    @typing.overload
     def interval(
         self,
         *,
@@ -168,7 +190,19 @@ class LoopWrapper(ABCLoopWrapper):
         hours: int = 0,
         minutes: int = 0,
         seconds: float = 0,
-    ):
+    ) -> typing.Callable[..., typing.Any]: ...
+
+    def interval(
+        self,
+        *,
+        days: int = 0,
+        hours: int = 0,
+        minutes: int = 0,
+        seconds: float | datetime.timedelta = 0,
+    ) -> typing.Callable[..., typing.Any]:
+        if isinstance(seconds, datetime.timedelta):
+            seconds = seconds.total_seconds()
+
         seconds += minutes * 60
         seconds += hours * 60 * 60
         seconds += days * 24 * 60 * 60