geopic-tag-reader 0.0.1__tar.gz

geopic-tag-reader-0.0.1/.gitignore

@@ -0,0 +1,6 @@
+__pycache__
+*.egg-info
+dist/
+env/
+venv
+.cache/

geopic-tag-reader-0.0.1/.gitlab-ci.yml

@@ -0,0 +1,38 @@
+variables:
+  PIP_CACHE_DIR: "$CI_PROJECT_DIR/.cache/pip"
+
+cache:
+  paths:
+    - .cache/pip
+
+before_script:
+  - python --version # For debugging
+  - apk add --update --no-cache libc-dev libffi-dev gcc
+
+test mypy:
+  image: python:3.9-alpine
+  script:
+    - pip install .[dev]
+    - mypy geopic_tag_reader/
+
+lint:
+  image: python:3.9-alpine
+  script:
+    - pip install .[dev]
+    - black --fast --check .
+
+tests:
+  image: python:3.9-alpine
+  script:
+    - pip install .[dev]
+    - pytest -s -vv
+
+deploy_pypi:
+  stage: deploy
+  image: python:3.9-alpine
+  script:
+    - apk add --update --no-cache git
+    - pip install .[build]
+    - flit publish # use [flit](https://flit.pypa.io/) and FLIT_USERNAME/FLIT_PASSWORD env var
+  only:
+    - tags

geopic-tag-reader-0.0.1/CODE_OF_CONDUCT.md

@@ -0,0 +1,134 @@
+
+# Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall
+  community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email address,
+  without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official e-mail address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at panieravide@riseup.net
+
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations
+

geopic-tag-reader-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Geovisio team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

geopic-tag-reader-0.0.1/Makefile

@@ -0,0 +1,21 @@
+.DEFAULT_GOAL := help
+
+.PHONY: docs test type-check fmt ci
+
+test: ## Run tests
+	pytest
+
+type-check: ## Check all python types
+	mypy geopic_tag_reader/
+
+fmt: ## Format code
+	black --fast .
+
+ci: type-check fmt test ## Run all check like the ci
+
+docs:  ## Generates documentation from Typer embedded docs
+	python -m typer_cli ./geopic_tag_reader/main.py utils docs --name geopic-tag-reader --output docs/CLI_USAGE.md
+	lazydocs --overview-file API_USAGE.md --ignored-modules main --output-path docs/ geopic_tag_reader/
+
+help: ## Print this help message
+	@grep -E '^[a-zA-Z_-]+:.*## .*$$' $(MAKEFILE_LIST) | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}'

geopic-tag-reader-0.0.1/PKG-INFO

@@ -0,0 +1,173 @@
+Metadata-Version: 2.1
+Name: geopic-tag-reader
+Version: 0.0.1
+Summary: GeoPicTagReader
+Author-email: Adrien PAVIE <panieravide@riseup.net>
+Description-Content-Type: text/markdown
+Classifier: License :: OSI Approved :: MIT License
+Requires-Dist: typer ~= 0.7.0
+Requires-Dist: Pillow ~= 9.4.0
+Requires-Dist: xmltodict ~= 0.13.0
+Requires-Dist: flit ~= 3.8.0 ; extra == "build"
+Requires-Dist: black ~= 22.8.0 ; extra == "dev"
+Requires-Dist: mypy ~= 1.0.0 ; extra == "dev"
+Requires-Dist: pytest ~= 7.2.0 ; extra == "dev"
+Requires-Dist: pytest-datafiles ~= 2.0.1 ; extra == "dev"
+Requires-Dist: typer-cli ~= 0.0.13 ; extra == "dev"
+Requires-Dist: lazydocs ~= 0.4.8 ; extra == "dev"
+Requires-Dist: types-xmltodict ~= 0.13.0 ; extra == "dev"
+Requires-Dist: types-Pillow ~= 9.4.0 ; extra == "dev"
+Project-URL: Home, https://gitlab.com/geovisio/geo-picture-tag-reader
+Provides-Extra: build
+Provides-Extra: dev
+
+# GeoPicTagReader
+
+![GeoVisio logo](https://gitlab.com/geovisio/api/-/raw/develop/images/logo_full.png)
+
+Python library to extract standardized metadata from geolocated pictures EXIF metadata.
+
+[[_TOC_]]
+
+
+## Features
+
+This tool allows you to:
+
+- Analyse various EXIF variables to extract standardized metadata for geolocated pictures applications
+
+
+## Install
+
+GeoPicTagReader can be installed using two methods:
+
+- From [PyPI](https://pypi.org/project/geopictagreader/), the Python central package repository
+- Using this [Git repository](https://gitlab.com/geovisio/geo-picture-tag-reader)
+
+### From PyPI
+
+Just launch this command:
+
+```bash
+pip install geopic_tag_reader
+```
+
+After this you should be able to use the CLI tool with the name `geopic-tag-reader`:
+
+```bash
+geopic-tag-reader --help
+```
+
+Alternatively, you can use [pipx](https://github.com/pypa/pipx) if you want all the script dependencies to be in a custom virtual env.
+
+You need to [install pipx](https://pypa.github.io/pipx/installation/), then:
+
+```bash
+pipx install geopic_tag_reader
+```
+
+### From Git repository
+
+Download the repository:
+
+```bash
+git clone https://gitlab.com/geovisio/geo-picture-tag-reader.git geopic_tag_reader
+cd geopic_tag_reader/
+```
+
+To avoid conflicts, it's considered a good practice to create a _[virtual environment](https://docs.python.org/3/library/venv.html)_ (or virtualenv). To do so, launch the following commands:
+
+```bash
+# Create the virtual environment in a folder named "env"
+python3 -m venv env
+
+# Launches utilities to make environment available in your Bash
+source ./env/bin/activate
+```
+
+Then, install the dependencies using pip:
+
+```bash
+pip install -e .
+```
+
+You can also install the `dev` dependencies if necessary (to have lints, format, tests, ...):
+
+```bash
+pip install -e .[dev]
+```
+
+Then, you can use the `geopic-tag-reader` command:
+```bash
+geopic-tag-reader --help
+```
+
+
+## Usage
+
+This library can be used both from command-line or as Python module.
+
+### As command-line
+
+To see all available commands:
+
+```bash
+geopic-tag-reader --help
+```
+
+[Full documentation is also available here](./docs/CLI_USAGE.md).
+
+### As Python library
+
+In your own script, you can use:
+
+```python
+from geopic_tag_reader import reader
+from PIL import Image
+
+# Open an image with Pillow
+img = Image.open("my_picture.jpg")
+
+# Read EXIF metadata
+metadata = reader.readPictureMetadata(img)
+
+# Print results
+print(metadata)
+```
+
+[Full documentation is also available here](./docs/API_USAGE.md).
+
+
+## Development
+
+### Tests
+
+Tests are run using PyTest. You can simply run this command to launch tests:
+
+```bash
+pytest
+```
+
+### Documentation
+
+High-level documentation is handled by [Typer](https://typer.tiangolo.com/). You can update the generated `USAGE.md` file using this command:
+
+```bash
+make docs
+```
+
+### Contributing
+
+Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.
+
+Note that before opening a pull requests, you may want to check formatting and tests of your changes:
+
+```bash
+make ci
+```
+
+
+## License
+
+Copyright (c) GeoVisio team 2023, [released under MIT license](./LICENSE).
+

geopic-tag-reader-0.0.1/README.md

@@ -0,0 +1,149 @@
+# GeoPicTagReader
+
+![GeoVisio logo](https://gitlab.com/geovisio/api/-/raw/develop/images/logo_full.png)
+
+Python library to extract standardized metadata from geolocated pictures EXIF metadata.
+
+[[_TOC_]]
+
+
+## Features
+
+This tool allows you to:
+
+- Analyse various EXIF variables to extract standardized metadata for geolocated pictures applications
+
+
+## Install
+
+GeoPicTagReader can be installed using two methods:
+
+- From [PyPI](https://pypi.org/project/geopictagreader/), the Python central package repository
+- Using this [Git repository](https://gitlab.com/geovisio/geo-picture-tag-reader)
+
+### From PyPI
+
+Just launch this command:
+
+```bash
+pip install geopic_tag_reader
+```
+
+After this you should be able to use the CLI tool with the name `geopic-tag-reader`:
+
+```bash
+geopic-tag-reader --help
+```
+
+Alternatively, you can use [pipx](https://github.com/pypa/pipx) if you want all the script dependencies to be in a custom virtual env.
+
+You need to [install pipx](https://pypa.github.io/pipx/installation/), then:
+
+```bash
+pipx install geopic_tag_reader
+```
+
+### From Git repository
+
+Download the repository:
+
+```bash
+git clone https://gitlab.com/geovisio/geo-picture-tag-reader.git geopic_tag_reader
+cd geopic_tag_reader/
+```
+
+To avoid conflicts, it's considered a good practice to create a _[virtual environment](https://docs.python.org/3/library/venv.html)_ (or virtualenv). To do so, launch the following commands:
+
+```bash
+# Create the virtual environment in a folder named "env"
+python3 -m venv env
+
+# Launches utilities to make environment available in your Bash
+source ./env/bin/activate
+```
+
+Then, install the dependencies using pip:
+
+```bash
+pip install -e .
+```
+
+You can also install the `dev` dependencies if necessary (to have lints, format, tests, ...):
+
+```bash
+pip install -e .[dev]
+```
+
+Then, you can use the `geopic-tag-reader` command:
+```bash
+geopic-tag-reader --help
+```
+
+
+## Usage
+
+This library can be used both from command-line or as Python module.
+
+### As command-line
+
+To see all available commands:
+
+```bash
+geopic-tag-reader --help
+```
+
+[Full documentation is also available here](./docs/CLI_USAGE.md).
+
+### As Python library
+
+In your own script, you can use:
+
+```python
+from geopic_tag_reader import reader
+from PIL import Image
+
+# Open an image with Pillow
+img = Image.open("my_picture.jpg")
+
+# Read EXIF metadata
+metadata = reader.readPictureMetadata(img)
+
+# Print results
+print(metadata)
+```
+
+[Full documentation is also available here](./docs/API_USAGE.md).
+
+
+## Development
+
+### Tests
+
+Tests are run using PyTest. You can simply run this command to launch tests:
+
+```bash
+pytest
+```
+
+### Documentation
+
+High-level documentation is handled by [Typer](https://typer.tiangolo.com/). You can update the generated `USAGE.md` file using this command:
+
+```bash
+make docs
+```
+
+### Contributing
+
+Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.
+
+Note that before opening a pull requests, you may want to check formatting and tests of your changes:
+
+```bash
+make ci
+```
+
+
+## License
+
+Copyright (c) GeoVisio team 2023, [released under MIT license](./LICENSE).

geopic-tag-reader-0.0.1/docs/.pages

@@ -0,0 +1,4 @@
+title: API Reference
+nav:
+    - Overview: API_USAGE.md
+    - ...

geopic-tag-reader-0.0.1/docs/API_USAGE.md

@@ -0,0 +1,23 @@
+<!-- markdownlint-disable -->
+
+# API Overview
+
+## Modules
+
+- [`reader`](./reader.md#module-reader)
+
+## Classes
+
+- [`reader.GeoPicTags`](./reader.md#class-geopictags): Tags associated to a geolocated picture
+- [`reader.PartialExifException`](./reader.md#class-partialexifexception): Exception for partial / missing EXIF information from image
+
+## Functions
+
+- [`reader.decodeMakeModel`](./reader.md#function-decodemakemodel): Python 2/3 compatible decoding of make/model field.
+- [`reader.isExifTagUsable`](./reader.md#function-isexiftagusable): Is a given EXIF tag usable (not null and not an empty string)
+- [`reader.readPictureMetadata`](./reader.md#function-readpicturemetadata): Extracts metadata from picture file
+
+
+---
+
+_This file was automatically generated via [lazydocs](https://github.com/ml-tooling/lazydocs)._

geopic-tag-reader-0.0.1/docs/CLI_USAGE.md

@@ -0,0 +1,16 @@
+# `geopic-tag-reader`
+
+Reads EXIF metadata from a picture file, and prints results
+
+**Usage**:
+
+```console
+$ geopic-tag-reader [OPTIONS]
+```
+
+**Options**:
+
+* `--image PATH`: Path to your JPEG image file  [required]
+* `--install-completion`: Install completion for the current shell.
+* `--show-completion`: Show completion for the current shell, to copy it or customize the installation.
+* `--help`: Show this message and exit.

geopic-tag-reader-0.0.1/docs/reader.md

@@ -0,0 +1,150 @@
+<!-- markdownlint-disable -->
+
+<a href="../geopic_tag_reader/reader.py#L0"><img align="right" style="float:right;" src="https://img.shields.io/badge/-source-cccccc?style=flat-square"></a>
+
+# <kbd>module</kbd> `reader`
+
+
+
+
+
+---
+
+<a href="../geopic_tag_reader/reader.py#L42"><img align="right" style="float:right;" src="https://img.shields.io/badge/-source-cccccc?style=flat-square"></a>
+
+## <kbd>function</kbd> `readPictureMetadata`
+
+```python
+readPictureMetadata(picture)
+```
+
+Extracts metadata from picture file 
+
+
+
+**Args:**
+ 
+ - <b>`picture`</b> (PIL.Image):  Picture file 
+
+
+
+**Returns:**
+ 
+ - <b>`GeoPicTags`</b>:  Extracted metadata from picture 
+
+
+---
+
+<a href="../geopic_tag_reader/reader.py#L194"><img align="right" style="float:right;" src="https://img.shields.io/badge/-source-cccccc?style=flat-square"></a>
+
+## <kbd>function</kbd> `decodeMakeModel`
+
+```python
+decodeMakeModel(value)
+```
+
+Python 2/3 compatible decoding of make/model field. 
+
+
+---
+
+<a href="../geopic_tag_reader/reader.py#L205"><img align="right" style="float:right;" src="https://img.shields.io/badge/-source-cccccc?style=flat-square"></a>
+
+## <kbd>function</kbd> `isExifTagUsable`
+
+```python
+isExifTagUsable(exif, tag, expectedType=<class 'str'>)
+```
+
+Is a given EXIF tag usable (not null and not an empty string) 
+
+
+
+**Args:**
+ 
+ - <b>`exif`</b> (dict):  The EXIF tags 
+ - <b>`tag`</b> (str):  The tag to check 
+ - <b>`expectedType`</b> (class):  The expected data type 
+
+
+
+**Returns:**
+ 
+ - <b>`bool`</b>:  True if not empty 
+
+
+---
+
+<a href="../geopic_tag_reader/reader.py#L8"><img align="right" style="float:right;" src="https://img.shields.io/badge/-source-cccccc?style=flat-square"></a>
+
+## <kbd>class</kbd> `GeoPicTags`
+Tags associated to a geolocated picture 
+
+
+
+**Attributes:**
+ 
+ - <b>`lat`</b> (float):  GPS Latitude (in WGS84) 
+ - <b>`lon`</b> (float):  GPS Longitude (in WGS84) 
+ - <b>`ts`</b> (float):  The capture date (as POSIX timestamp) 
+ - <b>`heading`</b> (int):  Picture heading (in degrees, North = 0°, East = 90°, South = 180°, West = 270°) 
+ - <b>`type`</b> (str):  The kind of picture (flat, equirectangular) 
+ - <b>`make`</b> (str):  The camera manufacturer name 
+ - <b>`model`</b> (str):  The camera model name 
+ - <b>`focal_length`</b> (float):  The camera focal length (in mm) 
+ - <b>`exif`</b> (dict[str, str]):  Raw EXIF tags from picture 
+
+<a href="../<string>"><img align="right" style="float:right;" src="https://img.shields.io/badge/-source-cccccc?style=flat-square"></a>
+
+### <kbd>method</kbd> `__init__`
+
+```python
+__init__(
+    lat: float,
+    lon: float,
+    ts: float,
+    heading: int,
+    type: str,
+    make: str,
+    model: str,
+    focal_length: float,
+    exif: Dict[str, str] = <factory>
+) → None
+```
+
+
+
+
+
+
+
+
+
+---
+
+<a href="../geopic_tag_reader/reader.py#L35"><img align="right" style="float:right;" src="https://img.shields.io/badge/-source-cccccc?style=flat-square"></a>
+
+## <kbd>class</kbd> `PartialExifException`
+Exception for partial / missing EXIF information from image 
+
+<a href="../geopic_tag_reader/reader.py#L38"><img align="right" style="float:right;" src="https://img.shields.io/badge/-source-cccccc?style=flat-square"></a>
+
+### <kbd>method</kbd> `__init__`
+
+```python
+__init__(msg)
+```
+
+
+
+
+
+
+
+
+
+
+
+---
+
+_This file was automatically generated via [lazydocs](https://github.com/ml-tooling/lazydocs)._

geopic-tag-reader-0.0.1/geopic_tag_reader/__init__.py

@@ -0,0 +1,4 @@
+"""
+GeoPicTagReader
+"""
+__version__ = "0.0.1"

geopic-tag-reader-0.0.1/geopic_tag_reader/main.py

@@ -0,0 +1,29 @@
+import typer
+from pathlib import Path
+from geopic_tag_reader import reader
+from PIL import Image
+
+app = typer.Typer(help="GeoPicTagReader")
+
+
+@app.command()
+def read(
+    image: Path = typer.Option(..., help="Path to your JPEG image file"),
+):
+    """Reads EXIF metadata from a picture file, and prints results"""
+
+    img = Image.open(image)
+    metadata = reader.readPictureMetadata(img)
+
+    print("Latitude:", metadata.lat)
+    print("Longitude:", metadata.lon)
+    print("Timestamp:", metadata.ts)
+    print("Heading:", metadata.heading)
+    print("Type:", metadata.type)
+    print("Make:", metadata.make)
+    print("Model:", metadata.model)
+    print("Focal length:", metadata.focal_length)
+
+
+if __name__ == "__main__":
+    app()

geopic-tag-reader-0.0.1/geopic_tag_reader/reader.py

@@ -0,0 +1,231 @@
+from PIL import Image, ExifTags
+import xmltodict
+import datetime
+from dataclasses import dataclass, field
+from typing import Dict
+
+
+@dataclass
+class GeoPicTags:
+    """Tags associated to a geolocated picture
+
+    Attributes:
+        lat (float): GPS Latitude (in WGS84)
+        lon (float): GPS Longitude (in WGS84)
+        ts (float): The capture date (as POSIX timestamp)
+        heading (int): Picture heading (in degrees, North = 0°, East = 90°, South = 180°, West = 270°)
+        type (str): The kind of picture (flat, equirectangular)
+        make (str): The camera manufacturer name
+        model (str): The camera model name
+        focal_length (float): The camera focal length (in mm)
+        exif (dict[str, str]): Raw EXIF tags from picture
+    """
+
+    lat: float
+    lon: float
+    ts: float
+    heading: int
+    type: str
+    make: str
+    model: str
+    focal_length: float
+    exif: Dict[str, str] = field(default_factory=lambda: {})
+
+
+class PartialExifException(Exception):
+    """Exception for partial / missing EXIF information from image"""
+
+    def __init__(self, msg):
+        super().__init__(msg)
+
+
+def readPictureMetadata(picture):
+    """Extracts metadata from picture file
+
+    Args:
+        picture (PIL.Image): Picture file
+
+    Returns:
+        GeoPicTags: Extracted metadata from picture
+    """
+
+    data = {}
+
+    info = picture._getexif()
+    if info:
+        for tag, value in info.items():
+            decoded = ExifTags.TAGS.get(tag, tag)
+            if decoded == "GPSInfo":
+                for t in value:
+                    sub_decoded = ExifTags.GPSTAGS.get(t, t)
+                    data[sub_decoded] = value[t]
+            else:
+                data[decoded] = value
+
+    # Read XMP tags
+    for segment, content in picture.applist:
+        if segment == "APP1":
+            marker, body = content.split(b"\x00", 1)
+            if marker == b"http://ns.adobe.com/xap/1.0/":
+                body = body.strip(b"\00")
+                description = xmltodict.parse(body)["x:xmpmeta"]["rdf:RDF"][
+                    "rdf:Description"
+                ]
+                if isinstance(description, list):
+                    # there can be several rdf:Description, if that's the case, we merge them all
+                    description = {k: v for d in description for k, v in d.items()}
+                data = data | description
+
+    # Cleanup XMP tags with @
+    for k in list(data):
+        if k.startswith("@"):
+            data[k[1:]] = data[k]
+            del data[k]
+
+    # Parse latitude/longitude
+    if (
+        isExifTagUsable(data, "GPSLatitude", tuple)
+        and isExifTagUsable(data, "GPSLongitude", tuple)
+        and isExifTagUsable(data, "GPSLatitudeRef")
+        and isExifTagUsable(data, "GPSLongitudeRef")
+    ):
+        latRaw = data["GPSLatitude"]
+        lat = (-1 if data["GPSLatitudeRef"] == "S" else 1) * (
+            float(latRaw[0]) + float(latRaw[1]) / 60 + float(latRaw[2]) / 3600
+        )
+
+        lonRaw = data["GPSLongitude"]
+        lon = (-1 if data["GPSLongitudeRef"] == "W" else 1) * (
+            float(lonRaw[0]) + float(lonRaw[1]) / 60 + float(lonRaw[2]) / 3600
+        )
+    else:
+        raise PartialExifException(
+            "No GPS coordinates or broken coordinates in picture EXIF tags"
+        )
+
+    # Parse date/time
+    if isExifTagUsable(data, "GPSTimeStamp", tuple) and isExifTagUsable(
+        data, "GPSDateStamp"
+    ):
+        timeRaw = data["GPSTimeStamp"]
+        dateRaw = data["GPSDateStamp"].replace(":", "-").replace("\x00", "")
+        msRaw = (
+            data["SubSecTimeOriginal"]
+            if isExifTagUsable(data, "SubSecTimeOriginal", float)
+            else "0"
+        )
+        d = datetime.datetime.combine(
+            datetime.date.fromisoformat(dateRaw),
+            datetime.time(
+                int(timeRaw[0]),
+                int(timeRaw[1]),
+                int(timeRaw[2]),
+                int(msRaw[:6].ljust(6, "0")),
+                tzinfo=datetime.timezone.utc,
+            ),
+        )
+    elif isExifTagUsable(data, "DateTimeOriginal"):
+        dateRaw = data["DateTimeOriginal"].split(" ")[0].replace(":", "-")
+        timeRaw = data["DateTimeOriginal"].split(" ")[1].split(":")
+        msRaw = (
+            data["SubSecTimeOriginal"]
+            if isExifTagUsable(data, "SubSecTimeOriginal", float)
+            else "0"
+        )
+        d = datetime.datetime.combine(
+            datetime.date.fromisoformat(dateRaw),
+            datetime.time(
+                int(timeRaw[0]),
+                int(timeRaw[1]),
+                int(timeRaw[2]),
+                int(msRaw[:6].ljust(6, "0")),
+                tzinfo=datetime.timezone.utc,
+            ),
+        )
+    else:
+        raise PartialExifException("No date in picture EXIF tags")
+
+    # Heading
+    heading = None
+    if isExifTagUsable(data, "GPano:PoseHeadingDegrees", float) and isExifTagUsable(
+        data, "GPSImgDirection", float
+    ):
+        gpsDir = int(round(data["GPSImgDirection"]))
+        gpanoHeading = int(round(float(data["GPano:PoseHeadingDegrees"])))
+        if gpsDir > 0 and gpanoHeading == 0:
+            heading = gpsDir
+        elif gpsDir == 0 and gpanoHeading > 0:
+            heading = gpanoHeading
+        else:
+            if gpsDir == gpanoHeading:
+                heading = gpanoHeading
+            else:
+                raise PartialExifException(
+                    "Contradicting heading values in EXIF PoseHeadingDegrees and GPSImgDirection tags"
+                )
+    elif isExifTagUsable(data, "GPano:PoseHeadingDegrees", float):
+        heading = int(round(float(data["GPano:PoseHeadingDegrees"])))
+    elif isExifTagUsable(data, "GPSImgDirection", float):
+        heading = int(round(data["GPSImgDirection"]))
+
+    # Make and model
+    make = decodeMakeModel(data["Make"]).strip() if "Make" in data else None
+    model = decodeMakeModel(data["Model"]).strip() if "Model" in data else None
+    if model is not None and model is not None:
+        model = model.replace(make, "").strip()
+
+    return GeoPicTags(
+        lat,
+        lon,
+        d.timestamp(),
+        heading,
+        data["GPano:ProjectionType"]
+        if isExifTagUsable(data, "GPano:ProjectionType")
+        else "flat",
+        make,
+        model,
+        float(data["FocalLength"])
+        if isExifTagUsable(data, "FocalLength", float)
+        else None,
+        data,
+    )
+
+
+def decodeMakeModel(value):
+    """Python 2/3 compatible decoding of make/model field."""
+    if hasattr(value, "decode"):
+        try:
+            return value.decode("utf-8").replace("\x00", "")
+        except UnicodeDecodeError:
+            return None
+    else:
+        return value.replace("\x00", "")
+
+
+def isExifTagUsable(exif, tag, expectedType=str):
+    """Is a given EXIF tag usable (not null and not an empty string)
+
+    Args:
+        exif (dict): The EXIF tags
+        tag (str): The tag to check
+        expectedType (class): The expected data type
+
+    Returns:
+        bool: True if not empty
+    """
+
+    try:
+        if not tag in exif:
+            return False
+        elif not (expectedType == float or isinstance(exif[tag], expectedType)):
+            return False
+        elif not (
+            expectedType != str or len(exif[tag].strip().replace("\x00", "")) > 0
+        ):
+            return False
+        elif not (expectedType != float or float(exif[tag]) is not None):
+            return False
+        else:
+            return True
+    except ValueError:
+        return False

geopic-tag-reader-0.0.1/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["flit_core ~= 3.8,<4"]
+build-backend = "flit_core.buildapi"
+
+[project]
+name = "geopic-tag-reader"
+authors = [
+    {name = "Adrien PAVIE", email = "panieravide@riseup.net"},
+]
+readme = "README.md"
+license = {file = "LICENSE"}
+classifiers = ["License :: OSI Approved :: MIT License"]
+dynamic = ["version", "description"]
+dependencies = [
+    "typer ~= 0.7.0",
+    "Pillow ~= 9.4.0",
+    "xmltodict ~= 0.13.0",
+]
+
+[project.urls]
+Home = "https://gitlab.com/geovisio/geo-picture-tag-reader"
+
+[project.scripts]
+geopic-tag-reader="geopic_tag_reader.main:app"
+
+[project.optional-dependencies]
+dev = [
+    "black ~= 22.8.0",
+    "mypy ~= 1.0.0",
+    "pytest ~= 7.2.0",
+    "pytest-datafiles ~= 2.0.1",
+    "typer-cli ~= 0.0.13",
+    "lazydocs ~= 0.4.8",
+    "types-xmltodict ~= 0.13.0",
+    "types-Pillow ~= 9.4.0",
+]
+build = ["flit ~= 3.8.0"]
+
+[tool.pytest.ini_options]
+addopts = [
+    "--import-mode=importlib",
+]

geopic-tag-reader-0.0.1/tests/test_reader.py

@@ -0,0 +1,192 @@
+import os
+import pytest
+from PIL import Image
+from geopic_tag_reader import reader
+
+FIXTURE_DIR = os.path.join(os.path.dirname(os.path.realpath(__file__)), "fixtures")
+
+
+def assertGeoPicTagsEquals(gpt, expectedDict):
+    assert gpt.lat == expectedDict.get("lat")
+    assert gpt.lon == expectedDict.get("lon")
+    assert gpt.ts == expectedDict.get("ts")
+    assert gpt.heading == expectedDict.get("heading")
+    assert gpt.type == expectedDict.get("type")
+    assert gpt.make == expectedDict.get("make")
+    assert gpt.model == expectedDict.get("model")
+    assert gpt.focal_length == expectedDict.get("focal_length")
+    assert len(gpt.exif) > 0
+
+
+@pytest.mark.datafiles(os.path.join(FIXTURE_DIR, "1.jpg"))
+def test_readPictureMetadata(datafiles):
+    result = reader.readPictureMetadata(Image.open(str(datafiles) + "/1.jpg"))
+    assertGeoPicTagsEquals(
+        result,
+        {
+            "lat": 49.00688961988304,
+            "lon": 1.9191854417991367,
+            "ts": 1627550214.0,
+            "heading": 349,
+            "type": "equirectangular",
+            "make": "GoPro",
+            "model": "Max",
+            "focal_length": 3,
+        },
+    )
+
+
+@pytest.mark.datafiles(os.path.join(FIXTURE_DIR, "a1.jpg"))
+def test_readPictureMetadata_negCoords(datafiles):
+    result = reader.readPictureMetadata(Image.open(str(datafiles) + "/a1.jpg"))
+    assertGeoPicTagsEquals(
+        result,
+        {
+            "lat": 48.33756428166505,
+            "lon": -1.9331088333333333,
+            "ts": 1652453580.0,
+            "heading": 32,
+            "type": "equirectangular",
+            "make": "GoPro",
+            "model": "Max",
+            "focal_length": 3,
+        },
+    )
+
+
+@pytest.mark.datafiles(os.path.join(FIXTURE_DIR, "b1.jpg"))
+def test_readPictureMetadata_flat(datafiles):
+    result = reader.readPictureMetadata(Image.open(str(datafiles) + "/b1.jpg"))
+    assertGeoPicTagsEquals(
+        result,
+        {
+            "lat": 48.139852239480945,
+            "lon": -1.9499731060073981,
+            "ts": 1429976268.0,
+            "heading": 155,
+            "type": "flat",
+            "make": "OLYMPUS IMAGING CORP.",
+            "model": "SP-720UZ",
+            "focal_length": 4.66,
+        },
+    )
+
+
+@pytest.mark.datafiles(os.path.join(FIXTURE_DIR, "c1.jpg"))
+def test_readPictureMetadata_flat2(datafiles):
+    result = reader.readPictureMetadata(Image.open(str(datafiles) + "/c1.jpg"))
+    assertGeoPicTagsEquals(
+        result,
+        {
+            "lat": 48.85779642035038,
+            "lon": 2.3392783047650747,
+            "ts": 1430744932.0,
+            "heading": 302,
+            "type": "flat",
+            "make": "Canon",
+            "model": "EOS 6D0",
+            "focal_length": 35.0,
+        },
+    )
+
+
+@pytest.mark.datafiles(os.path.join(FIXTURE_DIR, "d1.jpg"))
+def test_readPictureMetadata_xmpHeading(datafiles):
+    result = reader.readPictureMetadata(Image.open(str(datafiles) + "/d1.jpg"))
+    assertGeoPicTagsEquals(
+        result,
+        {
+            "lat": 50.87070833333333,
+            "lon": -1.5260916666666666,
+            "ts": 1600008019.0,
+            "heading": 67,
+            "type": "equirectangular",
+            "make": "Google",
+            "model": "Pixel 3",
+            "focal_length": None,
+        },
+    )
+
+
+@pytest.mark.datafiles(os.path.join(FIXTURE_DIR, "e1.jpg"))
+def test_readPictureMetadata_noHeading(datafiles):
+    result = reader.readPictureMetadata(Image.open(str(datafiles) + "/e1.jpg"))
+    assertGeoPicTagsEquals(
+        result,
+        {
+            "lat": 48.15506638888889,
+            "lon": -1.6844680555555556,
+            "ts": 1666166194.0,
+            "heading": None,
+            "type": "flat",
+            "make": "SONY",
+            "model": "FDR-X1000V",
+            "focal_length": 2.8,
+        },
+    )
+
+
+@pytest.mark.datafiles(os.path.join(FIXTURE_DIR, "img_Ricoh_Theta.jpg"))
+def test_readPictureMetadata_ricoh_theta(datafiles):
+    for f in datafiles.listdir():
+        result = reader.readPictureMetadata(Image.open(str(f)))
+        assertGeoPicTagsEquals(
+            result,
+            {
+                "focal_length": 0.75,
+                "heading": 270,
+                "lat": 48.83930905577957,
+                "lon": 2.3205357914890987,
+                "make": "RICOH",
+                "model": "THETA m15",
+                "ts": 1458911533.0,
+                "type": "equirectangular",
+            },
+        )
+
+
+@pytest.mark.datafiles(os.path.join(FIXTURE_DIR, "img_V4MPack.jpg"))
+def test_readPictureMetadata_v4mpack(datafiles):
+    for f in datafiles.listdir():
+        result = reader.readPictureMetadata(Image.open(str(f)))
+        assertGeoPicTagsEquals(
+            result,
+            {
+                "focal_length": None,
+                "heading": 64,
+                "lat": 47.08506017299737,
+                "lon": -1.2761512389983616,
+                "make": "STFMANI",
+                "model": "V4MPOD 1",
+                "ts": 1555417213.0,
+                "type": "equirectangular",
+            },
+        )
+
+
+@pytest.mark.datafiles(os.path.join(FIXTURE_DIR, "IMG_20210720_161352.jpg"))
+def test_readPictureMetadata_a5000(datafiles):
+    result = reader.readPictureMetadata(
+        Image.open(str(datafiles) + "/IMG_20210720_161352.jpg")
+    )
+    assertGeoPicTagsEquals(
+        result,
+        {
+            "focal_length": 4.103,
+            "heading": 355,
+            "lat": 48.96280504578332,
+            "lon": 2.51197323068765,
+            "make": "OnePlus",
+            "model": "ONEPLUS A5000",
+            "ts": 1626797632.0,
+            "type": "flat",
+        },
+    )
+
+
+@pytest.mark.datafiles(os.path.join(FIXTURE_DIR, "IMG_20210720_144918.jpg"))
+def test_readPictureMetadata_a5000_2(datafiles):
+    with pytest.raises(reader.PartialExifException) as e_info:
+        result = reader.readPictureMetadata(
+            Image.open(str(datafiles) + "/IMG_20210720_144918.jpg")
+        )