test library update

Update README.md

.github/workflows/pythonpackage.yml

@@ -9,7 +9,7 @@ jobs:
     strategy:
       max-parallel: 4
       matrix:
-        python-version: [3.6, 3.7]
+        python-version: [3.6, 3.7, 3.8]
 
     steps:
     - uses: actions/checkout@v1

CHANGELOG.md

@@ -4,6 +4,197 @@ All notable changes to this project will be documented in this file. Dates are d
 
 Generated by [`auto-changelog`](https://github.com/CookPete/auto-changelog).
 
+#### [v0.28.1](https://github.com/RhetTbull/osxphotos/compare/v0.27.4...v0.28.1)
+
+> 18 April 2020
+
+- Initial work on suppport for associated RAW images [`7e42ebb`](https://github.com/RhetTbull/osxphotos/commit/7e42ebb2402d45cd5d20bdd55bddddaa9db4679f)
+- Initial support for RAW photos in Photos 4 to address issue #101 [`9d15147`](https://github.com/RhetTbull/osxphotos/commit/9d151478d610291b8d482aafae3d445dfd391fca)
+- replaced CLI option --original-name with --current-name [`36c2821`](https://github.com/RhetTbull/osxphotos/commit/36c2821a0fa62eaaa54cf1edc2d9c6da98155354)
+
+#### [v0.27.4](https://github.com/RhetTbull/osxphotos/compare/v0.27.3...v0.27.4)
+
+> 12 April 2020
+
+- Added {folder_album} to template and --folder to CLI [`b7c7b9f`](https://github.com/RhetTbull/osxphotos/commit/b7c7b9f0664e69c743bdd8a228ad2936cf6b7600)
+- Test library update [`21e7020`](https://github.com/RhetTbull/osxphotos/commit/21e7020fec406b0f3926d7adc8a1451bfe77e75a)
+- Updated CHANGELOG.md [`952741d`](https://github.com/RhetTbull/osxphotos/commit/952741d488d2fbbaf8a0c1d3781ad7c4205c068f)
+
+#### [v0.27.3](https://github.com/RhetTbull/osxphotos/compare/v0.27.1...v0.27.3)
+
+> 12 April 2020
+
+- Added additional tests for album_info [`97362fc`](https://github.com/RhetTbull/osxphotos/commit/97362fc0f13b2867abc013f4ba97ae60b0700894)
+- Fixed bug with handling of deleted albums [`9fef12e`](https://github.com/RhetTbull/osxphotos/commit/9fef12ed37634a7bdb11232976b4b2ddccd1a7cb)
+
+#### [v0.27.1](https://github.com/RhetTbull/osxphotos/compare/v0.27.0...v0.27.1)
+
+> 12 April 2020
+
+- Changed AlbumInfo and FolderInfo interface to maintain backwards compatibility with PhotosDB.albums [`e09f0b4`](https://github.com/RhetTbull/osxphotos/commit/e09f0b40f1671d70ee399cdc519492b04fac8adc)
+- Updated CHANGELOG.md [`b749681`](https://github.com/RhetTbull/osxphotos/commit/b749681c6d2545eacf653ab1b2a5d1384e3123eb)
+
+#### [v0.27.0](https://github.com/RhetTbull/osxphotos/compare/v0.26.1...v0.27.0)
+
+> 11 April 2020
+
+- Update README.md [`#95`](https://github.com/RhetTbull/osxphotos/pull/95)
+- Added tests and README for AlbumInfo and FolderInfo [`d6a22b7`](https://github.com/RhetTbull/osxphotos/commit/d6a22b765ab17f6ef1ba8c50b77946f090979968)
+- Added albuminfo.py for AlbumInfo and FolderInfo classes [`9636572`](https://github.com/RhetTbull/osxphotos/commit/96365728c2ff42abfb6828872ffac53b4c3c8024)
+- Updated CHANGELOG.md [`cde56e9`](https://github.com/RhetTbull/osxphotos/commit/cde56e9d13baf3098ec85839cf1aaa33b4915ac9)
+- Update README.md TOC [`8544667`](https://github.com/RhetTbull/osxphotos/commit/8544667c729ea0d7fe39671d909e09cda519e250)
+
+#### [v0.26.1](https://github.com/RhetTbull/osxphotos/compare/v0.26.0...v0.26.1)
+
+> 11 April 2020
+
+- Bug fix for PhotosDB.photos() query [`1c9da5e`](https://github.com/RhetTbull/osxphotos/commit/1c9da5ed6ffa21f0577906b65b7da08951725d1f)
+- Updated test library [`d74f7f4`](https://github.com/RhetTbull/osxphotos/commit/d74f7f499bf59f37ec81cfa9d49cbbf3aafb5961)
+- Updated CHANGELOG.md [`c85bb02`](https://github.com/RhetTbull/osxphotos/commit/c85bb023042e072d6688060eb259156c2fa579b9)
+
+#### [v0.26.0](https://github.com/RhetTbull/osxphotos/compare/v0.25.1...v0.26.0)
+
+> 11 April 2020
+
+- Added test for 10.15.4 [`1820715`](https://github.com/RhetTbull/osxphotos/commit/182071584904d001a9b199eef5febfb79e00696e)
+- Changed PhotosDB albums interface as prep for adding folders [`3e50626`](https://github.com/RhetTbull/osxphotos/commit/3e5062684ab6d706d91d4abeb4e3b0ca47867b70)
+- Updated CHANGELOG.md [`a6ca3f4`](https://github.com/RhetTbull/osxphotos/commit/a6ca3f453ce0fae4e8d13c7c256ed69a16d2e3f2)
+
+#### [v0.25.1](https://github.com/RhetTbull/osxphotos/compare/v0.25.0...v0.25.1)
+
+> 5 April 2020
+
+- Added --no-extended-attributes option to CLI, closes #85 [`#85`](https://github.com/RhetTbull/osxphotos/issues/85)
+- Fixed CLI help for invalid topic, closes #76 [`#76`](https://github.com/RhetTbull/osxphotos/issues/76)
+- Updated test library [`bae0283`](https://github.com/RhetTbull/osxphotos/commit/bae0283441f04d71aa78dbd1cf014f376ef1f91a)
+
+#### [v0.25.0](https://github.com/RhetTbull/osxphotos/compare/v0.24.2...v0.25.0)
+
+> 4 April 2020
+
+- Added places, --place, --no-place to CLI, closes #87, #88 [`#87`](https://github.com/RhetTbull/osxphotos/issues/87)
+- Updated render_filepath_template to support multiple values [`6a89888`](https://github.com/RhetTbull/osxphotos/commit/6a898886ddadc9d5bc9dbad6ee7365270dd0a26d)
+- Added {album}, {keyword}, and {person} to template system [`507c4a3`](https://github.com/RhetTbull/osxphotos/commit/507c4a374014f999ca19789bce0df0c14332e021)
+- Added places command to CLI [`fd5e748`](https://github.com/RhetTbull/osxphotos/commit/fd5e748dca759ea1c3a7329d447f363afe8418b7)
+- Updated export example [`01cd7fe`](https://github.com/RhetTbull/osxphotos/commit/01cd7fed6d7fc0c61c171a05319c211eb0a9f7c1)
+- Updated CHANGELOG.md [`daea30f`](https://github.com/RhetTbull/osxphotos/commit/daea30f1626a208209ab6854cbd3b12f4b0a3405)
+
+#### [v0.24.2](https://github.com/RhetTbull/osxphotos/compare/v0.24.1...v0.24.2)
+
+> 28 March 2020
+
+- added {place.country_code} to template system [`be2e167`](https://github.com/RhetTbull/osxphotos/commit/be2e16769d5d2c75af6d7792f1311f5a65c3bc67)
+
+#### [v0.24.1](https://github.com/RhetTbull/osxphotos/compare/v0.23.4...v0.24.1)
+
+> 28 March 2020
+
+- Added detailed place data in PlaceInfo.names [`c06dd42`](https://github.com/RhetTbull/osxphotos/commit/c06dd4233f917f068c087f5604013d371b0a826a)
+- Template system now supports default values [`67a9a9e`](https://github.com/RhetTbull/osxphotos/commit/67a9a9e21bd05d01a3202b0a1279487f5d04c9d9)
+- Replaced template renderer with regex-based renderer [`427c4c0`](https://github.com/RhetTbull/osxphotos/commit/427c4c0bc49f671477866d30eee74834c67d7bc5)
+
+#### [v0.23.4](https://github.com/RhetTbull/osxphotos/compare/v0.23.3...v0.23.4)
+
+> 22 March 2020
+
+- Added export_by_album.py to examples [`908fead`](https://github.com/RhetTbull/osxphotos/commit/908fead8a2fbcef3b4a387f34d83d88c507c5939)
+- Updated CHANGELOG.md [`072e894`](https://github.com/RhetTbull/osxphotos/commit/072e894e56c4dfe5522d073b202933fed0204ef5)
+- Updated pathvalidate calls [`d066435`](https://github.com/RhetTbull/osxphotos/commit/d066435e3df4062be6a0a3d5fa7308f293e764d5)
+
+#### [v0.23.3](https://github.com/RhetTbull/osxphotos/compare/v0.23.1...v0.23.3)
+
+> 22 March 2020
+
+- Initial version of templating system for CLI [`2feb099`](https://github.com/RhetTbull/osxphotos/commit/2feb0999b3f9ffd9a24e37238f780239a027aa49)
+- Added __str__ to place [`ad58b03`](https://github.com/RhetTbull/osxphotos/commit/ad58b03f2d31daf33849b141570dd0fb5e0a262e)
+- Test library updates [`e90d9c6`](https://github.com/RhetTbull/osxphotos/commit/e90d9c6e11fce7a4e4aa348dcc5f57420c0b6c44)
+
+#### [v0.23.1](https://github.com/RhetTbull/osxphotos/compare/v0.23.0...v0.23.1)
+
+> 21 March 2020
+
+- Fixed requirements.txt for bplist2 [`cda5f44`](https://github.com/RhetTbull/osxphotos/commit/cda5f446933ea2272409d1f153e2a7811626ada6)
+- Updated CHANGELOG.md [`b8da976`](https://github.com/RhetTbull/osxphotos/commit/b8da9765b8949eb90852d249c2877eeb1806d987)
+- Updated requirements.txt [`9da7ad6`](https://github.com/RhetTbull/osxphotos/commit/9da7ad6dcc021fdafe358d74e1c52f69dc49ade8)
+
+#### [v0.23.0](https://github.com/RhetTbull/osxphotos/compare/v0.22.23...v0.23.0)
+
+> 21 March 2020
+
+- Added PhotoInfo.place for reverse geolocation data [`b338b34`](https://github.com/RhetTbull/osxphotos/commit/b338b34d5055a7621e4ebe4fbbae12227d77af6d)
+- Updated CHANGELOG.md [`816b98e`](https://github.com/RhetTbull/osxphotos/commit/816b98e617c30d0bdb51bc2413f9915742c8592e)
+- Update pythonpackage.yml [`92e5bdd`](https://github.com/RhetTbull/osxphotos/commit/92e5bdd2e986e5de2a710abf60ba0dc99c6a6730)
+
+#### [v0.22.23](https://github.com/RhetTbull/osxphotos/compare/v0.22.21...v0.22.23)
+
+> 15 March 2020
+
+- Lots of work on export code [`0940f03`](https://github.com/RhetTbull/osxphotos/commit/0940f039d3e628dc4f25c69bf27ce413807d3f71)
+- test library update [`1e08a74`](https://github.com/RhetTbull/osxphotos/commit/1e08a7449e69965a37373dadabb37c993d93fc69)
+
+#### [v0.22.21](https://github.com/RhetTbull/osxphotos/compare/v0.22.17...v0.22.21)
+
+> 15 March 2020
+
+- Working on export edited bug for issue #78 [`8542e1a`](https://github.com/RhetTbull/osxphotos/commit/8542e1a97f6b640f287b37af9e50fd05f964ec4d)
+- Fixed download-missing to only download when actually missing [`dd20b8d`](https://github.com/RhetTbull/osxphotos/commit/dd20b8d8ac3b16d3b72a26b97dcc620b11e3a7c0)
+- Updated CHANGELOG.md [`cc9220e`](https://github.com/RhetTbull/osxphotos/commit/cc9220e0763816d784f2fd8377dfe14a99981622)
+
+#### [v0.22.17](https://github.com/RhetTbull/osxphotos/compare/v0.22.16...v0.22.17)
+
+> 14 March 2020
+
+- Added MANIFEST.in [`279ab36`](https://github.com/RhetTbull/osxphotos/commit/279ab369295cfe1c778b38e212248271e4fc659e)
+- version bump [`783e097`](https://github.com/RhetTbull/osxphotos/commit/783e097da35a210a2aa5c75865a8599541b9da0b)
+
+#### [v0.22.16](https://github.com/RhetTbull/osxphotos/compare/v0.22.13...v0.22.16)
+
+> 14 March 2020
+
+- removed activate from --download-missing-photos Applescript, closes #69 [`#69`](https://github.com/RhetTbull/osxphotos/issues/69)
+- Added media type specials to json and string output, closes #68 [`#68`](https://github.com/RhetTbull/osxphotos/issues/68)
+- Added query/export options for special media types [`2b7d84a`](https://github.com/RhetTbull/osxphotos/commit/2b7d84a4d103982ad874d875bafbc34d654d539a)
+- README.md update [`a27ce33`](https://github.com/RhetTbull/osxphotos/commit/a27ce33473df3260dfb7ed26e28295cbf87d1e78)
+- Test library updates [`2d7d0b8`](https://github.com/RhetTbull/osxphotos/commit/2d7d0b86e0008cae043e314937504f36ad882990)
+- Fixed bug in --download-missing related to burst images [`1f13ba8`](https://github.com/RhetTbull/osxphotos/commit/1f13ba837fe36ff4eeb48cca02f5312a88a0a765)
+- test library update [`acb6b9e`](https://github.com/RhetTbull/osxphotos/commit/acb6b9e72f7f6b8f4f1d64b46f270a4d3e984fef)
+
+#### [v0.22.13](https://github.com/RhetTbull/osxphotos/compare/v0.22.12...v0.22.13)
+
+> 8 March 2020
+
+- Added media type specials, closes #60 [`#60`](https://github.com/RhetTbull/osxphotos/issues/60)
+- Updated CHANGELOG.md [`08a9793`](https://github.com/RhetTbull/osxphotos/commit/08a9793651481e1984a4482794ffedd48e4367a2)
+- Updated README.md [`1f8fd6e`](https://github.com/RhetTbull/osxphotos/commit/1f8fd6e929cc0edd3dd2f222416454d26955bf2a)
+
+#### [v0.22.12](https://github.com/RhetTbull/osxphotos/compare/0.22.10...v0.22.12)
+
+> 7 March 2020
+
+- Added exiftool [`8dea419`](https://github.com/RhetTbull/osxphotos/commit/8dea41961bad285be7058a68e5f7199e5cfb740e)
+- Added --exiftool to CLI export [`ef79961`](https://github.com/RhetTbull/osxphotos/commit/ef799610aea67b703a7d056b7eee227534ba78a5)
+- Updated test library [`9a0fc0d`](https://github.com/RhetTbull/osxphotos/commit/9a0fc0db3e79359610fd0f124a97b03fcf97d8a7)
+
+#### [0.22.10](https://github.com/RhetTbull/osxphotos/compare/v0.22.9...0.22.10)
+
+> 8 February 2020
+
+- Fixed bug in --download-missing to fix issue #64 [`c654e3d`](https://github.com/RhetTbull/osxphotos/commit/c654e3dc61283382b37b6892dab1516ec517143a)
+- removed commented out code [`69addc3`](https://github.com/RhetTbull/osxphotos/commit/69addc34649f992c6a4a0e0e334754a72530f0ba)
+- Updated CHANGELOG.md [`1e013b6`](https://github.com/RhetTbull/osxphotos/commit/1e013b6802e49e26ec5a94eb702e841b2eb68395)
+
+#### [v0.22.9](https://github.com/RhetTbull/osxphotos/compare/v0.22.7...v0.22.9)
+
+> 1 February 2020
+
+- Updated PhotosDB to only copy database if locked, speed improvement for cases where DB not locked; closes #34 [`#34`](https://github.com/RhetTbull/osxphotos/issues/34)
+- Changed temp file handling to use tempfile.TemporaryDirectory, closes #59 [`#59`](https://github.com/RhetTbull/osxphotos/issues/59)
+- Slight refactor to PhotosDB.photos() [`91d5729`](https://github.com/RhetTbull/osxphotos/commit/91d5729beaa0f0c2583e6320b18d958429e66075)
+- Test library updates [`6e563e2`](https://github.com/RhetTbull/osxphotos/commit/6e563e214c569ba7838f7464de9258c3bba5db23)
+- Removed _tmp_file code that's no longer needed [`27994c9`](https://github.com/RhetTbull/osxphotos/commit/27994c9fd372303833a5794f1de9815f425c762e)
+- Updated photos_repl.py [`fdf636a`](https://github.com/RhetTbull/osxphotos/commit/fdf636ac8864ebb2cc324b1f9d3c6c82ee3910f9)
+- Updated CHANGELOG.md [`f910124`](https://github.com/RhetTbull/osxphotos/commit/f910124fe1fbf75d44c09c79607374bf000733a1)
+
 #### [v0.22.7](https://github.com/RhetTbull/osxphotos/compare/v0.22.4...v0.22.7)
 
 > 27 January 2020

MANIFEST.in

@@ -0,0 +1,2 @@
+include README.md
+include osxphotos/templates/*

README.md

@@ -3,32 +3,39 @@
 [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/python/black)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
+
 - [OSXPhotos](#osxphotos)
   * [What is osxphotos?](#what-is-osxphotos)
   * [Supported operating systems](#supported-operating-systems)
   * [Installation instructions](#installation-instructions)
   * [Command Line Usage](#command-line-usage)
-  * [Example uses of the module](#example-uses-of-the-module)
-  * [Module Interface](#module-interface)
+  * [Example uses of the package](#example-uses-of-the-package)
+  * [Package Interface](#package-interface)
     + [PhotosDB](#photosdb)
     + [PhotoInfo](#photoinfo)
+    + [AlbumInfo](#albuminfo)
+    + [FolderInfo](#folderinfo)
+    + [PlaceInfo](#placeinfo)
+    + [Template Functions](#template-functions)
     + [Utility Functions](#utility-functions)
-    + [Examples](#examples)
+  * [Examples](#examples)
   * [Related Projects](#related-projects)
   * [Contributing](#contributing)
+  * [Known Bugs](#known-bugs)
   * [Implementation Notes](#implementation-notes)
   * [Dependencies](#dependencies)
-  * [Acknowledgements](#acknowledgements) 
+  * [Acknowledgements](#acknowledgements)
+
   
 ## What is osxphotos?
 
-OSXPhotos provides the ability to interact with and query Apple's Photos.app library database on MacOS. Using this module you can query the Photos database for information about the photos stored in a Photos library on your Mac--for example, file name, file path, and metadata such as keywords/tags, persons/faces, albums, etc. You can also easily export both the original and edited photos.
+OSXPhotos provides the ability to interact with and query Apple's Photos.app library database on MacOS. Using this package you can query the Photos database for information about the photos stored in a Photos library on your Mac--for example, file name, file path, and metadata such as keywords/tags, persons/faces, albums, etc. You can also easily export both the original and edited photos.
 
 ## Supported operating systems
 
 Only works on MacOS (aka Mac OS X). Tested on MacOS 10.12.6 / Photos 2.0, 10.13.6 / Photos 3.0, MacOS 10.14.5, 10.14.6 / Photos 4.0, MacOS 10.15.1 / Photos 5.0. Requires python >= 3.6
 
-This module will read Photos databases for any supported version on any supported OS version.  E.g. you can read a database created with Photos 4.0 on MacOS 10.14 on a machine running MacOS 10.12
+This package will read Photos databases for any supported version on any supported OS version.  E.g. you can read a database created with Photos 4.0 on MacOS 10.14 on a machine running MacOS 10.12
 
 
 ## Installation instructions
@@ -39,7 +46,7 @@ osxmetadata uses setuptools, thus simply run:
 
 ## Command Line Usage
 
-This module will install a command line utility called `osxphotos` that allows you to query the Photos database.  Alternatively, you can also run the command line utility like this: `python3 -m osxphotos`
+This package will install a command line utility called `osxphotos` that allows you to query the Photos database.  Alternatively, you can also run the command line utility like this: `python3 -m osxphotos`
 
 If you only care about the command line tool, I recommend installing with [pipx](https://github.com/pipxproject/pipx)
 
@@ -53,7 +60,14 @@ Then you should be able to run `osxphotos` on the command line:
 Usage: osxphotos [OPTIONS] COMMAND [ARGS]...
 
 Options:
-  --db <Photos database path>  Specify database file.
+  --db <Photos database path>  Specify Photos database path. Path to Photos
+                               library/database can be specified using either
+                               --db or directly as PHOTOS_LIBRARY positional
+                               argument. If neither --db or PHOTOS_LIBRARY
+                               provided, will attempt to find the library to
+                               use in the following order: 1. last opened
+                               library, 2. system library, 3.
+                               ~/Pictures/Photos Library.photoslibrary
   --json                       Print output in JSON format.
   -v, --version                Show the version and exit.
   -h, --help                   Show this message and exit.
@@ -67,6 +81,7 @@ Commands:
   keywords  Print out keywords found in the Photos library.
   list      Print list of Photos libraries found on the system.
   persons   Print out persons (faces) found in the Photos library.
+  places    Print out places found in the Photos library.
   query     Query the Photos database using 1 or more search options; if...
 ```
 
@@ -81,7 +96,10 @@ Usage: osxphotos export [OPTIONS] [PHOTOS_LIBRARY]... DEST
   Optionally, query the Photos database using 1 or more search options;  if
   more than one option is provided, they are treated as "AND"  (e.g. search
   for photos matching all options). If no query options are provided, all
-  photos will be exported.
+  photos will be exported. By default, all versions of all photos will be
+  exported including edited versions, live photo movies, burst photos, and
+  associated RAW images.  See --skip-edited, --skip-live, --skip-bursts, and
+  --skip-raw options to modify this behavior.
 
 Options:
   --db <Photos database path>     Specify Photos database path. Path to Photos
@@ -93,19 +111,35 @@ Options:
                                   order: 1. last opened library, 2. system
                                   library, 3. ~/Pictures/Photos
                                   Library.photoslibrary
-  --keyword KEYWORD               Search for keyword(s).
-  --person PERSON                 Search for person(s).
-  --album ALBUM                   Search for album(s).
-  --uuid UUID                     Search for UUID(s).
+  -V, --verbose                   Print verbose output.
+  --keyword KEYWORD               Search for photos with keyword KEYWORD. If
+                                  more than one keyword, treated as "OR", e.g.
+                                  find photos match any keyword
+  --person PERSON                 Search for photos with person PERSON. If
+                                  more than one person, treated as "OR", e.g.
+                                  find photos match any person
+  --album ALBUM                   Search for photos in album ALBUM. If more
+                                  than one album, treated as "OR", e.g. find
+                                  photos match any album
+  --folder FOLDER                 Search for photos in an album in folder
+                                  FOLDER. If more than one folder, treated as
+                                  "OR", e.g. find photos in any FOLDER.  Only
+                                  searches top level folders (e.g. does not
+                                  look at subfolders)
+  --uuid UUID                     Search for photos with UUID(s).
   --title TITLE                   Search for TITLE in title of photo.
   --no-title                      Search for photos with no title.
   --description DESC              Search for DESC in description of photo.
   --no-description                Search for photos with no description.
+  --place PLACE                   Search for PLACE in photo's reverse
+                                  geolocation info
+  --no-place                      Search for photos with no associated place
+                                  name info (no reverse geolocation info)
   --uti UTI                       Search for photos whose uniform type
                                   identifier (UTI) matches UTI
-  -i, --ignore-case               Case insensitive search for title or
-                                  description. Does not apply to keyword,
-                                  person, or album.
+  -i, --ignore-case               Case insensitive search for title,
+                                  description, or place. Does not apply to
+                                  keyword, person, or album.
   --edited                        Search for photos that have been edited.
   --external-edit                 Search for photos edited in external editor.
   --favorite                      Search for photos marked favorite.
@@ -122,7 +156,28 @@ Options:
                                   burst.
   --live                          Search for Apple live photos
   --not-live                      Search for photos that are not Apple live
-                                  photos
+                                  photos.
+  --portrait                      Search for Apple portrait mode photos.
+  --not-portrait                  Search for photos that are not Apple
+                                  portrait mode photos.
+  --screenshot                    Search for screenshot photos.
+  --not-screenshot                Search for photos that are not screenshot
+                                  photos.
+  --slow-mo                       Search for slow motion videos.
+  --not-slow-mo                   Search for photos that are not slow motion
+                                  videos.
+  --time-lapse                    Search for time lapse videos.
+  --not-time-lapse                Search for photos that are not time lapse
+                                  videos.
+  --hdr                           Search for high dynamic range (HDR) photos.
+  --not-hdr                       Search for photos that are not HDR photos.
+  --selfie                        Search for selfies (photos taken with front-
+                                  facing cameras).
+  --not-selfie                    Search for photos that are not selfies.
+  --panorama                      Search for panorama photos.
+  --not-panorama                  Search for photos that are not panoramas.
+  --has-raw                       Search for photos with both a jpeg and RAW
+                                  version
   --only-movies                   Search only for movies (default searches
                                   both images and movies).
   --only-photos                   Search only for photos/images (default
@@ -135,7 +190,6 @@ Options:
                                   Search by end item date, e.g.
                                   2000-01-12T12:00:00 or 2000-12-31 (ISO 8601
                                   w/o TZ).
-  -V, --verbose                   Print verbose output.
   --overwrite                     Overwrite existing files. Default behavior
                                   is to add (1), (2), etc to filename if file
                                   already exists. Use this with caution as it
@@ -144,17 +198,23 @@ Options:
   --export-by-date                Automatically create output folders to
                                   organize photos by date created (e.g.
                                   DEST/2019/12/20/photoname.jpg).
-  --export-edited                 Also export edited version of photo if an
-                                  edited version exists.  Edited photo will be
-                                  named in form of "photoname_edited.ext"
-  --export-bursts                 If a photo is a burst photo export all
-                                  associated burst images in the library.
-  --export-live                   If a photo is a live photo export the
-                                  associated live video component.  Live video
-                                  will have same name as photo but with .mov
-                                  extension.
-  --original-name                 Use photo's original filename instead of
-                                  current filename for export.
+  --skip-edited                   Do not export edited version of photo if an
+                                  edited version exists.
+  --skip-bursts                   Do not export all associated burst images in
+                                  the library if a photo is a burst photo.
+  --skip-live                     Do not export the associated live video
+                                  component of a live photo.
+  --skip-raw                      Do not export associated RAW images of a
+                                  RAW/jpeg pair.  Note: this does not skip RAW
+                                  photos if the RAW photo does not have an
+                                  associated jpeg image (e.g. the RAW file was
+                                  imported to Photos without a jpeg preview).
+  --current-name                  Use photo's current filename instead of
+                                  original filename for export.  Note:
+                                  Starting with Photos 5, all photos are
+                                  renamed upon import.  By default, photos are
+                                  exported with the the original name they had
+                                  before import.
   --sidecar FORMAT                Create sidecar for each photo exported;
                                   valid FORMAT values: xmp, json; --sidecar
                                   json: create JSON sidecar useable by
@@ -164,7 +224,7 @@ Options:
                                   -j=photoname.json photoname.jpg" The sidecar
                                   file is named in format photoname.json
                                   --sidecar xmp: create XMP sidecar used by
-                                  Adobe Lightroom, etc. The sidecar file is
+                                  Adobe Lightroom, etc.The sidecar file is
                                   named in format photoname.xmp
   --download-missing              Attempt to download missing photos from
                                   iCloud. The current implementation uses
@@ -174,23 +234,156 @@ Options:
                                   exist on disk.  This will be slow and will
                                   require internet connection. This obviously
                                   only works if the Photos library is synched
-                                  to iCloud.
+                                  to iCloud.  Note: --download-missing does
+                                  not currently export all burst images; only
+                                  the primary photo will be exported--
+                                  associated burst images will be skipped.
+  --exiftool                      Use exiftool to write metadata directly to
+                                  exported photos. To use this option,
+                                  exiftool must be installed and in the path.
+                                  exiftool may be installed from
+                                  https://exiftool.org/
+  --directory DIRECTORY           Optional template for specifying name of
+                                  output directory in the form
+                                  '{name,DEFAULT}'. See below for additional
+                                  details on templating system.
+  --no-extended-attributes        Don't copy extended attributes when
+                                  exporting.  You only need this if exporting
+                                  to a filesystem that doesn't support Mac OS
+                                  extended attributes.  Only use this if you
+                                  get an error while exporting.
   -h, --help                      Show this message and exit.
+
+**Templating System**
+
+With the --directory option, you may specify a template for the export
+directory.  This directory will be appended to the export path specified in
+the export DEST argument to export.  For example, if template is
+'{created.year}/{created.month}', and export desitnation DEST is
+'/Users/maria/Pictures/export', the actual export directory for a photo would
+be '/Users/maria/Pictures/export/2020/March' if the photo was created in March
+2020.
+
+In the template, valid template substitutions will be replaced by the
+corresponding value from the table below.  Invalid substitutions will result
+in a an error and the script will abort.
+
+If you want the actual text of the template substition to appear in the
+rendered name, use double braces, e.g. '{{' or '}}', thus using
+'{created.year}/{{name}}' for --directory would result in output of
+2020/{name}/photoname.jpg
+
+You may specify an optional default value to use if the substitution does not
+contain a value (e.g. the value is null) by specifying the default value after
+a ',' in the template string: for example, if template is
+'{created.year}/{place.address,'NO_ADDRESS'}' but there was no address
+associated with the photo, the resulting output would be:
+'2020/NO_ADDRESS/photoname.jpg'. If specified, the default value may not
+contain a brace symbol ('{' or '}').
+
+If you do not specify a default value and the template substitution has no
+value, '_' (underscore) will be used as the default value. For example, in the
+above example, this would result in '2020/_/photoname.jpg' if address was null
+I plan to eventually extend the templating system to the exported filename so
+you can specify the filename using a template.
+
+Substitution                    Description
+{name}                          Filename of the photo
+{original_name}                 Photo's original filename when imported to
+                                Photos
+{title}                         Title of the photo
+{descr}                         Description of the photo
+{created.date}                  Photo's creation date in ISO format, e.g.
+                                '2020-03-22'
+{created.year}                  4-digit year of file creation time
+{created.yy}                    2-digit year of file creation time
+{created.mm}                    2-digit month of the file creation time
+                                (zero padded)
+{created.month}                 Month name in user's locale of the file
+                                creation time
+{created.mon}                   Month abbreviation in the user's locale of
+                                the file creation time
+{created.doy}                   3-digit day of year (e.g Julian day) of file
+                                creation time, starting from 1 (zero padded)
+{modified.date}                 Photo's modification date in ISO format,
+                                e.g. '2020-03-22'
+{modified.year}                 4-digit year of file modification time
+{modified.yy}                   2-digit year of file modification time
+{modified.mm}                   2-digit month of the file modification time
+                                (zero padded)
+{modified.month}                Month name in user's locale of the file
+                                modification time
+{modified.mon}                  Month abbreviation in the user's locale of
+                                the file modification time
+{modified.doy}                  3-digit day of year (e.g Julian day) of file
+                                modification time, starting from 1 (zero
+                                padded)
+{place.name}                    Place name from the photo's reverse
+                                geolocation data, as displayed in Photos
+{place.country_code}            The ISO country code from the photo's
+                                reverse geolocation data
+{place.name.country}            Country name from the photo's reverse
+                                geolocation data
+{place.name.state_province}     State or province name from the photo's
+                                reverse geolocation data
+{place.name.city}               City or locality name from the photo's
+                                reverse geolocation data
+{place.name.area_of_interest}   Area of interest name (e.g. landmark or
+                                public place) from the photo's reverse
+                                geolocation data
+{place.address}                 Postal address from the photo's reverse
+                                geolocation data, e.g. '2007 18th St NW,
+                                Washington, DC 20009, United States'
+{place.address.street}          Street part of the postal address, e.g.
+                                '2007 18th St NW'
+{place.address.city}            City part of the postal address, e.g.
+                                'Washington'
+{place.address.state_province}  State/province part of the postal address,
+                                e.g. 'DC'
+{place.address.postal_code}     Postal code part of the postal address, e.g.
+                                '20009'
+{place.address.country}         Country name of the postal address, e.g.
+                                'United States'
+{place.address.country_code}    ISO country code of the postal address, e.g.
+                                'US'
+
+The following substitutions may result in multiple values. Thus if specified
+for --directory these could result in multiple copies of a photo being being
+exported, one to each directory.  For example: --directory
+'{created.year}/{album}' could result in the same photo being exported to each
+of the following directories if the photos were created in 2019 and were in
+albums 'Vacation' and 'Family': 2019/Vacation, 2019/Family
+
+Substitution    Description
+{album}         Album(s) photo is contained in
+{folder_album}  Folder path + album photo is contained in. e.g.
+                'Folder/Subfolder/Album' or just 'Album' if no enclosing
+                folder
+{keyword}       Keyword(s) assigned to photo
+{person}        Person(s) / face(s) in a photo
 ```
 
-Example: export all photos to ~/Desktop/export, including edited versions and live photo movies, group in folders by date created
-`osxphotos export --export-edited --export-live --export-by-date ~/Pictures/Photos\ Library.photoslibrary ~/Desktop/export`
+Example: export all photos to ~/Desktop/export group in folders by date created
+
+`osxphotos export --export-by-date ~/Pictures/Photos\ Library.photoslibrary ~/Desktop/export`
 
 **Note**: Photos library/database path can also be specified using --db option:
-`osxphotos export --export-edited --export-live --export-by-date --db ~/Pictures/Photos\ Library.photoslibrary ~/Desktop/export`
+
+`osxphotos export --export-by-date --db ~/Pictures/Photos\ Library.photoslibrary ~/Desktop/export`
 
 Example: find all photos with keyword "Kids" and output results to json file named results.json:
 
 `osxphotos query --keyword Kids --json ~/Pictures/Photos\ Library.photoslibrary >results.json`
 
-## Example uses of the module 
+Example: export photos to file structure based on 4-digit year and full name of month of photo's creation date:
+
+`osxphotos export ~/Desktop/export --directory "{created.year}/{created.month}"`
+
+
+## Example uses of the package 
 
 ```python
+""" Simple usage of the package """
 import os.path
 
 import osxphotos
@@ -200,7 +393,7 @@ def main():
     photosdb = osxphotos.PhotosDB(db)
     print(photosdb.keywords)
     print(photosdb.persons)
-    print(photosdb.albums)
+    print(photosdb.album_names)
 
     print(photosdb.keywords_as_dict)
     print(photosdb.persons_as_dict)
@@ -231,37 +424,84 @@ if __name__ == "__main__":
 ```
 
 ```python
-""" Export all photos to ~/Desktop/export
-    If file has been edited, export the edited version, 
-    otherwise, export the original version """
+""" Export all photos to specified directory using album names as folders
+    If file has been edited, also export the edited version, 
+    otherwise, export the original version 
+    This will result in duplicate photos if photo is in more than album """
 
 import os.path
+import pathlib
+import sys
+
+import click
+from pathvalidate import is_valid_filepath, sanitize_filepath
+
 import osxphotos
 
 
-def main():
-    db = os.path.expanduser("~/Pictures/Photos Library.photoslibrary")
-    photosdb = osxphotos.PhotosDB(db)
-    photos = photosdb.photos()
+@click.command()
+@click.argument("export_path", type=click.Path(exists=True))
+@click.option(
+    "--default-album",
+    help="Default folder for photos with no album. Defaults to 'unfiled'",
+    default="unfiled",
+)
+@click.option(
+    "--library-path",
+    help="Path to Photos library, default to last used library",
+    default=None,
+)
+def export(export_path, default_album, library_path):
+    export_path = os.path.expanduser(export_path)
+    library_path = os.path.expanduser(library_path) if library_path else None
 
-    export_path = os.path.expanduser("~/Desktop/export")
+    if library_path is not None:
+        photosdb = osxphotos.PhotosDB(library_path)
+    else:
+        photosdb = osxphotos.PhotosDB()
+
+    photos = photosdb.photos()
 
     for p in photos:
         if not p.ismissing:
-            if p.hasadjustments:
-                exported = p.export(export_path, edited=True)
-            else:
-                exported = p.export(export_path)
-            print(f"Exported {p.filename} to {exported}")
+            albums = p.albums
+            if not albums:
+                albums = [default_album]
+            for album in albums:
+                click.echo(f"exporting {p.filename} in album {album}")
+
+                # make sure no invalid characters in destination path (could be in album name)
+                album_name = sanitize_filepath(album, platform="auto")
+
+                # create destination folder, if necessary, based on album name
+                dest_dir = os.path.join(export_path, album_name)
+
+                # verify path is a valid path
+                if not is_valid_filepath(dest_dir, platform="auto"):
+                    sys.exit(f"Invalid filepath {dest_dir}")
+
+                # create destination dir if needed
+                if not os.path.isdir(dest_dir):
+                    os.makedirs(dest_dir)
+
+                # export the photo
+                if p.hasadjustments:
+                    # export edited version
+                    exported = p.export(dest_dir, edited=True)
+                    edited_name = pathlib.Path(p.path_edited).name
+                    click.echo(f"Exported {edited_name} to {exported}")
+                # export unedited version
+                exported = p.export(dest_dir)
+                click.echo(f"Exported {p.filename} to {exported}")
         else:
-            print(f"Skipping missing photo: {p.filename}")
+            click.echo(f"Skipping missing photo: {p.filename}")
 
 
 if __name__ == "__main__":
-    main()
+    export()  # pylint: disable=no-value-for-parameter
 ```
 
-## Module Interface
+## Package Interface
 
 ### PhotosDB
 
@@ -339,22 +579,52 @@ keywords = photosdb.keywords
 
 Returns a list of the keywords found in the Photos library
 
+#### `album_info`
+```python
+# assumes photosdb is a PhotosDB object (see above)
+albums = photosdb.album_info
+```
+
+Returns a list of [AlbumInfo](#AlbumInfo) objects representing albums in the database or empty list if there are no albums.  See also [albums](#albums).
+
 #### `albums`
 ```python
 # assumes photosdb is a PhotosDB object (see above)
-albums = photosdb.albums
+album_names = photosdb.albums
 ```
 
-Returns a list of the albums found in the Photos library.  
+Returns a list of the album names found in the Photos library.  
 
 **Note**: In Photos 5.0 (MacOS 10.15/Catalina), It is possible to have more than one album with the same name in Photos.  Albums with duplicate names are treated as a single album and the photos in each are combined.  For example, if you have two albums named "Wedding" and each has 2 photos, osxphotos will treat this as a single album named "Wedding" with 4 photos in it.
 
+See also [album_info](#album_info.)
+
 #### `albums_shared`
 
-Returns list of shared albums found in photos database (e.g. albums shared via iCloud photo sharing)
+Returns list of shared album names found in photos database (e.g. albums shared via iCloud photo sharing)
 
 **Note**: *Only valid for Photos 5 / MacOS 10.15*; on Photos <= 4, prints warning and returns empty list.
 
+#### `folder_info`
+```python
+# assumes photosdb is a PhotosDB object (see above)
+folders = photosdb.folder_info
+```
+
+Returns a list of [FolderInfo](#FolderInfo) objects representing top level folders in the database or empty list if there are no folders.  See also [folders](#folders).
+
+**Note**: Currently folder_info is only implemented for Photos 5 (Catalina); will return empty list and output warning if called on earlier database versions.
+
+#### `folders`
+```python
+# assumes photosdb is a PhotosDB object (see above)
+folders = photosdb.folders
+```
+
+Returns a list names of top level folder names in the database. 
+
+**Note**: Currently folders is only implemented for Photos 5 (Catalina); will return empty list and output warning if called on earlier database versions.
+
 #### `persons`
 ```python
 # assumes photosdb is a PhotosDB object (see above)
@@ -564,7 +834,10 @@ Returns the title of the photo
 Returns a list of keywords (e.g. tags) applied to the photo
 
 #### `albums`
-Returns a list of albums the photo is contained in
+Returns a list of albums the photo is contained in. See also [album_info](#album_info).
+
+#### `album_info`
+Returns a list of [AlbumInfo](#AlbumInfo) objects representing the albums the photo is contained in.  See also [albums](#albums).
 
 #### `persons`
 Returns a list of the names of the persons in the photo
@@ -595,6 +868,9 @@ Returns `True` if the picture has been marked as hidden, otherwise `False`
 #### `location`
 Returns latitude and longitude as a tuple of floats (latitude, longitude).  If location is not set, latitude and longitude are returned as `None`
 
+#### `place`
+Returns a [PlaceInfo](#PlaceInfo) object with reverse geolocation data or None if there is the photo has no reverse geolocation information.
+
 #### `shared`
 Returns True if photo is in a shared album, otherwise False.
 
@@ -652,21 +928,45 @@ Returns the path to the live video component of a [live photo](#live_photo). If
 
 **Note**: will also return None if the live video component is missing on disk. It's possible that the original photo may be on disk ([ismissing](#ismissing)==False) but the video component is missing, likely because it has not been downloaded from iCloud.
 
+#### `portrait`
+Returns True if photo was taken in iPhone portrait mode, otherwise False.
+
+#### `hdr`
+Returns True if photo was taken in High Dynamic Range (HDR) mode, otherwise False.
+
+#### `selfie`
+Returns True if photo is a selfie (taken with front-facing camera), otherwise False.  
+
+**Note**: Only implemented for Photos version 3.0+.  On Photos version < 3.0, returns None.
+
+#### `time_lapse`
+Returns True if photo is a time lapse video, otherwise False.
+
+#### `panorama`
+Returns True if photo is a panorama, otherwise False.
+
+**Note**: The result of `PhotoInfo.panorama` will differ from the "Panoramas" Media Types smart album in that it will also identify panorama photos from older phones that Photos does not recognize as panoramas. 
+
 #### `json()`
 Returns a JSON representation of all photo info 
 
-#### `export(dest, *filename, edited=False, overwrite=False, increment=True, sidecar_json=False, sidecar_xmp=False, use_photos_export=False, timeout=120,)`
+#### `export(dest, *filename, edited=False, live_photo=False, overwrite=False, increment=True, sidecar_json=False, sidecar_xmp=False, use_photos_export=False, timeout=120, exiftool=False, no_xattr=False)`
 
 Export photo from the Photos library to another destination on disk.  
 - dest: must be valid destination path as str (or exception raised).
-- *filename (optional): name of picture as str; if not provided, will use current filename
+- *filename (optional): name of picture as str; if not provided, will use current filename.  **NOTE**: if provided, user must ensure file extension (suffix) is correct. For example, if photo is .CR2 file, edited image may be .jpeg.  If you provide an extension different than what the actual file is, export will print a warning but will happily export the photo using the incorrect file extension.  e.g. to get the extension of the edited photo, look at [PhotoInfo.path_edited](#path_edited).
 - edited: boolean; if True (default=False), will export the edited version of the photo (or raise exception if no edited version)
 - overwrite: boolean; if True (default=False), will overwrite files if they alreay exist
+- live_photo: boolean; if True (default=False), will also export the associted .mov for live photos; exported live photo will be named filename.mov
 - increment: boolean; if True (default=True), will increment file name until a non-existent name is found
-- sidecar_json: (boolean, default = False); if True will also write a json sidecar with IPTC data in format readable by exiftool; sidecar filename will be dest/filename.json where filename is the stem of the photo name
-- sidecar_xmp: (boolean, default = False); if True will also write a XMP sidecar with IPTC data; sidecar filename will be dest/filename.xmp where filename is the stem of the photo name
+- sidecar_json: (boolean, default = False); if True will also write a json sidecar with metadata in format readable by exiftool; sidecar filename will be dest/filename.json where filename is the stem of the photo name
+- sidecar_xmp: (boolean, default = False); if True will also write a XMP sidecar with metadata; sidecar filename will be dest/filename.xmp where filename is the stem of the photo name
 - use_photos_export: boolean; (default=False), if True will attempt to export photo via applescript interaction with Photos; useful for forcing download of missing photos.  This only works if the Photos library being used is the default library (last opened by Photos) as applescript will directly interact with whichever library Photos is currently using.
 - timeout: (int, default=120) timeout in seconds used with use_photos_export
+- exiftool: (boolean, default = False) if True, will use [exiftool](https://exiftool.org/) to write metadata directly to the exported photo; exiftool must be installed and in the system path
+- no_xattr: (boolean, default = False); if True, exports file without preserving extended attributes
+
+Returns: list of paths to exported files. More than one file could be exported, for example if live_photo=True, both the original imaage and the associated .mov file will be exported
 
 The json sidecar file can be used by exiftool to apply the metadata from the json file to the image.  For example: 
 
@@ -684,40 +984,257 @@ Then
 
 If overwrite=False and increment=False, export will fail if destination file already exists
 
-Returns the full path to the exported file
+**Implementation Note**: Because the usual python file copy methods don't preserve all the metadata available on MacOS, export uses `/usr/bin/ditto` to do the copy for export. ditto preserves most metadata such as extended attributes, permissions, ACLs, etc.
 
-**Implementation Note**: Because the usual python file copy methods don't preserve all the metadata available on MacOS, export uses /usr/bin/ditto to do the copy for export. ditto preserves most metadata such as extended attributes, permissions, ACLs, etc.
+### AlbumInfo
+PhotosDB.album_info and PhotoInfo.album_info return a list of AlbumInfo objects.  Each AlbumInfo object represents a single album in the Photos library.
+
+#### `uuid`
+Returns the universally unique identifier (uuid) of the album.  This is how Photos keeps track of individual objects within the database.
+
+#### `title`
+Returns the title or name of the album.
+
+#### `photos`
+Returns a list of [PhotoInfo](#PhotoInfo) objects representing each photo contained in the album.
+
+#### `folder_list`
+Returns a hierarchical list of [FolderInfo](#FolderInfo) objects representing the folders the album is contained in.  For example, if album "AlbumInFolder" is in SubFolder2 of Folder1 as illustrated below, would return a list of `FolderInfo` objects representing ["Folder1", "SubFolder2"] 
+
+```txt
+Photos Library
+├── Folder1
+    ├── SubFolder1
+    ├── SubFolder2
+        └── AlbumInFolder
+```
+
+#### `folder_names`
+Returns a hierarchical list of names of the folders the album is contained in.  For example, if album is in SubFolder2 of Folder1 as illustrated below, would return ["Folder1", "SubFolder2"].  
+
+```txt
+Photos Library
+├── Folder1
+    ├── SubFolder1
+    ├── SubFolder2
+        └── AlbumInFolder
+```
+
+#### `parent`
+Returns a [FolderInfo](#FolderInfo) object representing the albums parent folder or `None` if album is not a in a folder.
+
+
+### FolderInfo 
+PhotosDB.folder_info returns a list of FolderInfo objects representing the top level folders in the library.  Each FolderInfo object represents a single folder in the Photos library.
+
+#### `uuid`
+Returns the universally unique identifier (uuid) of the folder.  This is how Photos keeps track of individual objects within the database.
+
+#### `title`
+Returns the title or name of the folder.
+
+#### `album_info`
+Returns a list of [AlbumInfo](#AlbumInfo) objects representing each album contained in the folder.
+
+#### `subfolders`
+Returns a list of [FolderInfo](#FolderInfo) objects representing the sub-folders of the folder.  
+
+#### `parent`
+Returns a [FolderInfo](#FolderInfo) object representing the folder's parent folder or `None` if album is not a in a folder.
+
+**Note**: FolderInfo and AlbumInfo objects effectively work as a linked list.  The children of a folder are contained in `subfolders` and `album_info` and the parent object of both `AlbumInfo` and `FolderInfo` is represented by `parent`.  For example:
+
+```python
+>>> import osxphotos
+>>> photosdb = osxphotos.PhotosDB()
+>>> photosdb.folder_info
+[<osxphotos.albuminfo.FolderInfo object at 0x10fcc0160>]
+>>> photosdb.folder_info[0].title
+'Folder1'
+>>> photosdb.folder_info[0].subfolders[1].title
+'SubFolder2'
+>>> photosdb.folder_info[0].subfolders[1].album_info[0].title
+'AlbumInFolder'
+>>> photosdb.folder_info[0].subfolders[1].album_info[0].parent.title
+'SubFolder2'
+>>> photosdb.folder_info[0].subfolders[1].album_info[0].parent.album_info[0].title
+'AlbumInFolder'
+```
+
+
+### PlaceInfo
+[PhotoInfo.place](#place) returns a PlaceInfo object if the photo contains valid reverse geolocation information.  PlaceInfo has the following properties.  
+
+**Note** For Photos versions <= 4, only `name`, `names`, and `country_code` properties are defined.  All others return `None`.  This is because older versions of Photos do not store the more detailed reverse geolocation information.
+
+#### `ishome`
+Returns `True` if photo place is user's home address, otherwise `False`.
+
+#### `name`
+Returns the name of the local place as str.  This is what Photos displays in the Info window.  **Note** Photos 5 uses a different algorithm to determine the name than earlier versions which means the same Photo may have a different place name in Photos 4 and Photos 5. `PhotoInfo.name` will return the name Photos would have shown depending on the version of the library being processed.  In Photos 5, the place name is generally more detailed than in earlier versions of Photos.
+
+For example, I have photo in my library that under Photos 4, has place name of "‎⁨Mayfair Shopping Centre⁩, ⁨Victoria⁩, ⁨Canada⁩" and under Photos 5 the same photo has place name of "Mayfair⁩, ⁨Vancouver Island⁩, ⁨Victoria⁩, ⁨British Columbia⁩, ⁨Canada⁩".
+
+Returns `None` if photo does not contain a name.
+
+#### `names`
+Returns a `PlaceNames` namedtuple with the following fields.  Each field is a list with zero or more values, sorted by area in ascending order.  E.g. `names.area_of_interest` could be ['Gulf Islands National Seashore', 'Santa Rosa Island'], ["Knott's Berry Farm"], or [] if `area_of_interest` not defined.  The value shown in Photos is the first value in the list. With the exception of `body_of_water` each of these field corresponds to an attribute of a [CLPlacemark](https://developer.apple.com/documentation/corelocation/clplacemark) object.  **Note** The `PlaceNames` namedtuple contains reserved fields not listed below (see implementation for details), thus it should be referenced only by name (e.g. `names.city`) and not by index.
+
+- `country`; the name of the country associated with the placemark.
+- `state_province`; administrativeArea, The state or province associated with the placemark.
+- `sub_administrative_area`; additional administrative area information for the placemark.
+- `city`; locality; the city associated with the placemark.
+- `additional_city_info`; subLocality, Additional city-level information for the placemark.
+- `ocean`; the name of the ocean associated with the placemark.
+- `area_of_interest`; areasOfInterest, The relevant areas of interest associated with the placemark.
+- `inland_water`; the name of the inland water body associated with the placemark.
+- `region`; the geographic region associated with the placemark.
+- `sub_throughfare`; additional street-level information for the placemark.
+- `postal_code`; the postal code associated with the placemark.
+- `street_address`; throughfare, The street address associated with the placemark.
+- `body_of_water`; in Photos 4, any body of water; in Photos 5 contains the union of ocean and inland_water
+
+**Note**: In Photos <= 4.0, only the following fields are defined; all others are set to empty list:
+
+- `country`
+- `state_province`
+- `sub_administrative_area`
+- `city` 
+- `additional_city_info`
+- `area_of_interest`
+- `body_of_water`
+
+#### `country_code`
+Returns the country_code of place, for example "GB".  Returns `None` if PhotoInfo contains no country code.
+
+#### `address_str`
+Returns the full postal address as a string if defined, otherwise `None`.
+
+For example: "2038 18th St NW, Washington, DC  20009, United States"
+
+#### `address`:
+Returns a `PostalAddress` namedtuple with details of the postal address containing the following fields:
+- `city`
+- `country`
+- `postal_code`
+- `state`
+- `street`
+- `sub_administrative_area`
+- `sub_locality`
+- `iso_country_code`
+
+For example:
+```python
+>>> photo.place.address
+PostalAddress(street='3700 Wailea Alanui Dr', sub_locality=None, city='Kihei', sub_administrative_area='Maui', state='HI', postal_code='96753', country='United States', iso_country_code='US')
+>>> photo.place.address.postal_code
+'96753'
+```
+
+### Template Functions
+
+There is a simple template system used by the command line client to specify the output directory using a template.  The following are available in `osxphotos.template`.
+
+#### `render_filepath_template(template, photo, none_str="_")`
+Render template string for photo.  none_str is used if template substitution results in None value and no default specified. 
+- `template`: str in form "{name,DEFAULT}" where name is one of the values in table below. The "," and default value that follows are optional. If specified, "DEFAULT" will be used if "name" is None.  This is useful for values which are not always present, for example reverse geolocation data.
+- `photo`: a [PhotoInfo](#photoinfo) object
+- `none_str`: optional str to use as substitution when template value is None and no default specified in the template string.  default is "_".
+
+Returns a tuple of (rendered, unmatched) where rendered is a list of rendered strings with all substitutions made and unmatched is a list of any strings that resembled a template substitution but did not match a known substitution. E.g. if template contained "{foo}", unmatched would be ["foo"].
+
+e.g. `render_filepath_template("{created.year}/{foo}", photo)` would return `(["2020/{foo}"],["foo"])`
+
+If you want to include "{" or "}" in the output, use "{{" or "}}"
+
+e.g. `render_filepath_template("{created.year}/{{foo}}", photo)` would return `(["2020/{foo}"],[])`
+
+Some substitutions, notably `album`, `keyword`, and `person` could return multiple values, hence a new string will be return for each possible substitution (hence why a list of rendered strings is returned).  For example, a photo in 2 albums: 'Vacation' and 'Family' would result in the following rendered values if template was "{created.year}/{album}" and created.year == 2020: `["2020/Vacation","2020/Family"]` 
+
+
+| Substitution | Description |
+|--------------|-------------|
+|{name}|Filename of the photo|
+|{original_name}|Photo's original filename when imported to Photos|
+|{title}|Title of the photo|
+|{descr}|Description of the photo|
+|{created.date}|Photo's creation date in ISO format, e.g. '2020-03-22'|
+|{created.year}|4-digit year of file creation time|
+|{created.yy}|2-digit year of file creation time|
+|{created.mm}|2-digit month of the file creation time (zero padded)|
+|{created.month}|Month name in user's locale of the file creation time|
+|{created.mon}|Month abbreviation in the user's locale of the file creation time|
+|{created.doy}|3-digit day of year (e.g Julian day) of file creation time, starting from 1 (zero padded)|
+|{modified.date}|Photo's modification date in ISO format, e.g. '2020-03-22'|
+|{modified.year}|4-digit year of file modification time|
+|{modified.yy}|2-digit year of file modification time|
+|{modified.mm}|2-digit month of the file modification time (zero padded)|
+|{modified.month}|Month name in user's locale of the file modification time|
+|{modified.mon}|Month abbreviation in the user's locale of the file modification time|
+|{modified.doy}|3-digit day of year (e.g Julian day) of file modification time, starting from 1 (zero padded)|
+|{place.name}|Place name from the photo's reverse geolocation data, as displayed in Photos|
+|{place.country_code}|The ISO country code from the photo's reverse geolocation data|
+|{place.name.country}|Country name from the photo's reverse geolocation data|
+|{place.name.state_province}|State or province name from the photo's reverse geolocation data|
+|{place.name.city}|City or locality name from the photo's reverse geolocation data|
+|{place.name.area_of_interest}|Area of interest name (e.g. landmark or public place) from the photo's reverse geolocation data|
+|{place.address}|Postal address from the photo's reverse geolocation data, e.g. '2007 18th St NW, Washington, DC 20009, United States'|
+|{place.address.street}|Street part of the postal address, e.g. '2007 18th St NW'|
+|{place.address.city}|City part of the postal address, e.g. 'Washington'|
+|{place.address.state_province}|State/province part of the postal address, e.g. 'DC'|
+|{place.address.postal_code}|Postal code part of the postal address, e.g. '20009'|
+|{place.address.country}|Country name of the postal address, e.g. 'United States'|
+|{place.address.country_code}|ISO country code of the postal address, e.g. 'US'|
+|{album}|Album(s) photo is contained in|
+|{keyword}|Keyword(s) assigned to photo|
+|{person}|Person(s) / face(s) in a photo|
+
+
+#### `DateTimeFormatter(dt)`
+Class that provides easy access to formatted datetime values.
+- `dt`: a datetime.datetime object
+
+Returnes `DateTimeFormater` class.
+
+Has the following properties:
+- `date`: Date in ISO format without timezone, e.g. "2020-03-04"
+- `year`: 4-digit year
+- `yy`: 2-digit year
+- `month`: month name in user's locale
+- `mon`: month abbreviation in user's locale
+- `mm`: 2-digit month
+- `doy`: 3-digit day of year (e.g. Julian day)
 
 ### Utility Functions
 
 The following functions are located in osxphotos.utils
 
-#### ```get_system_library_path()```
+#### `get_system_library_path()`
 
 **MacOS 10.15 Only** Returns path to System Photo Library as string.  On MacOS version < 10.15, returns None.
 
-#### ```get_last_library_path()```
+#### `get_last_library_path()`
 
 Returns path to last opened Photo Library as string.  
 
-#### ```list_photo_libraries()```
+#### `list_photo_libraries()`
 
 Returns list of Photos libraries found on the system.  **Note**: On MacOS 10.15, this appears to list all libraries. On older systems, it may not find some libraries if they are not located in ~/Pictures.  Provided for convenience but do not rely on this to find all libraries on the system.
 
-#### ```dd_to_dms_str(lat, lon)```
+#### `dd_to_dms_str(lat, lon)`
 Convert latitude, longitude in degrees to degrees, minutes, seconds as string.
-lat: latitude in degrees
-lon: longitude in degrees
+- `lat`: latitude in degrees
+- `lon`: longitude in degrees
 returns: string tuple in format ("51 deg 30' 12.86\\" N", "0 deg 7' 54.50\\" W")
 This is the same format used by exiftool's json format.
 
-#### ```create_path_by_date(dest, dt)```
+#### `create_path_by_date(dest, dt)`
 Creates a path in dest folder in form dest/YYYY/MM/DD/
-dest: valid path as str
-dt: datetime.timetuple() object
+- `dest`: valid path as str
+- `dt`: datetime.timetuple() object
 Checks to see if path exists, if it does, do nothing and return path. If path does not exist, creates it and returns path.  Useful for exporting photos to a date-based folder structure.
 
-### Examples
+## Examples
 
 ```python
 import osxphotos
@@ -730,7 +1247,7 @@ def main():
 
     print(photosdb.keywords)
     print(photosdb.persons)
-    print(photosdb.albums)
+    print(photosdb.album_names)
 
     print(photosdb.keywords_as_dict)
     print(photosdb.persons_as_dict)
@@ -771,7 +1288,13 @@ if __name__ == "__main__":
 
 ## Related Projects
 
-[photosmeta](https://github.com/rhettbull/photosmeta): uses osxphotos and [exiftool](https://exiftool.org/) to apply metadata from Photos as exif data in the photo files.  Can also export photos while preserving metadata and also apply Photos keywords as spotlight tags to make it easier to search for photos using spotlight.
+- [rhettbull/photosmeta](https://github.com/rhettbull/photosmeta): uses osxphotos and [exiftool](https://exiftool.org/) to apply metadata from Photos as exif data in the photo files.  Can also export photos while preserving metadata and also apply Photos keywords as spotlight tags to make it easier to search for photos using spotlight.  This is mostly made obsolete by osxphotos.  The one feature that photosmeta has that osxphotos does not is ability to update the metadata of the actual photo files in the Photos library without exporting them. (Use with caution!)
+- [patrikhson/photo-export](https://github.com/patrikhson/photo-export): Exports older versions of Photos databases.  Provided the inspiration for osxphotos.
+- [orangeturtle739/photos-export](https://github.com/orangeturtle739/photos-export): Set of scripts to export Photos libraries.
+- [ndbroadbent/icloud_photos_downloader](https://github.com/ndbroadbent/icloud_photos_downloader): Download photos from iCloud.  Currently unmaintained.
+- [AaronVanGeffen/ExportPhotosLibrary](https://github.com/AaronVanGeffen/ExportPhotosLibrary): Another python script for exporting older versions of Photos libraries.
+- [MossieurPropre/PhotosAlbumExporter](https://github.com/MossieurPropre/PhotosAlbumExporter): Javascript script to export photos while maintaining album structure.
+- [ajslater/magritte](https://github.com/ajslater/magritte): Another python command line script for exporting photos from older versions of Photos libraries.
 
 ## Contributing
 
@@ -779,26 +1302,35 @@ Contributing is easy!  if you find bugs or want to suggest additional features/c
 
 I'll gladly consider pull requests for bug fixes or feature implementations.  
 
-If you have an interesting example that shows usage of this module, submit an issue or pull request and i'll include it or link to it.
+If you have an interesting example that shows usage of this package, submit an issue or pull request and i'll include it or link to it.
 
 Testing against "real world" Photos libraries would be especially helpful.  If you discover issues in testing against your Photos libraries, please open an issue.  I've done extensive testing against my own Photos library but that's a since data point and I'm certain there are issues lurking in various edge cases I haven't discovered yet.
 
+## Known Bugs
+
+My goal is make osxphotos as reliable and comprehensive as possible.  The test suite currently has over 400 tests--but there are still some [bugs](https://github.com/RhetTbull/osxphotos/issues?q=is%3Aissue+is%3Aopen+label%3Abug) or incomplete features lurking.  If you find bugs please open an [issue](https://github.com/RhetTbull/osxphotos/issues).  Notable issues include:
+
+- RAW images imported to Photos with an associated jpeg preview are not handled correctly by osxphotos.  osxphotos query and export will operate on the jpeg preview instead of the RAW image as will `PhotoInfo.path`.  If the user selects "Use RAW as original" in Photos, the RAW image will be exported or operated on but the jpeg will be ignored.  See [Issue #101](https://github.com/RhetTbull/osxphotos/issues/101) Note: Alpha version of fix for this bug is implemented in the current version of osxphotos.
+- The `--download-missing` option for `osxphotos export` does not work correctly with burst images.  It will download the primary image but not the other burst images.  See [Issue #75](https://github.com/RhetTbull/osxphotos/issues/75)
+
 ## Implementation Notes
 
-This module works by creating a copy of the sqlite3 database that photos uses to store data about the photos library. the class photosdb then queries this database to extract information about the photos such as persons (faces identified in the photos), albums, keywords, etc.  If your library is large, the database can be hundreds of MB in size and the copy then read can take many 10s of seconds to complete.  Once copied, the entire database is processed and an in-memory data structure is created meaning all subsequent accesses of the PhotosDB object occur much more quickly. 
+This package works by creating a copy of the sqlite3 database that photos uses to store data about the photos library. The class PhotosDB then queries this database to extract information about the photos such as persons (faces identified in the photos), albums, keywords, etc.  If your library is large, the database can be hundreds of MB in size and the copy read then  can take many 10s of seconds to complete.  Once copied, the entire database is processed and an in-memory data structure is created meaning all subsequent accesses of the PhotosDB object occur much more quickly. 
 
 If apple changes the database format this will likely break.
 
-Apple does provide a framework ([PhotoKit](https://developer.apple.com/documentation/photokit?language=objc)) for querying the user's Photos library and I attempted to create the funcationality in this module using this framework but unfortunately PhotoKit does not provide access to much of the needed metadata (such as Faces/Persons).  While copying the sqlite file is a bit kludgy, it allows osxphotos to provide access to all available metadata.
+Apple does provide a framework ([PhotoKit](https://developer.apple.com/documentation/photokit?language=objc)) for querying the user's Photos library and I attempted to create the funcationality in this package using this framework but unfortunately PhotoKit does not provide access to much of the needed metadata (such as Faces/Persons) and Apple's System Integrity Protection (SIP) made the interface unreliable.  If you'd like to experiment with the PhotoKit interface, here's some sample [code](https://gist.github.com/RhetTbull/41cc85e5bdeb30f761147ce32fba5c94).  While copying the sqlite file is a bit kludgy, it allows osxphotos to provide access to all available metadata.
 
 ## Dependencies
 - [PyObjC](https://pythonhosted.org/pyobjc/)
 - [PyYAML](https://pypi.org/project/PyYAML/)
 - [Click](https://pypi.org/project/click/)
 - [Mako](https://www.makotemplates.org/)
+- [bpylist2](https://pypi.org/project/bpylist2/)
+- [pathvalidate](https://pypi.org/project/pathvalidate/)
 
 ## Acknowledgements
 This project was originally inspired by [photo-export](https://github.com/patrikhson/photo-export) by Patrick Fältström,  Copyright (c) 2015 Patrik Fältström paf@frobbit.se
 
-I use [py-applescript](https://github.com/rdhyee/py-applescript) by "Raymond Yee / rdhyee" to interact with Photos. Rather than import this module, I included the entire module (which is published as public domain code) in a private module to prevent ambiguity with other applescript modules on PyPi. py-applescript uses a native bridge via PyObjC and is very fast compared to the other osascript based modules.
+I use [py-applescript](https://github.com/rdhyee/py-applescript) by "Raymond Yee / rdhyee" to interact with Photos. Rather than import this package, I included the entire package (which is published as public domain code) in a private package to prevent ambiguity with other applescript packages on PyPi. py-applescript uses a native bridge via PyObjC and is very fast compared to the other osascript based packages.
 

examples/export_by_album.py

@@ -0,0 +1,86 @@
+""" Export all photos to specified directory using album names as folders
+    If file has been edited, also export the edited version, 
+    otherwise, export the original version 
+    This will result in duplicate photos if photo is in more than album """
+
+import os.path
+import pathlib
+import sys
+
+import click
+from pathvalidate import is_valid_filepath, sanitize_filepath
+
+import osxphotos
+
+
+@click.command()
+@click.argument("export_path", type=click.Path(exists=True))
+@click.option(
+    "--default-album",
+    help="Default folder for photos with no album. Defaults to 'unfiled'",
+    default="unfiled",
+)
+@click.option(
+    "--library-path",
+    help="Path to Photos library, default to last used library",
+    default=None,
+)
+@click.option(
+    "--edited",
+    help="Also export edited versions of photos (default is originals only)",
+    is_flag=True,
+    default=False,
+)
+def export(export_path, default_album, library_path, edited):
+    """ Export all photos, organized by album """
+    export_path = os.path.expanduser(export_path)
+    library_path = os.path.expanduser(library_path) if library_path else None
+
+    if library_path is not None:
+        photosdb = osxphotos.PhotosDB(library_path)
+    else:
+        photosdb = osxphotos.PhotosDB()
+
+    photos = photosdb.photos()
+
+    for p in photos:
+        if not p.ismissing:
+            albums = p.albums
+            if not albums:
+                albums = [default_album]
+            for album in albums:
+                click.echo(f"exporting {p.original_filename} in album {album}")
+
+                # make sure no invalid characters in destination path (could be in album name)
+                album_name = sanitize_filepath(album, platform="auto")
+
+                # create destination folder, if necessary, based on album name
+                dest_dir = os.path.join(export_path, album_name)
+
+                # verify path is a valid path
+                if not is_valid_filepath(dest_dir, platform="auto"):
+                    sys.exit(f"Invalid filepath {dest_dir}")
+
+                # create destination dir if needed
+                if not os.path.isdir(dest_dir):
+                    os.makedirs(dest_dir)
+
+                filename = p.original_filename
+                # export the photo but only if --edited, photo has adjustments, and 
+                # path_edited is not None (can be None if edited photo is missing)
+                if edited and p.hasadjustments and p.path_edited:
+                    # export edited version
+                    # use original filename with _edited appended but make sure suffix is 
+                    # same as edited file
+                    edited_filename = f"{pathlib.Path(filename).stem}_edited{pathlib.Path(p.path_edited).suffix}"
+                    exported = p.export(dest_dir, edited_filename, edited=True)
+                    click.echo(f"Exported {edited_filename} to {exported}")
+                # export unedited version
+                exported = p.export(dest_dir, filename)
+                click.echo(f"Exported {filename} to {exported}")
+        else:
+            click.echo(f"Skipping missing photo: {p.original_filename} in album {album}")
+
+
+if __name__ == "__main__":
+    export()  # pylint: disable=no-value-for-parameter

osxphotos/__main__.py

@@ -1,6 +1,7 @@
 import csv
 import datetime
 import json
+import logging
 import os
 import os.path
 import pathlib
@@ -8,12 +9,24 @@ import sys
 
 import click
 import yaml
+from pathvalidate import (
+    is_valid_filename,
+    is_valid_filepath,
+    sanitize_filepath,
+    sanitize_filename,
+)
 
 import osxphotos
 
-from ._constants import _EXIF_TOOL_URL, _PHOTOS_5_VERSION
+from ._constants import _EXIF_TOOL_URL, _PHOTOS_5_VERSION, _UNKNOWN_PLACE
 from ._version import __version__
-from .utils import create_path_by_date, _copy_file
+from .exiftool import get_exiftool_path
+from .template import (
+    render_filepath_template,
+    TEMPLATE_SUBSTITUTIONS,
+    TEMPLATE_SUBSTITUTIONS_MULTI_VALUED,
+)
+from .utils import _copy_file, create_path_by_date
 
 
 def get_photos_db(*db_options):
@@ -58,6 +71,86 @@ class CLI_Obj:
         self.json = json
 
 
+class ExportCommand(click.Command):
+    """ Custom click.Command that overrides get_help() to show additional help info for export """
+
+    def get_help(self, ctx):
+        help_text = super().get_help(ctx)
+        formatter = click.HelpFormatter()
+
+        formatter.write("\n\n")
+        # passed to click.HelpFormatter.write_dl for formatting
+        formatter.write_text("**Templating System**")
+        formatter.write("\n")
+        formatter.write_text(
+            "With the --directory option, you may specify a template for the "
+            + "export directory.  This directory will be appended to the export path specified "
+            + "in the export DEST argument to export.  For example, if template is "
+            + "'{created.year}/{created.month}', and export desitnation DEST is "
+            + "'/Users/maria/Pictures/export', "
+            + "the actual export directory for a photo would be '/Users/maria/Pictures/export/2020/March' "
+            + "if the photo was created in March 2020. "
+        )
+        formatter.write("\n")
+        formatter.write_text(
+            "In the template, valid template substitutions will be replaced by "
+            + "the corresponding value from the table below.  Invalid substitutions will result in a "
+            + "an error and the script will abort."
+        )
+        formatter.write("\n")
+        formatter.write_text(
+            "If you want the actual text of the template substition to appear "
+            + "in the rendered name, use double braces, e.g. '{{' or '}}', thus "
+            + "using '{created.year}/{{name}}' for --directory "
+            + "would result in output of 2020/{name}/photoname.jpg"
+        )
+        formatter.write("\n")
+        formatter.write_text(
+            "You may specify an optional default value to use if the substitution does not contain a value "
+            + "(e.g. the value is null) "
+            + "by specifying the default value after a ',' in the template string: "
+            + "for example, if template is '{created.year}/{place.address,'NO_ADDRESS'}' "
+            + "but there was no address associated with the photo, the resulting output would be: "
+            + "'2020/NO_ADDRESS/photoname.jpg'. "
+            + "If specified, the default value may not contain a brace symbol ('{' or '}')."
+        )
+        formatter.write("\n")
+        formatter.write_text(
+            "If you do not specify a default value and the template substitution "
+            + "has no value, '_' (underscore) will be used as the default value. For example, in the "
+            + "above example, this would result in '2020/_/photoname.jpg' if address was null"
+        )
+        formatter.write_text(
+            "I plan to eventually extend the templating system "
+            + "to the exported filename so you can specify the filename using a template."
+        )
+
+        formatter.write("\n")
+        templ_tuples = [("Substitution", "Description")]
+        templ_tuples.extend((k, v) for k, v in TEMPLATE_SUBSTITUTIONS.items())
+        formatter.write_dl(templ_tuples)
+
+        formatter.write("\n")
+        formatter.write_text(
+            "The following substitutions may result in multiple values. Thus "
+            + "if specified for --directory these could result in multiple copies of a photo being "
+            + "being exported, one to each directory.  For example: "
+            + "--directory '{created.year}/{album}' could result in the same photo being exported "
+            + "to each of the following directories if the photos were created in 2019 "
+            + "and were in albums 'Vacation' and 'Family': "
+            + "2019/Vacation, 2019/Family"
+        )
+        formatter.write("\n")
+        templ_tuples = [("Substitution", "Description")]
+        templ_tuples.extend(
+            (k, v) for k, v in TEMPLATE_SUBSTITUTIONS_MULTI_VALUED.items()
+        )
+
+        formatter.write_dl(templ_tuples)
+        help_text += formatter.getvalue()
+        return help_text
+
+
 CTX_SETTINGS = dict(help_option_names=["-h", "--help"])
 DB_OPTION = click.option(
     "--db",
@@ -94,7 +187,7 @@ def query_options(f):
             metavar="KEYWORD",
             default=None,
             multiple=True,
-            help="Search for keyword KEYWORD. "
+            help="Search for photos with keyword KEYWORD. "
             'If more than one keyword, treated as "OR", e.g. find photos match any keyword',
         ),
         o(
@@ -102,7 +195,7 @@ def query_options(f):
             metavar="PERSON",
             default=None,
             multiple=True,
-            help="Search for person PERSON. "
+            help="Search for photos with person PERSON. "
             'If more than one person, treated as "OR", e.g. find photos match any person',
         ),
         o(
@@ -110,15 +203,24 @@ def query_options(f):
             metavar="ALBUM",
             default=None,
             multiple=True,
-            help="Search for album ALBUM. "
+            help="Search for photos in album ALBUM. "
             'If more than one album, treated as "OR", e.g. find photos match any album',
         ),
+        o(
+            "--folder",
+            metavar="FOLDER",
+            default=None,
+            multiple=True,
+            help="Search for photos in an album in folder FOLDER. "
+            'If more than one folder, treated as "OR", e.g. find photos in any FOLDER.  '
+            "Only searches top level folders (e.g. does not look at subfolders)",
+        ),
         o(
             "--uuid",
             metavar="UUID",
             default=None,
             multiple=True,
-            help="Search for UUID(s).",
+            help="Search for photos with UUID(s).",
         ),
         o(
             "--title",
@@ -140,6 +242,18 @@ def query_options(f):
             is_flag=True,
             help="Search for photos with no description.",
         ),
+        o(
+            "--place",
+            metavar="PLACE",
+            default=None,
+            multiple=True,
+            help="Search for PLACE in photo's reverse geolocation info",
+        ),
+        o(
+            "--no-place",
+            is_flag=True,
+            help="Search for photos with no associated place name info (no reverse geolocation info)",
+        ),
         o(
             "--uti",
             metavar="UTI",
@@ -151,7 +265,7 @@ def query_options(f):
             "-i",
             "--ignore-case",
             is_flag=True,
-            help="Case insensitive search for title or description. Does not apply to keyword, person, or album.",
+            help="Case insensitive search for title, description, or place. Does not apply to keyword, person, or album.",
         ),
         o("--edited", is_flag=True, help="Search for photos that have been edited."),
         o(
@@ -191,7 +305,50 @@ def query_options(f):
         o(
             "--not-live",
             is_flag=True,
-            help="Search for photos that are not Apple live photos",
+            help="Search for photos that are not Apple live photos.",
+        ),
+        o("--portrait", is_flag=True, help="Search for Apple portrait mode photos."),
+        o(
+            "--not-portrait",
+            is_flag=True,
+            help="Search for photos that are not Apple portrait mode photos.",
+        ),
+        o("--screenshot", is_flag=True, help="Search for screenshot photos."),
+        o(
+            "--not-screenshot",
+            is_flag=True,
+            help="Search for photos that are not screenshot photos.",
+        ),
+        o("--slow-mo", is_flag=True, help="Search for slow motion videos."),
+        o(
+            "--not-slow-mo",
+            is_flag=True,
+            help="Search for photos that are not slow motion videos.",
+        ),
+        o("--time-lapse", is_flag=True, help="Search for time lapse videos."),
+        o(
+            "--not-time-lapse",
+            is_flag=True,
+            help="Search for photos that are not time lapse videos.",
+        ),
+        o("--hdr", is_flag=True, help="Search for high dynamic range (HDR) photos."),
+        o("--not-hdr", is_flag=True, help="Search for photos that are not HDR photos."),
+        o(
+            "--selfie",
+            is_flag=True,
+            help="Search for selfies (photos taken with front-facing cameras).",
+        ),
+        o("--not-selfie", is_flag=True, help="Search for photos that are not selfies."),
+        o("--panorama", is_flag=True, help="Search for panorama photos."),
+        o(
+            "--not-panorama",
+            is_flag=True,
+            help="Search for photos that are not panoramas.",
+        ),
+        o(
+            "--has-raw",
+            is_flag=True,
+            help="Search for photos with both a jpeg and RAW version",
         ),
         o(
             "--only-movies",
@@ -367,6 +524,56 @@ def info(ctx, cli_obj, db, json_, photos_library):
         click.echo(yaml.dump(info, sort_keys=False))
 
 
+@cli.command()
+@DB_OPTION
+@JSON_OPTION
+@DB_ARGUMENT
+@click.pass_obj
+@click.pass_context
+def places(ctx, cli_obj, db, json_, photos_library):
+    """ Print out places found in the Photos library. """
+
+    # below needed for to make CliRunner work for testing
+    cli_db = cli_obj.db if cli_obj is not None else None
+    db = get_photos_db(*photos_library, db, cli_db)
+    if db is None:
+        click.echo(cli.commands["places"].get_help(ctx), err=True)
+        click.echo("\n\nLocated the following Photos library databases: ", err=True)
+        _list_libraries()
+        return
+
+    photosdb = osxphotos.PhotosDB(dbfile=db)
+    place_names = {}
+    for photo in photosdb.photos(movies=True):
+        if photo.place:
+            try:
+                place_names[photo.place.name] += 1
+            except:
+                place_names[photo.place.name] = 1
+        else:
+            try:
+                place_names[_UNKNOWN_PLACE] += 1
+            except:
+                place_names[_UNKNOWN_PLACE] = 1
+
+    # sort by place count
+    places = {
+        "places": {
+            name: place_names[name]
+            for name in sorted(
+                place_names.keys(), key=lambda key: place_names[key], reverse=True
+            )
+        }
+    }
+
+    # below needed for to make CliRunner work for testing
+    cli_json = cli_obj.json if cli_obj is not None else None
+    if json_ or cli_json:
+        click.echo(json.dumps(places))
+    else:
+        click.echo(yaml.dump(places, sort_keys=False))
+
+
 @cli.command()
 @DB_OPTION
 @JSON_OPTION
@@ -477,6 +684,7 @@ def query(
     keyword,
     person,
     album,
+    folder,
     uuid,
     title,
     no_title,
@@ -507,6 +715,23 @@ def query(
     not_incloud,
     from_date,
     to_date,
+    portrait,
+    not_portrait,
+    screenshot,
+    not_screenshot,
+    slow_mo,
+    not_slow_mo,
+    time_lapse,
+    not_time_lapse,
+    hdr,
+    not_hdr,
+    selfie,
+    not_selfie,
+    panorama,
+    not_panorama,
+    has_raw,
+    place,
+    no_place,
 ):
     """ Query the Photos database using 1 or more search options; 
         if more than one option is provided, they are treated as "AND" 
@@ -519,10 +744,12 @@ def query(
         keyword,
         person,
         album,
+        folder,
         uuid,
         edited,
         external_edit,
         uti,
+        has_raw,
         from_date,
         to_date,
     ]
@@ -537,6 +764,14 @@ def query(
         (live, not_live),
         (cloudasset, not_cloudasset),
         (incloud, not_incloud),
+        (portrait, not_portrait),
+        (screenshot, not_screenshot),
+        (slow_mo, not_slow_mo),
+        (time_lapse, not_time_lapse),
+        (hdr, not_hdr),
+        (selfie, not_selfie),
+        (panorama, not_panorama),
+        (any(place), no_place),
     ]
     # print help if no non-exclusive term or a double exclusive term is given
     if not any(nonexclusive + [b ^ n for b, n in exclusive]):
@@ -564,6 +799,7 @@ def query(
         keyword=keyword,
         person=person,
         album=album,
+        folder=folder,
         uuid=uuid,
         title=title,
         no_title=no_title,
@@ -593,6 +829,23 @@ def query(
         not_incloud=not_incloud,
         from_date=from_date,
         to_date=to_date,
+        portrait=portrait,
+        not_portrait=not_portrait,
+        screenshot=screenshot,
+        not_screenshot=not_screenshot,
+        slow_mo=slow_mo,
+        not_slow_mo=not_slow_mo,
+        time_lapse=time_lapse,
+        not_time_lapse=not_time_lapse,
+        hdr=hdr,
+        not_hdr=not_hdr,
+        selfie=selfie,
+        not_selfie=not_selfie,
+        panorama=panorama,
+        not_panorama=not_panorama,
+        has_raw=has_raw,
+        place=place,
+        no_place=no_place,
     )
 
     # below needed for to make CliRunner work for testing
@@ -600,10 +853,10 @@ def query(
     print_photo_info(photos, cli_json or json_)
 
 
-@cli.command()
+@cli.command(cls=ExportCommand)
 @DB_OPTION
-@query_options
 @click.option("--verbose", "-V", is_flag=True, help="Print verbose output.")
+@query_options
 @click.option(
     "--overwrite",
     is_flag=True,
@@ -619,26 +872,33 @@ def query(
     "(e.g. DEST/2019/12/20/photoname.jpg).",
 )
 @click.option(
-    "--export-edited",
+    "--skip-edited",
     is_flag=True,
-    help="Also export edited version of photo if an edited version exists.  "
-    'Edited photo will be named in form of "photoname_edited.ext"',
+    help="Do not export edited version of photo if an edited version exists.",
 )
 @click.option(
-    "--export-bursts",
+    "--skip-bursts",
     is_flag=True,
-    help="If a photo is a burst photo export all associated burst images in the library.",
+    help="Do not export all associated burst images in the library if a photo is a burst photo.  ",
 )
 @click.option(
-    "--export-live",
+    "--skip-live",
     is_flag=True,
-    help="If a photo is a live photo export the associated live video component."
-    "  Live video will have same name as photo but with .mov extension. ",
+    help="Do not export the associated live video component of a live photo.",
 )
 @click.option(
-    "--original-name",
+    "--skip-raw",
     is_flag=True,
-    help="Use photo's original filename instead of current filename for export.",
+    help="Do not export associated RAW images of a RAW/jpeg pair.  "
+    "Note: this does not skip RAW photos if the RAW photo does not have an associated jpeg image "
+    "(e.g. the RAW file was imported to Photos without a jpeg preview).",
+)
+@click.option(
+    "--current-name",
+    is_flag=True,
+    help="Use photo's current filename instead of original filename for export.  "
+    "Note: Starting with Photos 5, all photos are renamed upon import.  By default, "
+    "photos are exported with the the original name they had before import.",
 )
 @click.option(
     "--sidecar",
@@ -660,7 +920,31 @@ def query(
     help="Attempt to download missing photos from iCloud. The current implementation uses Applescript "
     "to interact with Photos to export the photo which will force Photos to download from iCloud if "
     "the photo does not exist on disk.  This will be slow and will require internet connection. "
-    "This obviously only works if the Photos library is synched to iCloud.",
+    "This obviously only works if the Photos library is synched to iCloud.  "
+    "Note: --download-missing does not currently export all burst images; "
+    "only the primary photo will be exported--associated burst images will be skipped.",
+)
+@click.option(
+    "--exiftool",
+    is_flag=True,
+    help="Use exiftool to write metadata directly to exported photos. "
+    "To use this option, exiftool must be installed and in the path.  "
+    "exiftool may be installed from https://exiftool.org/",
+)
+@click.option(
+    "--directory",
+    metavar="DIRECTORY",
+    default=None,
+    help="Optional template for specifying name of output directory in the form '{name,DEFAULT}'. "
+    "See below for additional details on templating system.",
+)
+@click.option(
+    "--no-extended-attributes",
+    is_flag=True,
+    default=False,
+    help="Don't copy extended attributes when exporting.  You only need this if exporting "
+    "to a filesystem that doesn't support Mac OS extended attributes.  Only use this if you get "
+    "an error while exporting.",
 )
 @DB_ARGUMENT
 @click.argument("dest", nargs=1, type=click.Path(exists=True))
@@ -674,6 +958,7 @@ def export(
     keyword,
     person,
     album,
+    folder,
     uuid,
     title,
     no_title,
@@ -694,10 +979,11 @@ def export(
     verbose,
     overwrite,
     export_by_date,
-    export_edited,
-    export_bursts,
-    export_live,
-    original_name,
+    skip_edited,
+    skip_bursts,
+    skip_live,
+    skip_raw,
+    current_name,
     sidecar,
     only_photos,
     only_movies,
@@ -707,6 +993,26 @@ def export(
     not_live,
     download_missing,
     dest,
+    exiftool,
+    portrait,
+    not_portrait,
+    screenshot,
+    not_screenshot,
+    slow_mo,
+    not_slow_mo,
+    time_lapse,
+    not_time_lapse,
+    hdr,
+    not_hdr,
+    selfie,
+    not_selfie,
+    panorama,
+    not_panorama,
+    has_raw,
+    directory,
+    place,
+    no_place,
+    no_extended_attributes,
 ):
     """ Export photos from the Photos database.
         Export path DEST is required.
@@ -714,6 +1020,10 @@ def export(
         if more than one option is provided, they are treated as "AND" 
         (e.g. search for photos matching all options).
         If no query options are provided, all photos will be exported.
+        By default, all versions of all photos will be exported including edited
+        versions, live photo movies, burst photos, and associated RAW images. 
+        See --skip-edited, --skip-live, --skip-bursts, and --skip-raw options
+        to modify this behavior. 
     """
 
     if not os.path.isdir(dest):
@@ -728,11 +1038,43 @@ def export(
         (only_photos, only_movies),
         (burst, not_burst),
         (live, not_live),
+        (portrait, not_portrait),
+        (screenshot, not_screenshot),
+        (slow_mo, not_slow_mo),
+        (time_lapse, not_time_lapse),
+        (hdr, not_hdr),
+        (selfie, not_selfie),
+        (panorama, not_panorama),
+        (export_by_date, directory),
+        (any(place), no_place),
     ]
     if any([all(bb) for bb in exclusive]):
         click.echo(cli.commands["export"].get_help(ctx), err=True)
         return
 
+    # initialize export flags
+    # by default, will export all versions of photos unless skip flag is set
+    (export_edited, export_bursts, export_live, export_raw) = [
+        not x for x in [skip_edited, skip_bursts, skip_live, skip_raw]
+    ]
+
+    # though the command line option is current_name, internally all processing
+    # logic uses original_name which is the boolean inverse of current_name
+    # because the original code used --original-name as an option
+    original_name = not current_name
+
+    # verify exiftool installed an in path
+    if exiftool:
+        try:
+            _ = get_exiftool_path()
+        except FileNotFoundError:
+            click.echo(
+                "Could not find exiftool. Please download and install"
+                " from https://exiftool.org/",
+                err=True,
+            )
+            ctx.exit(2)
+
     isphoto = ismovie = True  # default searches for everything
     if only_movies:
         isphoto = False
@@ -753,6 +1095,7 @@ def export(
         keyword=keyword,
         person=person,
         album=album,
+        folder=folder,
         uuid=uuid,
         title=title,
         no_title=no_title,
@@ -782,6 +1125,23 @@ def export(
         not_incloud=False,
         from_date=from_date,
         to_date=to_date,
+        portrait=portrait,
+        not_portrait=not_portrait,
+        screenshot=screenshot,
+        not_screenshot=not_screenshot,
+        slow_mo=slow_mo,
+        not_slow_mo=not_slow_mo,
+        time_lapse=time_lapse,
+        not_time_lapse=not_time_lapse,
+        hdr=hdr,
+        not_hdr=not_hdr,
+        selfie=selfie,
+        not_selfie=not_selfie,
+        panorama=panorama,
+        not_panorama=not_panorama,
+        has_raw=has_raw,
+        place=place,
+        no_place=no_place,
     )
 
     if photos:
@@ -810,10 +1170,14 @@ def export(
                         original_name,
                         export_live,
                         download_missing,
+                        exiftool,
+                        directory,
+                        no_extended_attributes,
+                        export_raw,
                     )
         else:
             for p in photos:
-                export_path = export_photo(
+                export_paths = export_photo(
                     p,
                     dest,
                     verbose,
@@ -824,9 +1188,13 @@ def export(
                     original_name,
                     export_live,
                     download_missing,
+                    exiftool,
+                    directory,
+                    no_extended_attributes,
+                    export_raw,
                 )
-                if export_path:
-                    click.echo(f"Exported {p.filename} to {export_path}")
+                if export_paths:
+                    click.echo(f"Exported {p.filename} to {export_paths}")
                 else:
                     click.echo(f"Did not export missing file {p.filename}")
     else:
@@ -840,9 +1208,12 @@ def help(ctx, topic, **kw):
     """ Print help; for help on commands: help <command>. """
     if topic is None:
         click.echo(ctx.parent.get_help())
-    else:
+    elif topic in cli.commands:
         ctx.info_name = topic
-        click.echo(cli.commands[topic].get_help(ctx))
+        click.echo_via_pager(cli.commands[topic].get_help(ctx))
+    else:
+        click.echo(f"Invalid command: {topic}", err=True)
+        click.echo(ctx.parent.get_help())
 
 
 def print_photo_info(photos, json=False):
@@ -888,6 +1259,16 @@ def print_photo_info(photos, json=False):
                 "iscloudasset",
                 "incloud",
                 "date_modified",
+                "portrait",
+                "screenshot",
+                "slow_mo",
+                "time_lapse",
+                "hdr",
+                "selfie",
+                "panorama",
+                "has_raw",
+                "uti_raw",
+                "path_raw",
             ]
         )
         for p in photos:
@@ -922,6 +1303,16 @@ def print_photo_info(photos, json=False):
                     p.iscloudasset,
                     p.incloud,
                     date_modified_iso,
+                    p.portrait,
+                    p.screenshot,
+                    p.slow_mo,
+                    p.time_lapse,
+                    p.hdr,
+                    p.selfie,
+                    p.panorama,
+                    p.has_raw,
+                    p.uti_raw,
+                    p.path_raw,
                 ]
             )
         for row in dump:
@@ -933,6 +1324,7 @@ def _query(
     keyword=None,
     person=None,
     album=None,
+    folder=None,
     uuid=None,
     title=None,
     no_title=None,
@@ -962,11 +1354,28 @@ def _query(
     not_incloud=None,
     from_date=None,
     to_date=None,
+    portrait=None,
+    not_portrait=None,
+    screenshot=None,
+    not_screenshot=None,
+    slow_mo=None,
+    not_slow_mo=None,
+    time_lapse=None,
+    not_time_lapse=None,
+    hdr=None,
+    not_hdr=None,
+    selfie=None,
+    not_selfie=None,
+    panorama=None,
+    not_panorama=None,
+    has_raw=None,
+    place=None,
+    no_place=None,
 ):
-    """ run a query against PhotosDB to extract the photos based on user supply criteria """
-    """ used by query and export commands """
-    """ arguments must be passed in same order as query and export """
-    """ if either is modified, need to ensure all three functions are updated """
+    """ run a query against PhotosDB to extract the photos based on user supply criteria 
+        used by query and export commands 
+        arguments must be passed in same order as query and export 
+        if either is modified, need to ensure all three functions are updated """
 
     photosdb = osxphotos.PhotosDB(dbfile=db)
     photos = photosdb.photos(
@@ -980,6 +1389,21 @@ def _query(
         to_date=to_date,
     )
 
+    if folder:
+        # search for photos in an album in folder
+        # finds photos that have albums whose top level folder matches folder
+        photo_list = []
+        for f in folder:
+            photo_list.extend(
+                [
+                    p
+                    for p in photos
+                    if p.album_info
+                    and f in [a.folder_names[0] for a in p.album_info if a.folder_names]
+                ]
+            )
+        photos = photo_list
+
     if title:
         # search title field for text
         # if more than one, find photos with all title values in title
@@ -996,7 +1420,7 @@ def _query(
 
     if description:
         # search description field for text
-        # if more than one, find photos with all name values in description
+        # if more than one, find photos with all description values in description
         if ignore_case:
             # case-insensitive
             for d in description:
@@ -1010,6 +1434,40 @@ def _query(
     elif no_description:
         photos = [p for p in photos if not p.description]
 
+    if place:
+        # search place.names for text matching place
+        # if more than one place, find photos with all place values in description
+        if ignore_case:
+            # case-insensitive
+            for place_name in place:
+                place_name = place_name.lower()
+                photos = [
+                    p
+                    for p in photos
+                    if p.place
+                    and any(
+                        pname
+                        for pname in p.place.names
+                        if any(
+                            pvalue for pvalue in pname if place_name in pvalue.lower()
+                        )
+                    )
+                ]
+        else:
+            for place_name in place:
+                photos = [
+                    p
+                    for p in photos
+                    if p.place
+                    and any(
+                        pname
+                        for pname in p.place.names
+                        if any(pvalue for pvalue in pname if place_name in pvalue)
+                    )
+                ]
+    elif no_place:
+        photos = [p for p in photos if not p.place]
+
     if edited:
         photos = [p for p in photos if p.hasadjustments]
 
@@ -1054,6 +1512,41 @@ def _query(
     elif not_live:
         photos = [p for p in photos if not p.live_photo]
 
+    if portrait:
+        photos = [p for p in photos if p.portrait]
+    elif not_portrait:
+        photos = [p for p in photos if not p.portrait]
+
+    if screenshot:
+        photos = [p for p in photos if p.screenshot]
+    elif not_screenshot:
+        photos = [p for p in photos if not p.screenshot]
+
+    if slow_mo:
+        photos = [p for p in photos if p.slow_mo]
+    elif not_slow_mo:
+        photos = [p for p in photos if not p.slow_mo]
+
+    if time_lapse:
+        photos = [p for p in photos if p.time_lapse]
+    elif not_time_lapse:
+        photos = [p for p in photos if not p.time_lapse]
+
+    if hdr:
+        photos = [p for p in photos if p.hdr]
+    elif not_hdr:
+        photos = [p for p in photos if not p.hdr]
+
+    if selfie:
+        photos = [p for p in photos if p.selfie]
+    elif not_selfie:
+        photos = [p for p in photos if not p.selfie]
+
+    if panorama:
+        photos = [p for p in photos if p.panorama]
+    elif not_panorama:
+        photos = [p for p in photos if not p.panorama]
+
     if cloudasset:
         photos = [p for p in photos if p.iscloudasset]
     elif not_cloudasset:
@@ -1064,6 +1557,9 @@ def _query(
     elif not_incloud:
         photos = [p for p in photos if not p.incloud]
 
+    if has_raw:
+        photos = [p for p in photos if p.has_raw]
+
     return photos
 
 
@@ -1078,6 +1574,10 @@ def export_photo(
     original_name,
     export_live,
     download_missing,
+    exiftool,
+    directory,
+    no_extended_attributes,
+    export_raw,
 ):
     """ Helper function for export that does the actual export
         photo: PhotoInfo object
@@ -1090,9 +1590,17 @@ def export_photo(
         export_live: boolean; also export live video component if photo is a live photo
                      live video will have same name as photo but with .mov extension
         download_missing: attempt download of missing iCloud photos
-        returns destination path of exported photo or None if photo was missing 
+        exiftool: use exiftool to write EXIF metadata directly to exported photo
+        directory: template used to determine output directory
+        no_extended_attributes: boolean; if True, exports photo without preserving extended attributes
+        export_raw: boolean; if True exports RAW image associate with the photo
+        returns list of path(s) of exported photo or None if photo was missing 
     """
 
+    # Can export to multiple paths
+    # Start with single path [dest] but direcotry and export_by_date will modify dest_paths
+    dest_paths = [dest]
+
     if not download_missing:
         if photo.ismissing:
             space = " " if not verbose else ""
@@ -1122,7 +1630,25 @@ def export_photo(
 
     if export_by_date:
         date_created = photo.date.timetuple()
-        dest = create_path_by_date(dest, date_created)
+        dest_path = create_path_by_date(dest, date_created)
+        dest_paths = [dest_path]
+    elif directory:
+        # got a directory template, render it and check results are valid
+        dirnames, unmatched = render_filepath_template(directory, photo)
+        if unmatched:
+            raise click.BadOptionUsage(
+                "directory",
+                f"Invalid substitution in template '{directory}': {unmatched}",
+            )
+        dest_paths = []
+        for dirname in dirnames:
+            dirname = sanitize_filepath(dirname, platform="auto")
+            if not is_valid_filepath(dirname, platform="auto"):
+                raise ValueError(f"Invalid file path: {dirname}")
+            dest_path = os.path.join(dest, dirname)
+            if not os.path.isdir(dest_path):
+                os.makedirs(dest_path)
+            dest_paths.append(dest_path)
 
     sidecar = [s.lower() for s in sidecar]
     sidecar_json = sidecar_xmp = False
@@ -1131,54 +1657,65 @@ def export_photo(
     if "xmp" in sidecar:
         sidecar_xmp = True
 
-    photo_path = photo.export(
-        dest,
-        filename,
-        sidecar_json=sidecar_json,
-        sidecar_xmp=sidecar_xmp,
-        overwrite=overwrite,
-        use_photos_export=download_missing,
+    # if download_missing and the photo is missing or path doesn't exist,
+    # try to download with Photos
+    use_photos_export = download_missing and (
+        photo.ismissing or not os.path.exists(photo.path)
     )
 
-    # if export-edited, also export the edited version
-    # verify the photo has adjustments and valid path to avoid raising an exception
-    if export_edited and photo.hasadjustments:
-        if download_missing or photo.path_edited is not None:
-            edited_name = pathlib.Path(filename)
-            edited_name = f"{edited_name.stem}_edited{edited_name.suffix}"
-            if verbose:
-                click.echo(f"Exporting edited version of {filename} as {edited_name}")
-            photo.export(
-                dest,
-                edited_name,
-                sidecar_json=sidecar_json,
-                sidecar_xmp=sidecar_xmp,
-                overwrite=overwrite,
-                edited=True,
-                use_photos_export=download_missing,
-            )
-        else:
-            click.echo(f"Skipping missing edited photo for {filename}")
+    # export the photo to each path in dest_paths
+    photo_paths = []
+    for dest_path in dest_paths:
+        photo_path = photo.export(
+            dest_path,
+            filename,
+            sidecar_json=sidecar_json,
+            sidecar_xmp=sidecar_xmp,
+            live_photo=export_live,
+            raw_photo=export_raw,
+            overwrite=overwrite,
+            use_photos_export=use_photos_export,
+            exiftool=exiftool,
+            no_xattr=no_extended_attributes,
+        )[0]
+        photo_paths.append(photo_path)
 
-    if export_live and photo.live_photo and photo.path_live_photo is not None:
-        # if destination exists, will be overwritten regardless of overwrite
-        # so that name matches name of live photo
-        live_name = pathlib.Path(photo_path)
-        live_name = f"{live_name.stem}.mov"
+        # if export-edited, also export the edited version
+        # verify the photo has adjustments and valid path to avoid raising an exception
+        if export_edited and photo.hasadjustments:
+            # if download_missing and the photo is missing or path doesn't exist,
+            # try to download with Photos
+            use_photos_export = download_missing and photo.path_edited is None
+            if not download_missing and photo.path_edited is None:
+                click.echo(f"Skipping missing edited photo for {filename}")
+            else:
+                edited_name = pathlib.Path(filename)
+                # check for correct edited suffix
+                if photo.path_edited is not None:
+                    edited_suffix = pathlib.Path(photo.path_edited).suffix
+                else:
+                    # use filename suffix which might be wrong,
+                    # will be corrected by use_photos_export
+                    edited_suffix = pathlib.Path(photo.filename).suffix
+                edited_name = f"{edited_name.stem}_edited{edited_suffix}"
+                if verbose:
+                    click.echo(
+                        f"Exporting edited version of {filename} as {edited_name}"
+                    )
+                photo.export(
+                    dest_path,
+                    edited_name,
+                    sidecar_json=sidecar_json,
+                    sidecar_xmp=sidecar_xmp,
+                    overwrite=overwrite,
+                    edited=True,
+                    use_photos_export=use_photos_export,
+                    exiftool=exiftool,
+                    no_xattr=no_extended_attributes,
+                )
 
-        src_live = photo.path_live_photo
-        dest_live = pathlib.Path(photo_path).parent / pathlib.Path(live_name)
-
-        if src_live is not None:
-            if verbose:
-                click.echo(f"Exporting live photo video of {filename} as {live_name}")
-
-            _copy_file(src_live, str(dest_live))
-        else:
-            click.echo(f"Skipping missing live movie for {filename}")
-
-    return photo_path
+    return photo_paths
 
 
 if __name__ == "__main__":
-    cli()
+    cli()  # pylint: disable=no-value-for-parameter

osxphotos/_constants.py

@@ -13,8 +13,12 @@ import os.path
 # TODO: Should this also use compatibleBackToVersion from LiGlobals?
 _TESTED_DB_VERSIONS = ["6000", "4025", "4016", "3301", "2622"]
 
-# versions later than this have a different database structure
-_PHOTOS_5_VERSION = "6000"
+# only version 3 - 4 have RKVersion.selfPortrait
+_PHOTOS_3_VERSION = "3301"
+
+# versions 5.0 and later have a different database structure
+_PHOTOS_4_VERSION = "4025"  # latest Mojove version on 10.14.6
+_PHOTOS_5_VERSION = "6000"  # seems to be current on 10.15.1 through 10.15.4
 
 # which major version operating systems have been tested
 _TESTED_OS_VERSIONS = ["12", "13", "14", "15"]
@@ -22,6 +26,9 @@ _TESTED_OS_VERSIONS = ["12", "13", "14", "15"]
 # Photos 5 has persons who are empty string if unidentified face
 _UNKNOWN_PERSON = "_UNKNOWN_"
 
+# photos with no reverse geolocation info (place)
+_UNKNOWN_PLACE = "_UNKNOWN_"
+
 _EXIF_TOOL_URL = "https://exiftool.org/"
 
 # Where are shared iCloud photos located?
@@ -34,3 +41,13 @@ _MOVIE_TYPE = 1
 # Name of XMP template file
 _TEMPLATE_DIR = os.path.join(os.path.dirname(__file__), "templates")
 _XMP_TEMPLATE_NAME = "xmp_sidecar.mako"
+
+# Constants used for processing folders and albums
+_PHOTOS_5_ALBUM_KIND = 2  # normal user album
+_PHOTOS_5_SHARED_ALBUM_KIND = 1505  # shared album
+_PHOTOS_5_FOLDER_KIND = 4000  # user folder
+_PHOTOS_5_ROOT_FOLDER_KIND = 3999  # root folder
+
+_PHOTOS_4_ALBUM_KIND = 3  # RKAlbum.albumSubclass
+_PHOTOS_4_TOP_LEVEL_ALBUM = "TopLevelAlbums"
+_PHOTOS_4_ROOT_FOLDER = "LibraryFolder"

osxphotos/_version.py

@@ -1,3 +1,3 @@
 """ version info """
 
-__version__ = "0.22.9"
+__version__ = "0.28.2"

osxphotos/albuminfo.py

@@ -0,0 +1,211 @@
+"""
+AlbumInfo and FolderInfo classes for dealing with albums and folders
+
+AlbumInfo class
+Represents a single Album in the Photos library and provides access to the album's attributes
+PhotosDB.albums() returns a list of AlbumInfo objects
+
+FolderInfo class
+Represents a single Folder in the Photos library and provides access to the folders attributes
+PhotosDB.folders() returns a list of FolderInfo objects
+"""
+
+import logging
+
+from ._constants import (
+    _PHOTOS_4_ALBUM_KIND,
+    _PHOTOS_4_TOP_LEVEL_ALBUM,
+    _PHOTOS_4_VERSION,
+    _PHOTOS_5_ALBUM_KIND,
+    _PHOTOS_5_FOLDER_KIND,
+)
+
+
+class AlbumInfo:
+    """
+    Info about a specific Album, contains all the details about the album
+    including folders, photos, etc.
+    """
+
+    def __init__(self, db=None, uuid=None):
+        self._uuid = uuid
+        self._db = db
+        self._title = self._db._dbalbum_details[uuid]["title"]
+
+    @property
+    def title(self):
+        """ return title / name of album """
+        return self._title
+
+    @property
+    def uuid(self):
+        """ return uuid of album """
+        return self._uuid
+
+    @property
+    def photos(self):
+        """ return list of photos contained in album """
+        try:
+            return self._photos
+        except AttributeError:
+            uuid = self._db._dbalbums_album[self._uuid]
+            self._photos = self._db.photos(uuid=uuid)
+            return self._photos
+
+    @property
+    def folder_names(self):
+        """ return hierarchical list of folders the album is contained in
+            the folder list is in form:
+            ["Top level folder", "sub folder 1", "sub folder 2", ...]
+            returns empty list if album is not in any folders """
+
+        try:
+            return self._folder_names
+        except AttributeError:
+            if self._db._db_version <= _PHOTOS_4_VERSION:
+                self._folder_names = self._db._album_folder_hierarchy_list(self._uuid)
+            else:
+                self._folder_names = self._db._album_folder_hierarchy_list(self._uuid)
+            return self._folder_names
+
+    @property
+    def folder_list(self):
+        """ return hierarchical list of folders the album is contained in
+            as list of FolderInfo objects in form 
+            ["Top level folder", "sub folder 1", "sub folder 2", ...]
+            returns empty list if album is not in any folders """
+
+        try:
+            return self._folders
+        except AttributeError:
+            self._folders = self._db._album_folder_hierarchy_folderinfo(self._uuid)
+            return self._folders
+
+    @property
+    def parent(self):
+        """ returns FolderInfo object for parent folder or None if no parent (e.g. top-level album) """
+        try:
+            return self._parent
+        except AttributeError:
+            if self._db._db_version <= _PHOTOS_4_VERSION:
+                parent_uuid = self._db._dbalbum_details[self._uuid]["folderUuid"]
+                self._parent = (
+                    FolderInfo(db=self._db, uuid=parent_uuid)
+                    if parent_uuid != _PHOTOS_4_TOP_LEVEL_ALBUM
+                    else None
+                )
+            else:
+                parent_pk = self._db._dbalbum_details[self._uuid]["parentfolder"]
+                self._parent = (
+                    FolderInfo(db=self._db, uuid=self._db._dbalbums_pk[parent_pk])
+                    if parent_pk != self._db._folder_root_pk
+                    else None
+                )
+            return self._parent
+
+    def __len__(self):
+        """ return number of photos contained in album """
+        return len(self.photos)
+
+
+class FolderInfo:
+    """
+    Info about a specific folder, contains all the details about the folder 
+    including folders, albums, etc
+    """
+
+    def __init__(self, db=None, uuid=None):
+        self._uuid = uuid
+        self._db = db
+        if self._db._db_version <= _PHOTOS_4_VERSION:
+            self._pk = None
+            self._title = self._db._dbfolder_details[uuid]["name"]
+        else:
+            self._pk = self._db._dbalbum_details[uuid]["pk"]
+            self._title = self._db._dbalbum_details[uuid]["title"]
+
+    @property
+    def title(self):
+        """ return title / name of folder"""
+        return self._title
+
+    @property
+    def uuid(self):
+        """ return uuid of folder """
+        return self._uuid
+
+    @property
+    def album_info(self):
+        """ return list of albums (as AlbumInfo objects) contained in the folder """
+        try:
+            return self._albums
+        except AttributeError:
+            if self._db._db_version <= _PHOTOS_4_VERSION:
+                albums = [
+                    AlbumInfo(db=self._db, uuid=album)
+                    for album, detail in self._db._dbalbum_details.items()
+                    if not detail["intrash"]
+                    and detail["albumSubclass"] == _PHOTOS_4_ALBUM_KIND
+                    and detail["folderUuid"] == self._uuid
+                ]
+            else:
+                albums = [
+                    AlbumInfo(db=self._db, uuid=album)
+                    for album, detail in self._db._dbalbum_details.items()
+                    if not detail["intrash"]
+                    and detail["kind"] == _PHOTOS_5_ALBUM_KIND
+                    and detail["parentfolder"] == self._pk
+                ]
+            self._albums = albums
+            return self._albums
+
+    @property
+    def parent(self):
+        """ returns FolderInfo object for parent or None if no parent (e.g. top-level folder) """
+        try:
+            return self._parent
+        except AttributeError:
+            if self._db._db_version <= _PHOTOS_4_VERSION:
+                parent_uuid = self._db._dbfolder_details[self._uuid]["parentFolderUuid"]
+                self._parent = (
+                    FolderInfo(db=self._db, uuid=parent_uuid)
+                    if parent_uuid != _PHOTOS_4_TOP_LEVEL_ALBUM
+                    else None
+                )
+            else:
+                parent_pk = self._db._dbalbum_details[self._uuid]["parentfolder"]
+                self._parent = (
+                    FolderInfo(db=self._db, uuid=self._db._dbalbums_pk[parent_pk])
+                    if parent_pk != self._db._folder_root_pk
+                    else None
+                )
+            return self._parent
+
+    @property
+    def subfolders(self):
+        """ return list of folders (as FolderInfo objects) contained in the folder """
+        try:
+            return self._folders
+        except AttributeError:
+            if self._db._db_version <= _PHOTOS_4_VERSION:
+                folders = [
+                    FolderInfo(db=self._db, uuid=folder)
+                    for folder, detail in self._db._dbfolder_details.items()
+                    if not detail["intrash"]
+                    and not detail["isMagic"]
+                    and detail["parentFolderUuid"] == self._uuid
+                ]
+            else:
+                folders = [
+                    FolderInfo(db=self._db, uuid=album)
+                    for album, detail in self._db._dbalbum_details.items()
+                    if not detail["intrash"]
+                    and detail["kind"] == _PHOTOS_5_FOLDER_KIND
+                    and detail["parentfolder"] == self._pk
+                ]
+            self._folders = folders
+            return self._folders
+
+    def __len__(self):
+        """ returns count of folders + albums contained in the folder """
+        return len(self.subfolders) + len(self.album_info)

osxphotos/exiftool.py

@@ -0,0 +1,251 @@
+""" Yet another simple exiftool wrapper 
+    I rolled my own for following reasons: 
+    1. I wanted something under MIT license (best alternative was licensed under GPL/BSD)
+    2. I wanted singleton behavior so only a single exiftool process was ever running
+    If these aren't important to you, I highly recommend you use Sven Marnach's excellent 
+    pyexiftool: https://github.com/smarnach/pyexiftool which provides more functionality """
+
+import json
+import logging
+import os
+import subprocess
+import sys
+from functools import lru_cache # pylint: disable=syntax-error
+
+from .utils import _debug
+
+# exiftool -stay_open commands outputs this EOF marker after command is run
+EXIFTOOL_STAYOPEN_EOF = "{ready}"
+EXIFTOOL_STAYOPEN_EOF_LEN = len(EXIFTOOL_STAYOPEN_EOF)
+
+
+@lru_cache(maxsize=1)
+def get_exiftool_path():
+    """ return path of exiftool, cache result """
+    result = subprocess.run(["which", "exiftool"], stdout=subprocess.PIPE)
+    exiftool_path = result.stdout.decode("utf-8")
+    if _debug():
+        logging.debug("exiftool path = %s" % (exiftool_path))
+    if exiftool_path:
+        return exiftool_path.rstrip()
+    else:
+        raise FileNotFoundError(
+            "Could not find exiftool. Please download and install from "
+            "https://exiftool.org/"
+        )
+
+
+class _ExifToolProc:
+    """ Runs exiftool in a subprocess via Popen
+        Creates a singleton object """
+
+    def __new__(cls, *args, **kwargs):
+        """ create new object or return instance of already created singleton """
+        if not hasattr(cls, "instance") or not cls.instance:
+            cls.instance = super().__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, exiftool=None):
+        """ construct _ExifToolProc singleton object or return instance of already created object
+            exiftool: optional path to exiftool binary (if not provided, will search path to find it) """
+
+        if hasattr(self, "_process_running") and self._process_running:
+            # already running
+            if exiftool is not None:
+                logging.warning(
+                    f"exiftool subprocess already running, "
+                    f"ignoring exiftool={exiftool}"
+                )
+            return
+
+        if exiftool:
+            self._exiftool = exiftool
+        else:
+            self._exiftool = get_exiftool_path()
+
+        self._process_running = False
+        self._start_proc()
+
+    @property
+    def process(self):
+        """ return the exiftool subprocess """
+        if self._process_running:
+            return self._process
+        else:
+            raise ValueError("exiftool process is not running")
+
+    @property
+    def pid(self):
+        """ return process id (PID) of the exiftool process """
+        return self._process.pid
+
+    @property
+    def exiftool(self):
+        """ return path to exiftool process """
+        return self._exiftool
+
+    def _start_proc(self):
+        """ start exiftool in batch mode """
+
+        if self._process_running:
+            logging.warning("exiftool already running: {self._process}")
+            return
+
+        # open exiftool process
+        self._process = subprocess.Popen(
+            [
+                self._exiftool,
+                "-stay_open",  # keep process open in batch mode
+                "True",  # -stay_open=True, keep process open in batch mode
+                "-@",  # read command-line arguments from file
+                "-",  # read from stdin
+                "-common_args",  # specifies args common to all commands subsequently run
+                "-n",  # no print conversion (e.g. print tag values in machine readable format)
+                "-G",  # print group name for each tag
+            ],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.DEVNULL,
+        )
+        self._process_running = True
+
+    def _stop_proc(self):
+        """ stop the exiftool process if it's running, otherwise, do nothing """
+        if not self._process_running:
+            logging.warning("exiftool process is not running")
+            return
+
+        self._process.stdin.write(b"-stay_open\n")
+        self._process.stdin.write(b"False\n")
+        self._process.stdin.flush()
+        try:
+            self._process.communicate(timeout=5)
+        except subprocess.TimeoutExpired:
+            logging.warning(
+                f"exiftool pid {self._process.pid} did not exit, killing it"
+            )
+            self._process.kill()
+            self._process.communicate()
+
+        del self._process
+        self._process_running = False
+
+    def __del__(self):
+        self._stop_proc()
+
+
+class ExifTool:
+    """ Basic exiftool interface for reading and writing EXIF tags """
+
+    def __init__(self, filepath, exiftool=None, overwrite=True):
+        """ Return ExifTool object
+            file: path to image file
+            exiftool: path to exiftool, if not specified will look in path
+            overwrite: if True, will overwrite image file without creating backup, default=False """
+        self.file = filepath
+        self.overwrite = overwrite
+        self.data = {}
+        self._exiftoolproc = _ExifToolProc(exiftool=exiftool)
+        self._process = self._exiftoolproc.process
+        self._read_exif()
+
+    def setvalue(self, tag, value):
+        """ Set tag to value(s) 
+            if value is None, will delete tag """
+
+        if value is None:
+            value = ""
+        command = []
+        command.append(f"-{tag}={value}")
+        if self.overwrite:
+            command.append("-overwrite_original")
+        self.run_commands(*command)
+
+    def addvalues(self, tag, *values):
+        """ Add one or more value(s) to tag
+            If more than one value is passed, each value will be added to the tag
+            Notes: exiftool may add duplicate values for some tags so the caller must ensure
+                   the values being added are not already in the EXIF data
+                   For some tags, such as IPTC:Keywords, this will add a new value to the list of keywords, 
+                   but for others, such as EXIF:ISO, this will literally add a value to the existing value.
+                   It's up to the caller to know what exiftool will do for each tag
+                   If setvalue called before addvalues, exiftool does not appear to add duplicates, 
+                   but if addvalues called without first calling setvalue, exiftool will add duplicate values
+        """
+        if not values:
+            raise ValueError("Must pass at least one value")
+
+        command = []
+        for value in values:
+            if value is None:
+                raise ValueError("Can't add None value to tag")
+            command.append(f"-{tag}+={value}")
+
+        if self.overwrite:
+            command.append("-overwrite_original")
+
+        if command:
+            self.run_commands(*command)
+
+    def run_commands(self, *commands, no_file=False):
+        """ run commands in the exiftool process and return result 
+            no_file: (bool) do not pass the filename to exiftool (default=False)
+                     by default, all commands will be run against self.file
+                     use no_file=True to run a command without passing the filename """
+        if not hasattr(self, "_process") or not self._process:
+            raise ValueError("exiftool process is not running")
+
+        if not commands:
+            raise TypeError("must provide one or more command to run")
+
+        filename = os.fsencode(self.file) if not no_file else b""
+        command_str = (
+            b"\n".join([c.encode("utf-8") for c in commands])
+            + b"\n"
+            + filename
+            + b"\n"
+            + b"-execute\n"
+        )
+
+        if _debug():
+            logging.debug(command_str)
+
+        # send the command
+        self._process.stdin.write(command_str)
+        self._process.stdin.flush()
+
+        # read the output
+        output = b""
+        while EXIFTOOL_STAYOPEN_EOF not in str(output):
+            output += self._process.stdout.readline().strip()
+        return output[:-EXIFTOOL_STAYOPEN_EOF_LEN]
+
+    @property
+    def pid(self):
+        """ return process id (PID) of the exiftool process """
+        return self._process.pid
+
+    @property
+    def version(self):
+        """ returns exiftool version """
+        ver = self.run_commands("-ver", no_file=True)
+        return ver.decode("utf-8")
+
+    def json(self):
+        """ return JSON dictionary from exiftool as dict """
+        json_str = self.run_commands("-json")
+        if json_str:
+            return json.loads(json_str)
+        else:
+            return None
+
+    def _read_exif(self):
+        """ read exif data from file """
+        json = self.json()
+        self.data = {k: v for k, v in json[0].items()}
+
+    def __str__(self):
+        str_ = f"file: {self.file}\nexiftool: {self._exiftoolproc._exiftool}"
+        return str_
+

osxphotos/photoinfo.py

@@ -21,16 +21,21 @@ from mako.template import Template
 from ._constants import (
     _MOVIE_TYPE,
     _PHOTO_TYPE,
+    _PHOTOS_4_VERSION,
     _PHOTOS_5_SHARED_PHOTO_PATH,
-    _PHOTOS_5_VERSION,
     _TEMPLATE_DIR,
     _XMP_TEMPLATE_NAME,
 )
+from .exiftool import ExifTool
+from .placeinfo import PlaceInfo4, PlaceInfo5
+from .albuminfo import AlbumInfo
 from .utils import (
     _copy_file,
     _export_photo_uuid_applescript,
     _get_resource_loc,
     dd_to_dms_str,
+    findfiles,
+    get_preferred_uti_extension,
 )
 
 
@@ -93,7 +98,7 @@ class PhotoInfo:
         if self._info["isMissing"] == 1:
             return photopath  # path would be meaningless until downloaded
 
-        if self._db._db_version < _PHOTOS_5_VERSION:
+        if self._db._db_version <= _PHOTOS_4_VERSION:
             vol = self._info["volume"]
             if vol is not None:
                 photopath = os.path.join("/Volumes", vol, self._info["imagePath"])
@@ -114,8 +119,6 @@ class PhotoInfo:
             )
             return photopath
 
-        # if self._info["masterFingerprint"]:
-        # if masterFingerprint is not null, path appears to be valid
         if self._info["directory"].startswith("/"):
             photopath = os.path.join(self._info["directory"], self._info["filename"])
         else:
@@ -124,13 +127,6 @@ class PhotoInfo:
             )
         return photopath
 
-        # if all else fails, photopath = None
-        # photopath = None
-        # logging.debug(
-        #     f"WARNING: photopath None, masterFingerprint null, not shared {pformat(self._info)}"
-        # )
-        # return photopath
-
     @property
     def path_edited(self):
         """ absolute path on disk of the edited picture """
@@ -141,7 +137,7 @@ class PhotoInfo:
 
         photopath = None
 
-        if self._db._db_version < _PHOTOS_5_VERSION:
+        if self._db._db_version <= _PHOTOS_4_VERSION:
             if self._info["hasAdjustments"]:
                 edit_id = self._info["edit_resource_id"]
                 if edit_id is not None:
@@ -245,6 +241,75 @@ class PhotoInfo:
 
         return photopath
 
+    @property
+    def path_raw(self):
+        """ absolute path of associated RAW image or None if there is not one """
+
+        # In Photos 5, raw is in same folder as original but with _4.ext
+        # Unless "Copy Items to the Photos Library" is not checked
+        # then RAW image is not renamed but has same name is jpeg buth with raw extension
+        # Current implementation uses findfiles to find images with the correct raw UTI extension
+        # in same folder as the original and with same stem as original in form: original_stem*.raw_ext
+        # TODO: I don't like this -- would prefer a more deterministic approach but until I have more
+        # data on how Photos stores and retrieves RAW images, this seems to be working
+
+        if self._info["isMissing"] == 1:
+            return None  # path would be meaningless until downloaded
+
+        if not self.has_raw:
+            return None  # no raw image to get path for
+
+        # if self._info["shared"]:
+        #     # shared photo
+        #     photopath = os.path.join(
+        #         self._db._library_path,
+        #         _PHOTOS_5_SHARED_PHOTO_PATH,
+        #         self._info["directory"],
+        #         self._info["filename"],
+        #     )
+        #     return photopath
+
+        if self._db._db_version <= _PHOTOS_4_VERSION:
+            vol = self._info["raw_info"]["volume"]
+            if vol is not None:
+                photopath = os.path.join(
+                    "/Volumes", vol, self._info["raw_info"]["imagePath"]
+                )
+            else:
+                photopath = os.path.join(
+                    self._db._masters_path, self._info["raw_info"]["imagePath"]
+                )
+            if not os.path.isfile(photopath):
+                logging.debug(
+                    f"MISSING PATH: RAW photo for UUID {self._uuid} should be at {photopath} but does not appear to exist"
+                )
+                photopath = None
+        else:
+            filestem = pathlib.Path(self._info["filename"]).stem
+            raw_ext = get_preferred_uti_extension(self._info["UTI_raw"])
+
+            if self._info["directory"].startswith("/"):
+                filepath = self._info["directory"]
+            else:
+                filepath = os.path.join(self._db._masters_path, self._info["directory"])
+
+            glob_str = f"{filestem}*.{raw_ext}"
+            raw_file = findfiles(glob_str, filepath)
+            if len(raw_file) != 1:
+                logging.warning(
+                    f"Error getting path to RAW file: {filepath}/{glob_str}"
+                )
+                photopath = None
+            else:
+                photopath = os.path.join(filepath, raw_file[0])
+                if not os.path.isfile(photopath):
+                    logging.debug(
+                        f"MISSING PATH: RAW photo for UUID {self._uuid} should be at {photopath} but does not appear to exist"
+                    )
+                    photopath = None
+
+        return photopath
+
     @property
     def description(self):
         """ long / extended description of picture """
@@ -260,7 +325,18 @@ class PhotoInfo:
         """ list of albums picture is contained in """
         albums = []
         for album in self._info["albums"]:
-            albums.append(self._db._dbalbum_details[album]["title"])
+            if not self._db._dbalbum_details[album]["intrash"]:
+                albums.append(self._db._dbalbum_details[album]["title"])
+        return albums
+
+    @property
+    def album_info(self):
+        """ list of AlbumInfo objects representing albums the photos is contained in """
+        albums = []
+        for album in self._info["albums"]:
+            if not self._db._dbalbum_details[album]["intrash"]:
+                albums.append(AlbumInfo(db=self._db, uuid=album))
+
         return albums
 
     @property
@@ -324,7 +400,7 @@ class PhotoInfo:
     def shared(self):
         """ returns True if photos is in a shared iCloud album otherwise false
             Only valid on Photos 5; returns None on older versions """
-        if self._db._db_version >= _PHOTOS_5_VERSION:
+        if self._db._db_version > _PHOTOS_4_VERSION:
             return self._info["shared"]
         else:
             return None
@@ -336,6 +412,14 @@ class PhotoInfo:
         """
         return self._info["UTI"]
 
+    @property
+    def uti_raw(self):
+        """ Returns Uniform Type Identifier (UTI) for the RAW image if there is one
+            for example: com.canon.cr2-raw-image
+            Returns None if no associated RAW image
+        """
+        return self._info["UTI_raw"]
+
     @property
     def ismovie(self):
         """ Returns True if file is a movie, otherwise False
@@ -361,7 +445,7 @@ class PhotoInfo:
         """ Returns True if photo is a cloud asset (in an iCloud library),
             otherwise False 
         """
-        if self._db._db_version < _PHOTOS_5_VERSION:
+        if self._db._db_version <= _PHOTOS_4_VERSION:
             return (
                 True
                 if self._info["cloudLibraryState"] is not None
@@ -404,7 +488,7 @@ class PhotoInfo:
             If photo is missing, returns None """
 
         photopath = None
-        if self._db._db_version < _PHOTOS_5_VERSION:
+        if self._db._db_version <= _PHOTOS_4_VERSION:
             if self.live_photo and not self.ismissing:
                 live_model_id = self._info["live_model_id"]
                 if live_model_id == None:
@@ -453,23 +537,110 @@ class PhotoInfo:
 
         return photopath
 
+    @property
+    def panorama(self):
+        """ Returns True if photo is a panorama, otherwise False """
+        return self._info["panorama"]
+
+    @property
+    def slow_mo(self):
+        """ Returns True if photo is a slow motion video, otherwise False """
+        return self._info["slow_mo"]
+
+    @property
+    def time_lapse(self):
+        """ Returns True if photo is a time lapse video, otherwise False """
+        return self._info["time_lapse"]
+
+    @property
+    def hdr(self):
+        """ Returns True if photo is an HDR photo, otherwise False """
+        return self._info["hdr"]
+
+    @property
+    def screenshot(self):
+        """ Returns True if photo is an HDR photo, otherwise False """
+        return self._info["screenshot"]
+
+    @property
+    def portrait(self):
+        """ Returns True if photo is a portrait, otherwise False """
+        return self._info["portrait"]
+
+    @property
+    def selfie(self):
+        """ Returns True if photo is a selfie (front facing camera), otherwise False """
+        return self._info["selfie"]
+
+    @property
+    def place(self):
+        """ Returns PlaceInfo object containing reverse geolocation info """
+
+        # implementation note: doesn't create the PlaceInfo object until requested
+        # then memoizes the object in self._place to avoid recreating the object
+
+        if self._db._db_version <= _PHOTOS_4_VERSION:
+            try:
+                return self._place  # pylint: disable=access-member-before-definition
+            except AttributeError:
+                if self._info["placeNames"]:
+                    self._place = PlaceInfo4(
+                        self._info["placeNames"], self._info["countryCode"]
+                    )
+                else:
+                    self._place = None
+                return self._place
+        else:
+            try:
+                return self._place  # pylint: disable=access-member-before-definition
+            except AttributeError:
+                if self._info["reverse_geolocation"]:
+                    self._place = PlaceInfo5(self._info["reverse_geolocation"])
+                else:
+                    self._place = None
+                return self._place
+
+    @property
+    def has_raw(self):
+        """ returns True if photo has an associated RAW image, otherwise False """
+        return self._info["has_raw"]
+
+    @property
+    def raw_original(self):
+        """ returns True if associated RAW image and the RAW image is selected in Photos
+            via "Use RAW as Original "
+            otherwise returns False """
+        return True if self._info["original_resource_choice"] == 1 else False
+
     def export(
         self,
         dest,
         *filename,
         edited=False,
+        live_photo=False,
+        raw_photo=False,
         overwrite=False,
         increment=True,
         sidecar_json=False,
         sidecar_xmp=False,
         use_photos_export=False,
         timeout=120,
+        exiftool=False,
+        no_xattr=False,
     ):
         """ export photo 
             dest: must be valid destination path (or exception raised) 
-            filename: (optional): name of picture; if not provided, will use current filename 
+            filename: (optional): name of exported picture; if not provided, will use current filename 
+                      **NOTE**: if provided, user must ensure file extension (suffix) is correct. 
+                      For example, if photo is .CR2 file, edited image may be .jpeg.  
+                      If you provide an extension different than what the actual file is, 
+                      export will print a warning but will happily export the photo using the 
+                      incorrect file extension.  e.g. to get the extension of the edited photo, 
+                      reference PhotoInfo.path_edited
             edited: (boolean, default=False); if True will export the edited version of the photo 
                     (or raise exception if no edited version) 
+            live_photo: (boolean, default=False); if True, will also export the associted .mov for live photos
+            raw_photo: (boolean, default=False); if True, will also export the associted RAW photo
             overwrite: (boolean, default=False); if True will overwrite files if they alreay exist 
             increment: (boolean, default=True); if True, will increment file name until a non-existant name is found 
                        if overwrite=False and increment=False, export will fail if destination file already exists 
@@ -479,10 +650,19 @@ class PhotoInfo:
                       sidecar filename will be dest/filename.xmp 
             use_photos_export: (boolean, default=False); if True will attempt to export photo via applescript interaction with Photos
             timeout: (int, default=120) timeout in seconds used with use_photos_export
-            returns the full path to the exported file """
+            exiftool: (boolean, default = False); if True, will use exiftool to write metadata to export file
+            no_xattr: (boolean, default = False); if True, exports file without preserving extended attributes
+            returns list of full paths to the exported files """
 
-        # TODO: add this docs:
-        #  ( for jpeg in *.jpeg; do exiftool -v -json=$jpeg.json $jpeg; done )
+        # list of all files exported during this call to export
+        exported_files = []
+
+        # check edited and raise exception trying to export edited version of
+        # photo that hasn't been edited
+        if edited and not self.hasadjustments:
+            raise ValueError(
+                "Photo does not have adjustments, cannot export edited version"
+            )
 
         # check arguments and get destination path and filename (if provided)
         if filename and len(filename) > 2:
@@ -497,13 +677,13 @@ class PhotoInfo:
                 raise FileNotFoundError("Invalid path passed to export")
 
             if filename and len(filename) == 1:
-                # second arg is filename of picture
-                filename = filename[0]
+                # if filename passed, use it
+                fname = filename[0]
             else:
                 # no filename provided so use the default
                 # if edited file requested, use filename but add _edited
                 # need to use file extension from edited file as Photos saves a jpeg once edited
-                if edited:
+                if edited and not use_photos_export:
                     # verify we have a valid path_edited and use that to get filename
                     if not self.path_edited:
                         raise FileNotFoundError(
@@ -512,16 +692,38 @@ class PhotoInfo:
                         )
                     edited_name = pathlib.Path(self.path_edited).name
                     edited_suffix = pathlib.Path(edited_name).suffix
-                    filename = (
-                        pathlib.Path(self.filename).stem + "_edited" + edited_suffix
-                    )
+                    fname = pathlib.Path(self.filename).stem + "_edited" + edited_suffix
                 else:
-                    filename = self.filename
+                    fname = self.filename
 
         # check destination path
         dest = pathlib.Path(dest)
-        filename = pathlib.Path(filename)
-        dest = dest / filename
+        fname = pathlib.Path(fname)
+        dest = dest / fname
+
+        # check extension of destination
+        if edited and self.path_edited is not None:
+            # use suffix from edited file
+            actual_suffix = pathlib.Path(self.path_edited).suffix
+        elif edited:
+            # use .jpeg as that's probably correct
+            # if edited and path_edited is None, will raise FileNotFoundError below
+            # unless use_photos_export is True
+            actual_suffix = ".jpeg"
+        else:
+            # use suffix from the non-edited file
+            actual_suffix = pathlib.Path(self.filename).suffix
+
+        # warn if suffixes don't match but ignore .JPG / .jpeg as
+        # Photo's often converts .JPG to .jpeg
+        suffixes = sorted([x.lower() for x in [dest.suffix, actual_suffix]])
+        if dest.suffix.lower() != actual_suffix.lower() and suffixes != [
+            ".jpeg",
+            ".jpg",
+        ]:
+            logging.warning(
+                f"Invalid destination suffix: {dest.suffix}, should be {actual_suffix}"
+            )
 
         # check to see if file exists and if so, add (1), (2), etc until we find one that works
         # Photos checks the stem and adds (1), (2), etc which avoids collision with sidecars
@@ -550,16 +752,11 @@ class PhotoInfo:
             # get path to source file and verify it's not None and is valid file
             # TODO: how to handle ismissing or not hasadjustments and edited=True cases?
             if edited:
-                if not self.hasadjustments:
-                    logging.warning(
-                        "Attempting to export edited photo but hasadjustments=False"
-                    )
-
                 if self.path_edited is not None:
                     src = self.path_edited
                 else:
                     raise FileNotFoundError(
-                        f"edited=True but path_edited is none; hasadjustments: {self.hasadjustments}"
+                        f"Cannot export edited photo if path_edited is None"
                     )
             else:
                 if self.ismissing:
@@ -567,13 +764,10 @@ class PhotoInfo:
                         f"Attempting to export photo with ismissing=True: path = {self.path}"
                     )
 
-                if self.path is None:
-                    logging.warning(
-                        f"Attempting to export photo but path is None: ismissing = {self.ismissing}"
-                    )
-                    raise FileNotFoundError("Cannot export photo if path is None")
-                else:
+                if self.path is not None:
                     src = self.path
+                else:
+                    raise FileNotFoundError("Cannot export photo if path is None")
 
             if not os.path.isfile(src):
                 raise FileNotFoundError(f"{src} does not appear to exist")
@@ -583,23 +777,81 @@ class PhotoInfo:
             )
 
             # copy the file, _copy_file uses ditto to preserve Mac extended attributes
-            _copy_file(src, dest)
+            _copy_file(src, dest, norsrc=no_xattr)
+            exported_files.append(str(dest))
+
+            # copy live photo associated .mov if requested
+            if live_photo and self.live_photo:
+                live_name = dest.parent / f"{dest.stem}.mov"
+                src_live = self.path_live_photo
+
+                if src_live is not None:
+                    logging.debug(
+                        f"Exporting live photo video of {filename} as {live_name.name}"
+                    )
+                    _copy_file(src_live, str(live_name), norsrc=no_xattr)
+                    exported_files.append(str(live_name))
+                else:
+                    logging.warning(f"Skipping missing live movie for {filename}")
+
+            # copy associated RAW image if requested
+            if raw_photo and self.has_raw:
+                raw_path = pathlib.Path(self.path_raw)
+                raw_ext = raw_path.suffix
+                raw_name = dest.parent / f"{dest.stem}{raw_ext}"
+                if raw_path is not None:
+                    logging.debug(
+                        f"Exporting RAW photo of {filename} as {raw_name.name}"
+                    )
+                    _copy_file(str(raw_path), str(raw_name), norsrc=no_xattr)
+                    exported_files.append(str(raw_name))
+                else:
+                    logging.warning(f"Skipping missing RAW photo for {filename}")
         else:
             # use_photo_export
             exported = None
+            # export live_photo .mov file?
+            live_photo = True if live_photo and self.live_photo else False
             if edited:
                 # exported edited version and not original
+                if filename:
+                    # use filename stem provided
+                    filestem = dest.stem
+                else:
+                    # didn't get passed a filename, add _edited
+                    filestem = f"{dest.stem}_edited"
+                    dest = dest.parent / f"{filestem}.jpeg"
+
                 exported = _export_photo_uuid_applescript(
-                    self.uuid, dest, original=False, edited=True, timeout=timeout
+                    self.uuid,
+                    dest.parent,
+                    filestem=filestem,
+                    original=False,
+                    edited=True,
+                    live_photo=live_photo,
+                    timeout=timeout,
+                    burst=self.burst,
                 )
             else:
                 # export original version and not edited
+                filestem = dest.stem
                 exported = _export_photo_uuid_applescript(
-                    self.uuid, dest, original=True, edited=False, timeout=timeout
+                    self.uuid,
+                    dest.parent,
+                    filestem=filestem,
+                    original=True,
+                    edited=False,
+                    live_photo=live_photo,
+                    timeout=timeout,
+                    burst=self.burst,
                 )
 
-            if exported is None:
-                logging.warning(f"Error exporting photo {self.uuid} to {dest}")
+            if exported is not None:
+                exported_files.extend(exported)
+            else:
+                logging.warning(
+                    f"Error exporting photo {self.uuid} to {dest} with use_photos_export"
+                )
 
         if sidecar_json:
             logging.debug("writing exiftool_json_sidecar")
@@ -621,7 +873,29 @@ class PhotoInfo:
                 logging.warning(f"Error writing xmp sidecar to {sidecar_filename}")
                 raise e
 
-        return str(dest)
+        # if exiftool, write the metadata
+        if exiftool and exported_files:
+            for exported_file in exported_files:
+                self._write_exif_data(exported_file)
+
+        return exported_files
+
+    def _write_exif_data(self, filepath):
+        """ write exif data to image file at filepath
+        filepath: full path to the image file """
+        if not os.path.exists(filepath):
+            raise FileNotFoundError(f"Could not find file {filepath}")
+        exiftool = ExifTool(filepath)
+        exif_info = json.loads(self._exiftool_json_sidecar())[0]
+        for exiftag, val in exif_info.items():
+            if type(val) == list:
+                # more than one, set first value the add additional values
+                exiftool.setvalue(exiftag, val.pop(0))
+                if val:
+                    # add any remaining items
+                    exiftool.addvalues(exiftag, *val)
+            else:
+                exiftool.setvalue(exiftag, val)
 
     def _exiftool_json_sidecar(self):
         """ return json string of EXIF details in exiftool sidecar format
@@ -644,27 +918,26 @@ class PhotoInfo:
 
         exif = {}
         exif["_CreatedBy"] = "osxphotos, https://github.com/RhetTbull/osxphotos"
-        exif["FileName"] = self.filename
 
         if self.description:
-            exif["ImageDescription"] = self.description
-            exif["Description"] = self.description
+            exif["EXIF:ImageDescription"] = self.description
+            exif["XMP:Description"] = self.description
 
         if self.title:
-            exif["Title"] = self.title
+            exif["XMP:Title"] = self.title
 
         if self.keywords:
-            exif["TagsList"] = exif["Keywords"] = list(self.keywords)
+            exif["XMP:TagsList"] = exif["IPTC:Keywords"] = list(self.keywords)
             # Photos puts both keywords and persons in Subject when using "Export IPTC as XMP"
-            exif["Subject"] = list(self.keywords)
+            exif["XMP:Subject"] = list(self.keywords)
 
         if self.persons:
-            exif["PersonInImage"] = self.persons
+            exif["XMP:PersonInImage"] = self.persons
             # Photos puts both keywords and persons in Subject when using "Export IPTC as XMP"
-            if "Subject" in exif:
-                exif["Subject"].extend(self.persons)
+            if "XMP:Subject" in exif:
+                exif["XMP:Subject"].extend(self.persons)
             else:
-                exif["Subject"] = self.persons
+                exif["XMP:Subject"] = self.persons
 
         # if self.favorite():
         #     exif["Rating"] = 5
@@ -672,13 +945,13 @@ class PhotoInfo:
         (lat, lon) = self.location
         if lat is not None and lon is not None:
             lat_str, lon_str = dd_to_dms_str(lat, lon)
-            exif["GPSLatitude"] = lat_str
-            exif["GPSLongitude"] = lon_str
-            exif["GPSPosition"] = f"{lat_str}, {lon_str}"
+            exif["EXIF:GPSLatitude"] = lat_str
+            exif["EXIF:GPSLongitude"] = lon_str
+            exif["Composite:GPSPosition"] = f"{lat_str}, {lon_str}"
             lat_ref = "North" if lat >= 0 else "South"
             lon_ref = "East" if lon >= 0 else "West"
-            exif["GPSLatitudeRef"] = lat_ref
-            exif["GPSLongitudeRef"] = lon_ref
+            exif["EXIF:GPSLatitudeRef"] = lat_ref
+            exif["EXIF:GPSLongitudeRef"] = lon_ref
 
         # process date/time and timezone offset
         date = self.date
@@ -689,11 +962,11 @@ class PhotoInfo:
         offset = re.findall(r"([+-]?)([\d]{2})([\d]{2})", offsettime)
         offset = offset[0]  # findall returns list of tuples
         offsettime = f"{offset[0]}{offset[1]}:{offset[2]}"
-        exif["DateTimeOriginal"] = datetimeoriginal
-        exif["OffsetTimeOriginal"] = offsettime
+        exif["EXIF:DateTimeOriginal"] = datetimeoriginal
+        exif["EXIF:OffsetTimeOriginal"] = offsettime
 
         if self.date_modified is not None:
-            exif["ModifyDate"] = self.date_modified.strftime("%Y:%m:%d %H:%M:%S")
+            exif["EXIF:ModifyDate"] = self.date_modified.strftime("%Y:%m:%d %H:%M:%S")
 
         json_str = json.dumps([exif])
         return json_str
@@ -701,13 +974,15 @@ class PhotoInfo:
     def _xmp_sidecar(self):
         """ returns string for XMP sidecar """
         # TODO: add additional fields to XMP file?
-        
+
         xmp_template = Template(
             filename=os.path.join(_TEMPLATE_DIR, _XMP_TEMPLATE_NAME)
         )
         xmp_str = xmp_template.render(photo=self)
         # remove extra lines that mako inserts from template
-        xmp_str = "\n".join([line for line in xmp_str.split("\n") if line.strip() != ""])
+        xmp_str = "\n".join(
+            [line for line in xmp_str.split("\n") if line.strip() != ""]
+        )
         return xmp_str
 
     def _write_sidecar(self, filename, sidecar_str):
@@ -775,6 +1050,16 @@ class PhotoInfo:
             "iscloudasset": self.iscloudasset,
             "incloud": self.incloud,
             "date_modified": date_modified_iso,
+            "portrait": self.portrait,
+            "screenshot": self.screenshot,
+            "slow_mo": self.slow_mo,
+            "time_lapse": self.time_lapse,
+            "hdr": self.hdr,
+            "selfie": self.selfie,
+            "panorama": self.panorama,
+            "has_raw": self.has_raw,
+            "uti_raw": self.uti_raw,
+            "path_raw": self.path_raw,
         }
         return yaml.dump(info, sort_keys=False)
 
@@ -814,6 +1099,16 @@ class PhotoInfo:
             "iscloudasset": self.iscloudasset,
             "incloud": self.incloud,
             "date_modified": date_modified_iso,
+            "portrait": self.portrait,
+            "screenshot": self.screenshot,
+            "slow_mo": self.slow_mo,
+            "time_lapse": self.time_lapse,
+            "hdr": self.hdr,
+            "selfie": self.selfie,
+            "panorama": self.panorama,
+            "has_raw": self.has_raw,
+            "uti_raw": self.uti_raw,
+            "path_raw": self.path_raw,
         }
         return json.dumps(pic)
 

osxphotos/placeinfo.py

@@ -0,0 +1,626 @@
+""" 
+    PlaceInfo class
+    Provides reverse geolocation info for photos 
+    
+    See https://developer.apple.com/documentation/corelocation/clplacemark
+    for additional documentation on reverse geolocation data
+"""
+from abc import ABC, abstractmethod
+from collections import namedtuple  # pylint: disable=syntax-error
+
+import yaml
+from bpylist import archiver
+
+# postal address information, returned by PlaceInfo.address
+PostalAddress = namedtuple(
+    "PostalAddress",
+    [
+        "street",
+        "sub_locality",
+        "city",
+        "sub_administrative_area",
+        "state_province",
+        "postal_code",
+        "country",
+        "iso_country_code",
+    ],
+)
+
+# PlaceNames tuple returned by PlaceInfo.names
+# order of fields 0 - 17 is mapped to placeType value in
+# PLRevGeoLocationInfo.mapInfo.sortedPlaceInfos
+# field 18 is combined bodies of water (ocean + inland_water)
+# and maps to Photos <= 4, RKPlace.type == 44
+# (Photos <= 4 doesn't have ocean or inland_water types)
+# The fields named "field0", etc. appear to be unused
+PlaceNames = namedtuple(
+    "PlaceNames",
+    [
+        "field0",
+        "country",  # The name of the country associated with the placemark.
+        "state_province",  # administrativeArea, The state or province associated with the placemark.
+        "sub_administrative_area",  # Additional administrative area information for the placemark.
+        "city",  # locality, The city associated with the placemark.
+        "field5",
+        "additional_city_info",  # subLocality, Additional city-level information for the placemark.
+        "ocean",  # The name of the ocean associated with the placemark.
+        "area_of_interest",  # areasOfInterest, The relevant areas of interest associated with the placemark.
+        "inland_water",  # The name of the inland water body associated with the placemark.
+        "field10",
+        "region",  # The geographic region associated with the placemark.
+        "sub_throughfare",  # Additional street-level information for the placemark.
+        "field13",
+        "postal_code",  # The postal code associated with the placemark.
+        "field15",
+        "field16",
+        "street_address",  # throughfare, The street address associated with the placemark.
+        "body_of_water",  # RKPlace.type == 44, appears to be any body of water (ocean or inland)
+    ],
+)
+
+# The following classes represent Photo Library Reverse Geolocation Info as stored
+# in ZADDITIONALASSETATTRIBUTES.ZREVERSELOCATIONDATA
+# These classes are used by bpylist.archiver to unarchive the serialized objects
+class PLRevGeoLocationInfo:
+    """ The top level reverse geolocation object """
+
+    def __init__(
+        self,
+        addressString,
+        countryCode,
+        mapItem,
+        isHome,
+        compoundNames,
+        compoundSecondaryNames,
+        version,
+        geoServiceProvider,
+        postalAddress,
+    ):
+        self.addressString = addressString
+        self.countryCode = countryCode
+        self.mapItem = mapItem
+        self.isHome = isHome
+        self.compoundNames = compoundNames
+        self.compoundSecondaryNames = compoundSecondaryNames
+        self.version = version
+        self.geoServiceProvider = geoServiceProvider
+        self.postalAddress = postalAddress
+
+    def __eq__(self, other):
+        for field in [
+            "addressString",
+            "countryCode",
+            "isHome",
+            "compoundNames",
+            "compoundSecondaryNames",
+            "version",
+            "geoServiceProvider",
+            "postalAddress",
+        ]:
+            if getattr(self, field) != getattr(other, field):
+                return False
+        return True
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def __str__(self):
+        return f"addressString: {self.addressString}, countryCode: {self.countryCode}, isHome: {self.isHome}, mapItem: {self.mapItem}, postalAddress: {self.postalAddress}"
+
+    @staticmethod
+    def encode_archive(obj, archive):
+        archive.encode("addressString", obj.addressString)
+        archive.encode("countryCode", obj.countryCode)
+        archive.encode("mapItem", obj.mapItem)
+        archive.encode("isHome", obj.isHome)
+        archive.encode("compoundNames", obj.compoundNames)
+        archive.encode("compoundSecondaryNames", obj.compoundSecondaryNames)
+        archive.encode("version", obj.version)
+        archive.encode("geoServiceProvider", obj.geoServiceProvider)
+        archive.encode("postalAddress", obj.postalAddress)
+
+    @staticmethod
+    def decode_archive(archive):
+        addressString = archive.decode("addressString")
+        countryCode = archive.decode("countryCode")
+        mapItem = archive.decode("mapItem")
+        isHome = archive.decode("isHome")
+        compoundNames = archive.decode("compoundNames")
+        compoundSecondaryNames = archive.decode("compoundSecondaryNames")
+        version = archive.decode("version")
+        geoServiceProvider = archive.decode("geoServiceProvider")
+        postalAddress = archive.decode("postalAddress")
+        return PLRevGeoLocationInfo(
+            addressString,
+            countryCode,
+            mapItem,
+            isHome,
+            compoundNames,
+            compoundSecondaryNames,
+            version,
+            geoServiceProvider,
+            postalAddress,
+        )
+
+
+class PLRevGeoMapItem:
+    """ Stores the list of place names, organized by area """
+
+    def __init__(self, sortedPlaceInfos, finalPlaceInfos):
+        self.sortedPlaceInfos = sortedPlaceInfos
+        self.finalPlaceInfos = finalPlaceInfos
+
+    def __eq__(self, other):
+        for field in ["sortedPlaceInfos", "finalPlaceInfos"]:
+            if getattr(self, field) != getattr(other, field):
+                return False
+        return True
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def __str__(self):
+        sortedPlaceInfos = []
+        finalPlaceInfos = []
+        for place in self.sortedPlaceInfos:
+            sortedPlaceInfos.append(str(place))
+        for place in self.finalPlaceInfos:
+            finalPlaceInfos.append(str(place))
+        return (
+            f"finalPlaceInfos: {finalPlaceInfos}, sortedPlaceInfos: {sortedPlaceInfos}"
+        )
+
+    @staticmethod
+    def encode_archive(obj, archive):
+        archive.encode("sortedPlaceInfos", obj.sortedPlaceInfos)
+        archive.encode("finalPlaceInfos", obj.finalPlaceInfos)
+
+    @staticmethod
+    def decode_archive(archive):
+        sortedPlaceInfos = archive.decode("sortedPlaceInfos")
+        finalPlaceInfos = archive.decode("finalPlaceInfos")
+        return PLRevGeoMapItem(sortedPlaceInfos, finalPlaceInfos)
+
+
+class PLRevGeoMapItemAdditionalPlaceInfo:
+    """ Additional info about individual places """
+
+    def __init__(self, area, name, placeType, dominantOrderType):
+        self.area = area
+        self.name = name
+        self.placeType = placeType
+        self.dominantOrderType = dominantOrderType
+
+    def __eq__(self, other):
+        for field in ["area", "name", "placeType", "dominantOrderType"]:
+            if getattr(self, field) != getattr(other, field):
+                return False
+        return True
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def __str__(self):
+        return f"area: {self.area}, name: {self.name}, placeType: {self.placeType}"
+
+    @staticmethod
+    def encode_archive(obj, archive):
+        archive.encode("area", obj.area)
+        archive.encode("name", obj.name)
+        archive.encode("placeType", obj.placeType)
+        archive.encode("dominantOrderType", obj.dominantOrderType)
+
+    @staticmethod
+    def decode_archive(archive):
+        area = archive.decode("area")
+        name = archive.decode("name")
+        placeType = archive.decode("placeType")
+        dominantOrderType = archive.decode("dominantOrderType")
+        return PLRevGeoMapItemAdditionalPlaceInfo(
+            area, name, placeType, dominantOrderType
+        )
+
+
+class CNPostalAddress:
+    """ postal address for the reverse geolocation info """
+
+    def __init__(
+        self,
+        _ISOCountryCode,
+        _city,
+        _country,
+        _postalCode,
+        _state,
+        _street,
+        _subAdministrativeArea,
+        _subLocality,
+    ):
+        self._ISOCountryCode = _ISOCountryCode
+        self._city = _city
+        self._country = _country
+        self._postalCode = _postalCode
+        self._state = _state
+        self._street = _street
+        self._subAdministrativeArea = _subAdministrativeArea
+        self._subLocality = _subLocality
+
+    def __eq__(self, other):
+        for field in [
+            "_ISOCountryCode",
+            "_city",
+            "_country",
+            "_postalCode",
+            "_state",
+            "_street",
+            "_subAdministrativeArea",
+            "_subLocality",
+        ]:
+            if getattr(self, field) != getattr(other, field):
+                return False
+        return True
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def __str__(self):
+        return ", ".join(
+            map(
+                str,
+                [
+                    self._street,
+                    self._city,
+                    self._subLocality,
+                    self._subAdministrativeArea,
+                    self._state,
+                    self._postalCode,
+                    self._country,
+                    self._ISOCountryCode,
+                ],
+            )
+        )
+
+    @staticmethod
+    def encode_archive(obj, archive):
+        archive.encode("_ISOCountryCode", obj._ISOCountryCode)
+        archive.encode("_country", obj._country)
+        archive.encode("_city", obj._city)
+        archive.encode("_postalCode", obj._postalCode)
+        archive.encode("_state", obj._state)
+        archive.encode("_street", obj._street)
+        archive.encode("_subAdministrativeArea", obj._subAdministrativeArea)
+        archive.encode("_subLocality", obj._subLocality)
+
+    @staticmethod
+    def decode_archive(archive):
+        _ISOCountryCode = archive.decode("_ISOCountryCode")
+        _country = archive.decode("_country")
+        _city = archive.decode("_city")
+        _postalCode = archive.decode("_postalCode")
+        _state = archive.decode("_state")
+        _street = archive.decode("_street")
+        _subAdministrativeArea = archive.decode("_subAdministrativeArea")
+        _subLocality = archive.decode("_subLocality")
+
+        return CNPostalAddress(
+            _ISOCountryCode,
+            _city,
+            _country,
+            _postalCode,
+            _state,
+            _street,
+            _subAdministrativeArea,
+            _subLocality,
+        )
+
+
+# register the classes with bpylist.archiver
+archiver.update_class_map({"CNPostalAddress": CNPostalAddress})
+archiver.update_class_map(
+    {"PLRevGeoMapItemAdditionalPlaceInfo": PLRevGeoMapItemAdditionalPlaceInfo}
+)
+archiver.update_class_map({"PLRevGeoMapItem": PLRevGeoMapItem})
+archiver.update_class_map({"PLRevGeoLocationInfo": PLRevGeoLocationInfo})
+
+
+class PlaceInfo(ABC):
+    @property
+    @abstractmethod
+    def address_str(self):
+        pass
+
+    @property
+    @abstractmethod
+    def country_code(self):
+        pass
+
+    @property
+    @abstractmethod
+    def ishome(self):
+        pass
+
+    @property
+    @abstractmethod
+    def name(self):
+        pass
+
+    @property
+    @abstractmethod
+    def names(self):
+        pass
+
+    @property
+    @abstractmethod
+    def address(self):
+        pass
+
+
+class PlaceInfo4(PlaceInfo):
+    """ Reverse geolocation place info for a photo (Photos <= 4) """
+
+    def __init__(self, place_names, country_code):
+        """ place_names: list of place name tuples in ascending order by area 
+            tuple fields are: modelID, place name, place type, area, e.g.
+            [(5, "St James's Park", 45, 0), 
+            (4, 'Westminster', 16, 22097376), 
+            (3, 'London', 4, 1596146816), 
+            (2, 'England', 2, 180406091776), 
+            (1, 'United Kingdom', 1, 414681432064)] 
+            country_code: two letter country code for the country
+        """
+        self._place_names = place_names
+        self._country_code = country_code
+        self._process_place_info()
+
+    @property
+    def address_str(self):
+        return None
+
+    @property
+    def country_code(self):
+        return self._country_code
+
+    @property
+    def ishome(self):
+        return None
+
+    @property
+    def name(self):
+        return self._name
+
+    @property
+    def names(self):
+        return self._names
+
+    @property
+    def address(self):
+        return PostalAddress(None, None, None, None, None, None, None, None)
+
+    def __eq__(self, other):
+        if not isinstance(other, type(self)):
+            return False
+        else:
+            return (
+                self._place_names == other._place_names
+                and self._country_code == other._country_code
+            )
+
+    def _process_place_info(self):
+        """ Process place_names to set self._name and self._names """
+        places = self._place_names
+
+        # build a dictionary where key is placetype
+        places_dict = {}
+        for p in places:
+            # places in format:
+            # [(5, "St James's Park", 45, 0), ]
+            #   0: modelID
+            #   1: name
+            #   2: type
+            #   3: area
+            try:
+                places_dict[p[2]].append((p[1], p[3]))
+            except KeyError:
+                places_dict[p[2]] = [(p[1], p[3])]
+
+        # build list to populate PlaceNames tuple
+        # initialize with empty lists for each field in PlaceNames
+        place_info = [[]] * 19
+
+        # add the place names sorted by area (ascending)
+        # in Photos <=4, possible place type values are:
+        # 45: areasOfInterest (The relevant areas of interest associated with the placemark.)
+        # 44: body of water (includes both inlandWater and ocean)
+        # 43: subLocality (Additional city-level information for the placemark.
+        # 16: locality (The city associated with the placemark.)
+        # 4: subAdministrativeArea (Additional administrative area information for the placemark.)
+        # 2: administrativeArea (The state or province associated with the placemark.)
+        # 1: country
+        # mapping = mapping from PlaceNames to field in places_dict
+        # PlaceNames fields map to the placeType value in Photos5 (0..17)
+        # but place type in Photos <=4 has different values
+        # hence (3, 4) means PlaceNames[3] = places_dict[4] (sub_administrative_area)
+        mapping = [(1, 1), (2, 2), (3, 4), (4, 16), (18, 44), (8, 45)]
+        for field5, field4 in mapping:
+            try:
+                place_info[field5] = [
+                    p[0]
+                    for p in sorted(places_dict[field4], key=lambda place: place[1])
+                ]
+            except KeyError:
+                pass
+
+        place_names = PlaceNames(*place_info)
+        self._names = place_names
+
+        # build the name as it appears in Photos
+        # the length of the name is at most 3 fields and appears to be based on available
+        # reverse geolocation data in the following order (left to right, joined by ',')
+        # always has country if available then either area of interest and city OR
+        # city and state
+        # e.g. 4, 2, 1 OR 8, 4, 1
+        # 8 (45): area_of_interest
+        # 4 (16): locality / city
+        # 2 (2): administrative area (state/province)
+        # 1 (1): country
+        name_list = []
+        if place_names[8]:
+            name_list.append(place_names[8][0])
+            if place_names[4]:
+                name_list.append(place_names[4][0])
+        elif place_names[4]:
+            name_list.append(place_names[4][0])
+            if place_names[2]:
+                name_list.append(place_names[2][0])
+        elif place_names[2]:
+            name_list.append(place_names[2][0])
+
+        # add country
+        if place_names[1]:
+            name_list.append(place_names[1][0])
+
+        name = ", ".join(name_list)
+        self._name = name if name != "" else None
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def __str__(self):
+        info = {
+            "name": self.name,
+            "names": self.names,
+            "country_code": self.country_code,
+        }
+        strval = "PlaceInfo(" + ", ".join([f"{k}='{v}'" for k, v in info.items()]) + ")"
+        return strval
+
+
+class PlaceInfo5(PlaceInfo):
+    """ Reverse geolocation place info for a photo (Photos >= 5) """
+
+    def __init__(self, revgeoloc_bplist):
+        """ revgeoloc_bplist: a binary plist blob containing 
+                a serialized PLRevGeoLocationInfo object """
+        self._bplist = revgeoloc_bplist
+        # todo: check for None?
+        self._plrevgeoloc = archiver.unarchive(revgeoloc_bplist)
+        self._process_place_info()
+
+    @property
+    def address_str(self):
+        """ returns the postal address as a string """
+        return self._plrevgeoloc.addressString
+
+    @property
+    def country_code(self):
+        """ returns the country code """
+        return self._plrevgeoloc.countryCode
+
+    @property
+    def ishome(self):
+        """ returns True if place is user's home address """
+        return self._plrevgeoloc.isHome
+
+    @property
+    def name(self):
+        """ returns local place name """
+        return self._name
+
+    @property
+    def names(self):
+        """ returns PlaceNames tuple with detailed reverse geolocation place names """
+        return self._names
+
+    @property
+    def address(self):
+        addr = self._plrevgeoloc.postalAddress
+        address = PostalAddress(
+            street=addr._street,
+            sub_locality=addr._subLocality,
+            city=addr._city,
+            sub_administrative_area=addr._subAdministrativeArea,
+            state_province=addr._state,
+            postal_code=addr._postalCode,
+            country=addr._country,
+            iso_country_code=addr._ISOCountryCode,
+        )
+        return address
+
+    def _process_place_info(self):
+        """ Process sortedPlaceInfos to set self._name and self._names """
+        places = self._plrevgeoloc.mapItem.sortedPlaceInfos
+
+        # build a dictionary where key is placetype
+        places_dict = {}
+        for p in places:
+            try:
+                places_dict[p.placeType].append((p.name, p.area))
+            except KeyError:
+                places_dict[p.placeType] = [(p.name, p.area)]
+
+        # build list to populate PlaceNames tuple
+        place_info = []
+        for field in range(18):
+            try:
+                # add the place names sorted by area (ascending)
+                place_info.append(
+                    [
+                        p[0]
+                        for p in sorted(places_dict[field], key=lambda place: place[1])
+                    ]
+                )
+            except:
+                place_info.append([])
+
+        # fill in body_of_water for compatibility with Photos <= 4
+        place_info.append(place_info[7] + place_info[9])
+
+        place_names = PlaceNames(*place_info)
+        self._names = place_names
+
+        # build the name as it appears in Photos
+        # the length of the name is variable and appears to be based on available
+        # reverse geolocation data in the following order (left to right, joined by ',')
+        # 8: area_of_interest
+        # 11: region (I've only seen this applied to islands)
+        # 4: locality / city
+        # 2: administrative area (state/province)
+        # 1: country
+        # 9: inland_water
+        # 7: ocean
+        name = ", ".join(
+            [
+                p[0]
+                for p in [
+                    place_names[8],  # area of interest
+                    place_names[11],  # region (I've only seen this applied to islands)
+                    place_names[4],  # locality / city
+                    place_names[2],  # administrative area (state/province)
+                    place_names[1],  # country
+                    place_names[9],  # inland_water
+                    place_names[7],  # ocean
+                ]
+                if p and p[0]
+            ]
+        )
+        self._name = name if name != "" else None
+
+    def __eq__(self, other):
+        if not isinstance(other, type(self)):
+            return False
+        else:
+            return self._plrevgeoloc == other._plrevgeoloc
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def __str__(self):
+        info = {
+            "name": self.name,
+            "names": self.names,
+            "country_code": self.country_code,
+            "ishome": self.ishome,
+            "address_str": self.address_str,
+            "address": str(self.address),
+        }
+        strval = "PlaceInfo(" + ", ".join([f"{k}='{v}'" for k, v in info.items()]) + ")"
+        return strval

osxphotos/template.py

@@ -0,0 +1,439 @@
+""" Custom template system for osxphotos """
+
+# Rolled my own template system because:
+# 1. Needed to handle multiple values (e.g. album, keyword)
+# 2. Needed to handle default values if template not found
+# 3. Didn't want user to need to know python (e.g. by using Mako which is
+#    already used elsewhere in this project)
+# 4. Couldn't figure out how to do #1 and #2 with str.format()
+#
+# This code isn't elegant but it seems to work well.  PRs gladly accepted.
+
+import datetime
+import os
+import pathlib
+import re
+from typing import Tuple, List  # pylint: disable=syntax-error
+
+from .photoinfo import PhotoInfo
+from ._constants import _UNKNOWN_PERSON
+
+# Permitted substitutions (each of these returns a single value or None)
+TEMPLATE_SUBSTITUTIONS = {
+    "{name}": "Filename of the photo",
+    "{original_name}": "Photo's original filename when imported to Photos",
+    "{title}": "Title of the photo",
+    "{descr}": "Description of the photo",
+    "{created.date}": "Photo's creation date in ISO format, e.g. '2020-03-22'",
+    "{created.year}": "4-digit year of file creation time",
+    "{created.yy}": "2-digit year of file creation time",
+    "{created.mm}": "2-digit month of the file creation time (zero padded)",
+    "{created.month}": "Month name in user's locale of the file creation time",
+    "{created.mon}": "Month abbreviation in the user's locale of the file creation time",
+    "{created.doy}": "3-digit day of year (e.g Julian day) of file creation time, starting from 1 (zero padded)",
+    "{modified.date}": "Photo's modification date in ISO format, e.g. '2020-03-22'",
+    "{modified.year}": "4-digit year of file modification time",
+    "{modified.yy}": "2-digit year of file modification time",
+    "{modified.mm}": "2-digit month of the file modification time (zero padded)",
+    "{modified.month}": "Month name in user's locale of the file modification time",
+    "{modified.mon}": "Month abbreviation in the user's locale of the file modification time",
+    "{modified.doy}": "3-digit day of year (e.g Julian day) of file modification time, starting from 1 (zero padded)",
+    "{place.name}": "Place name from the photo's reverse geolocation data, as displayed in Photos",
+    "{place.country_code}": "The ISO country code from the photo's reverse geolocation data",
+    "{place.name.country}": "Country name from the photo's reverse geolocation data",
+    "{place.name.state_province}": "State or province name from the photo's reverse geolocation data",
+    "{place.name.city}": "City or locality name from the photo's reverse geolocation data",
+    "{place.name.area_of_interest}": "Area of interest name (e.g. landmark or public place) from the photo's reverse geolocation data",
+    "{place.address}": "Postal address from the photo's reverse geolocation data, e.g. '2007 18th St NW, Washington, DC 20009, United States'",
+    "{place.address.street}": "Street part of the postal address, e.g. '2007 18th St NW'",
+    "{place.address.city}": "City part of the postal address, e.g. 'Washington'",
+    "{place.address.state_province}": "State/province part of the postal address, e.g. 'DC'",
+    "{place.address.postal_code}": "Postal code part of the postal address, e.g. '20009'",
+    "{place.address.country}": "Country name of the postal address, e.g. 'United States'",
+    "{place.address.country_code}": "ISO country code of the postal address, e.g. 'US'",
+}
+
+# Permitted multi-value substitutions (each of these returns None or 1 or more values)
+TEMPLATE_SUBSTITUTIONS_MULTI_VALUED = {
+    "{album}": "Album(s) photo is contained in",
+    "{folder_album}": "Folder path + album photo is contained in. e.g. 'Folder/Subfolder/Album' or just 'Album' if no enclosing folder",
+    "{keyword}": "Keyword(s) assigned to photo",
+    "{person}": "Person(s) / face(s) in a photo",
+}
+
+# Just the multi-valued substitution names without the braces
+MULTI_VALUE_SUBSTITUTIONS = [
+    field.replace("{", "").replace("}", "")
+    for field in TEMPLATE_SUBSTITUTIONS_MULTI_VALUED.keys()
+]
+
+
+def get_template_value(lookup, photo):
+    """ lookup template value (single-value template substitutions) for use in make_subst_function
+        lookup: value to find a match for
+        photo: PhotoInfo object whose data will be used for value substitutions
+        returns: either the matching template value (which may be None)
+        raises: KeyError if no rule exists for lookup """
+
+    # must be a valid keyword
+    if lookup == "name":
+        return pathlib.Path(photo.filename).stem
+
+    if lookup == "original_name":
+        return pathlib.Path(photo.original_filename).stem
+
+    if lookup == "title":
+        return photo.title
+
+    if lookup == "descr":
+        return photo.description
+
+    if lookup == "created.date":
+        return DateTimeFormatter(photo.date).date
+
+    if lookup == "created.year":
+        return DateTimeFormatter(photo.date).year
+
+    if lookup == "created.yy":
+        return DateTimeFormatter(photo.date).yy
+
+    if lookup == "created.mm":
+        return DateTimeFormatter(photo.date).mm
+
+    if lookup == "created.month":
+        return DateTimeFormatter(photo.date).month
+
+    if lookup == "created.mon":
+        return DateTimeFormatter(photo.date).mon
+
+    if lookup == "created.doy":
+        return DateTimeFormatter(photo.date).doy
+
+    if lookup == "modified.date":
+        return (
+            DateTimeFormatter(photo.date_modified).date if photo.date_modified else None
+        )
+
+    if lookup == "modified.year":
+        return (
+            DateTimeFormatter(photo.date_modified).year if photo.date_modified else None
+        )
+
+    if lookup == "modified.yy":
+        return (
+            DateTimeFormatter(photo.date_modified).yy if photo.date_modified else None
+        )
+
+    if lookup == "modified.mm":
+        return (
+            DateTimeFormatter(photo.date_modified).mm if photo.date_modified else None
+        )
+
+    if lookup == "modified.month":
+        return (
+            DateTimeFormatter(photo.date_modified).month
+            if photo.date_modified
+            else None
+        )
+
+    if lookup == "modified.mon":
+        return (
+            DateTimeFormatter(photo.date_modified).mon if photo.date_modified else None
+        )
+
+    if lookup == "modified.doy":
+        return (
+            DateTimeFormatter(photo.date_modified).doy if photo.date_modified else None
+        )
+
+    if lookup == "place.name":
+        return photo.place.name if photo.place else None
+
+    if lookup == "place.country_code":
+        return photo.place.country_code if photo.place else None
+
+    if lookup == "place.name.country":
+        return (
+            photo.place.names.country[0]
+            if photo.place and photo.place.names.country
+            else None
+        )
+
+    if lookup == "place.name.state_province":
+        return (
+            photo.place.names.state_province[0]
+            if photo.place and photo.place.names.state_province
+            else None
+        )
+
+    if lookup == "place.name.city":
+        return (
+            photo.place.names.city[0]
+            if photo.place and photo.place.names.city
+            else None
+        )
+
+    if lookup == "place.name.area_of_interest":
+        return (
+            photo.place.names.area_of_interest[0]
+            if photo.place and photo.place.names.area_of_interest
+            else None
+        )
+
+    if lookup == "place.address":
+        return (
+            photo.place.address_str if photo.place and photo.place.address_str else None
+        )
+
+    if lookup == "place.address.street":
+        return (
+            photo.place.address.street
+            if photo.place and photo.place.address.street
+            else None
+        )
+
+    if lookup == "place.address.city":
+        return (
+            photo.place.address.city
+            if photo.place and photo.place.address.city
+            else None
+        )
+
+    if lookup == "place.address.state_province":
+        return (
+            photo.place.address.state_province
+            if photo.place and photo.place.address.state_province
+            else None
+        )
+
+    if lookup == "place.address.postal_code":
+        return (
+            photo.place.address.postal_code
+            if photo.place and photo.place.address.postal_code
+            else None
+        )
+
+    if lookup == "place.address.country":
+        return (
+            photo.place.address.country
+            if photo.place and photo.place.address.country
+            else None
+        )
+
+    if lookup == "place.address.country_code":
+        return (
+            photo.place.address.iso_country_code
+            if photo.place and photo.place.address.iso_country_code
+            else None
+        )
+
+    # if here, didn't get a match
+    raise KeyError(f"No rule for processing {lookup}")
+
+
+def render_filepath_template(template, photo, none_str="_"):
+    """ render a filename or directory template 
+        template: str template 
+        photo: PhotoInfo object
+        none_str: str to use default for None values, default is '_' """
+
+    # the rendering happens in two phases:
+    # phase 1: handle all the single-value template substitutions
+    #          results in a single string with all the template fields replaced
+    # phase 2: loop through all the multi-value template substitutions
+    #          could result in multiple strings
+    #          e.g. if template is "{album}/{person}" and there are 2 albums and 3 persons in the photo
+    #          there would be 6 possible renderings (2 albums x 3 persons)
+
+    # regex to find {template_field,optional_default} in strings
+    # for explanation of regex see https://regex101.com/r/4JJg42/1
+    # pylint: disable=anomalous-backslash-in-string
+    regex = r"(?<!\{)\{([^\\,}]+)(,{0,1}(([\w\-. ]+))?)(?=\}(?!\}))\}"
+
+    if type(template) is not str:
+        raise TypeError(f"template must be type str, not {type(template)}")
+
+    if type(photo) is not PhotoInfo:
+        raise TypeError(f"photo must be type osxphotos.PhotoInfo, not {type(photo)}")
+
+    def make_subst_function(photo, none_str, get_func=get_template_value):
+        """ returns: substitution function for use in re.sub 
+            photo: a PhotoInfo object
+            none_str: value to use if substitution lookup is None and no default provided
+            get_func: function that gets the substitution value for a given template field
+                      default is get_template_value which handles the single-value fields """
+
+        # closure to capture photo, none_str in subst
+        def subst(matchobj):
+            groups = len(matchobj.groups())
+            if groups == 4:
+                try:
+                    val = get_func(matchobj.group(1), photo)
+                except KeyError:
+                    return matchobj.group(0)
+
+                if val is None:
+                    return (
+                        matchobj.group(3) if matchobj.group(3) is not None else none_str
+                    )
+                else:
+                    return val
+            else:
+                raise ValueError(
+                    f"Unexpected number of groups: expected 4, got {groups}"
+                )
+
+        return subst
+
+    subst_func = make_subst_function(photo, none_str)
+
+    # do the replacements
+    rendered = re.sub(regex, subst_func, template)
+
+    # do multi-valued placements
+    # start with the single string from phase 1 above then loop through all
+    # multi-valued fields and all values for each of those fields
+    # rendered_strings will be updated as each field is processed
+    # for example: if two albums, two keywords, and one person and template is:
+    # "{created.year}/{album}/{keyword}/{person}"
+    # rendered strings would do the following:
+    # start (created.year filled in phase 1)
+    #   ['2011/{album}/{keyword}/{person}']
+    # after processing albums:
+    #   ['2011/Album1/{keyword}/{person}',
+    #    '2011/Album2/{keyword}/{person}',]
+    # after processing keywords:
+    #   ['2011/Album1/keyword1/{person}',
+    #    '2011/Album1/keyword2/{person}',
+    #    '2011/Album2/keyword1/{person}',
+    #    '2011/Album2/keyword2/{person}',]
+    # after processing person:
+    #   ['2011/Album1/keyword1/person1',
+    #    '2011/Album1/keyword2/person1',
+    #    '2011/Album2/keyword1/person1',
+    #    '2011/Album2/keyword2/person1',]
+
+    rendered_strings = set([rendered])
+    for field in MULTI_VALUE_SUBSTITUTIONS:
+        if field == "album":
+            values = photo.albums
+        elif field == "keyword":
+            values = photo.keywords
+        elif field == "person":
+            values = photo.persons
+            # remove any _UNKNOWN_PERSON values
+            values = [val for val in values if val != _UNKNOWN_PERSON]
+        elif field == "folder_album":
+            values = []
+            # photos must be in an album to be in a folder
+            for album in photo.album_info:
+                if album.folder_names:
+                    # album in folder
+                    folder = os.path.sep.join(album.folder_names)
+                    folder += os.path.sep + album.title
+                    values.append(folder)
+                else:
+                    # album not in folder
+                    values.append(album.title)
+
+        else:
+            raise ValueError(f"Unhandleded template value: {field}")
+
+        # If no values, insert None so code below will substite none_str for None
+        values = values or [None]
+
+        # Build a regex that matches only the field being processed
+        re_str = r"(?<!\\)\{(" + field + r")(,{0,1}(([\w\-. ]+))?)\}"
+        regex_multi = re.compile(re_str)
+
+        # holds each of the new rendered_strings, set() to avoid duplicates
+        new_strings = set()
+
+        for str_template in rendered_strings:
+            for val in values:
+
+                def get_template_value_multi(lookup_value, photo):
+                    """ Closure passed to make_subst_function get_func 
+                        Capture val and field in the closure 
+                        Allows make_subst_function to be re-used w/o modification """
+                    if lookup_value == field:
+                        return val
+                    else:
+                        raise KeyError(f"Unexpected value: {lookup_value}")
+
+                subst = make_subst_function(
+                    photo, none_str, get_func=get_template_value_multi
+                )
+                new_string = regex_multi.sub(subst, str_template)
+                new_strings.add(new_string)
+
+        # update rendered_strings for the next field to process
+        rendered_strings = new_strings
+
+    # find any {fields} that weren't replaced
+    unmatched = []
+    for rendered_str in rendered_strings:
+        unmatched.extend(
+            [
+                no_match[0]
+                for no_match in re.findall(regex, rendered_str)
+                if no_match[0] not in unmatched
+            ]
+        )
+
+    # fix any escaped curly braces
+    rendered_strings = [
+        rendered_str.replace("{{", "{").replace("}}", "}")
+        for rendered_str in rendered_strings
+    ]
+
+    return rendered_strings, unmatched
+
+
+class DateTimeFormatter:
+    """ provides property access to formatted datetime.datetime strftime values """
+
+    def __init__(self, dt: datetime.datetime):
+        self.dt = dt
+
+    @property
+    def date(self):
+        """ ISO date in form 2020-03-22 """
+        date = self.dt.date().isoformat()
+        return date
+
+    @property
+    def year(self):
+        """ 4 digit year """
+        year = f"{self.dt.year}"
+        return year
+
+    @property
+    def yy(self):
+        """ 2 digit year """
+        yy = f"{self.dt.strftime('%y')}"
+        return yy
+
+    @property
+    def mm(self):
+        """ 2 digit month """
+        mm = f"{self.dt.strftime('%m')}"
+        return mm
+
+    @property
+    def month(self):
+        """ Month as locale's full name """
+        month = f"{self.dt.strftime('%B')}"
+        return month
+
+    @property
+    def mon(self):
+        """ Month as locale's abbreviated name """
+        mon = f"{self.dt.strftime('%b')}"
+        return mon
+
+    @property
+    def doy(self):
+        """ Julian day of year starting from 001 """
+        doy = f"{self.dt.strftime('%j')}"
+        return doy

osxphotos/utils.py

@@ -1,15 +1,20 @@
+import fnmatch
 import glob
 import logging
+import os
 import os.path
+import pathlib
 import platform
+import re
 import sqlite3
 import subprocess
+import sys
 import tempfile
 import urllib.parse
-import pathlib
 from plistlib import load as plistload
 
 import CoreFoundation
+import CoreServices
 import objc
 from Foundation import *
 
@@ -113,10 +118,14 @@ def _dd_to_dms(dd):
     return int(deg_), int(min_), sec_
 
 
-def _copy_file(src, dest):
+def _copy_file(src, dest, norsrc=False):
     """ Copies a file from src path to dest path 
         src: source path as string 
         dest: destination path as string
+        norsrc: (bool) if True, uses --norsrc flag with ditto so it will not copy
+                resource fork or extended attributes.  May be useful on volumes that
+                don't work with extended attributes (likely only certain SMB mounts)
+                default is False
         Uses ditto to perform copy; will silently overwrite dest if it exists
         Raises exception if copy fails or either path is None """
 
@@ -124,19 +133,24 @@ def _copy_file(src, dest):
         raise ValueError("src and dest must not be None", src, dest)
 
     if not os.path.isfile(src):
-        raise ValueError("src file does not appear to exist", src)
+        raise FileNotFoundError("src file does not appear to exist", src)
+
+    if norsrc:
+        command = ["/usr/bin/ditto", "--norsrc", src, dest]
+    else:
+        command = ["/usr/bin/ditto", src, dest]
 
     # if error on copy, subprocess will raise CalledProcessError
     try:
-        subprocess.run(
-            ["/usr/bin/ditto", src, dest], check=True, stderr=subprocess.PIPE
-        )
+        result = subprocess.run(command, check=True, stderr=subprocess.PIPE)
     except subprocess.CalledProcessError as e:
         logging.critical(
             f"ditto returned error: {e.returncode} {e.stderr.decode(sys.getfilesystemencoding()).rstrip()}"
         )
         raise e
 
+    return result.returncode
+
 
 def dd_to_dms_str(lat, lon):
     """ convert latitude, longitude in degrees to degrees, minutes, seconds as string """
@@ -218,6 +232,8 @@ def get_last_library_path():
 
     if photosurlref is not None:
         # use CFURLCreateByResolvingBookmarkData to de-serialize bookmark data into a CFURLRef
+        # pylint: disable=no-member
+        # pylint: disable=undefined-variable
         photosurl = CoreFoundation.CFURLCreateByResolvingBookmarkData(
             kCFAllocatorDefault, photosurlref, 0, None, None, None, None
         )
@@ -255,7 +271,7 @@ def list_photo_libraries():
     # On older MacOS versions, mdfind appears to ignore some libraries
     # glob to find libraries in ~/Pictures then mdfind to find all the others
     # TODO: make this more robust
-    lib_list = glob.glob(f"{str(Path.home())}/Pictures/*.photoslibrary")
+    lib_list = glob.glob(f"{str(pathlib.Path.home())}/Pictures/*.photoslibrary")
 
     # On older OS, may not get all libraries so make sure we get the last one
     last_lib = get_last_library_path()
@@ -290,6 +306,28 @@ def create_path_by_date(dest, dt):
     return new_dest
 
 
+def get_preferred_uti_extension(uti):
+    """ get preferred extension for a UTI type
+        uti: UTI str, e.g. 'public.jpeg'
+        returns: preferred extension as str """
+
+    # reference: https://developer.apple.com/documentation/coreservices/1442744-uttypecopypreferredtagwithclass?language=objc
+
+    ext = CoreServices.UTTypeCopyPreferredTagWithClass(
+        uti, CoreServices.kUTTagClassFilenameExtension
+    )
+    return ext
+
+
+def findfiles(pattern, path_):
+    """Returns list of filenames from path_ matched by pattern
+       shell pattern. Matching is case-insensitive."""
+    # See: https://gist.github.com/techtonik/5694830
+
+    rule = re.compile(fnmatch.translate(pattern), re.IGNORECASE)
+    return [name for name in os.listdir(path_) if rule.match(name)]
+
+
 # TODO: this doesn't always work, still looking for a way to
 # force Photos to open the library being operated on
 # def _open_photos_library_applescript(library_path):
@@ -299,8 +337,7 @@ def create_path_by_date(dest, dt):
 #         f"""
 #         on openLibrary
 #             tell application "Photos"
-# 	         activate
-# 	         open POSIX file "{library_path}"
+# 	          open POSIX file "{library_path}"
 #             end tell
 #         end openLibrary
 #         """
@@ -309,17 +346,35 @@ def create_path_by_date(dest, dt):
 
 
 def _export_photo_uuid_applescript(
-    uuid, dest, original=True, edited=False, timeout=120
+    uuid,
+    dest,
+    filestem=None,
+    original=True,
+    edited=False,
+    live_photo=False,
+    timeout=120,
+    burst=False,
 ):
     """ Export photo to dest path using applescript to control Photos
+        If photo is a live photo, exports both the photo and associated .mov file
         uuid: UUID of photo to export
-        dest: destination path to export to; may be either a directory or a filename
-              if filename provided and file exists, exiting file will be overwritten
+        dest: destination path to export to
+        filestem: (string) if provided, exported filename will be named stem.ext 
+                  where ext is extension of the file exported by photos (e.g. .jpeg, .mov, etc)
+                  If not provided, file will be named with whatever name Photos uses
+                  If filestem.ext exists, it wil be overwritten
         original: (boolean) if True, export original image; default = True
         edited: (boolean) if True, export edited photo; default = False
-                will produce an error if image does not have edits/adjustments  
+                If photo not edited and edited=True, will still export the original image
+                caller must verify image has been edited
+        *Note*: must be called with either edited or original but not both, 
+                will raise error if called with both edited and original = True
+        live_photo: (boolean) if True, export associated .mov live photo; default = False
         timeout: timeout value in seconds; export will fail if applescript run time exceeds timeout
-        Returns: path to exported file or None if export failed
+        burst: (boolean) set to True if file is a burst image to avoid Photos export error
+        Returns: list of paths to exported file(s) or None if export failed
+        Note: For Live Photos, if edited=True, will export a jpeg but not the movie, even if photo
+              has not been edited. This is due to how Photos Applescript interface works.
     """
 
     # setup the applescript to do the export
@@ -327,7 +382,6 @@ def _export_photo_uuid_applescript(
         """ 
 		on export_by_uuid(theUUID, thePath, original, edited, theTimeOut)
 			tell application "Photos"
-				activate
 				set thePath to thePath
 				set theItem to media item id theUUID
 				set theFilename to filename of theItem
@@ -352,6 +406,13 @@ def _export_photo_uuid_applescript(
 		"""
     )
 
+    dest = pathlib.Path(dest)
+    if not dest.is_dir:
+        raise ValueError(f"dest {dest} must be a directory")
+
+    if not original ^ edited:
+        raise ValueError(f"edited or original must be True but not both")
+
     tmpdir = tempfile.TemporaryDirectory(prefix="osxphotos_")
 
     # export original
@@ -366,15 +427,31 @@ def _export_photo_uuid_applescript(
 
     if filename is not None:
         # need to find actual filename as sometimes Photos renames JPG to jpeg on export
-        # this assumes only a single file in export folder, which should be true as
+        # may be more than one file exported (e.g. if Live Photo, Photos exports both .jpeg and .mov)
         # TemporaryDirectory will cleanup on return
-        path = glob.glob(os.path.join(tmpdir.name, "*"))[0]
-        _copy_file(path, dest)
-        if os.path.isdir(dest):
-            new_path = os.path.join(dest, filename)
-        else:
-            new_path = dest
-        return new_path
+        filename_stem = pathlib.Path(filename).stem
+        files = glob.glob(os.path.join(tmpdir.name, "*"))
+        exported_paths = []
+        for fname in files:
+            path = pathlib.Path(fname)
+            if len(files) > 1 and not live_photo and path.suffix.lower() == ".mov":
+                # it's the .mov part of live photo but not requested, so don't export
+                logging.debug(f"Skipping live photo file {path}")
+                continue
+            if len(files) > 1 and burst and path.stem != filename_stem:
+                # skip any burst photo that's not the one we asked for
+                logging.debug(f"Skipping burst photo file {path}")
+                continue
+            if filestem:
+                # rename the file based on filestem, keeping original extension
+                dest_new = dest / f"{filestem}{path.suffix}"
+            else:
+                # use the name Photos provided
+                dest_new = dest / path.name
+            logging.debug(f"exporting {path} to dest_new: {dest_new}")
+            _copy_file(str(path), str(dest_new))
+            exported_paths.append(str(dest_new))
+        return exported_paths
     else:
         return None
 
@@ -410,7 +487,7 @@ def _db_is_locked(dbname):
         conn.close()
         logging.debug(f"{dbname} is not locked")
         locked = False
-    except Exception as e:
+    except:
         logging.debug(f"{dbname} is locked")
         locked = True
 

requirements.txt

@@ -1,23 +1,36 @@
+altgraph==0.17
 ansimarkup==1.4.0
+appdirs==1.4.3
 astroid==2.2.5
 atomicwrites==1.3.0
 attrs==19.1.0
 better-exceptions-fork==0.2.1.post6
+# bpylist2==2.0.3;python_version<"3.8"
+https://github.com/RhetTbull/bpylist/releases/download/v2.0.3/bpylist2-2.0.3.tar.gz#egg=bpylist2;python_version<"3.8"
+bpylist2==3.0.0;python_version>="3.8"
 certifi==2019.3.9
 Click==7.0
 colorama==0.4.1
 coverage==4.5.4
-importlib-metadata==0.18
+importlib-metadata>=0.18
 isort==4.3.20
 lazy-object-proxy==1.4.1
 loguru==0.2.5
+macholib==1.14
+Mako==1.1.1
+MarkupSafe==1.1.1
 mccabe==0.6.1
+modulegraph==0.18
 more-itertools==7.2.0
--e git+https://github.com/RhetTbull/osxphotos.git@0271b8ad9daf8b2fb80ce81e894478370e421379#egg=osxphotos
 packaging==19.0
+pathspec==0.7.0
+pathvalidate==2.2.1
 pluggy==0.12.0
 py==1.8.0
+py2app==0.21
 Pygments==2.4.2
+PyInstaller==3.6
+pyinstaller-setuptools==2019.3
 pylint==2.3.1
 pyobjc==6.0.1
 pyobjc-core==6.0.1
@@ -134,13 +147,12 @@ pyobjc-framework-VideoToolbox==6.0.1
 pyobjc-framework-Vision==6.0.1
 pyobjc-framework-WebKit==6.0.1
 pyparsing==2.4.1.1
-pytest==5.3.1
-pytest-cov==2.8.1
-pytest-sugar==0.9.2
 PyYAML==5.1.2
+regex==2020.2.20
 six==1.12.0
 termcolor==1.1.0
+toml==0.10.0
+typed-ast==1.4.1
 wcwidth==0.1.7
 wrapt==1.11.1
 zipp==0.5.2
-Mako==1.1.1

setup.py

@@ -50,7 +50,7 @@ setup(
     url="https://github.com/RhetTbull/",
     project_urls={"GitHub": "https://github.com/RhetTbull/osxphotos"},
     download_url="https://github.com/RhetTbull/osxphotos",
-    packages=find_packages(exclude=["tests", "examples"]),
+    packages=find_packages(exclude=["tests", "examples", "utils"]),
     license="License :: OSI Approved :: MIT License",
     classifiers=[
         "Development Status :: 4 - Beta",
@@ -61,6 +61,15 @@ setup(
         "Programming Language :: Python :: 3.6",
         "Topic :: Software Development :: Libraries :: Python Modules",
     ],
-    install_requires=["pyobjc>=6.0.1", "Click>=7", "PyYAML>=5.1.2", "Mako>=1.1.1"],
+    install_requires=[
+        "pyobjc>=6.0.1",
+        "Click>=7",
+        "PyYAML>=5.1.2",
+        "Mako>=1.1.1",
+        "bpylist2==2.0.3;python_version<'3.8'",
+        "bpylist2==3.0.0;python_version>='3.8'",
+        "pathvalidate==2.2.1",
+    ],
     entry_points={"console_scripts": ["osxphotos=osxphotos.__main__:cli"]},
+    include_package_data=True,
 )

tests/Test-10.12.6.photoslibrary/private/com.apple.Photos/appPrivateData.plist

@@ -5,7 +5,7 @@
 	<key>LithiumMessageTracer</key>
 	<dict>
 		<key>LastReportedDate</key>
-		<date>2019-12-08T16:44:38Z</date>
+		<date>2020-04-17T18:39:50Z</date>
 	</dict>
 	<key>PXPeopleScreenUnlocked</key>
 	<true/>

tests/Test-10.12.6.photoslibrary/private/com.apple.photoanalysisd/GraphService/PhotoAnalysisServicePreferences.plist

@@ -3,8 +3,8 @@
 <plist version="1.0">
 <dict>
 	<key>PhotoAnalysisGraphLastBackgroundGraphRebuildJobDate</key>
-	<date>2020-01-22T02:10:26Z</date>
+	<date>2020-04-17T18:40:46Z</date>
 	<key>PhotoAnalysisGraphLastBackgroundMemoryGenerationJobDate</key>
-	<date>2020-01-22T02:10:27Z</date>
+	<date>2020-04-17T18:39:51Z</date>
 </dict>
 </plist>

tests/Test-10.12.6.photoslibrary/resources/moments/analysismetadata.plist

@@ -11,6 +11,6 @@
 	<key>PLLastRevGeoForcedProviderOutOfDateCheckVersionKey</key>
 	<integer>1</integer>
 	<key>PLLastRevGeoVerFileFetchDateKey</key>
-	<date>2020-01-19T17:29:28Z</date>
+	<date>2020-04-17T18:39:52Z</date>
 </dict>
 </plist>

tests/Test-10.12.6.photoslibrary/resources/moments/historicalmarker.plist

@@ -3,7 +3,7 @@
 <plist version="1.0">
 <dict>
 	<key>LastHistoryRowId</key>
-	<integer>414</integer>
+	<integer>502</integer>
 	<key>LibraryBuildTag</key>
 	<string>E3E46F2A-7168-4973-AB3E-5848F80BFC7D</string>
 	<key>LibrarySchemaVersion</key>

tests/Test-10.12.6.photoslibrary/resources/recovery/Info.plist

@@ -9,7 +9,7 @@
 	<key>HistoricalMarker</key>
 	<dict>
 		<key>LastHistoryRowId</key>
-		<integer>414</integer>
+		<integer>502</integer>
 		<key>LibraryBuildTag</key>
 		<string>E3E46F2A-7168-4973-AB3E-5848F80BFC7D</string>
 		<key>LibrarySchemaVersion</key>

tests/Test-10.14.6.photoslibrary/private/com.apple.Photos/appPrivateData.plist

@@ -9,12 +9,14 @@
 		<key>ExpandedSidebarItemIdentifiers</key>
 		<array>
 			<string>TopLevelAlbums</string>
+			<string>QtSnVvTkQ%i2z3hB834M1A</string>
 			<string>TopLevelSlideshows</string>
+			<string>N7eQ4VhfTfeHFp9PPHaJDw</string>
 		</array>
 		<key>IPXWorkspaceControllerZoomLevelsKey</key>
 		<dict>
 			<key>kZoomLevelIdentifierAlbums</key>
-			<integer>10</integer>
+			<integer>5</integer>
 			<key>kZoomLevelIdentifierVersions</key>
 			<integer>7</integer>
 		</dict>
@@ -23,11 +25,11 @@
 			<key>key</key>
 			<integer>1</integer>
 			<key>lastKnownDisplayName</key>
-			<string>Test Album (1)</string>
+			<string>Pumpkin Farm (1)</string>
 			<key>type</key>
 			<string>album</string>
 			<key>uuid</key>
-			<string>Uq6qsKihRRSjMHTiD+0Azg</string>
+			<string>xJ8ya3NBRWC24gKhcwwNeQ</string>
 		</dict>
 		<key>lastKnownItemCounts</key>
 		<dict>

tests/Test-10.14.6.photoslibrary/private/com.apple.photoanalysisd/GraphService/PhotoAnalysisServicePreferences.plist

@@ -3,8 +3,8 @@
 <plist version="1.0">
 <dict>
 	<key>PhotoAnalysisGraphLastBackgroundGraphRebuildJobDate</key>
-	<date>2020-01-29T06:24:15Z</date>
+	<date>2020-04-18T18:01:02Z</date>
 	<key>PhotoAnalysisGraphLastBackgroundMemoryGenerationJobDate</key>
-	<date>2020-01-29T13:44:20Z</date>
+	<date>2020-04-18T17:22:55Z</date>
 </dict>
 </plist>

tests/Test-10.14.6.photoslibrary/private/com.apple.photomodel/appPrivateData.plist

@@ -5,7 +5,7 @@
 	<key>LithiumMessageTracer</key>
 	<dict>
 		<key>LastReportedDate</key>
-		<date>2020-01-19T14:48:46Z</date>
+		<date>2020-04-17T17:51:16Z</date>
 	</dict>
 </dict>
 </plist>

tests/Test-10.14.6.photoslibrary/resources/moments/analysismetadata.plist

@@ -11,6 +11,6 @@
 	<key>PLLastRevGeoForcedProviderOutOfDateCheckVersionKey</key>
 	<integer>1</integer>
 	<key>PLLastRevGeoVerFileFetchDateKey</key>
-	<date>2020-01-29T06:24:08Z</date>
+	<date>2020-04-17T17:49:52Z</date>
 </dict>
 </plist>

tests/Test-10.14.6.photoslibrary/resources/moments/historicalmarker.plist

@@ -3,7 +3,7 @@
 <plist version="1.0">
 <dict>
 	<key>LastHistoryRowId</key>
-	<integer>575</integer>
+	<integer>606</integer>
 	<key>LibraryBuildTag</key>
 	<string>D8C4AAA1-3AB6-4A65-BEBD-99CC3E5D433E</string>
 	<key>LibrarySchemaVersion</key>

tests/Test-10.14.6.photoslibrary/resources/recovery/Info.plist

@@ -9,7 +9,7 @@
 	<key>HistoricalMarker</key>
 	<dict>
 		<key>LastHistoryRowId</key>
-		<integer>575</integer>
+		<integer>606</integer>
 		<key>LibraryBuildTag</key>
 		<string>D8C4AAA1-3AB6-4A65-BEBD-99CC3E5D433E</string>
 		<key>LibrarySchemaVersion</key>
@@ -24,7 +24,7 @@
 	<key>SnapshotCompletedDate</key>
 	<date>2019-07-27T13:16:43Z</date>
 	<key>SnapshotLastValidated</key>
-	<date>2020-01-29T06:26:14Z</date>
+	<date>2020-04-17T17:51:16Z</date>
 	<key>SnapshotTables</key>
 	<dict/>
 </dict>

tests/Test-10.15.1.photoslibrary/database/Photos.sqlite.lock

@@ -7,7 +7,7 @@
 	<key>hostuuid</key>
 	<string>9575E48B-8D5F-5654-ABAC-4431B1167324</string>
 	<key>pid</key>
-	<integer>1309</integer>
+	<integer>900</integer>
 	<key>processname</key>
 	<string>photolibraryd</string>
 	<key>uid</key>

tests/Test-10.15.1.photoslibrary/private/com.apple.photoanalysisd/caches/graph/PhotoAnalysisServicePreferences.plist

@@ -3,24 +3,24 @@
 <plist version="1.0">
 <dict>
 	<key>BackgroundHighlightCollection</key>
-	<date>2020-01-30T02:33:23Z</date>
+	<date>2020-04-17T14:33:32Z</date>
 	<key>BackgroundHighlightEnrichment</key>
-	<date>2020-01-30T02:33:23Z</date>
+	<date>2020-04-17T14:33:32Z</date>
 	<key>BackgroundJobAssetRevGeocode</key>
-	<date>2020-01-30T04:13:27Z</date>
+	<date>2020-04-17T14:33:33Z</date>
 	<key>BackgroundJobSearch</key>
-	<date>2020-01-30T02:33:24Z</date>
+	<date>2020-04-17T14:33:33Z</date>
 	<key>BackgroundPeopleSuggestion</key>
-	<date>2020-01-30T02:33:23Z</date>
+	<date>2020-04-17T14:33:31Z</date>
 	<key>BackgroundUserBehaviorProcessor</key>
-	<date>2020-01-30T02:33:24Z</date>
+	<date>2020-04-17T07:32:04Z</date>
 	<key>PhotoAnalysisGraphLastBackgroundGraphConsistencyUpdateJobDateKey</key>
-	<date>2020-01-30T04:13:27Z</date>
+	<date>2020-04-17T14:33:37Z</date>
 	<key>PhotoAnalysisGraphLastBackgroundGraphRebuildJobDate</key>
-	<date>2020-01-30T02:33:23Z</date>
+	<date>2020-04-17T07:32:00Z</date>
 	<key>PhotoAnalysisGraphLastBackgroundMemoryGenerationJobDate</key>
-	<date>2020-01-30T02:33:24Z</date>
+	<date>2020-04-17T14:33:34Z</date>
 	<key>SiriPortraitDonation</key>
-	<date>2020-01-30T02:33:24Z</date>
+	<date>2020-04-17T07:32:04Z</date>
 </dict>
 </plist>

tests/Test-10.15.1.photoslibrary/private/com.apple.photoanalysisd/caches/vision/PhotoAnalysisServicePreferences.plist

@@ -3,8 +3,8 @@
 <plist version="1.0">
 <dict>
 	<key>FaceIDModelLastGenerationKey</key>
-	<date>2020-01-30T02:33:24Z</date>
+	<date>2020-04-17T07:32:07Z</date>
 	<key>LastContactClassificationKey</key>
-	<date>2020-01-30T02:33:26Z</date>
+	<date>2020-04-17T07:32:12Z</date>
 </dict>
 </plist>

tests/Test-10.15.1.photoslibrary/resources/journals/Album.plist

@@ -3,7 +3,7 @@
 <plist version="1.0">
 <dict>
 	<key>coalesceDate</key>
-	<date>2019-12-08T18:06:37Z</date>
+	<date>2020-04-11T16:34:16Z</date>
 	<key>coalescePayloadVersion</key>
 	<integer>1</integer>
 	<key>currentPayloadVersion</key>

tests/Test-10.15.4.photoslibrary/database/DataModelVersion.plist

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>LibrarySchemaVersion</key>
+	<integer>5001</integer>
+	<key>MetaSchemaVersion</key>
+	<integer>3</integer>
+</dict>
+</plist>