stele1-filesystem 0.0.1__tar.gz

stele1_filesystem-0.0.1/LICENSE

@@ -0,0 +1,8 @@
+Copyright (c) Stele Climbing contributors
+
+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.
+

stele1_filesystem-0.0.1/PKG-INFO

@@ -0,0 +1,62 @@
+Metadata-Version: 2.4
+Name: stele1-filesystem
+Version: 0.0.1
+Summary: Filesystem interface for stele1 catalogs
+Author-email: Daniel M <contact@steleclimbing.org>
+License-Expression: MIT
+Project-URL: Homepage, https://stele1.steleclimbing.org
+Project-URL: Repository, https://codeberg.org/stele-climbing/stele1
+Project-URL: Issues, https://codeberg.org/stele-climbing/stele1/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 4 - Beta
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: stele1-datatypes>=0.0.1
+Dynamic: license-file
+
+# stele1-filesystem
+
+Filesystem interface for [stele1](https://stele1.steleclimbing.org) catalogs.
+
+Reads and writes catalogs on disk. Each catalog is a directory; records are
+individual JSON files organized by datatype.
+
+Exposes primitives: get, set, list, remove.
+Higher-level operations (queries, traversals, indexing) are left to consumers.
+
+## Use
+
+```python
+from stele1.filesystem import Catalog
+
+catalog = Catalog('/path/to/catalog.stele1.d')
+
+if not catalog.exists():
+    catalog.create()
+
+for uuid in catalog.climb_uuids():
+    climb = catalog.get_climb_by_uuid(uuid)
+    climb.get_name().to_data()  # 'The Mandala'
+```
+
+Each datatype (`Climb`, `Area`, `Photo`, `Parking`, `Approach`) has matching
+`{type}_uuids()`, `get_{type}_by_uuid(uuid)`, `set_{type}({type})`, and
+`remove_{type}_by_uuid(uuid)` methods.
+
+Photos additionally support `get_photo_image_by_uuid` and
+`set_photo_image_by_uuid` for the associated image file.
+
+See [stele1-datatypes](https://pypi.org/project/stele1-datatypes/) for the
+datatypes returned by the getters.
+
+## Install
+
+```
+pip install stele1-filesystem
+```
+
+## License
+
+MIT

stele1_filesystem-0.0.1/README.md

@@ -0,0 +1,44 @@
+# stele1-filesystem
+
+Filesystem interface for [stele1](https://stele1.steleclimbing.org) catalogs.
+
+Reads and writes catalogs on disk. Each catalog is a directory; records are
+individual JSON files organized by datatype.
+
+Exposes primitives: get, set, list, remove.
+Higher-level operations (queries, traversals, indexing) are left to consumers.
+
+## Use
+
+```python
+from stele1.filesystem import Catalog
+
+catalog = Catalog('/path/to/catalog.stele1.d')
+
+if not catalog.exists():
+    catalog.create()
+
+for uuid in catalog.climb_uuids():
+    climb = catalog.get_climb_by_uuid(uuid)
+    climb.get_name().to_data()  # 'The Mandala'
+```
+
+Each datatype (`Climb`, `Area`, `Photo`, `Parking`, `Approach`) has matching
+`{type}_uuids()`, `get_{type}_by_uuid(uuid)`, `set_{type}({type})`, and
+`remove_{type}_by_uuid(uuid)` methods.
+
+Photos additionally support `get_photo_image_by_uuid` and
+`set_photo_image_by_uuid` for the associated image file.
+
+See [stele1-datatypes](https://pypi.org/project/stele1-datatypes/) for the
+datatypes returned by the getters.
+
+## Install
+
+```
+pip install stele1-filesystem
+```
+
+## License
+
+MIT

stele1_filesystem-0.0.1/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "stele1-filesystem"
+version = "0.0.1"
+description = "Filesystem interface for stele1 catalogs"
+readme = "README.md"
+license = "MIT"
+authors = [{ name = "Daniel M", email = "contact@steleclimbing.org" }]
+requires-python = ">=3.8"
+dependencies = [
+  "stele1-datatypes>=0.0.1",
+]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Operating System :: OS Independent",
+  "Development Status :: 4 - Beta",
+]
+
+[project.urls]
+Homepage = "https://stele1.steleclimbing.org"
+Repository = "https://codeberg.org/stele-climbing/stele1"
+Issues = "https://codeberg.org/stele-climbing/stele1/issues"
+
+[tool.setuptools.packages.find]
+namespaces = true
+where = ["."]

stele1_filesystem-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

stele1_filesystem-0.0.1/stele1/filesystem.py

@@ -0,0 +1,248 @@
+import shutil
+import os
+import os.path
+import json
+
+import stele1.climb as climb
+import stele1.approach as approach
+import stele1.photo as photo
+import stele1.parking as parking
+import stele1.area as area
+import stele1.metadata as metadata
+
+class Catalog:
+
+    def __init__(self, path):
+        self._path_original = path;
+        self._path = os.path.abspath(path);
+    def _subpath(self, *segments):
+        return os.path.join(self._path, *segments)
+    def _ensure_dir(self, path):
+        if not os.path.isdir(path):
+            os.mkdir(path)
+        return None
+    def _ensure_parent_dir(self, path):
+        return self._ensure_dir(os.path.dirname(path))
+
+    def exists(self):
+        isfile = os.path.isfile
+        metafile = self._subpath('stele1.json')
+        humanfile = self._subpath('stele1.txt')
+        return isfile(metafile) and isfile(humanfile)
+
+    def create(self):
+        parent = os.path.dirname(self._path)
+        if os.path.isdir(self._path):
+            raise Exception(f'directory exists {self._path}')
+        if not os.path.isdir(parent):
+            raise Exception(f'parent directory missing {parent} (for {self._path})')
+        os.mkdir(self._path)
+        os.mkdir(self._subpath('climbs'))
+        os.mkdir(self._subpath('approaches'))
+        os.mkdir(self._subpath('photos'))
+        os.mkdir(self._subpath('parkings'))
+        os.mkdir(self._subpath('areas'))
+        with open(os.path.join(self._path, 'stele1.txt'), 'w') as f:
+            f.write('stele1' + os.linesep)
+        self.set_metadata(metadata.Metadata())
+
+    def get_metadata(self):
+        metapath = self._subpath('stele1.json')
+        if os.path.isfile(metapath):
+            with open(metapath, 'r') as f:
+                try:
+                    return metadata.Metadata.from_data(json.load(f))
+                except json.decoder.JSONDecodeError as e:
+                    raise Exception(f'bad json at {pat}: {e.args[0]}')
+        else:
+            return None
+    def set_metadata(self, metadata):
+        metapath = self._subpath('stele1.json')
+        if os.path.isdir(os.path.dirname(metapath)):
+            with open(metapath, 'w') as f:
+                json.dump(metadata.to_data(), f, indent=4, ensure_ascii=False)
+                f.write(os.linesep)
+        else:
+            return None
+
+    def climb_uuids(self):
+        dir = self._subpath('climbs')
+        if os.path.isdir(dir):
+            for f in os.listdir(dir):
+                if f.endswith('.json'):
+                    yield climb.Uuid.from_data(f.replace('.json', ''))
+    def get_climb_by_uuid(self, uuid):
+        pat = self._subpath('climbs', uuid.to_data() + '.json')
+        if os.path.isfile(pat):
+            with open(pat, 'r') as f:
+                try:
+                    e = climb.Climb.from_data(json.load(f)) 
+                    if uuid.to_data() != e.get_uuid().to_data():
+                        raise Exception(f'path {pat} does not match the uuid {e.get_uuid().to_data()}')
+                    return e
+                except json.decoder.JSONDecodeError as e:
+                    raise Exception(f'bad json at {pat}: {e.args[0]}')
+    def set_climb(self, climb):
+        uuid = climb.get_uuid()
+        if not uuid:
+            raise Exception('can not use climb without a uuid')
+        pat = self._subpath('climbs', climb.get_uuid().to_data() + '.json')
+        self._ensure_parent_dir(pat)
+        with open(pat, 'w') as f:
+            json.dump(climb.to_data(), f, indent=4, ensure_ascii=False)
+            f.write(os.linesep)
+    def remove_climb_by_uuid(self, uuid):
+        pat = self._subpath('climbs', uuid.to_data() + '.json')
+        if os.path.isfile(pat):
+            os.unlink(pat)
+
+    def approach_uuids(self):
+        dir = self._subpath('approaches')
+        if os.path.isdir(dir):
+            for f in os.listdir(dir):
+                if f.endswith('.json'):
+                    yield approach.Uuid.from_data(f.replace('.json', ''))
+    def get_approach_by_uuid(self, uuid):
+        pat = self._subpath('approaches', uuid.to_data() + '.json')
+        if os.path.isfile(pat):
+            with open(pat, 'r') as f:
+                try:
+                    e = approach.Approach.from_data(json.load(f)) 
+                    if uuid.to_data() != e.get_uuid().to_data():
+                        raise Exception(f'path {pat} does not match the uuid {e.get_uuid().to_data()}')
+                    return e
+                except json.decoder.JSONDecodeError as e:
+                    raise Exception(f'bad json at {pat}: {e.args[0]}')
+    def set_approach(self, approach):
+        uuid = approach.get_uuid()
+        if not uuid:
+            raise Exception('can not use approach without a uuid')
+        pat = self._subpath('approaches', approach.get_uuid().to_data() + '.json')
+        self._ensure_parent_dir(pat)
+        with open(pat, 'w') as f:
+            json.dump(approach.to_data(), f, indent=4, ensure_ascii=False)
+            f.write(os.linesep)
+    def remove_approach_by_uuid(self, uuid):
+        pat = self._subpath('approaches', uuid.to_data() + '.json')
+        if os.path.isfile(pat):
+            os.unlink(pat)
+
+    def photo_uuids(self):
+        dir = self._subpath('photos')
+        if os.path.isdir(dir):
+            for f in os.listdir(dir):
+                if f.endswith('.json'):
+                    yield photo.Uuid.from_data(f.replace('.json', ''))
+    def get_photo_by_uuid(self, uuid):
+        pat = self._subpath('photos', uuid.to_data() + '.json')
+        if os.path.isfile(pat):
+            with open(pat, 'r') as f:
+                try:
+                    e = photo.Photo.from_data(json.load(f)) 
+                    if uuid.to_data() != e.get_uuid().to_data():
+                        raise Exception(f'path {pat} does not match the uuid {e.get_uuid().to_data()}')
+                    return e
+                except json.decoder.JSONDecodeError as e:
+                    raise Exception(f'bad json at {pat}: {e.args[0]}')
+    def set_photo(self, photo):
+        uuid = photo.get_uuid()
+        if not uuid:
+            raise Exception('can not use photo without a uuid')
+        pat = self._subpath('photos', photo.get_uuid().to_data() + '.json')
+        self._ensure_parent_dir(pat)
+        with open(pat, 'w') as f:
+            json.dump(photo.to_data(), f, indent=4, ensure_ascii=False)
+            f.write(os.linesep)
+    def remove_photo_by_uuid(self, uuid):
+        pat = self._subpath('photos', uuid.to_data() + '.json')
+        imgpat = self._get_photo_image_path(uuid)
+        if os.path.isfile(pat):
+            os.unlink(pat)
+        if os.path.isfile(imgpat):
+            os.unlink(imgpat)
+    def _get_photo_image_path(self, uuid):
+        dir = self._subpath('photos')
+        prefix = uuid.to_data() + '_image'
+        if os.path.isdir(dir):
+            for f in os.listdir(dir):
+                if f.startswith(prefix):
+                    return os.path.join(dir, f)
+    def set_photo_image_by_uuid(self, uuid, path):
+        if not os.path.isfile(path):
+            raise Exception('no file at path ' + path)
+        dir = self._subpath('photos')
+        existing = self._get_photo_image_path(uuid)
+        ext = os.path.basename(path).split('.')[-1]
+        suffix = '.' + ext if ext else ''
+        if existing:
+            # TODO: warn the user because this is a terrible idea
+            os.unlink(existing)
+        shutil.copyfile(path, os.path.join(dir, f'{uuid.to_data()}_image{suffix}'))
+    def get_photo_image_by_uuid(self, uuid):
+        return self._get_photo_image_path(uuid)
+
+    def parking_uuids(self):
+        dir = self._subpath('parkings')
+        if os.path.isdir(dir):
+            for f in os.listdir(dir):
+                if f.endswith('.json'):
+                    yield parking.Uuid.from_data(f.replace('.json', ''))
+    def get_parking_by_uuid(self, uuid):
+        pat = self._subpath('parkings', uuid.to_data() + '.json')
+        if os.path.isfile(pat):
+            with open(pat, 'r') as f:
+                try:
+                    e = parking.Parking.from_data(json.load(f)) 
+                    if uuid.to_data() != e.get_uuid().to_data():
+                        raise Exception(f'path {pat} does not match the uuid {e.get_uuid().to_data()}')
+                    return e
+                except json.decoder.JSONDecodeError as e:
+                    raise Exception(f'bad json at {pat}: {e.args[0]}')
+    def set_parking(self, parking):
+        uuid = parking.get_uuid()
+        if not uuid:
+            raise Exception('can not use parking without a uuid')
+        pat = self._subpath('parkings', parking.get_uuid().to_data() + '.json')
+        self._ensure_parent_dir(pat)
+        with open(pat, 'w') as f:
+            json.dump(parking.to_data(), f, indent=4, ensure_ascii=False)
+            f.write(os.linesep)
+    def remove_parking_by_uuid(self, uuid):
+        pat = self._subpath('parkings', uuid.to_data() + '.json')
+        if os.path.isfile(pat):
+            os.unlink(pat)
+
+    def area_uuids(self):
+        dir = self._subpath('areas')
+        if os.path.isdir(dir):
+            for f in os.listdir(dir):
+                if f.endswith('.json'):
+                    yield area.Uuid.from_data(f.replace('.json', ''))
+    def get_area_by_uuid(self, uuid):
+        pat = self._subpath('areas', uuid.to_data() + '.json')
+        if os.path.isfile(pat):
+            with open(pat, 'r') as f:
+                try:
+                    e = area.Area.from_data(json.load(f)) 
+                    if uuid.to_data() != e.get_uuid().to_data():
+                        raise Exception(f'path {pat} does not match the uuid {e.get_uuid().to_data()}')
+                    return e
+                except json.decoder.JSONDecodeError as e:
+                    raise Exception(f'bad json at {pat}: {e.args[0]}')
+    def set_area(self, area):
+        uuid = area.get_uuid()
+        if not uuid:
+            raise Exception('can not use area without a uuid')
+        pat = self._subpath('areas', area.get_uuid().to_data() + '.json')
+        self._ensure_parent_dir(pat)
+        with open(pat, 'w') as f:
+            json.dump(area.to_data(), f, indent=4, ensure_ascii=False)
+            f.write(os.linesep)
+    def remove_area_by_uuid(self, uuid):
+        pat = self._subpath('areas', uuid.to_data() + '.json')
+        if os.path.isfile(pat):
+            os.unlink(pat)
+
+if __name__ == '__main__':
+    import stele1.filesystemcli
+    stele1.filesystemcli.main()

stele1_filesystem-0.0.1/stele1/filesystemcli.py

@@ -0,0 +1,177 @@
+import os
+import os.path
+import sys
+import uuid
+import stele1.filesystem
+
+import stele1.climb as climb
+import stele1.approach as approach
+import stele1.photo as photo
+import stele1.parking as parking
+import stele1.area as area
+import stele1.metadata as metadata
+
+def list_climbs(args):
+    print('listing climbs')
+    for id in catalog.climb_uuids():
+        print(id.to_data())
+def add_climb(args):
+    e = stele1.climb.Climb()
+    id = stele1.climb.Uuid.from_data(str(uuid.uuid4()))
+    e.setUuid(id)
+    catalog.set_climb(d)
+    print(id.to_data())
+def get_climb_by_uuid(args):
+    print('getting climb')
+def set_climb(args):
+    print('setting climb')
+def remove_climb_by_uuid(args):
+    print('removing climb')
+
+def list_approaches(args):
+    print('listing approaches')
+    for id in catalog.approach_uuids():
+        print(id.to_data())
+def add_approach(args):
+    e = stele1.approach.Approach()
+    id = stele1.approach.Uuid.from_data(str(uuid.uuid4()))
+    e.setUuid(id)
+    catalog.set_approach(d)
+    print(id.to_data())
+def get_approach_by_uuid(args):
+    print('getting approach')
+def set_approach(args):
+    print('setting approach')
+def remove_approach_by_uuid(args):
+    print('removing approach')
+
+def list_photos(args):
+    print('listing photos')
+    for id in catalog.photo_uuids():
+        print(id.to_data())
+def add_photo(args):
+    e = stele1.photo.Photo()
+    id = stele1.photo.Uuid.from_data(str(uuid.uuid4()))
+    e.setUuid(id)
+    catalog.set_photo(d)
+    print(id.to_data())
+def get_photo_by_uuid(args):
+    print('getting photo')
+def set_photo(args):
+    print('setting photo')
+def remove_photo_by_uuid(args):
+    print('removing photo')
+
+def list_parkings(args):
+    print('listing parkings')
+    for id in catalog.parking_uuids():
+        print(id.to_data())
+def add_parking(args):
+    e = stele1.parking.Parking()
+    id = stele1.parking.Uuid.from_data(str(uuid.uuid4()))
+    e.setUuid(id)
+    catalog.set_parking(d)
+    print(id.to_data())
+def get_parking_by_uuid(args):
+    print('getting parking')
+def set_parking(args):
+    print('setting parking')
+def remove_parking_by_uuid(args):
+    print('removing parking')
+
+def list_areas(args):
+    print('listing areas')
+    for id in catalog.area_uuids():
+        print(id.to_data())
+def add_area(args):
+    e = stele1.area.Area()
+    id = stele1.area.Uuid.from_data(str(uuid.uuid4()))
+    e.setUuid(id)
+    catalog.set_area(d)
+    print(id.to_data())
+def get_area_by_uuid(args):
+    print('getting area')
+def set_area(args):
+    print('setting area')
+def remove_area_by_uuid(args):
+    print('removing area')
+
+def main():
+    subcmd = sys.argv[1]
+    subcmd_args = sys.argv[2:]
+    catalog = stele1.filesystem.Catalog(os.environ['STELE1_CATALOG']) if 'STELE1_CATALOG' in os.environ else None
+    print(catalog)
+    if subcmd == 'help':
+        print(f'usage: {os.path.basename(sys.argv[0])} SUBCOMMAND ...')
+        print('subcommands:')
+        print('    create, exists, get-metadata, set-metadata')
+        print('    list-climbs add-climb ' +
+            'get-climb set-climb remove-climb')
+        print('    list-approaches add-approach ' +
+            'get-approach set-approach remove-approach')
+        print('    list-photos add-photo ' +
+            'get-photo set-photo remove-photo')
+        print('    list-parkings add-parking ' +
+            'get-parking set-parking remove-parking')
+        print('    list-areas add-area ' +
+            'get-area set-area remove-area')
+        print('environment vars:')
+        print('    STELE1_CATALOG')
+    elif subcmd == 'exists':
+        print('TODO: exists')
+    elif subcmd == 'create':
+        print('TODO: create')
+    elif subcmd == 'set-metadata':
+        print('TODO: set metadata')
+    elif subcmd == 'list-climbs':
+        list_climbs(subcmd_args)
+    elif subcmd == 'add-climb':
+        add_climb(subcmd_args)
+    elif subcmd == 'get-climb':
+        get_climb(subcmd_args)
+    elif subcmd == 'set-climb':
+        set_climb(subcmd_args)
+    elif subcmd == 'remove-climb':
+        remove_climb(subcmd_args)
+    elif subcmd == 'list-approaches':
+        list_approaches(subcmd_args)
+    elif subcmd == 'add-approach':
+        add_approach(subcmd_args)
+    elif subcmd == 'get-approach':
+        get_approach(subcmd_args)
+    elif subcmd == 'set-approach':
+        set_approach(subcmd_args)
+    elif subcmd == 'remove-approach':
+        remove_approach(subcmd_args)
+    elif subcmd == 'list-photos':
+        list_photos(subcmd_args)
+    elif subcmd == 'add-photo':
+        add_photo(subcmd_args)
+    elif subcmd == 'get-photo':
+        get_photo(subcmd_args)
+    elif subcmd == 'set-photo':
+        set_photo(subcmd_args)
+    elif subcmd == 'remove-photo':
+        remove_photo(subcmd_args)
+    elif subcmd == 'list-parkings':
+        list_parkings(subcmd_args)
+    elif subcmd == 'add-parking':
+        add_parking(subcmd_args)
+    elif subcmd == 'get-parking':
+        get_parking(subcmd_args)
+    elif subcmd == 'set-parking':
+        set_parking(subcmd_args)
+    elif subcmd == 'remove-parking':
+        remove_parking(subcmd_args)
+    elif subcmd == 'list-areas':
+        list_areas(subcmd_args)
+    elif subcmd == 'add-area':
+        add_area(subcmd_args)
+    elif subcmd == 'get-area':
+        get_area(subcmd_args)
+    elif subcmd == 'set-area':
+        set_area(subcmd_args)
+    elif subcmd == 'remove-area':
+        remove_area(subcmd_args)
+    else:
+        raise Exception('unknown subcommand ' + subcmd)

stele1_filesystem-0.0.1/stele1_filesystem.egg-info/PKG-INFO

@@ -0,0 +1,62 @@
+Metadata-Version: 2.4
+Name: stele1-filesystem
+Version: 0.0.1
+Summary: Filesystem interface for stele1 catalogs
+Author-email: Daniel M <contact@steleclimbing.org>
+License-Expression: MIT
+Project-URL: Homepage, https://stele1.steleclimbing.org
+Project-URL: Repository, https://codeberg.org/stele-climbing/stele1
+Project-URL: Issues, https://codeberg.org/stele-climbing/stele1/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 4 - Beta
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: stele1-datatypes>=0.0.1
+Dynamic: license-file
+
+# stele1-filesystem
+
+Filesystem interface for [stele1](https://stele1.steleclimbing.org) catalogs.
+
+Reads and writes catalogs on disk. Each catalog is a directory; records are
+individual JSON files organized by datatype.
+
+Exposes primitives: get, set, list, remove.
+Higher-level operations (queries, traversals, indexing) are left to consumers.
+
+## Use
+
+```python
+from stele1.filesystem import Catalog
+
+catalog = Catalog('/path/to/catalog.stele1.d')
+
+if not catalog.exists():
+    catalog.create()
+
+for uuid in catalog.climb_uuids():
+    climb = catalog.get_climb_by_uuid(uuid)
+    climb.get_name().to_data()  # 'The Mandala'
+```
+
+Each datatype (`Climb`, `Area`, `Photo`, `Parking`, `Approach`) has matching
+`{type}_uuids()`, `get_{type}_by_uuid(uuid)`, `set_{type}({type})`, and
+`remove_{type}_by_uuid(uuid)` methods.
+
+Photos additionally support `get_photo_image_by_uuid` and
+`set_photo_image_by_uuid` for the associated image file.
+
+See [stele1-datatypes](https://pypi.org/project/stele1-datatypes/) for the
+datatypes returned by the getters.
+
+## Install
+
+```
+pip install stele1-filesystem
+```
+
+## License
+
+MIT

stele1_filesystem-0.0.1/stele1_filesystem.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+LICENSE
+README.md
+pyproject.toml
+stele1/filesystem.py
+stele1/filesystemcli.py
+stele1_filesystem.egg-info/PKG-INFO
+stele1_filesystem.egg-info/SOURCES.txt
+stele1_filesystem.egg-info/dependency_links.txt
+stele1_filesystem.egg-info/requires.txt
+stele1_filesystem.egg-info/top_level.txt

stele1_filesystem-0.0.1/stele1_filesystem.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

stele1_filesystem-0.0.1/stele1_filesystem.egg-info/requires.txt

@@ -0,0 +1 @@
+stele1-datatypes>=0.0.1

stele1_filesystem-0.0.1/stele1_filesystem.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+dist
+stele1