leafobject 0.0.13__tar.gz

leafobject-0.0.13/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Tom Chen (tomchen.org)
+
+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.

leafobject-0.0.13/PKG-INFO

@@ -0,0 +1,151 @@
+Metadata-Version: 2.4
+Name: leafobject
+Version: 0.0.13
+Summary: LEAF Object Package
+License: MIT
+License-File: LICENSE
+Keywords: leaf,influx,json,package
+Author: Jasper Koehorst
+Author-email: jasper.koehorst@wur.nl
+Requires-Python: >=3.9,<4.0
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development :: Build Tools
+Provides-Extra: dev
+Project-URL: Documentation, https://gitlab.com/leaf-framework/leaf-object
+Project-URL: Homepage, https://gitlab.com/leaf-framework/leaf-object
+Project-URL: Repository, https://gitlab.com/leaf-framework/leaf-object
+Description-Content-Type: text/markdown
+
+# Leaf Point
+
+## Description
+
+This module enables the creation of a LeafPoint object that can be transformed into either a JSON or LineProtocol format.
+
+### Features
+
+#### InfluxDB Line Protocol Format
+
+The InfluxDB Line Protocol is a text-based format designed for the efficient writing of time-series data into InfluxDB. It organizes the data points with timestamps, measurement names, fields (key-value pairs representing the data), and tags (optional key-value pairs used to store metadata that describes the data). The format is highly optimized for time-series data, enabling quick parsing and writing. A typical line in this format looks like this:
+
+> measurementName,tagKey=tagValue fieldKey="fieldValue" 1465839830100400200
+
+- measurementName: Identifies the measurement.
+- tagKey=tagValue: Zero or more tag sets separated by commas. Tags are optional but recommended for indexing.
+- fieldKey="fieldValue": At least one field set, with multiple fields separated by commas. Fields are the actual data points.
+- 1465839830100400200: An optional timestamp for the data point. If not specified, the server's current time is used.
+
+### JSON Format
+
+The JSON format offers a more flexible way to represent data. 
+
+```json
+{
+    "measurement": "measurement",
+    "tags": {"tag1": "value1"},
+    "fields": {"field1": 1, "field2": 2},
+    "timestamp": 1609455600,
+}
+```
+
+## Usage
+
+```python
+
+    from leafobject.leafpoint import LeafPoint
+
+    leaf_point = LeafPoint()
+    leaf_point.set_measurement("measurement")
+    leaf_point.set_tags({"tag1": "value1"})
+    leaf_point.set_fields({"field1": 1, "field2": 2})
+    leaf_point.set_timestamp(datetime.datetime(2021, 1, 1))\
+    
+    print(leaf_point.to_json())
+
+        # {
+        #     "measurement": "measurement",
+        #     "tags": {"tag1": "value1"},
+        #     "fields": {"field1": 1, "field2": 2},
+        #     "timestamp": 1609455600,
+        # }
+        
+    print(leaf_point.to_line_protocol())
+
+        # "measurement,tag1=value1 field1=1,field2=2 1609455600"
+```
+
+All functinoalities of the LeafPoint object are listed below:
+
+```python
+    import leafobject
+    x = leafobject.LeafPoint()
+    x.
+        x.add_field(..., ...)
+        x.from_json(...)
+        x.remove_field(...)
+        x.set_measurement(...)
+        x.to_line_protocol()
+        x.add_tag(..., ...)
+        x.remove_tag(...)
+        x.set_tags(...)
+        x.validate()
+        x.parse_line_protocol(...)
+        x.set_fields(...)
+        x.set_timestamp(...)
+        x.to_json()
+```
+
+## Migrating from influxobject
+
+`influxobject` is now `leafobject` and `InfluxPoint` is now `LeafPoint`. `InfluxPoint` still works as a deprecated alias:
+
+```python
+    from leafobject import LeafPoint  # was: from influxobject.influxpoint import InfluxPoint
+```
+
+## Installation
+
+To install the package use the pip package manager
+
+```bash
+    pip install leafobject
+```
+
+## Development
+
+Tox is used as the test runner for this project. To run the entire tox suite use the following command:
+
+```bash
+    tox
+```
+
+To only run the tests under python 3.9
+
+```bash
+    tox -e py39
+```
+
+Build
+
+```bash
+    python setup.py sdist
+```
+
+Publish
+
+```bash
+    twine upload dist/*
+```
+

leafobject-0.0.13/README.md

@@ -0,0 +1,120 @@
+# Leaf Point
+
+## Description
+
+This module enables the creation of a LeafPoint object that can be transformed into either a JSON or LineProtocol format.
+
+### Features
+
+#### InfluxDB Line Protocol Format
+
+The InfluxDB Line Protocol is a text-based format designed for the efficient writing of time-series data into InfluxDB. It organizes the data points with timestamps, measurement names, fields (key-value pairs representing the data), and tags (optional key-value pairs used to store metadata that describes the data). The format is highly optimized for time-series data, enabling quick parsing and writing. A typical line in this format looks like this:
+
+> measurementName,tagKey=tagValue fieldKey="fieldValue" 1465839830100400200
+
+- measurementName: Identifies the measurement.
+- tagKey=tagValue: Zero or more tag sets separated by commas. Tags are optional but recommended for indexing.
+- fieldKey="fieldValue": At least one field set, with multiple fields separated by commas. Fields are the actual data points.
+- 1465839830100400200: An optional timestamp for the data point. If not specified, the server's current time is used.
+
+### JSON Format
+
+The JSON format offers a more flexible way to represent data. 
+
+```json
+{
+    "measurement": "measurement",
+    "tags": {"tag1": "value1"},
+    "fields": {"field1": 1, "field2": 2},
+    "timestamp": 1609455600,
+}
+```
+
+## Usage
+
+```python
+
+    from leafobject.leafpoint import LeafPoint
+
+    leaf_point = LeafPoint()
+    leaf_point.set_measurement("measurement")
+    leaf_point.set_tags({"tag1": "value1"})
+    leaf_point.set_fields({"field1": 1, "field2": 2})
+    leaf_point.set_timestamp(datetime.datetime(2021, 1, 1))\
+    
+    print(leaf_point.to_json())
+
+        # {
+        #     "measurement": "measurement",
+        #     "tags": {"tag1": "value1"},
+        #     "fields": {"field1": 1, "field2": 2},
+        #     "timestamp": 1609455600,
+        # }
+        
+    print(leaf_point.to_line_protocol())
+
+        # "measurement,tag1=value1 field1=1,field2=2 1609455600"
+```
+
+All functinoalities of the LeafPoint object are listed below:
+
+```python
+    import leafobject
+    x = leafobject.LeafPoint()
+    x.
+        x.add_field(..., ...)
+        x.from_json(...)
+        x.remove_field(...)
+        x.set_measurement(...)
+        x.to_line_protocol()
+        x.add_tag(..., ...)
+        x.remove_tag(...)
+        x.set_tags(...)
+        x.validate()
+        x.parse_line_protocol(...)
+        x.set_fields(...)
+        x.set_timestamp(...)
+        x.to_json()
+```
+
+## Migrating from influxobject
+
+`influxobject` is now `leafobject` and `InfluxPoint` is now `LeafPoint`. `InfluxPoint` still works as a deprecated alias:
+
+```python
+    from leafobject import LeafPoint  # was: from influxobject.influxpoint import InfluxPoint
+```
+
+## Installation
+
+To install the package use the pip package manager
+
+```bash
+    pip install leafobject
+```
+
+## Development
+
+Tox is used as the test runner for this project. To run the entire tox suite use the following command:
+
+```bash
+    tox
+```
+
+To only run the tests under python 3.9
+
+```bash
+    tox -e py39
+```
+
+Build
+
+```bash
+    python setup.py sdist
+```
+
+Publish
+
+```bash
+    twine upload dist/*
+```

leafobject-0.0.13/pyproject.toml

@@ -0,0 +1,64 @@
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry]
+name = "leafobject"
+version = "0.0.13"
+description = "LEAF Object Package"
+authors = [
+    "Jasper Koehorst <jasper.koehorst@wur.nl>",
+    "Brett Metcalfe"
+]
+license = "MIT"
+readme = "README.md"
+homepage = "https://gitlab.com/leaf-framework/leaf-object"
+repository = "https://gitlab.com/leaf-framework/leaf-object"
+documentation = "https://gitlab.com/leaf-framework/leaf-object"
+keywords = ["leaf", "influx", "json", "package"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Topic :: Software Development :: Build Tools",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3 :: Only",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent"
+]
+packages = [
+    { include = "leafobject", from = "src" }
+]
+
+[tool.poetry.dependencies]
+python = "^3.9"
+
+[tool.poetry.group.dev.dependencies]
+check-manifest = { version = "*", optional = true }
+pytest = "^8.4.1"
+pytest-xdist = "^3.8.0"
+ruff = "^0.9"
+pre-commit = "^4.0"
+
+[tool.poetry.extras]
+dev = ["check-manifest"]
+
+[tool.ruff]
+target-version = "py39"
+line-length = 88
+src = ["src", "tests"]
+
+[tool.ruff.lint]
+select = [
+    "E",      # pycodestyle errors
+    "W",      # pycodestyle warnings
+    "F",      # Pyflakes
+    "I",      # isort
+    "UP",     # pyupgrade
+    "B",      # flake8-bugbear
+    "SIM",    # flake8-simplify
+]
+ignore = []
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"

leafobject-0.0.13/src/leafobject/__init__.py

@@ -0,0 +1,7 @@
+__version__ = "0.0.3"
+
+# from .module1 import *
+
+from .leafpoint import InfluxPoint, LeafPoint, convert_to_seconds
+
+__all__ = ["LeafPoint", "InfluxPoint", "convert_to_seconds"]

leafobject-0.0.13/src/leafobject/influxpoint.py

@@ -0,0 +1,5 @@
+"""influxpoint.py: Deprecated module, use leafobject.leafpoint instead."""
+
+from .leafpoint import InfluxPoint, LeafPoint, convert_to_seconds
+
+__all__ = ["InfluxPoint", "LeafPoint", "convert_to_seconds"]

leafobject-0.0.13/src/leafobject/leafobject_tools.py

@@ -0,0 +1,37 @@
+"""leafobject_tools.py"""
+# ----------------------------
+#        PACKAGES
+# ----------------------------
+
+
+# ----------------------------
+#        VARIABLES
+# ----------------------------
+
+
+# ----------------------------
+#        FUNCTIONS
+# ----------------------------
+def celsius_to_fahrenheit(temperature_in_celsius) -> float:
+    """celsius_to_fahrenheit: Convert celsius to fahrenheit"""
+    return (temperature_in_celsius * 9 / 5) + 32
+
+
+def celsius_to_kelvin(temperature_in_celsius) -> float:
+    """celsius_to_kelvin: Convert celsius to kelvin"""
+    return temperature_in_celsius + 273.15
+
+
+def fahrenheit_to_celsius(temperature_in_fahrenheit) -> float:
+    """fahrenheit_to_celsius: Convert fahrenheit to celsius"""
+    return (temperature_in_fahrenheit - 32) * 5 / 9
+
+
+def fahrenheit_to_kelvin(temperature_in_fahrenheit) -> float:
+    """fahrenheit_to_celsius: Convert fahrenheit to celsius"""
+    return ((temperature_in_fahrenheit - 32) * 5 / 9) + 273.15
+
+
+# ----------------------------
+#         CLASSES
+# ----------------------------

leafobject-0.0.13/src/leafobject/leafpoint.py

@@ -0,0 +1,528 @@
+"""leafpoint.py
+
+
+
+REQUIREMENTS:
+    import logging
+    from typing import Dict, Optional, Union
+    from datetime import datetime
+    import re
+
+
+
+"""
+
+# ----------------------------
+#        PACKAGES
+# ----------------------------
+import logging
+import re
+import warnings
+from datetime import datetime
+from typing import Optional, Union
+
+# ----------------------------
+#        VARIABLES
+# ----------------------------
+
+
+# ----------------------------
+#        FUNCTIONS
+# ----------------------------
+
+
+def convert_to_seconds(timestamp: int) -> float:
+    """convert_to_seconds: Convert timestamp to seconds
+
+    INPUT:
+        timestamp = original timestamp, an int
+
+    OUTPUT:
+        timestamp = converted timestamp, a float
+
+
+    """
+    length = len(str(timestamp))
+    if length >= 19:  # nanoseconds
+        logging.warning("Timestamp is converted to seconds, precision is lost.")
+        return timestamp / 1_000_000_000
+    elif length >= 16:  # microseconds
+        logging.warning("Timestamp is converted to seconds, precision is lost.")
+        return timestamp / 1_000_000
+    elif length >= 13:  # milliseconds
+        logging.warning("Timestamp is converted to seconds, precision is lost.")
+        return timestamp / 1_000
+    elif length >= 10:  # seconds
+        return timestamp
+    else:
+        raise ValueError("Timestamp value is too short to be valid")
+
+
+# ----------------------------
+#         CLASSES
+# ----------------------------
+
+
+class LeafPoint:
+    def __init__(self) -> None:
+        """init: Initialise class
+
+        INPUT:
+            None
+
+        OUTPUT:
+            None, initialise self.measurement
+                            self.tags
+                            self.fields
+                            self.timestamp
+
+
+        """
+        self.measurement: Optional[str] = None
+        self.tags: dict[str, str] = {}
+        self.fields: dict[str, Union[int, float, str]] = {}
+        self.timestamp: Optional[datetime] = datetime.now()
+
+    def set_measurement(self, measurement: str) -> None:
+        """set_measurement: Set measurement
+
+        INPUT:
+            measurement = measurement value to set, of type str
+
+        OUTPUT:
+            None, sets self.measurement or raises TypeError
+
+
+        """
+        if not isinstance(measurement, str):
+            raise TypeError(
+                f"Measurement must be of type str, not {type(measurement).__name__}"
+            )
+        self.measurement = measurement
+
+    def set_tags(self, tags: dict[str, str]) -> None:
+        """set_tags: Set tags"""
+        for k, v in tags.items():
+            if not isinstance(v, str):
+                raise TypeError(
+                    f"Value for '{k}' must be of type str, not {type(v).__name__}"
+                )
+        self.tags = tags
+
+    def set_fields(self, fields: dict[str, Union[int, float, str]]) -> None:
+        """set_fields: Set fields"""
+        for k, v in fields.items():
+            if not isinstance(v, (int, float, str)):
+                raise TypeError(
+                    f"Value for '{k}' must be int, float, or str, "
+                    f"not {type(v).__name__}"
+                )
+        self.fields = fields
+
+    def set_timestamp(self, timestamp: datetime) -> None:
+        """set_timestamp: Set timestamp"""
+        if not isinstance(timestamp, datetime):
+            if isinstance(timestamp, int):
+                timestamp = datetime.fromtimestamp(convert_to_seconds(timestamp))
+            else:
+                raise ValueError(
+                    "Timestamp must be either numeric (seconds) or a datetime object"
+                )
+        self.timestamp = timestamp
+
+    def to_line_protocol(self) -> str:
+        """set_timestamp: Set timestamp"""
+        self.validate()
+        tags = ",".join([f"{k}={v}" for k, v in self.tags.items()])
+        fields = ",".join([f"{k}={v}" for k, v in self.fields.items()])
+        return f"{self.measurement},{tags} {fields} {int(self.timestamp.timestamp())}"
+
+    def __str__(self) -> str:
+        """str: Get line protocol"""
+        return self.to_line_protocol()
+
+    # ----------------------------
+    #   Add or remove tags
+    # ----------------------------
+    def add_tag(self, key: str, value: str) -> None:
+        """add_tag: Add tag"""
+        if not isinstance(value, (int, float, str)):
+            raise TypeError(
+                f"Value for '{key}' must be int, float, or str, "
+                f"not {type(value).__name__}"
+            )
+        self.tags[key] = value
+
+    def remove_tag(self, key: str) -> None:
+        """remove_tag: Remove tag"""
+        del self.tags[key]
+
+    # ----------------------------
+    #   Add or remove fields
+    # ----------------------------
+    def add_field(self, key: str, value: Union[int, float, str]) -> None:
+        """add_field: Add field"""
+        if not isinstance(value, (int, float, str)):
+            raise TypeError(
+                f"Value for '{key}' must be int, float, or str, "
+                f"not {type(value).__name__}"
+            )
+        self.fields[key] = value
+
+    def remove_field(self, key: str) -> None:
+        """remove_field: Remove field timestamp"""
+        del self.fields[key]
+
+    # ----------------------------
+    #   Add specific tags if needed
+    # ----------------------------
+    def set_entity_tag(self, entity: str) -> None:
+        """set_entity_tag: Set entity tag
+
+        Add an entity tag to the LeafPoint for example a weather station,
+        bioreactor, storage instance.
+
+        INPUT:
+            entity: The entity to add as a tag.
+
+        OUTPUT:
+            None, raises TypeError: If the entity is not a string.
+
+        """
+        if not isinstance(entity, str):
+            raise TypeError(f"Entity must be of type str, not {type(entity).__name__}")
+        self.add_tag("entity", entity)
+
+    def get_entity_tag(self) -> Optional[str]:
+        """
+            Get the entity tag from the LeafPoint.
+        :return: The entity tag if it exists, otherwise None.
+        """
+        if not self.tags:
+            return None
+        if "entity" not in self.tags:
+            logging.warning("Entity tag is not set, returning None")
+            return None
+        return self.tags.get("entity")
+
+    def set_value(self, value: Union[int, float]) -> None:
+        """set_value: Set the value field for the LeafPoint.
+
+        This is a convenience method to set a primary value field in the LeafPoint.
+        :param value: The value to set in the fields.
+        :raises TypeError: If the value is not of type int, float.
+        """
+        if not isinstance(value, (int, float)):
+            raise TypeError(
+                f"Value must be of type int, float, not {type(value).__name__}"
+            )
+        self.add_field("value", value)
+
+    def get_value(self) -> Optional[Union[int, float]]:
+        """
+        Get the value field from the LeafPoint.
+        :return: The value field if it exists, otherwise None.
+        """
+        if not self.fields:
+            return None
+        if "value" not in self.fields:
+            logging.warning("Value field is not set, returning None")
+            return None
+        return self.fields.get("value")
+
+    def set_metric(self, metric: str) -> None:
+        """
+        Set the metric tag for the LeafPoint to identify the type of data.
+        Useful for categorizing the data, such as temperature, humidity, etc.
+        :param metric: The metric to set as a tag.
+        :raises TypeError: If the metric is not a string.
+        """
+        if not isinstance(metric, str):
+            raise TypeError(f"Metric must be of type str, not {type(metric).__name__}")
+        self.add_tag("metric", metric)
+
+    def get_metric(self) -> Optional[str]:
+        """
+        Get the metric tag from the LeafPoint.
+        :return: The metric tag if it exists, otherwise None.
+        """
+        if not self.tags:
+            return None
+        if "metric" not in self.tags:
+            logging.warning("Metric tag is not set, returning None")
+            return None
+        return self.tags.get("metric")
+
+    def set_unit(self, unit: str) -> None:
+        """
+        Set the unit tag for the LeafPoint to specify the unit of measurement.
+        :param unit: The unit to set as a tag.
+        :raises TypeError: If the unit is not a string.
+        """
+        if not isinstance(unit, str):
+            raise TypeError(f"Unit must be of type str, not {type(unit).__name__}")
+        self.add_tag("unit", unit)
+
+    def get_unit(self) -> Optional[str]:
+        """get_unit: Get the unit tag from the LeafPoint.
+
+        INPUT:
+            None
+
+        OUTPUT:
+            :return: The unit tag if it exists, otherwise None.
+
+        """
+        if not self.tags:
+            return None
+        if "unit" not in self.tags:
+            logging.warning("Unit tag is not set, returning None")
+            return None
+        return self.tags.get("unit")
+
+    def set_organisation(self, organisation: str) -> None:
+        """set_organisation: Set the organisation tag for the LeafPoint to specify the
+        organisation.
+
+        :param organisation: The organisation to set as a tag.
+        :raises TypeError: If the organisation is not a string.
+        """
+        if not isinstance(organisation, str):
+            raise TypeError(
+                f"Organisation must be of type str, not {type(organisation).__name__}"
+            )
+        self.add_tag("organisation", organisation)
+
+    def get_organisation(self) -> Optional[str]:
+        """get_organisation: Get the organisation tag from the LeafPoint.
+
+        INPUT:
+            None
+
+        OUTPUT:
+            :return: The organisation tag if it exists, otherwise None.
+
+        """
+        if not self.tags:
+            return None
+        if "organisation" not in self.tags:
+            logging.warning("Organisation tag is not set, returning None")
+            return None
+        return self.tags.get("organisation")
+
+    def set_institute(self, institute: str) -> None:
+        """set_institute: Deprecated alias for set_organisation.
+
+        :param institute: The organisation to set as a tag.
+        :raises TypeError: If the institute is not a string.
+        """
+        warnings.warn(
+            "set_institute is deprecated, use set_organisation instead",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        self.set_organisation(institute)
+
+    def get_institute(self) -> Optional[str]:
+        """get_institute: Deprecated alias for get_organisation.
+
+        INPUT:
+            None
+
+        OUTPUT:
+            :return: The organisation tag if it exists, otherwise None.
+
+        """
+        warnings.warn(
+            "get_institute is deprecated, use get_organisation instead",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.get_organisation()
+
+    def set_department(self, department: str) -> None:
+        """set_department: Set the department tag for the LeafPoint to specify the
+        department.
+
+        :param department: The department to set as a tag.
+        :raises TypeError: If the department is not a string.
+        """
+        if not isinstance(department, str):
+            raise TypeError(
+                f"Department must be of type str, not {type(department).__name__}"
+            )
+        self.add_tag("department", department)
+
+    def get_department(self) -> Optional[str]:
+        """get_department: Get the department tag from the LeafPoint.
+
+        INPUT:
+            None
+
+        OUTPUT:
+            :return: The department tag if it exists, otherwise None.
+
+        """
+        if not self.tags:
+            return None
+        if "department" not in self.tags:
+            logging.warning("Department tag is not set, returning None")
+            return None
+        return self.tags.get("department")
+
+    def validate(self) -> None:
+        """validate: Validate the line protocol
+
+        INPUT:
+            None
+
+        OUTPUT:
+            None, raise valueerror if line is missing
+                   measurement, timestamp, fields or
+                   tags
+
+        """
+        errors = []
+
+        # -------------------------
+        # CHECK
+        if self.measurement is None:
+            errors.append("Measurement is not set")
+
+        if self.timestamp is None:
+            errors.append("Timestamp is not set")
+
+        if not self.fields:
+            errors.append("Fields are not set")
+
+        if not self.tags:
+            errors.append("Tags are not set")
+
+        # -------------------------
+        # IF errors are not empty
+        if errors:
+            raise ValueError(", ".join(errors))
+
+    # ----------------------------
+    #   to and from json
+    # ----------------------------
+    def to_json(
+        self,
+    ) -> dict[str, Union[str, dict[str, str], dict[str, Union[int, float, str]], str]]:
+        """to_json: Convert point to json
+
+        INPUT:
+            None
+
+        OUTPUT:
+            json object with keys: measurement, tags, fields, and timestamp
+
+        """
+        # ----------------------
+        # CHECK
+        self.validate()
+
+        # ----------------------
+        # IF validation successful return json dict
+        return {
+            "measurement": self.measurement,
+            "tags": self.tags,
+            "fields": self.fields,
+            "timestamp": self.timestamp.timestamp() if self.timestamp else None,
+        }
+
+    def from_json(
+        self,
+        json: dict[
+            str, Union[str, dict[str, str], dict[str, Union[int, float, str]], str]
+        ],
+    ) -> None:
+        """from_json: Set class variables
+
+        INPUT:
+            json = dictionary of line protocol
+
+        OUTPUT:
+            None, set the various class variables
+                    from a json dict
+
+        """
+        measurement = json.get("measurement")
+        tags = json.get("tags", {})
+        fields = json.get("fields", {})
+        timestamp = (
+            datetime.fromtimestamp(json.get("timestamp"))
+            if json.get("timestamp")
+            else None
+        )
+
+        self.measurement = measurement
+        self.tags = tags
+        self.fields = fields
+        self.timestamp = timestamp
+
+    def parse_line_protocol(self, line_protocol: str) -> None:
+        """parse_line_protocol: Set class variables from a line protocol
+
+        INPUT:
+            line_protocol = line protocol to parse
+
+        OUTPUT:
+            None, set the various class variables
+                    from a line protocol
+
+        """
+        # -----------------------------------
+        # Regex split on white space only that
+        # are not escaped with \
+        measurement_tags, fields, epoch = re.split(r"(?<!\\)\s", line_protocol)
+        self.set_timestamp(datetime.fromtimestamp(convert_to_seconds(int(epoch))))
+
+        # -----------------------------------
+        # Split the measurement from the tags
+        measurement, tags = re.split(r"(?<!\\),", measurement_tags, maxsplit=1)
+        self.set_measurement(measurement)
+
+        # -----------------------------------
+        # For each tag split...
+        tags = re.split(r"(?<!\\),", tags)
+
+        # -----------------------------------
+        # ...turn it into a dictionary
+        for tag in tags:
+            key, value = re.split(r"(?<!\\)=", tag)
+            self.add_tag(key, value)
+
+        # -----------------------------------
+        # For each field split...
+        fields = re.split(r"(?<!\\),", fields)
+
+        # -----------------------------------
+        # ...turn it into a dictionary
+        for field in fields:
+            key, value = re.split(r"(?<!\\)=", field)
+            self.add_field(key, value)
+
+        # -----------------------------------
+        # Map field value to int or float if possible
+        for k, v in self.fields.items():
+            if v.isdigit():
+                self.fields[k] = int(v)
+            elif v.replace(".", "", 1).isdigit():
+                self.fields[k] = float(v)
+
+        # -----------------------------------
+        # Convert a int timestamp to a datetime object
+        # open('test.txt', 'w').write(f"{epoch} + {datetime.fromtimestamp(int(epoch))}")
+        self.validate()
+
+
+class InfluxPoint(LeafPoint):
+    # Deprecated alias kept so existing InfluxPoint code keeps working.
+    def __init__(self) -> None:
+        warnings.warn(
+            "InfluxPoint is deprecated, use LeafPoint instead",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        super().__init__()

leafobject-0.0.13/src/leafobject/module1.py

@@ -0,0 +1,22 @@
+# Example PyPI (Python Package Index) Package
+
+
+class LeafObject:
+    def __init__(self, n):
+        self.value = n
+
+    def val(self):
+        return self.value
+
+    def add(self, n2):
+        self.value += n2.val()
+
+    def __add__(self, n2):
+        return self.__class__(self.value + n2.val())
+
+    def __str__(self):
+        return str(self.val())
+
+    @classmethod
+    def addall(cls, number_obj_iter):
+        cls(sum(n.val() for n in number_obj_iter))