stele1-datatypes 0.0.1__tar.gz

stele1_datatypes-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_datatypes-0.0.1/PKG-INFO

@@ -0,0 +1,59 @@
+Metadata-Version: 2.4
+Name: stele1-datatypes
+Version: 0.0.1
+Summary: Core datatypes 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
+Dynamic: license-file
+
+# stele1-datatypes
+
+Core datatypes for [stele1](https://stele1.steleclimbing.org) catalogs.
+
+Covers `Metadata`, `Climb`, `Area`, `Photo`, `Parking`, and `Approach`.
+See the [stele1 spec](https://stele1.steleclimbing.org/spec/) for the data
+model these implement.
+
+Each datatype validates its input and exposes `from_data` / `to_data` for
+serialization to and from plain dicts.
+
+## Use
+
+```python
+from stele1.climb import Climb
+
+climb = Climb.from_data({
+    'uuid': '550e8400-e29b-41d4-a716-446655440000',
+    'name': 'The Mandala',
+    'rating': {'difficulty': 'V12'},
+})
+
+climb.to_data()                  # {'uuid': ..., 'name': ..., 'rating': ...}
+
+climb.get_name().to_data()       # 'The Mandala'
+```
+
+Invalid input raises `TypeError` or `ValueError`.
+
+`to_data` returns plain dicts.
+`json.dumps(climb.to_data())` produces spec-compliant output;
+formatting is up to the caller.
+
+## Install
+
+```
+pip install stele1-datatypes
+```
+
+## License
+
+MIT

stele1_datatypes-0.0.1/README.md

@@ -0,0 +1,42 @@
+# stele1-datatypes
+
+Core datatypes for [stele1](https://stele1.steleclimbing.org) catalogs.
+
+Covers `Metadata`, `Climb`, `Area`, `Photo`, `Parking`, and `Approach`.
+See the [stele1 spec](https://stele1.steleclimbing.org/spec/) for the data
+model these implement.
+
+Each datatype validates its input and exposes `from_data` / `to_data` for
+serialization to and from plain dicts.
+
+## Use
+
+```python
+from stele1.climb import Climb
+
+climb = Climb.from_data({
+    'uuid': '550e8400-e29b-41d4-a716-446655440000',
+    'name': 'The Mandala',
+    'rating': {'difficulty': 'V12'},
+})
+
+climb.to_data()                  # {'uuid': ..., 'name': ..., 'rating': ...}
+
+climb.get_name().to_data()       # 'The Mandala'
+```
+
+Invalid input raises `TypeError` or `ValueError`.
+
+`to_data` returns plain dicts.
+`json.dumps(climb.to_data())` produces spec-compliant output;
+formatting is up to the caller.
+
+## Install
+
+```
+pip install stele1-datatypes
+```
+
+## License
+
+MIT

stele1_datatypes-0.0.1/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "stele1-datatypes"
+version = "0.0.1"
+description = "Core datatypes for stele1 catalogs"
+readme = "README.md"
+license = "MIT"
+authors = [{ name = "Daniel M", email = "contact@steleclimbing.org" }]
+requires-python = ">=3.8"
+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_datatypes-0.0.1/setup.cfg

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

stele1_datatypes-0.0.1/stele1/approach.py

@@ -0,0 +1,152 @@
+class Name:
+    def __init__(self, n):
+        if not isinstance(n, str):
+            raise TypeError("approach name is not a string")
+        if n == "":
+            raise ValueError("approach name is an empty string")
+        self._name = n
+    @staticmethod
+    def from_data(j):
+        return Name(j)
+    def to_data(self):
+        return self._name
+
+class Description:
+    def __init__(self, description):
+        if not isinstance(description, str):
+            raise TypeError("approach description is not a string")
+        if description == "":
+            raise ValueError("approach description is an empty string")
+        self._description = description
+    @staticmethod
+    def from_data(j):
+        return Description(j)
+    def to_data(self):
+        return self._description
+
+class Path:
+    def __init__(self, points):
+        if not isinstance(points, list):
+            raise TypeError("approach path must be a list")
+        if len(points) < 2:
+            raise TypeError("approach path must have a least two points")
+        good = []
+        for longitude, latitude in points:
+            if not isinstance(longitude, (int, float)):
+                raise TypeError("approach path points' longitude must be a number")
+            if not isinstance(latitude, (int, float)):
+                raise TypeError("approach path points' latitude must be a number")
+            if longitude < -180 or 180 < longitude:
+                raise ValueError("approach path points' longitude must be between -180 and 180")
+            if latitude < -90 or 90 < latitude:
+                raise ValueError("approach location's latitude must be between -90 and 90")
+            good.append((longitude, latitude))
+        self._points = good
+    @staticmethod
+    def from_data(j):
+        return Path([(pt['longitude'], pt['latitude']) for pt in j])
+    def to_data(self):
+        return [{'longitude': lng, 'latitude': lat} for (lng, lat) in  self._points]
+
+class Uuid:
+    def __init__(self, a):
+        import uuid
+        if isinstance(a, str):
+            self._uuid = uuid.UUID(a)
+        elif isinstance(a, uuid.UUID):
+            self._uuid = a
+        else:
+            raise TypeError("approach uuid must be a string or UUID")
+    @staticmethod
+    def from_data(a):
+        import re
+        rex = re.compile('[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}')
+        if not isinstance(a, str):
+            raise TypeError("approach uuid must be a string")
+        if not rex.match(a):
+            raise ValueError("approach uuid string must look like a uuid: " +
+                             "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx")
+        return Uuid(a)
+    def to_data(self):
+        return str(self._uuid)
+
+class Approach:
+
+    def __init__(self):
+        self._description = None
+        self._name = None
+        self._path = None
+        self._uuid = None
+
+    @staticmethod
+    def from_data(d):
+        a = Approach()
+        for k, v in d.items():
+            if k == 'description':
+                a._description = Description.from_data(v)
+            elif k == 'name':
+                a._name = Name.from_data(v)
+            elif k == 'path':
+                a._path = Path.from_data(v)
+            elif k == 'uuid':
+                a._uuid = Uuid.from_data(v)
+            else:
+                raise ValueError('unexpected key ' + k)
+        return a
+
+    def to_data(self):
+        d = {}
+        if self._description:
+            d['description'] = self._description.to_data()
+        if self._name:
+            d['name'] = self._name.to_data()
+        if self._path:
+            d['path'] = self._path.to_data()
+        if self._uuid:
+            d['uuid'] = self._uuid.to_data()
+        return d
+
+    def get_description(self):
+        return self._description
+    def unset_description(self):
+        self._description = None
+        return self
+    def set_description(self, v):
+        if not isinstance(v, Description):
+            raise TypeError('arguments to set_description must be an instance of Description')
+        self._description = v
+        return self
+
+    def get_name(self):
+        return self._name
+    def unset_name(self):
+        self._name = None
+        return self
+    def set_name(self, v):
+        if not isinstance(v, Name):
+            raise TypeError('arguments to set_name must be an instance of Name')
+        self._name = v
+        return self
+
+    def get_path(self):
+        return self._path
+    def unset_path(self):
+        self._path = None
+        return self
+    def set_path(self, v):
+        if not isinstance(v, Path):
+            raise TypeError('arguments to set_path must be an instance of Path')
+        self._path = v
+        return self
+
+    def get_uuid(self):
+        return self._uuid
+    def unset_uuid(self):
+        self._uuid = None
+        return self
+    def set_uuid(self, v):
+        if not isinstance(v, Uuid):
+            raise TypeError('arguments to set_uuid must be an instance of Uuid')
+        self._uuid = v
+        return self
+

stele1_datatypes-0.0.1/stele1/area.py

@@ -0,0 +1,320 @@
+class Name:
+    def __init__(self, name):
+        if not isinstance(name, str):
+            raise TypeError("area name is not a string")
+        if name == "":
+            raise ValueError("area name is an empty string")
+        self._name = name
+    @staticmethod
+    def from_data(j):
+        return Name(j)
+    def to_data(self):
+        return self._name
+
+class AlternateNames:
+    def __init__(self, names):
+        if not isinstance(names, list):
+            raise TypeError("area alternate names is not a list")
+        self._names = []
+        for n in names:
+            self._names.append(Name(n))
+    @staticmethod
+    def from_data(j):
+        return AlternateNames(j)
+    def to_data(self):
+        return [n.to_data() for n in self._names]
+
+class Location:
+    # TODO: use these internally
+    # APPROXIMATION = 'approximation' 
+    # PERIMETER = 'perimeter'
+    def __init__(self, type, coords):
+        if not isinstance(type, str):
+            raise TypeError("area location type must be a string")
+        if type == 'approximation':
+            self._type = 'approximation'
+            if not isinstance(coords, dict):
+                raise TypeError("an \"approximation\" area location coordinates must be a dict")
+            # TODO: check structure
+            if not isinstance(coords['latitude'], (int, float)):
+                raise TypeError("area location's latitude must be numbers")
+            if coords['latitude'] < -90 or 90 < coords['latitude']:
+                raise TypeError("area location's latitude must from -90 to 90")
+            if not isinstance(coords['longitude'], (int, float)):
+                raise TypeError("area location's longitude must be numbers")
+            if coords['longitude'] < -180 or 180 < coords['longitude']:
+                raise TypeError("area location's longitude must from -180 to 180")
+            if not isinstance(coords['meter_radius'], (int, float)):
+                raise TypeError("area location's meter_radius must be a number")
+            if coords['meter_radius'] <= 0:
+                raise TypeError("area location's meter_radius must be greater than 0")
+            self._coords = {
+                'longitude': coords['longitude'],
+                'latitude': coords['latitude'],
+                'radius': coords['meter_radius'],
+            }
+        elif type == 'perimeter':
+            self._type = 'perimeter'
+            self._coords = []
+            if not isinstance(coords, list):
+                raise TypeError("a \"perimeter\" area location's coordinates must be a list")
+            if not isinstance(coords[0], dict):
+                raise ValueError("a \"perimeter\" area location must be an array of {'longitude': lng, 'latitude': lat} points")
+            if len(coords) < 4:
+                raise ValueError("a \"perimeter\" area location must have at least 4 points")
+            for ll in coords:
+                if not isinstance(ll['latitude'], (int, float)):
+                    raise TypeError("area location's latitude must be numbers")
+                if ll['latitude'] < -90 or 90 < ll['latitude']:
+                    raise TypeError("area location's latitude must from -90 to 90")
+                if not isinstance(ll['longitude'], (int, float)):
+                    raise TypeError("area location's longitude must be numbers")
+                if ll['longitude'] < -180 or 180 < ll['longitude']:
+                    raise TypeError("area location's longitude must from -180 to 180")
+                self._coords.append((ll['longitude'], ll['latitude']))
+        else:
+            raise ValueError("area location type must be a \"approximation\" or \"perimeter\"")
+    @staticmethod
+    def approximation(lngLat, meter_radius):
+        longitude, latitude = lngLat
+        return Location('approximation', {
+            'longitude': longitude,
+            'latitude': latitude,
+            'meter_radius': meter_radius,
+        })
+    @staticmethod
+    def perimeter(pts):
+        return Location('perimeter', [{
+            'latitude': lat,
+            'longitude': lng
+        } for (lng, lat) in pts])
+    @staticmethod
+    def from_data(j):
+        if j['type'] == 'approximation':
+            return Location('approximation', j['circle'])
+        if j['type'] == 'perimeter':
+            return Location('perimeter', j['polygon'])
+    def to_data(self):
+        if self._type == 'approximation':
+            return {
+                'type': self._type,
+                'circle': {
+                    'longitude': self._coords['longitude'],
+                    'latitude': self._coords['latitude'],
+                    'meter_radius': self._coords['radius'],
+                },
+            }
+        if self._type == 'perimeter':
+            return {
+                'type': self._type,
+                'polygon': [{'latitude': lat, 'longitude': lng} for (lng, lat) in self._coords],
+            }
+
+class Tags:
+    def __init__(self, tags):
+        if not isinstance(tags, list):
+            raise TypeError("area tags must be a list")
+        self._tags = []
+        for tag in tags:
+            if not isinstance(tag, str):
+                raise TypeError("area tags must be a string")
+            if tag == "":
+                raise ValueError("area tag must be a non-empty string")
+            self._tags.append(tag)
+    @staticmethod
+    def from_data(j):
+        return Tags(j)
+    def to_data(self):
+        return [t for t in self._tags]
+
+class Fields:
+    def __init__(self, fields):
+        if not isinstance(fields, dict):
+            raise TypeError("area fields must be a dict")
+        self._fields = {}
+        for f, v in fields.items():
+            if not isinstance(v, str):
+                raise TypeError("area field values must be a string")
+            self._fields[f] = v
+    @staticmethod
+    def from_data(j):
+        return Fields(j)
+    def to_data(self):
+        return self._fields.copy()
+
+class Notes:
+    def __init__(self, notes):
+        if not isinstance(notes, list):
+            raise TypeError("area notes must be a list")
+        good = []
+        topics = set()
+        for (topic, content) in notes:
+            if not isinstance(topic, str):
+                raise TypeError("area note topic must be a string")
+            if topic == '':
+                raise ValueError("area notes topic must not be empty")
+            if topic in topics:
+                raise ValueError("area notes topics must all be unique")
+            if not isinstance(content, str):
+                raise TypeError("area note topic must be a string")
+            if topic == '':
+                raise ValueError("area notes topic must not be empty")
+            topics.add(topic)
+            good.append((topic, content))
+        self._notes = good
+    @staticmethod
+    def from_data(j):
+        return Notes([(n['topic'], n['content']) for n in j])
+    def to_data(self):
+        return [{'topic': t, 'content': c} for (t, c) in self._notes]
+
+class Uuid:
+    def __init__(self, a):
+        import uuid
+        if isinstance(a, str):
+            self._uuid = uuid.UUID(a)
+        elif isinstance(a, uuid.UUID):
+            self._uuid = a
+        else:
+            raise TypeError("area uuid must be a string or UUID")
+    @staticmethod
+    def from_data(a):
+        import re
+        rex = re.compile('[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}')
+        if not isinstance(a, str):
+            raise TypeError("area uuid must be a string")
+        if not rex.match(a):
+            raise ValueError("area uuid string must look like a uuid: " +
+                             "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx")
+        return Uuid(a)
+    def to_data(self):
+        return str(self._uuid)
+
+class Area:
+
+    def __init__(self):
+        self._alternate_names = None
+        self._fields = None
+        self._location = None
+        self._name = None
+        self._notes = None
+        self._tags = None
+        self._uuid = None
+
+    @staticmethod
+    def from_data(d):
+        a = Area()
+        for k, v in d.items():
+            if k == 'alternate_names':
+                a._alternate_names = AlternateNames.from_data(v)
+            elif k == 'fields':
+                a._fields = Fields.from_data(v)
+            elif k == 'location':
+                a._location = Location.from_data(v)
+            elif k == 'name':
+                a._name = Name.from_data(v)
+            elif k == 'notes':
+                a._notes = Notes.from_data(v)
+            elif k == 'tags':
+                a._tags = Tags.from_data(v)
+            elif k == 'uuid':
+                a._uuid = Uuid.from_data(v)
+            else:
+                raise ValueError('unexpected key ' + k)
+        return a
+
+    def to_data(self):
+        d = {}
+        if self._alternate_names:
+            d['alternate_names'] = self._alternate_names.to_data()
+        if self._fields:
+            d['fields'] = self._fields.to_data()
+        if self._location:
+            d['location'] = self._location.to_data()
+        if self._name:
+            d['name'] = self._name.to_data()
+        if self._notes:
+            d['notes'] = self._notes.to_data()
+        if self._tags:
+            d['tags'] = self._tags.to_data()
+        if self._uuid:
+            d['uuid'] = self._uuid.to_data()
+        return d
+
+    def get_alternate_names(self):
+        return self._alternate_names
+    def unset_alternate_names(self):
+        self._alternate_names = None
+        return self
+    def set_alternate_names(self, v):
+        if not isinstance(v, AlternateNames):
+            raise TypeError('arguments to set_alternate_names must be an instance of AlternateNames')
+        self._alternate_names = v
+        return self
+
+    def get_fields(self):
+        return self._fields
+    def unset_fields(self):
+        self._fields = None
+        return self
+    def set_fields(self, v):
+        if not isinstance(v, Fields):
+            raise TypeError('arguments to set_fields must be an instance of Fields')
+        self._fields = v
+        return self
+
+    def get_location(self):
+        return self._location
+    def unset_location(self):
+        self._location = None
+        return self
+    def set_location(self, v):
+        if not isinstance(v, Location):
+            raise TypeError('arguments to set_location must be an instance of Location')
+        self._location = v
+        return self
+
+    def get_name(self):
+        return self._name
+    def unset_name(self):
+        self._name = None
+        return self
+    def set_name(self, v):
+        if not isinstance(v, Name):
+            raise TypeError('arguments to set_name must be an instance of Name')
+        self._name = v
+        return self
+
+    def get_notes(self):
+        return self._notes
+    def unset_notes(self):
+        self._notes = None
+        return self
+    def set_notes(self, v):
+        if not isinstance(v, Notes):
+            raise TypeError('arguments to set_notes must be an instance of Notes')
+        self._notes = v
+        return self
+
+    def get_tags(self):
+        return self._tags
+    def unset_tags(self):
+        self._tags = None
+        return self
+    def set_tags(self, v):
+        if not isinstance(v, Tags):
+            raise TypeError('arguments to set_tags must be an instance of Tags')
+        self._tags = v
+        return self
+
+    def get_uuid(self):
+        return self._uuid
+    def unset_uuid(self):
+        self._uuid = None
+        return self
+    def set_uuid(self, v):
+        if not isinstance(v, Uuid):
+            raise TypeError('arguments to set_uuid must be an instance of Uuid')
+        self._uuid = v
+        return self
+