cue4parse 0.0.4__tar.gz → 0.0.6__tar.gz

{cue4parse-0.0.4 → cue4parse-0.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: cue4parse
-Version: 0.0.4
+Version: 0.0.6
 Summary: CUE4Parse Python wrapper and CLI tool to extract packages from Unreal Engine games
 Project-URL: Homepage, https://github.com/joric/CUE4Parse-Python/wiki
 Project-URL: Repository, https://github.com/joric/CUE4Parse-Python
@@ -20,11 +20,4 @@ Description-Content-Type: text/markdown
 
 CUE4Parse Python wrapper, CLI tool, and scripting engine
 
-## Usage
-
-`pip install cue4parse`
-
-* Make sure executable is added to paths, e.g. `%LOCALAPPDATA%\Python\pythoncore-3.14-64\Scripts`.
-* Needs CUE4Parse libraries in `%LOCALAPPDATA%/cue4parse/libs` (downloads and unpacks FModel on Windows).
-* To run CLI: `cue4parse`
-
+* Documentation: https://github.com/joric/CUE4Parse-Python/wiki

cue4parse-0.0.6/README.md

@@ -0,0 +1,5 @@
+# CUE4Parse-Python
+
+CUE4Parse Python wrapper, CLI tool, and scripting engine
+
+* Documentation: https://github.com/joric/CUE4Parse-Python/wiki

{cue4parse-0.0.4 → cue4parse-0.0.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "cue4parse"
-version = "0.0.4"
+version = "0.0.6"
 description = "CUE4Parse Python wrapper and CLI tool to extract packages from Unreal Engine games"
 requires-python = ">=3.9"
 dependencies = ["pythonnet>=3.0"]

{cue4parse-0.0.4 → cue4parse-0.0.6}/src/cue4parse/cli.py

@@ -3,7 +3,10 @@ from cue4parse import *
 import tempfile
 import fnmatch
 import time
+import argparse
+import threading
 from importlib.metadata import version
+from concurrent.futures import ThreadPoolExecutor, as_completed
 
 export_directory = ""
 overwrite_files = False
@@ -33,12 +36,14 @@ class CliOptions:
     yes: bool
     verbose: bool
     mesh_format: str
-    anim_format: str
     texture_format: str
-    material_format: str
-    lod_format: str
+    material_depth: str
+    mesh_quality: str
     socket_format: str
-    nanite_format: str  # kept for parity (not assigned if enum unavailable)
+    nanite_format: str
+    texture_platform: str
+    texture_quality: int
+    export_all_mips: bool
     export_morph_targets: bool
     export_materials: bool
     export_hdr_as_hdr: bool
@@ -49,9 +54,7 @@ def norm_path(path: str) -> str:
         return "."
     return path.replace("/", os.sep).replace("\\\\", "\\")
 
-
 def parse_enum(enum_type: Any, value: str, default_name: str | None = None) -> Any:
-    # pythonnet enum access: getattr(EnumType, "ValueName")
     if hasattr(enum_type, value):
         return getattr(enum_type, value)
     for name in dir(enum_type):
@@ -61,11 +64,9 @@ def parse_enum(enum_type: Any, value: str, default_name: str | None = None) -> A
         print(f"Warning: Unknown value '{value}' for {enum_type.__name__}, using default '{default_name}'", file=sys.stderr)
         return getattr(enum_type, default_name)
     print(f"Warning: Unknown value '{value}' for {enum_type.__name__}, using default", file=sys.stderr)
-    # best-effort default
     names = [n for n in dir(enum_type) if not n.startswith("_")]
     return getattr(enum_type, names[0]) if names else None
 
-
 def check_file(out_path: Path, silent: bool = False) -> bool:
     skip = (not overwrite_files) and out_path.exists()
     if not silent:
@@ -75,11 +76,9 @@ def check_file(out_path: Path, silent: bool = False) -> bool:
             Log.Information("Writing {Path}", norm_path(str(out_path)))
     return not skip
 
-
 def write_to_log(_folder: str, _log_message: str, counter: list[int]) -> None:
     counter[0] += 1
 
-
 def write_to_file(folder: str, file_name: str, data: bytes, log_message: str, counter: list[int]) -> None:
     out_path = Path(export_directory) / folder / file_name
     if not check_file(out_path):
@@ -89,12 +88,10 @@ def write_to_file(folder: str, file_name: str, data: bytes, log_message: str, co
     write_to_log(folder, log_message, counter)
 
 def save_json(folder: str, name: str, exports: Any, counter: list[int]) -> None:
-    #text = JsonConvert.SerializeObject(exports, Formatting.Indented) # alternative way
-
-    serializer = JsonSerializer();
-    serializer.Formatting = Formatting.Indented;
+    serializer = JsonSerializer()
+    serializer.Formatting = Formatting.Indented
 
-    output_to_stdout = export_directory==""
+    output_to_stdout = export_directory == ""
     if output_to_stdout:
         writer = JsonTextWriter(Console.Out)
         serializer.Serialize(writer, exports)
@@ -108,12 +105,11 @@ def save_json(folder: str, name: str, exports: Any, counter: list[int]) -> None:
         return
 
     out_path.parent.mkdir(parents=True, exist_ok=True)
-
-    stream = StreamWriter(str(out_path), False, Encoding.UTF8);
+    stream = StreamWriter(str(out_path), False, Encoding.UTF8)
     try:
-        writer = JsonTextWriter(stream);
+        writer = JsonTextWriter(stream)
         try:
-            serializer.Serialize(writer, exports);
+            serializer.Serialize(writer, exports)
             writer.Flush()
         finally:
             writer.Close()
@@ -122,7 +118,6 @@ def save_json(folder: str, name: str, exports: Any, counter: list[int]) -> None:
 
     write_to_log(folder, name, counter)
 
-
 def save_raw(folder: str, package, provider, counter: list[int]) -> None:
     name = str(package.Name)
     out_path = Path(export_directory) / folder / name
@@ -132,7 +127,6 @@ def save_raw(folder: str, package, provider, counter: list[int]) -> None:
     data = bytes(provider.Files[package.Path].Read())
     write_to_file(folder, name, data, name, counter)
 
-
 def try_load_locmeta(package) -> tuple[bool, Any]:
     ok, reader = package.TryCreateReader()
     if not ok or reader is None:
@@ -142,7 +136,6 @@ def try_load_locmeta(package) -> tuple[bool, Any]:
     except Exception:
         return False, None
 
-
 def try_load_locres(package) -> tuple[bool, Any]:
     ok, reader = package.TryCreateReader()
     if not ok or reader is None:
@@ -152,48 +145,18 @@ def try_load_locres(package) -> tuple[bool, Any]:
     except Exception:
         return False, None
 
-
-def save_texture(folder: str, texture: UTexture, platform: ETexturePlatform, options: ExporterOptions, counter: list[int], name_prefix='') -> None:
-    out_base = Path(export_directory) / folder / str(texture.Name)
-    for ext in (".png", ".hdr"):
-        p = out_base.with_suffix(ext)
-        if not check_file(p, silent=True):
-            check_file(p, silent=False)
-            return
-
-    if isinstance(texture, UTexture2DArray):
-        bitmaps = list(TextureDecoder.DecodeTextureArray(texture, platform))
-    else:
-        bitmap = TextureDecoder.Decode(texture, platform)
-        if isinstance(texture, UTextureCube):
-            bitmap = CubemapConverter.ToPanorama(bitmap) if bitmap is not None else None
-        bitmaps = [bitmap]
-
-    for bitmap in bitmaps or []:
-        if bitmap is None:
-            continue
-        result = TextureEncoder.Encode(bitmap, options.TextureFormat, options.ExportHdrTexturesAsHdr)
-        if isinstance(result, tuple):
-            encoded, extension = result
-        else:
-            encoded, extension = result, "png"
-        file_name = f"{name_prefix}{texture.Name}.{extension}"
-        write_to_file(folder, file_name, bytes(encoded), f"{file_name} ({bitmap.Width}x{bitmap.Height})", counter)
-
-
 def filter_paths(paths: Iterable[str], pattern: str) -> list[str]:
     return [p for p in paths if fnmatch.fnmatch(p, pattern)]
 
-
 def execute(options: CliOptions) -> int:
     global export_directory, overwrite_files
 
     overwrite_files = options.yes
 
     if options.verbose:
-        Log.Logger = with_console(LoggerConfiguration().MinimumLevel.Verbose()).CreateLogger()
+        Log.Logger = LoggerConfiguration().MinimumLevel.Verbose().WriteTo.Console().CreateLogger()
     else:
-        Log.Logger = with_console(LoggerConfiguration().MinimumLevel.Fatal()).CreateLogger()
+        Log.Logger = LoggerConfiguration().MinimumLevel.Fatal().WriteTo.Console().CreateLogger()
 
     try:
         game_version = parse_enum(EGame, options.game, "GAME_UE5_LATEST")
@@ -204,7 +167,8 @@ def execute(options: CliOptions) -> int:
         print(f"Mappings not found: {options.mappings}", file=sys.stderr)
         return 1
 
-    version = VersionContainer(game_version, ETexturePlatform.DesktopMobile)
+    texture_platform_value = parse_enum(ETexturePlatform, options.texture_platform, "DesktopMobile")
+    version = VersionContainer(game_version, texture_platform_value)
 
     single_pak_mode = bool(options.pak)
     if single_pak_mode:
@@ -255,11 +219,6 @@ def execute(options: CliOptions) -> int:
     print(f"Total assets: {provider.Files.Count}", file=sys.stderr)
     print(f"Output format: {options.format}", file=sys.stderr)
 
-    detex_path = os.path.join(tempfile.gettempdir(), str(DetexHelper.DLL_NAME))
-    if not Path(detex_path).exists():
-        DetexHelper.LoadDllAsync(detex_path).GetAwaiter().GetResult()
-    DetexHelper.Initialize(detex_path)
-
     package_paths: list[str] = []
     for list_file in options.config:
         if list_file and Path(list_file).exists():
@@ -293,20 +252,21 @@ def execute(options: CliOptions) -> int:
         print("No matches, exiting.", file=sys.stderr)
         return 0
 
-    export_type = ExportType.TEXTURE | ExportType.SOUND | ExportType.MESH | ExportType.ANIMATION | ExportType.OTHER
-
-    exp_options = ExporterOptions()
-    exp_options.LodFormat = parse_enum(ELodFormat, options.lod_format, "AllLods")
-    exp_options.MeshFormat = parse_enum(EMeshFormat, options.mesh_format, "ActorX")
-    exp_options.AnimFormat = parse_enum(EAnimFormat, options.anim_format, "ActorX")
-    exp_options.MaterialFormat = parse_enum(EMaterialFormat, options.material_format, "AllLayersNoRef")
-    exp_options.TextureFormat = parse_enum(ETextureFormat, options.texture_format, "Png")
-    exp_options.CompressionFormat = parse_enum(EFileCompressionFormat, options.compression, "None")
-    exp_options.Platform = version.Platform
-    exp_options.SocketFormat = parse_enum(ESocketFormat, options.socket_format, "Bone")
-    exp_options.ExportMorphTargets = options.export_morph_targets
-    exp_options.ExportMaterials = options.export_materials
-    exp_options.ExportHdrTexturesAsHdr = options.export_hdr_as_hdr
+    exp_options = ExportOptions(
+        parse_enum(EMeshFormat, options.mesh_format, "ActorX"),
+        parse_enum(ENaniteMeshFormat, options.nanite_format, "NaniteFirst") if 'ENaniteMeshFormat' in globals() else None,
+        parse_enum(EMeshQuality, options.mesh_quality, "Highest"),
+        texture_platform_value,
+        parse_enum(ETextureFormat, options.texture_format, "Png"),
+        options.texture_quality,
+        options.export_hdr_as_hdr,
+        options.export_all_mips,
+        parse_enum(EMaterialDepth, options.material_depth, "TopLayerOnly"),
+        options.export_materials,
+        options.export_morph_targets,
+        parse_enum(ESocketFormat, options.socket_format, "Bone"),
+        parse_enum(EFileCompressionFormat, options.compression, "None")
+    )
 
     needs_output_dir = (not options.list_only) and options.format not in ("csv", "json")
     if not options.output:
@@ -317,13 +277,13 @@ def execute(options: CliOptions) -> int:
     else:
         export_directory = norm_path(options.output)
 
-    import threading
-    from concurrent.futures import ThreadPoolExecutor, as_completed
 
     counter_lock = threading.Lock()
     export_count = [0]
     counter = 0
     start = time.monotonic()
+    
+    session_objects = []
 
     def process_package(package):
         folder = str(package.Path).rsplit("/", 1)[0] if "/" in str(package.Path) else ""
@@ -347,7 +307,7 @@ def execute(options: CliOptions) -> int:
         ok, pkg = provider.TryLoadPackage(package)
         if not ok or pkg is None:
             if ext in (".uasset", ".umap"):
-                raise RuntimeError("Could not load standard asset, check game version, mappings or keys.")
+                raise RuntimeError(f"Could not load standard asset, check game version, mappings or keys: {package.Name}")
             if target_format in ("auto", "raw"):
                 target_format = "raw"
             else:
@@ -364,10 +324,9 @@ def execute(options: CliOptions) -> int:
         if target_format not in ("auto", "png"):
             return True
 
-        if target_format == "png":
-            local_export_type = ExportType.TEXTURE
-        else:
-            local_export_type = ExportType.TEXTURE | ExportType.SOUND | ExportType.MESH | ExportType.ANIMATION | ExportType.OTHER
+        local_export_type = ExportType.TEXTURE if target_format == "png" else (
+            ExportType.TEXTURE | ExportType.SOUND | ExportType.MESH | ExportType.ANIMATION | ExportType.OTHER
+        )
 
         parsed = False
 
@@ -381,12 +340,8 @@ def execute(options: CliOptions) -> int:
 
             value = pointer.Object.Value
             if isinstance(dummy, UTexture) and (ExportType.TEXTURE in local_export_type) and isinstance(value, UTexture):
-
-                name_prefix = folder if ext != ".umap" else str(package.Path).rsplit(".", 1)[0]+'.'+str(i)+'.'
-                try:
-                    save_texture(folder, value, exp_options.Platform, exp_options, export_count, name_prefix)
-                except Exception as exc:
-                    Log.Warning("failed to decode {ValueName}: {Error}", value.Name, exc)
+                with counter_lock:
+                    session_objects.append(value)
                 parsed = True
 
             elif isinstance(dummy, (USoundWave, UAkMediaAssetData)) and (ExportType.SOUND in local_export_type):
@@ -401,10 +356,8 @@ def execute(options: CliOptions) -> int:
             elif isinstance(dummy, (UAnimSequenceBase, USkeletalMesh, UStaticMesh, USkeleton)) and (
                 ExportType.ANIMATION in local_export_type or ExportType.MESH in local_export_type
             ):
-                exporter = CUE4Exporter(value, exp_options)
-                ok_write, _, file_path = exporter.TryWriteToDir(DirectoryInfo(export_directory), None, None)
-                if ok_write:
-                    write_to_log(folder, os.path.basename(str(file_path)), export_count)
+                with counter_lock:
+                    session_objects.append(value)
                 parsed = True
 
         if not parsed and (target_format == 'json' or target_format == 'auto'):
@@ -419,9 +372,8 @@ def execute(options: CliOptions) -> int:
             else:
                 print(package.Path)
     else:
-
         max_workers = os.cpu_count() or 4 if not DEBUG else 1
-        fatal_error = [None]  # shared error slot
+        fatal_error = [None] 
 
         print(f"Using parallel processing, {max_workers} threads", file=sys.stderr)
 
@@ -443,6 +395,17 @@ def execute(options: CliOptions) -> int:
 
         if fatal_error[0]:
             return 1
+            
+        if session_objects:
+            print(f"Exporting {len(session_objects)} assets via ExportSession...", file=sys.stderr)
+            session = ExportSession()
+            session.MaxDegreeOfParallelism = 1 if options.verbose else max_workers
+            for obj in session_objects:
+                session.Add(obj)
+            
+            task = session.RunAsync(export_directory, exp_options)
+            task.GetAwaiter().GetResult()
+            export_count[0] += len(session_objects)
 
     elapsed = time.monotonic() - start
 
@@ -452,8 +415,6 @@ def execute(options: CliOptions) -> int:
     Log.Information(f"Processed {len(packages)} packages in {elapsed:.2f}s")
     return 0
 
-import argparse
-
 class CustomHelpFormatter(argparse.RawTextHelpFormatter):
     def __init__(self, prog):
         super().__init__(prog, max_help_position=60, width=120)
@@ -472,7 +433,7 @@ examples = [
     ["Export a single package to stdout in json format:", "cue4parse -i MyGame -p Assets/MyAsset.uasset -f json"],
     ["Export multiple packages matching wildcard patterns to a directory:", "cue4parse -i MyGame -p */Textures* -p */Icons* -o Exports"],
     ["Export packages from list, overwrite existing files:", "cue4parse -i MyGame -c packages.txt -o Exports -y"],
-    ["Export with PSK meshes and PSA animations:", "cue4parse -i MyGame -p */SkeletalMeshes/* -o Exports --mesh-format ActorX --anim-format ActorX"],
+    ["Export with PSK meshes and PSA animations:", "cue4parse -i MyGame -p */SkeletalMeshes/* -o Exports --mesh-format ActorX"],
     ["Process a single .pak file:", "cue4parse --pak MyMod.pak -o Exports -m Mappings.usmap -g GAME_UE5_1"],
 ]
 
@@ -496,15 +457,17 @@ parser.add_argument("-l", "--list", action="store_true", dest="list_only", help=
 parser.add_argument("-y", "--yes", action="store_true", help="Overwrite existing files")
 parser.add_argument("-v", "--verbose", action="store_true", help="Enable verbose output")
 
-# more options
+# Options synced with Program.cs CUE4Parse_Conversion updates
 parser.add_argument("--pak", help="Single .pak file to process (no directory scanning)")
-parser.add_argument("--mesh-format", default="ActorX", help="Mesh format: ActorX (psk), Gltf2 (glb), UEFormat (uemodel), OBJ")
-parser.add_argument("--anim-format", default="ActorX", help="Animation format: ActorX (psa), UEFormat (ueanim)")
-parser.add_argument("--texture-format", default="Png", help="Texture format: Png, Jpeg, Tga, Dds")
-parser.add_argument("--material-format", default="AllLayersNoRef", help="Material format: FirstLayer, AllLayersNoRef, AllLayers")
-parser.add_argument("--lod-format", default="AllLods", help="LOD format: FirstLod, AllLods")
+parser.add_argument("--mesh-format", default="ActorX", help="Mesh format: ActorX (psk), Gltf2 (glb), UEFormat (uemodel), USD (usda)")
+parser.add_argument("--texture-format", default="Png", help="Texture format: Png, Jpeg, Tga, Webp")
+parser.add_argument("--material-depth", default="TopLayerOnly", help="Material depth: TopLayerOnly, AllLayersNoRef, AllLayers")
+parser.add_argument("--mesh-quality", default="Highest", help="Mesh quality: Highest, Lowest, All")
 parser.add_argument("--socket-format", default="Bone", help="Socket format: Bone, Socket, None")
-parser.add_argument("--nanite-format", default="AllLayersNaniteFirst", help="Nanite format: OnlyNaniteLOD, OnlyNormalLODs, AllLayersNaniteFirst, AllLayersNaniteLast")
+parser.add_argument("--nanite-format", default="NaniteFirst", help="Nanite format: NaniteOnly, NoNanite, NaniteFirst, NaniteLast")
+parser.add_argument("--texture-platform", default="DesktopMobile", help="Texture platform: DesktopMobile, XboxAndPlaystation4, NintendoSwitch, Playstation5")
+parser.add_argument("--texture-quality", type=int, default=100, help="Texture quality 1-100")
+parser.add_argument("--export-all-mips", action=argparse.BooleanOptionalAction, default=False, help="Export all texture mip levels")
 parser.add_argument("--export-morph-targets", action=argparse.BooleanOptionalAction, default=True, help="Export morph targets")
 parser.add_argument("--export-materials", action=argparse.BooleanOptionalAction, default=True, help="Export materials with meshes")
 parser.add_argument("--export-hdr-as-hdr", action=argparse.BooleanOptionalAction, default=True, help="Export HDR textures as .hdr")

cue4parse-0.0.6/src/cue4parse/core.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+import fnmatch
+import json
+import logging
+import os
+import sys
+import time
+from dataclasses import dataclass
+from enum import Flag, auto
+from pathlib import Path
+from typing import Any, Iterable
+
+from cue4parse import _DLL_DIR
+
+def _find_dotnet_root() -> Path | None:
+    candidates = [
+        Path.home() / ".dotnet",
+        Path("/usr/share/dotnet"),
+        Path("/usr/lib/dotnet"),
+    ]
+    for candidate in candidates:
+        if (candidate / "host" / "fxr").exists():
+            return candidate
+    return None
+
+def _find_runtime_config() -> str | None:
+    libs_dir = Path(__file__).parent / "libs"
+    configs = list(libs_dir.glob("*.runtimeconfig.json"))
+    return str(configs[0]) if configs else None
+
+dotnet_root = _find_dotnet_root()
+if dotnet_root:
+    os.environ["DOTNET_ROOT"] = str(dotnet_root)
+
+import pythonnet
+
+runtime_config = _find_runtime_config()
+if runtime_config:
+    pythonnet.load("coreclr", runtime_config=runtime_config)
+else:
+    pythonnet.load("coreclr")
+
+import clr
+
+libs_dir = _DLL_DIR
+cue4parse_dll_dir = str(libs_dir)
+sys.path.append(cue4parse_dll_dir)
+
+clr.AddReference("CUE4Parse")
+clr.AddReference("CUE4Parse-Conversion")
+
+clr.AddReference("System")
+clr.AddReference("System.Core")
+clr.AddReference("Newtonsoft.Json")
+
+# enable logger
+
+clr.AddReference("Serilog")
+clr.AddReference("Serilog.Sinks.Console")
+
+import System
+from Serilog import Log, LoggerConfiguration
+from Serilog.Configuration import LoggerSinkConfiguration
+from Serilog.Events import LogEventLevel
+
+def patch_serilog_console() -> None:
+    flags = System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Static
+    sink_type = clr.GetClrType(LoggerSinkConfiguration)
+    logger_type = clr.GetClrType(LoggerConfiguration)
+    assembly = System.Reflection.Assembly.Load("Serilog.Sinks.Console")
+
+    console_method = next(
+        method
+        for typ in assembly.GetTypes()
+        for method in typ.GetMethods(flags)
+        if method.Name == "Console"
+        and (params := method.GetParameters())
+        and params[0].ParameterType == sink_type
+    )
+
+    parent_field = next(
+        field
+        for field in sink_type.GetFields(
+            System.Reflection.BindingFlags.Public
+            | System.Reflection.BindingFlags.NonPublic
+            | System.Reflection.BindingFlags.Instance
+        )
+        if field.FieldType == logger_type
+    )
+
+    def console(self, *args, **kwargs):
+        overrides = {"standardErrorFromLevel": LogEventLevel.Verbose, **kwargs}
+        positional = (self, *args)
+        values = [
+            overrides[p.Name]
+            if p.Name in overrides
+            else positional[i]
+            if i < len(positional)
+            else System.Type.Missing
+            for i, p in enumerate(console_method.GetParameters())
+        ]
+        console_method.Invoke(None, System.Array[System.Object](values))
+        return parent_field.GetValue(self)
+
+    setattr(LoggerSinkConfiguration, "Console", console)
+
+patch_serilog_console()
+
+Log.Logger = LoggerConfiguration().MinimumLevel.Verbose().WriteTo.Console().CreateLogger()

{cue4parse-0.0.4 → cue4parse-0.0.6}/src/cue4parse/example.py

@@ -1,4 +1,5 @@
-import time
+import time, sys
+
 from cue4parse import *
 
 GAME_DIR = r"E:\Games\Subnautica2\Subnautica2\Content\Paks"
@@ -7,7 +8,7 @@ MAPPINGS_FILE = r"E:\Games\Subnautica2\Subnautica2.usmap"
 def main():
     start = time.perf_counter()
 
-    Log.Logger = with_console(LoggerConfiguration().MinimumLevel.Verbose()).CreateLogger()
+    Log.Logger = LoggerConfiguration().MinimumLevel.Verbose().WriteTo.Console().CreateLogger()
 
     version = VersionContainer(EGame.GAME_UE5_6, ETexturePlatform.DesktopMobile)
     provider = DefaultFileProvider(GAME_DIR, SearchOption.TopDirectoryOnly, version, StringComparer.OrdinalIgnoreCase)
@@ -24,15 +25,14 @@ def main():
 
     exports = package.GetExports()
 
-    name_filter = lambda name: 'Lifepod' in str(name)
+    filter = lambda name: 'Lifepod' in str(name)
 
     for export in exports:
-        name = str(export)
-        if not name_filter(name):
+        if not filter(export.ExportType):
             continue
-        print(export.ExportType)
+        print(export.ExportType, export.Name)
 
-    print(f'Finished in {time.perf_counter() - start:.4f}s')
+    print(f'Finished in {time.perf_counter() - start:.4f}s', file=sys.stderr)
 
 if __name__ == '__main__':
     raise SystemExit(main())

{cue4parse-0.0.4 → cue4parse-0.0.6}/src/cue4parse/includes.py

@@ -6,13 +6,14 @@ from System.Text import Encoding
 from Newtonsoft.Json import JsonSerializer, Formatting, JsonTextWriter, JsonConvert
 
 from System import Guid, StringComparer
-from System.IO import SearchOption, DirectoryInfo
+from System.IO import SearchOption
 from CUE4Parse.Compression import OodleHelper, ZlibHelper
 from CUE4Parse.Encryption.Aes import FAesKey
 from CUE4Parse.FileProvider import DefaultFileProvider, ApkFileProvider
-from CUE4Parse.MappingsProvider import FileUsmapTypeMappingsProvider
+from CUE4Parse.MappingsProvider.Usmap import FileUsmapTypeMappingsProvider
 from CUE4Parse.UE4.Assets import AbstractUePackage
 from CUE4Parse.UE4.Assets.Exports.Animation import UAnimSequenceBase, USkeleton
+from CUE4Parse.UE4.Assets.Exports.Material import EMaterialDepth
 from CUE4Parse.UE4.Assets.Exports.SkeletalMesh import USkeletalMesh
 from CUE4Parse.UE4.Assets.Exports.Sound import USoundWave
 from CUE4Parse.UE4.Assets.Exports.StaticMesh import UStaticMesh
@@ -24,11 +25,9 @@ from CUE4Parse.UE4.Objects.UObject import FPackageIndex
 from CUE4Parse.UE4.Versions import VersionContainer, EGame, ELanguage
 from CUE4Parse.UE4.Assets.Exports.Texture import ETexturePlatform
 
-from CUE4Parse_Conversion import Exporter as CUE4Exporter, ExporterOptions
-from CUE4Parse_Conversion.Animations import EAnimFormat
-from CUE4Parse_Conversion.Meshes import EMeshFormat, ELodFormat, ESocketFormat
-from CUE4Parse_Conversion.Textures import ETextureFormat, TextureDecoder, TextureEncoder, CubemapConverter, CTexture
-from CUE4Parse_Conversion.Textures.BC import DetexHelper
-from CUE4Parse_Conversion.UEFormat.Enums import EFileCompressionFormat
-from CUE4Parse.UE4.Assets.Exports.Material import EMaterialFormat
+from CUE4Parse_Conversion import ExportSession
+from CUE4Parse_Conversion.Options import ExportOptions
+from CUE4Parse_Conversion.Options import EMeshFormat, EMeshQuality, ESocketFormat, ENaniteMeshFormat
+from CUE4Parse_Conversion.Options import ETextureFormat
+from CUE4Parse_Conversion.Writers.UEFormat.Enums import EFileCompressionFormat
 

cue4parse-0.0.4/README.md

@@ -1,12 +0,0 @@
-# CUE4Parse-Python
-
-CUE4Parse Python wrapper, CLI tool, and scripting engine
-
-## Usage
-
-`pip install cue4parse`
-
-* Make sure executable is added to paths, e.g. `%LOCALAPPDATA%\Python\pythoncore-3.14-64\Scripts`.
-* Needs CUE4Parse libraries in `%LOCALAPPDATA%/cue4parse/libs` (downloads and unpacks FModel on Windows).
-* To run CLI: `cue4parse`
-

cue4parse-0.0.4/src/cue4parse/core.py

@@ -1,90 +0,0 @@
-from __future__ import annotations
-
-import fnmatch
-import json
-import logging
-import os
-import sys
-import time
-from dataclasses import dataclass
-from enum import Flag, auto
-from pathlib import Path
-from typing import Any, Iterable
-
-from cue4parse import _DLL_DIR
-
-def _find_dotnet_root() -> Path | None:
-    candidates = [
-        Path.home() / ".dotnet",
-        Path("/usr/share/dotnet"),
-        Path("/usr/lib/dotnet"),
-    ]
-    for candidate in candidates:
-        if (candidate / "host" / "fxr").exists():
-            return candidate
-    return None
-
-def _find_runtime_config() -> str | None:
-    libs_dir = Path(__file__).parent / "libs"
-    configs = list(libs_dir.glob("*.runtimeconfig.json"))
-    return str(configs[0]) if configs else None
-
-dotnet_root = _find_dotnet_root()
-if dotnet_root:
-    os.environ["DOTNET_ROOT"] = str(dotnet_root)
-
-import pythonnet
-
-runtime_config = _find_runtime_config()
-if runtime_config:
-    pythonnet.load("coreclr", runtime_config=runtime_config)
-else:
-    pythonnet.load("coreclr")
-
-import clr
-
-libs_dir = _DLL_DIR
-cue4parse_dll_dir = str(libs_dir)
-sys.path.append(cue4parse_dll_dir)
-
-clr.AddReference("CUE4Parse")
-clr.AddReference("CUE4Parse-Conversion")
-
-clr.AddReference("System")
-clr.AddReference("System.Core")
-clr.AddReference("Newtonsoft.Json")
-
-clr.AddReference("Serilog")
-clr.AddReference("Serilog.Sinks.Console")
-
-import System
-from Serilog import Log, LoggerConfiguration
-from Serilog.Events import LogEventLevel
-from Serilog.Configuration import LoggerSinkConfiguration
-
-def with_console(cfg: LoggerConfiguration) -> LoggerConfiguration:
-    asm = System.Reflection.Assembly.Load("Serilog.Sinks.Console")
-    bf = System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Static
-    lsc_t = clr.GetClrType(LoggerSinkConfiguration)
-    for t in asm.GetTypes():
-        if not (t.IsSealed and t.IsAbstract):
-            continue
-        for m in t.GetMethods(bf):
-            if m.Name != "Console":
-                continue
-            ps = m.GetParameters()
-            if len(ps) >= 1 and ps[0].ParameterType == lsc_t:
-                args = [System.Type.Missing] * len(ps)
-                args[0] = cfg.WriteTo
-                # Find and set the standardErrorFromLevel parameter so it's stderr, not stdout
-                for i, p in enumerate(ps):
-                    if p.Name == "standardErrorFromLevel":
-                        lel_t = System.Type.GetType("Serilog.Events.LogEventLevel, Serilog")
-                        args[i] = System.Enum.Parse(lel_t, "Verbose")
-                        break
-                m.Invoke(None, System.Array[System.Object](args))
-                return cfg
-    raise RuntimeError("Serilog console sink extension method not found")
-
-# you can re-define it in user code later with Verbose() or any other level
-Log.Logger = with_console(LoggerConfiguration().MinimumLevel.Fatal()).CreateLogger()