auto-editor 25.2.0__py3-none-any.whl → 25.3.1__py3-none-any.whl

auto_editor/__init__.py

@@ -1 +1 @@
-__version__ = "25.2.0"
+__version__ = "25.3.1"

auto_editor/__main__.py

@@ -1,11 +1,15 @@
 #!/usr/bin/env python3
 
+import re
 import sys
 from os import environ
+from os.path import exists, isdir, isfile, lexists, splitext
+from subprocess import run
 
 import auto_editor
 from auto_editor.edit import edit_media
-from auto_editor.ffwrapper import FFmpeg
+from auto_editor.ffwrapper import FFmpeg, initFFmpeg
+from auto_editor.utils.func import get_stdout
 from auto_editor.utils.log import Log
 from auto_editor.utils.types import (
     Args,
@@ -20,7 +24,6 @@ from auto_editor.utils.types import (
     speed_range,
     time_range,
 )
-from auto_editor.validate_input import valid_input
 from auto_editor.vanparse import ArgumentParser
 
 
@@ -254,6 +257,11 @@ def main_options(parser: ArgumentParser) -> ArgumentParser:
         flag=True,
         help="Disable the inclusion of subtitle streams in the output file",
     )
+    parser.add_argument(
+        "-dn",
+        flag=True,
+        help="Disable the inclusion of data streams in the output file",
+    )
     parser.add_argument(
         "--extras",
         metavar="CMD",
@@ -269,6 +277,50 @@ def main_options(parser: ArgumentParser) -> ArgumentParser:
     return parser
 
 
+def download_video(my_input: str, args: Args, ffmpeg: FFmpeg, log: Log) -> str:
+    log.conwrite("Downloading video...")
+
+    def get_domain(url: str) -> str:
+        t = __import__("urllib").parse.urlparse(url).netloc
+        return ".".join(t.split(".")[-2:])
+
+    download_format = args.download_format
+    if download_format is None and get_domain(my_input) == "youtube.com":
+        download_format = "bestvideo[ext=mp4]+bestaudio[ext=m4a]"
+
+    if args.output_format is None:
+        output_format = re.sub(r"\W+", "-", splitext(my_input)[0]) + ".%(ext)s"
+    else:
+        output_format = args.output_format
+
+    yt_dlp_path = args.yt_dlp_location
+
+    cmd = ["--ffmpeg-location", ffmpeg.path]
+
+    if download_format is not None:
+        cmd.extend(["-f", download_format])
+
+    cmd.extend(["-o", output_format, my_input])
+
+    if args.yt_dlp_extras is not None:
+        cmd.extend(args.yt_dlp_extras.split(" "))
+
+    try:
+        location = get_stdout(
+            [yt_dlp_path, "--get-filename", "--no-warnings"] + cmd
+        ).strip()
+    except FileNotFoundError:
+        log.error("Program `yt-dlp` must be installed and on PATH.")
+
+    if not isfile(location):
+        run([yt_dlp_path] + cmd)
+
+    if not isfile(location):
+        log.error(f"Download file wasn't created: {location}")
+
+    return location
+
+
 def main() -> None:
     subcommands = ("test", "info", "levels", "subdump", "desc", "repl", "palet")
 
@@ -279,8 +331,7 @@ def main() -> None:
         obj.main(sys.argv[2:])
         return
 
-    ff_color = "AV_LOG_FORCE_NOCOLOR"
-    no_color = bool(environ.get("NO_COLOR")) or bool(environ.get(ff_color))
+    no_color = bool(environ.get("NO_COLOR") or environ.get("AV_LOG_FORCE_NOCOLOR"))
     log = Log(no_color=no_color)
 
     args = main_options(ArgumentParser("Auto-Editor")).parse_args(
@@ -322,13 +373,28 @@ def main() -> None:
     is_machine = args.progress == "machine"
     log = Log(args.debug, args.quiet, args.temp_dir, is_machine, no_color)
 
-    ffmpeg = FFmpeg(
+    ffmpeg = initFFmpeg(
+        log,
         args.ffmpeg_location,
         args.my_ffmpeg,
         args.show_ffmpeg_commands,
         args.show_ffmpeg_output,
     )
-    paths = valid_input(args.input, ffmpeg, args, log)
+    paths = []
+    for my_input in args.input:
+        if my_input.startswith("http://") or my_input.startswith("https://"):
+            paths.append(download_video(my_input, args, ffmpeg, log))
+        else:
+            if not splitext(my_input)[1]:
+                if isdir(my_input):
+                    log.error("Input must be a file or a URL, not a directory.")
+                if exists(my_input):
+                    log.error(f"Input file must have an extension: {my_input}")
+                if lexists(my_input):
+                    log.error(f"Input file is a broken symbolic link: {my_input}")
+                if my_input.startswith("-"):
+                    log.error(f"Option/Input file doesn't exist: {my_input}")
+            paths.append(my_input)
 
     try:
         edit_media(paths, ffmpeg, args, log)

auto_editor/analyze.py

@@ -14,12 +14,11 @@ from av.audio.fifo import AudioFifo
 from av.subtitles.subtitle import AssSubtitle
 
 from auto_editor import __version__
-from auto_editor.utils.subtitle_tools import convert_ass_to_text
 
 if TYPE_CHECKING:
-    from collections.abc import Iterator
+    from collections.abc import Iterator, Sequence
     from fractions import Fraction
-    from typing import Any
+    from pathlib import Path
 
     from numpy.typing import NDArray
 
@@ -70,15 +69,6 @@ def mut_remove_large(
             active = False
 
 
-def obj_tag(tag: str, tb: Fraction, obj: dict[str, Any]) -> str:
-    key = f"{tag}:{tb}:"
-    for k, v in obj.items():
-        key += f"{k}={v},"
-
-    key = key[:-1]  # remove unnecessary char
-    return key
-
-
 def iter_audio(src, tb: Fraction, stream: int = 0) -> Iterator[np.float32]:
     fifo = AudioFifo()
     try:
@@ -122,7 +112,7 @@ def iter_motion(src, tb, stream: int, blur: int, width: int) -> Iterator[np.floa
 
     prev_frame = None
     current_frame = None
-    total_pixels = src.videos[0].width * src.videos[0].height
+    total_pixels = None
     index = 0
     prev_index = -1
 
@@ -140,10 +130,13 @@ def iter_motion(src, tb, stream: int, blur: int, width: int) -> Iterator[np.floa
             continue
 
         graph.push(unframe)
-        frame = graph.pull()
+        frame = graph.vpull()
         assert frame.time is not None
         index = round(frame.time * tb)
 
+        if total_pixels is None:
+            total_pixels = frame.width * frame.height
+
         current_frame = frame.to_ndarray()
         if prev_frame is None:
             value = np.float32(0.0)
@@ -161,6 +154,12 @@ def iter_motion(src, tb, stream: int, blur: int, width: int) -> Iterator[np.floa
     container.close()
 
 
+def obj_tag(path: Path, kind: str, tb: Fraction, obj: Sequence[object]) -> str:
+    mod_time = int(path.stat().st_mtime)
+    key = f"{path.name}:{mod_time:x}:{kind}:{tb}:"
+    return key + ",".join(f"{v}" for v in obj)
+
+
 @dataclass(slots=True)
 class Levels:
     src: FileInfo
@@ -173,7 +172,7 @@ class Levels:
     @property
     def media_length(self) -> int:
         if self.src.audios:
-            if (arr := self.read_cache("audio", {"stream": 0})) is not None:
+            if (arr := self.read_cache("audio", (0,))) is not None:
                 return len(arr)
 
             result = sum(1 for _ in iter_audio(self.src, self.tb, 0))
@@ -201,7 +200,7 @@ class Levels:
     def all(self) -> NDArray[np.bool_]:
         return np.zeros(self.media_length, dtype=np.bool_)
 
-    def read_cache(self, tag: str, obj: dict[str, Any]) -> None | np.ndarray:
+    def read_cache(self, kind: str, obj: Sequence[object]) -> None | np.ndarray:
         if self.no_cache:
             return None
 
@@ -213,14 +212,14 @@ class Levels:
             self.log.debug(e)
             return None
 
-        key = f"{self.src.path}:{obj_tag(tag, self.tb, obj)}"
+        key = obj_tag(self.src.path, kind, self.tb, obj)
         if key not in npzfile.files:
             return None
 
         self.log.debug("Using cache")
         return npzfile[key]
 
-    def cache(self, arr: np.ndarray, tag: str, obj: dict[str, Any]) -> np.ndarray:
+    def cache(self, arr: np.ndarray, kind: str, obj: Sequence[object]) -> np.ndarray:
         if self.no_cache:
             return arr
 
@@ -228,8 +227,8 @@ class Levels:
         if not os.path.exists(workdur):
             os.mkdir(workdur)
 
-        tag = obj_tag(tag, self.tb, obj)
-        np.savez(os.path.join(workdur, "cache.npz"), **{f"{self.src.path}:{tag}": arr})
+        key = obj_tag(self.src.path, kind, self.tb, obj)
+        np.savez(os.path.join(workdur, "cache.npz"), **{key: arr})
 
         return arr
 
@@ -237,7 +236,7 @@ class Levels:
         if stream >= len(self.src.audios):
             raise LevelError(f"audio: audio stream '{stream}' does not exist.")
 
-        if (arr := self.read_cache("audio", {"stream": stream})) is not None:
+        if (arr := self.read_cache("audio", (stream,))) is not None:
             return arr
 
         with av.open(self.src.path, "r") as container:
@@ -264,13 +263,13 @@ class Levels:
             index += 1
 
         bar.end()
-        return self.cache(result[:index], "audio", {"stream": stream})
+        return self.cache(result[:index], "audio", (stream,))
 
     def motion(self, stream: int, blur: int, width: int) -> NDArray[np.float32]:
         if stream >= len(self.src.videos):
             raise LevelError(f"motion: video stream '{stream}' does not exist.")
 
-        mobj = {"stream": stream, "width": width, "blur": blur}
+        mobj = (stream, width, blur)
         if (arr := self.read_cache("motion", mobj)) is not None:
             return arr
 
@@ -359,11 +358,10 @@ class Levels:
                 san_end = round((start + dur) * self.tb)
 
                 for sub in subset:
-                    if isinstance(sub, AssSubtitle):
-                        line = convert_ass_to_text(sub.ass.decode(errors="ignore"))
-                    else:
+                    if not isinstance(sub, AssSubtitle):
                         continue
 
+                    line = sub.dialogue.decode(errors="ignore")
                     if line and re.search(re_pattern, line):
                         result[san_start:san_end] = 1
                         count += 1

auto_editor/edit.py

@@ -1,6 +1,8 @@
 from __future__ import annotations
 
 import os
+import sys
+from subprocess import run
 from typing import Any
 
 from auto_editor.ffwrapper import FFmpeg, FileInfo, initFileInfo
@@ -11,11 +13,10 @@ from auto_editor.render.audio import make_new_audio
 from auto_editor.render.subtitle import make_new_subtitles
 from auto_editor.render.video import render_av
 from auto_editor.timeline import v1, v3
-from auto_editor.utils.bar import Bar
+from auto_editor.utils.bar import initBar
 from auto_editor.utils.chunks import Chunk, Chunks
 from auto_editor.utils.cmdkw import ParserError, parse_with_palet, pAttr, pAttrs
 from auto_editor.utils.container import Container, container_constructor
-from auto_editor.utils.func import open_with_system_default
 from auto_editor.utils.log import Log
 from auto_editor.utils.types import Args
 
@@ -125,7 +126,9 @@ def parse_export(export: str, log: Log) -> dict[str, Any]:
         "default": pAttrs("default"),
         "premiere": pAttrs("premiere", name_attr),
         "resolve-fcp7": pAttrs("resolve-fcp7", name_attr),
-        "final-cut-pro": pAttrs("final-cut-pro", name_attr),
+        "final-cut-pro": pAttrs(
+            "final-cut-pro", name_attr, pAttr("version", 11, is_int)
+        ),
         "resolve": pAttrs("resolve", name_attr),
         "shotcut": pAttrs("shotcut"),
         "json": pAttrs("json", pAttr("api", 3, is_int)),
@@ -146,7 +149,7 @@ def parse_export(export: str, log: Log) -> dict[str, Any]:
 
 
 def edit_media(paths: list[str], ffmpeg: FFmpeg, args: Args, log: Log) -> None:
-    bar = Bar(args.progress)
+    bar = initBar(args.progress)
     tl = None
 
     if paths:
@@ -232,11 +235,19 @@ def edit_media(paths: list[str], ffmpeg: FFmpeg, args: Args, log: Log) -> None:
         fcp7_write_xml(export_ops["name"], output, is_resolve, tl, log)
         return
 
-    if export in ("final-cut-pro", "resolve"):
+    if export == "final-cut-pro":
         from auto_editor.formats.fcp11 import fcp11_write_xml
 
-        is_resolve = export.startswith("resolve")
-        fcp11_write_xml(export_ops["name"], ffmpeg, output, is_resolve, tl, log)
+        ver = export_ops["version"]
+        fcp11_write_xml(export_ops["name"], ver, output, False, tl, log)
+        return
+
+    if export == "resolve":
+        from auto_editor.formats.fcp11 import fcp11_write_xml
+        from auto_editor.timeline import set_stream_to_0
+
+        set_stream_to_0(tl, log)
+        fcp11_write_xml(export_ops["name"], 10, output, True, tl, log)
         return
 
     if export == "shotcut":
@@ -318,7 +329,7 @@ def edit_media(paths: list[str], ffmpeg: FFmpeg, args: Args, log: Log) -> None:
         total_frames = tl.v1.chunks[-1][1] - 1
         clip_num = 0
         for chunk in tl.v1.chunks:
-            if chunk[2] == 99999:
+            if chunk[2] == 0 or chunk[2] >= 99999:
                 continue
 
             padded_chunks = pad_chunk(chunk, total_frames)
@@ -344,11 +355,23 @@ def edit_media(paths: list[str], ffmpeg: FFmpeg, args: Args, log: Log) -> None:
 
     log.stop_timer()
 
-    if not args.no_open and export in ("default", "audio", "clip-sequence"):
+    if not args.no_open and export in ("default", "audio"):
         if args.player is None:
-            open_with_system_default(output, log)
+            if sys.platform == "win32":
+                try:
+                    os.startfile(output)
+                except OSError:
+                    log.warning(f"Could not find application to open file: {output}")
+            else:
+                try:  # MacOS case
+                    run(["open", output])
+                except Exception:
+                    try:  # WSL2 case
+                        run(["cmd.exe", "/C", "start", output])
+                    except Exception:
+                        try:  # Linux case
+                            run(["xdg-open", output])
+                        except Exception:
+                            log.warning(f"Could not open output file: {output}")
         else:
-            import subprocess
-            from shlex import split
-
-            subprocess.run(split(args.player) + [output])
+            run(__import__("shlex").split(args.player) + [output])

auto_editor/ffwrapper.py

@@ -1,83 +1,59 @@
 from __future__ import annotations
 
 import os.path
-import subprocess
 import sys
 from dataclasses import dataclass
 from fractions import Fraction
 from pathlib import Path
 from re import search
 from shutil import which
-from subprocess import PIPE, Popen
+from subprocess import PIPE, Popen, run
 from typing import Any
 
 import av
 
-from auto_editor.utils.func import get_stdout
 from auto_editor.utils.log import Log
 
 
-class FFmpeg:
-    __slots__ = ("debug", "show_cmd", "path", "version")
-
-    def __init__(
-        self,
-        ff_location: str | None = None,
-        my_ffmpeg: bool = False,
-        show_cmd: bool = False,
-        debug: bool = False,
-    ):
-        def _set_ff_path(ff_location: str | None, my_ffmpeg: bool) -> str:
-            if ff_location is not None:
-                return ff_location
-            if my_ffmpeg:
-                return "ffmpeg"
-
-            try:
-                import ae_ffmpeg
-
-                return ae_ffmpeg.get_path()
-            except ImportError:
-                return "ffmpeg"
-
-        self.debug = debug
-        self.show_cmd = show_cmd
-        _path: str | None = _set_ff_path(ff_location, my_ffmpeg)
-
-        if _path == "ffmpeg":
-            _path = which("ffmpeg")
-
-        if _path is None:
-            Log().error("Did not find ffmpeg on PATH.")
-        self.path = _path
-
+def initFFmpeg(
+    log: Log, ff_location: str | None, my_ffmpeg: bool, show_cmd: bool, debug: bool
+) -> FFmpeg:
+    if ff_location is not None:
+        program = ff_location
+    elif my_ffmpeg:
+        program = "ffmpeg"
+    else:
         try:
-            _version = get_stdout([self.path, "-version"]).split("\n")[0]
-            self.version = _version.replace("ffmpeg version", "").strip().split(" ")[0]
-        except FileNotFoundError:
-            Log().error("ffmpeg must be installed and on PATH.")
+            import ae_ffmpeg
 
-    def print(self, message: str) -> None:
-        if self.debug:
-            sys.stderr.write(f"FFmpeg: {message}\n")
+            program = ae_ffmpeg.get_path()
+        except ImportError:
+            program = "ffmpeg"
 
-    def print_cmd(self, cmd: list[str]) -> None:
-        if self.show_cmd:
-            sys.stderr.write(f"{' '.join(cmd)}\n\n")
+    path: str | None = which(program)
+    if path is None:
+        log.error("Did not find ffmpeg on PATH.")
+
+    return FFmpeg(log, path, show_cmd, debug)
+
+
+@dataclass(slots=True)
+class FFmpeg:
+    log: Log
+    path: str
+    show_cmd: bool
+    debug: bool
 
     def run(self, cmd: list[str]) -> None:
         cmd = [self.path, "-hide_banner", "-y"] + cmd
         if not self.debug:
             cmd.extend(["-nostats", "-loglevel", "error"])
-        self.print_cmd(cmd)
-        subprocess.run(cmd)
+        if self.show_cmd:
+            sys.stderr.write(f"{' '.join(cmd)}\n\n")
+        run(cmd)
 
     def run_check_errors(
-        self,
-        cmd: list[str],
-        log: Log,
-        show_out: bool = False,
-        path: str | None = None,
+        self, cmd: list[str], show_out: bool = False, path: str | None = None
     ) -> None:
         process = self.Popen(cmd, stdin=PIPE, stdout=PIPE, stderr=PIPE)
         _, stderr = process.communicate()
@@ -104,27 +80,39 @@ class FFmpeg:
 
         for item in error_list:
             if check := search(item, output):
-                log.error(check.group())
+                self.log.error(check.group())
 
         if path is not None and not os.path.isfile(path):
-            log.error(f"The file {path} was not created.")
-        elif show_out and not self.debug:
+            self.log.error(f"The file {path} was not created.")
+        if show_out and not self.debug:
             print(f"stderr: {output}")
 
     def Popen(
         self, cmd: list[str], stdin: Any = None, stdout: Any = PIPE, stderr: Any = None
     ) -> Popen:
-        cmd = [self.path] + cmd
-        self.print_cmd(cmd)
-        return Popen(cmd, stdin=stdin, stdout=stdout, stderr=stderr)
+        if self.show_cmd:
+            sys.stderr.write(f"{self.path} {' '.join(cmd)}\n\n")
+        return Popen([self.path] + cmd, stdin=stdin, stdout=stdout, stderr=stderr)
+
+
+def mux(input: Path, output: Path, stream: int) -> None:
+    input_container = av.open(input, "r")
+    output_container = av.open(output, "w")
+
+    input_audio_stream = input_container.streams.audio[stream]
+    output_audio_stream = output_container.add_stream("pcm_s16le")
+
+    for frame in input_container.decode(input_audio_stream):
+        packet = output_audio_stream.encode(frame)
+        if packet:
+            output_container.mux(packet)
 
-    def pipe(self, cmd: list[str]) -> str:
-        cmd = [self.path, "-y"] + cmd
+    packet = output_audio_stream.encode(None)
+    if packet:
+        output_container.mux(packet)
 
-        self.print_cmd(cmd)
-        output = get_stdout(cmd)
-        self.print(output)
-        return output
+    output_container.close()
+    input_container.close()
 
 
 @dataclass(slots=True, frozen=True)
@@ -269,7 +257,7 @@ def initFileInfo(path: str, log: Log) -> FileInfo:
 
     desc = cont.metadata.get("description", None)
     bitrate = 0 if cont.bit_rate is None else cont.bit_rate
-    dur = 0 if cont.duration is None else cont.duration / 1_000_000
+    dur = 0 if cont.duration is None else cont.duration / av.time_base
 
     cont.close()
 

auto_editor/formats/fcp11.py

@@ -3,17 +3,15 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Any, cast
 from xml.etree.ElementTree import Element, ElementTree, SubElement, indent
 
-from auto_editor.ffwrapper import FFmpeg, FileInfo, initFileInfo
-
-from .utils import make_tracks_dir
-
 if TYPE_CHECKING:
     from collections.abc import Sequence
     from fractions import Fraction
 
+    from auto_editor.ffwrapper import FileInfo
     from auto_editor.timeline import TlAudio, TlVideo, v3
     from auto_editor.utils.log import Log
 
+
 """
 Export a FCPXML 11 file readable with Final Cut Pro 10.6.8 or later.
 
@@ -54,7 +52,7 @@ def make_name(src: FileInfo, tb: Fraction) -> str:
 
 
 def fcp11_write_xml(
-    group_name: str, ffmpeg: FFmpeg, output: str, resolve: bool, tl: v3, log: Log
+    group_name: str, version: int, output: str, resolve: bool, tl: v3, log: Log
 ) -> None:
     def fraction(val: int) -> str:
         if val == 0:
@@ -68,23 +66,17 @@ def fcp11_write_xml(
     src_dur = int(src.duration * tl.tb)
     tl_dur = src_dur if resolve else tl.out_len()
 
-    all_srcs: list[FileInfo] = [src]
-    all_refs: list[str] = ["r2"]
-    if resolve and len(src.audios) > 1:
-        fold = make_tracks_dir(src)
-
-        for i in range(1, len(src.audios)):
-            newtrack = fold / f"{i}.wav"
-            ffmpeg.run(
-                ["-i", f"{src.path.resolve()}", "-map", f"0:a:{i}", f"{newtrack}"]
-            )
-            all_srcs.append(initFileInfo(f"{newtrack}", log))
-            all_refs.append(f"r{(i + 1) * 2}")
+    if version == 11:
+        ver_str = "1.11"
+    elif version == 10:
+        ver_str = "1.10"
+    else:
+        log.error(f"Unknown final cut pro version: {version}")
 
-    fcpxml = Element("fcpxml", version="1.10" if resolve else "1.11")
+    fcpxml = Element("fcpxml", version=ver_str)
     resources = SubElement(fcpxml, "resources")
 
-    for i, one_src in enumerate(all_srcs):
+    for i, one_src in enumerate(tl.unique_sources()):
         SubElement(
             resources,
             "format",
@@ -126,13 +118,6 @@ def fcp11_write_xml(
     )
     spine = SubElement(sequence, "spine")
 
-    if tl.v and tl.v[0]:
-        clips: Sequence[TlVideo | TlAudio] = cast(Any, tl.v[0])
-    elif tl.a and tl.a[0]:
-        clips = tl.a[0]
-    else:
-        clips = []
-
     def make_clip(ref: str, clip: TlVideo | TlAudio) -> None:
         clip_properties = {
             "name": proj_name,
@@ -157,7 +142,19 @@ def fcp11_write_xml(
                 interp="smooth2",
             )
 
-    for my_ref in all_refs:
+    if tl.v and tl.v[0]:
+        clips: Sequence[TlVideo | TlAudio] = cast(Any, tl.v[0])
+    elif tl.a and tl.a[0]:
+        clips = tl.a[0]
+    else:
+        clips = []
+
+    all_refs: list[str] = ["r2"]
+    if resolve:
+        for i in range(1, len(tl.a)):
+            all_refs.append(f"r{(i + 1) * 2}")
+
+    for my_ref in reversed(all_refs):
         for clip in clips:
             make_clip(my_ref, clip)
 

auto_editor/formats/utils.py

@@ -4,9 +4,6 @@ from typing import TYPE_CHECKING
 from xml.etree.ElementTree import Element
 
 if TYPE_CHECKING:
-    from pathlib import Path
-
-    from auto_editor.ffwrapper import FileInfo
     from auto_editor.utils.log import Log
 
 
@@ -19,21 +16,6 @@ def show(ele: Element, limit: int, depth: int = 0) -> None:
             show(child, limit, depth + 1)
 
 
-def make_tracks_dir(src: FileInfo) -> Path:
-    from os import mkdir
-    from shutil import rmtree
-
-    fold = src.path.parent / f"{src.path.stem}_tracks"
-
-    try:
-        mkdir(fold)
-    except OSError:
-        rmtree(fold)
-        mkdir(fold)
-
-    return fold
-
-
 class Validator:
     def __init__(self, log: Log):
         self.log = log