stellaspark-utils 0.1__tar.gz

stellaspark-utils-0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 StellaSpark
+
+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.

stellaspark-utils-0.1/PKG-INFO

@@ -0,0 +1,125 @@
+Metadata-Version: 2.1
+Name: stellaspark-utils
+Version: 0.1
+Summary: A collection of python utilities for StellaSpark Nexus Digital Twin
+Home-page: https://github.com/StellaSpark/stellaspark_utils
+Download-URL: https://github.com/StellaSpark/stellaspark_utils/archive/v0.1.tar.gz
+Author: StellaSpark
+Author-email: support@stellaspark.com
+Maintainer: StellaSpark
+Maintainer-email: support@stellaspark.com
+License: MIT
+Keywords: stellaspark,nexus,utils,calculation,python
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Topic :: Software Development :: Build Tools
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Provides-Extra: test
+License-File: LICENSE
+
+[Nexus Digital Twin]: https://www.stellaspark.com/
+
+### Description
+A collection of python utilities for StellaSpark [Nexus Digital Twin] technology.
+
+
+### Usage
+```
+TODO
+```
+
+### Development
+
+###### Create an environment:
+```
+# Install virtualenv if you didn't do that already
+pip install virtualenv
+
+# Navigate to the project root directory
+cd <project_root>
+
+# Create your new environment (called 'venv' here)
+virtualenv venv
+
+# Enter the virtual environment
+.\venv\Scripts\activate
+       
+# Install the requirements in the current environment
+pip install -r requirements.txt
+
+# Install the development requirements in the current environment
+pip install -r requirements_dev.txt   
+```
+
+###### Run tests
+```
+TODO
+```
+
+###### Autoformat your code with:
+```
+# Navigate to the project root directory
+cd <project_root>
+
+# Enter the virtual environment
+.\venv\Scripts\activate
+
+# Make the code look nice              
+black .
+
+# Sort the import statements
+isort .
+
+# Validate the code syntax
+flake8
+```
+
+###### Prepare release
+```
+0. You need a Pypi account with an API token (https://pypi.org/manage/account/)
+1. Update version and change message in CHANGES.md
+2. Update the 'version' number in version.txt
+3. Autoformat code (see above)
+4. Optionally, create a pull request in a branch "release <version>"
+5. Optionally, Add commit message "release <version>"
+6. Optionally, Merge PR in main branch
+7. Optionally, Checkout main branch and pull
+```
+
+###### Release automatically
+```
+cd <project_root>
+.\venv\Scripts\activate
+python release.py
+```
+
+###### Release manually
+```
+# Navigate to the project root directory
+cd <project_root>
+
+# Enter the virtual environment
+.\venv\Scripts\activate
+
+# Create distribution (with a '.tar.gz' in it)
+python setup.py sdist
+
+# Validate all distibutions in stellaspark_utils/dist
+twine check dist/*
+
+# Upload distribution to pypi.org
+twine upload dist/stellaspark_utils-<version>.tar.gz
+
+# You will be prompted for a username and password. 
+# - for the username, use __token__ (yes literally '__token__')
+# - for the password, use the pypi token value, including the pypi- prefix
+```

stellaspark-utils-0.1/README.rst

@@ -0,0 +1,97 @@
+[Nexus Digital Twin]: https://www.stellaspark.com/
+
+### Description
+A collection of python utilities for StellaSpark [Nexus Digital Twin] technology.
+
+
+### Usage
+```
+TODO
+```
+
+### Development
+
+###### Create an environment:
+```
+# Install virtualenv if you didn't do that already
+pip install virtualenv
+
+# Navigate to the project root directory
+cd <project_root>
+
+# Create your new environment (called 'venv' here)
+virtualenv venv
+
+# Enter the virtual environment
+.\venv\Scripts\activate
+       
+# Install the requirements in the current environment
+pip install -r requirements.txt
+
+# Install the development requirements in the current environment
+pip install -r requirements_dev.txt   
+```
+
+###### Run tests
+```
+TODO
+```
+
+###### Autoformat your code with:
+```
+# Navigate to the project root directory
+cd <project_root>
+
+# Enter the virtual environment
+.\venv\Scripts\activate
+
+# Make the code look nice              
+black .
+
+# Sort the import statements
+isort .
+
+# Validate the code syntax
+flake8
+```
+
+###### Prepare release
+```
+0. You need a Pypi account with an API token (https://pypi.org/manage/account/)
+1. Update version and change message in CHANGES.md
+2. Update the 'version' number in version.txt
+3. Autoformat code (see above)
+4. Optionally, create a pull request in a branch "release <version>"
+5. Optionally, Add commit message "release <version>"
+6. Optionally, Merge PR in main branch
+7. Optionally, Checkout main branch and pull
+```
+
+###### Release automatically
+```
+cd <project_root>
+.\venv\Scripts\activate
+python release.py
+```
+
+###### Release manually
+```
+# Navigate to the project root directory
+cd <project_root>
+
+# Enter the virtual environment
+.\venv\Scripts\activate
+
+# Create distribution (with a '.tar.gz' in it)
+python setup.py sdist
+
+# Validate all distibutions in stellaspark_utils/dist
+twine check dist/*
+
+# Upload distribution to pypi.org
+twine upload dist/stellaspark_utils-<version>.tar.gz
+
+# You will be prompted for a username and password. 
+# - for the username, use __token__ (yes literally '__token__')
+# - for the password, use the pypi token value, including the pypi- prefix
+```

stellaspark-utils-0.1/pyproject.toml

@@ -0,0 +1,56 @@
+# Note that you have to use single-quoted strings in TOML for regular expressions.
+# It's the equivalent of r-strings in Python.
+# Multiline strings are treated as verbose regular expressions by Black.
+# Use [ ] to denote a significant space character.
+
+[tool.isort]
+atomic = true
+force_alphabetical_sort = true
+force_single_line = true
+include_trailing_comma = true
+line_length = 120
+lines_after_imports = 2
+multi_line_output = 3
+skip = ["venv/"]
+use_parentheses = true
+
+[tool.black]
+line-length = 120
+target-version = ['py37', 'py38','py39']
+# include = '\.pyi?$'
+exclude = '''
+/(
+    \.eggs
+  | \.git
+  | \.hg
+  | \.mypy_cache
+  | \.tox
+  | \.venv
+  | venv
+  | _build
+  | buck-out
+  | build
+  | dist
+)/
+'''
+
+# pytest coverage (you need pytest-cov installed, then run 'pytest --cov')
+[tool.coverage.run]
+source = ['.']
+omit = [
+    # omit anything in a .local directory anywhere
+    '*/.local/*',
+    '__init__.py',
+    # omit anything that is a test
+    'tests/*',
+    'test/*',
+    '*/tests/*',
+    '*/tests/*',
+    # omit anything in a .venv directory anywhere
+    '.venv/*'
+]
+
+# pytest coverage (you need pytest-cov installed, then run 'pytest --cov')
+[tool.coverage.report]
+skip_empty = true
+show_missing = false

stellaspark-utils-0.1/setup.cfg

@@ -0,0 +1,19 @@
+[aliases]
+test = pytest
+
+[tool:pytest]
+python_files = tests.py test_*.py
+
+[flake8]
+max-line-length = 120
+max-complexity = 10
+exclude = 
+	env
+	.env
+	venv
+	.venv
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

stellaspark-utils-0.1/setup.py

@@ -0,0 +1,58 @@
+from constants import ENV_PACKAGE_VERSION
+from constants import MODULE_NAMES
+from constants import PACKAGE_NAME
+from constants import REPO_NAME
+from os import path
+from setuptools import find_packages
+from setuptools import setup
+
+import os
+
+
+# read the contents of your README file
+this_directory = path.abspath(path.dirname(__file__))
+with open(path.join(this_directory, "README.rst"), encoding="utf-8") as f:
+    long_description = f.read()
+
+
+version = os.getenv(ENV_PACKAGE_VERSION)
+
+install_requires = ["pytz", "unidecode"]
+tests_require = [
+    "pytest",
+]
+
+setup(
+    name=PACKAGE_NAME,
+    packages=find_packages(include=MODULE_NAMES),
+    version=version,
+    license="MIT",
+    description="A collection of python utilities for StellaSpark Nexus Digital Twin",
+    long_description_content_type="text/markdown",
+    long_description=long_description,
+    author="StellaSpark",
+    author_email="support@stellaspark.com",
+    maintainer="StellaSpark",
+    maintainer_email="support@stellaspark.com",
+    url="https://github.com/StellaSpark/stellaspark_utils",
+    download_url=f"https://github.com/StellaSpark/{REPO_NAME}/archive/v{version}.tar.gz",
+    keywords=["stellaspark", "nexus", "utils", "calculation", "python"],
+    zip_safe=False,
+    python_requires=">=3.7",
+    install_requires=install_requires,
+    tests_require=tests_require,
+    extras_require={"test": tests_require},
+    classifiers=[
+        "Development Status :: 4 - Beta",
+        "Intended Audience :: Developers",
+        "Intended Audience :: Information Technology",
+        "Intended Audience :: Science/Research",
+        "License :: OSI Approved :: MIT License",
+        "Natural Language :: English",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Topic :: Software Development :: Build Tools",
+    ],
+)

stellaspark-utils-0.1/stellaspark_utils/db.py

@@ -0,0 +1,236 @@
+from stellaspark_utils.text import q
+from typing import Dict
+from typing import List
+
+
+def get_indexes(executor, schema: str, table: str, pk: bool = True, unique: bool = True) -> List[Dict]:
+    """Return a list of dicts, each dict indicating the index name and definition.
+
+    Args: executor: Engine, Connection (SQLAlchemy) or DBAPI-like Cursor (Psycopg2, Django)
+    Returns a list of dicts, each dict being an index with its details
+    """
+    sql_filter = ""
+
+    if not pk:
+        sql_filter = sql_filter + " and indexname not ilike '%%_pkey%%'"
+    if not unique:
+        sql_filter = sql_filter + " and indexdef not ilike '%% unique index %%'"
+
+    results = executor.execute(
+        f"select indexname as name, indexdef as definition "
+        f"from pg_indexes "
+        f"where schemaname = %s and tablename = %s {sql_filter}",
+        (schema, table),
+    )
+
+    if results is None:
+        # Python DBAPI Cursor object (Django, Psycopg2)
+        indexes = [dict(zip([col[0] for col in executor.description], row)) for row in executor.fetchall()]
+    else:
+        # Database connection or engine-based query (SQLAlchemy)
+        indexes = [dict(row) for row in results.fetchall()]
+
+    return indexes
+
+
+def get_constraints(executor, schema: str, table: str, pk: bool = True, child_fks: bool = False) -> List[Dict]:
+    """Return a list of dicts, each dict indicating the constraint name, type, definition etc.
+
+    Args: executor: Engine, Connection (SQLAlchemy) or DBAPI-like Cursor (Psycopg2, Django)
+    Returns a list of dicts, each dict being a constraint with its details
+    """
+    sql_where = "" if pk else "and pgc.contype != 'p'"
+
+    results = executor.execute(
+        f"select pgc.conname as name, "
+        f"pg_get_constraintdef(pgc.oid) as definition, "
+        f"pgc.contype as type, "
+        f"nullif(split_part(pgc.confrelid::regclass::text, '.',2), '') as table_referenced "
+        f"from pg_constraint pgc "
+        f"join pg_namespace nsp on nsp.oid = pgc.connamespace "
+        f"left join pg_class cls on pgc.conrelid = cls.oid "
+        f"where nspname = %s and relname = %s "
+        f"{sql_where}",
+        (schema, table),
+    )
+    if results is None:
+        # Python DBAPI Cursor object (Django, Psycopg2)
+        constraints = [dict(zip([col[0] for col in executor.description], row)) for row in executor.fetchall()]
+    else:
+        # Database connection or engine-based query (SQLAlchemy)
+        constraints = [dict(row) for row in results.fetchall()]
+
+    for constraint in constraints:
+        constraint["schema"] = schema
+        constraint["table"] = table
+        constraint["child"] = False
+        constraint["definition"] = f"alter table {schema}.{q(table)} add {constraint['definition']}"
+
+    if child_fks:
+        results = executor.execute(
+            "with unnested_confkey as ( "
+            "    select oid, unnest(confkey) as confkey "
+            "    from pg_constraint), "
+            "unnested_conkey as ( "
+            "    select oid, unnest(conkey) as conkey "
+            "    from pg_constraint ) "
+            "select c.conname as name, "
+            "tbl.relname as table, "
+            "col.attname as col, "
+            "pg_get_constraintdef(c.oid) as definition "
+            "from pg_constraint c "
+            "left join unnested_conkey con on c.oid = con.oid "
+            "left join pg_class tbl on tbl.oid = c.conrelid "
+            "left join pg_attribute col on (col.attrelid = tbl.oid and col.attnum = con.conkey) "
+            "left join pg_class referenced_tbl on c.confrelid = referenced_tbl.oid "
+            "left join unnested_confkey conf on c.oid = conf.oid "
+            "left join pg_attribute referenced_field on (referenced_field.attrelid = c.confrelid and referenced_field.attnum = conf.confkey) "  # noqa
+            "where c.contype = 'f' "
+            "and tbl.relnamespace::regnamespace::text = %s "
+            "and referenced_tbl.relname = %s ",
+            (schema, table),
+        )
+        if results is None:
+            # Python DBAPI Cursor object (Django, Psycopg2)
+            constraints_children = [
+                dict(zip([col[0] for col in executor.description], row)) for row in executor.fetchall()
+            ]
+        else:
+            # Database connection or engine-based query (SQLAlchemy)
+            constraints_children = [dict(row) for row in results.fetchall()]
+
+        for child_constraint in constraints_children:
+            child_constraint["schema"] = schema
+            child_constraint["type"] = "f"
+            child_constraint["child"] = True
+            child_constraint[
+                "definition"
+            ] = f"alter table {schema}.{child_constraint['table']} add {child_constraint['definition']}"
+
+        constraints = constraints + constraints_children
+
+    return constraints
+
+
+def get_dependent_views(executor, schema: str, table: str) -> List[Dict]:
+    """Get all views that depend on this table.
+
+    Args:executor: Engine, Connection (SQLAlchemy) or DBAPI-like Cursor (Psycopg2, Django)
+    Returns a list of dicts, each dict being a view with its details
+    """
+    results = executor.execute(
+        "select distinct on (objid) objid, "
+        "dependent_view.relname as name, "
+        "dependent_ns.nspname as schema, "
+        "pgv.definition as definition "
+        "from pg_depend "
+        "join pg_rewrite on pg_depend.objid = pg_rewrite.oid "
+        "join pg_class as dependent_view on pg_rewrite.ev_class = dependent_view.oid "
+        "join pg_class as source_table on pg_depend.refobjid = source_table.oid "
+        "join pg_attribute on pg_depend.refobjid = pg_attribute.attrelid "
+        "  and pg_depend.refobjsubid = pg_attribute.attnum "
+        "join pg_namespace dependent_ns on dependent_ns.oid = dependent_view.relnamespace "
+        "join pg_namespace source_ns on source_ns.oid = source_table.relnamespace "
+        "join pg_views pgv on pgv.schemaname = dependent_ns.nspname and pgv.viewname = dependent_view.relname "
+        "where source_ns.nspname = %s "
+        "and source_table.relname = %s "
+        "and pg_attribute.attnum > 0",
+        (schema, table),
+    )
+
+    if results is None:
+        # Python DBAPI Cursor object (Django, Psycopg2)
+        dependent_views = [dict(zip([col[0] for col in executor.description], row)) for row in executor.fetchall()]
+    else:
+        # Database connection or engine-based query (SQLAlchemy)
+        dependent_views = [dict(row) for row in results.fetchall()]
+
+    for view in dependent_views:
+        view.pop("objid", None)
+        view["definition"] = f"create view {view['schema']}.{view['name']} as {view['definition']}"
+
+    return dependent_views
+
+
+def get_dependent_matviews(executor, schema: str, table: str) -> List[Dict]:
+    """Get all materialized views that depend on this table.
+
+    Args:executor: Engine, Connection (SQLAlchemy) or DBAPI-like Cursor (Psycopg2, Django)
+    Returns a list of dicts, each dict being a dependent materialized view with its details
+    """
+    results = executor.execute(
+        f"select matviewname as name, schemaname as schema, definition "
+        f"from pg_matviews "
+        f"where definition ilike '%%{schema}.{table}%%'"
+    )
+
+    if results is None:
+        # Python DBAPI Cursor object (Django, Psycopg2)
+        dependent_matviews = [dict(zip([col[0] for col in executor.description], row)) for row in executor.fetchall()]
+    else:
+        # Database connection or engine-based query (SQLAlchemy)
+        dependent_matviews = [dict(row) for row in results.fetchall()]
+
+    for matview in dependent_matviews:
+        matview[
+            "definition"
+        ] = f"create materialized view {matview['schema']}.{matview['name']} as {matview['definition']}"
+
+    return dependent_matviews
+
+
+def get_privileges(executor, schema: str, table: str) -> List[Dict]:
+    """List user privileges on table.
+
+    Args: executor: Engine, Connection (SQLAlchemy) or DBAPI-like Cursor (Psycopg2, Django)
+    Returns a list of dicts, each dict being a privilege with its details
+    """
+    results = executor.execute(
+        f"select grantee, privilege_type as name "
+        f"from information_schema.role_table_grants "
+        f"where table_schema = '{schema}' "
+        f"and table_name = '{table}'",
+        (schema, table),
+    )
+
+    if results is None:
+        # Python DBAPI Cursor object (Django, Psycopg2)
+        privileges = [dict(zip([col[0] for col in executor.description], row)) for row in executor.fetchall()]
+    else:
+        # Database connection or engine-based query (SQLAlchemy)
+        privileges = [dict(row) for row in results.fetchall()]
+
+    for privilege in privileges:
+        privilege["definition"] = f"grant {privilege['name']} on table {schema}.{q(table)} to {q(privilege['grantee'])}"
+
+    return privileges
+
+
+def get_clustered_tables(executor) -> List[Dict]:
+    """Get a list of all clustered tables.
+
+    Args: executor: Engine, Connection (SQLAlchemy) or DBAPI-like Cursor (Psycopg2, Django)
+    Returns a list of dicts, each dict being a clustered table with its details
+    """
+    results = executor.execute(
+        "select n.nspname as schema, c.relname as table, split_part(indexrelid::regclass::text, '.', 2) as index "
+        "from pg_class c "
+        "join pg_namespace n "
+        "on n.oid = c.relnamespace "
+        "join pg_index i "
+        "on i.indrelid = c.oid "
+        "where c.relkind = 'r' and c.relhasindex = 't' "
+        "and i.indisclustered = 't'"
+    )
+
+    if results is None:
+        # Python DBAPI Cursor object (Django, Psycopg2)
+        clustered_tables = [dict(zip([col[0] for col in executor.description], row)) for row in executor.fetchall()]
+    else:
+        # Database connection or engine-based query (SQLAlchemy)
+        clustered_tables = [dict(row) for row in results.fetchall()]
+
+    for table in clustered_tables:
+        table["definition"] = f"alter table {table['schema']}.{q(table['table'])} cluster on {table['index']}"
+
+    return clustered_tables

stellaspark-utils-0.1/stellaspark_utils/text.py

@@ -0,0 +1,201 @@
+from calendar import monthrange
+from datetime import datetime
+from datetime import timedelta
+from typing import List
+from typing import Union
+
+import pytz
+import re
+import unidecode
+
+
+def q(ids) -> Union[str, List]:
+    """Return quoted and sanitized SQL column or table identifiers."""
+    if isinstance(ids, (list, tuple)):
+        return [f'"{_id}"' for _id in ids]
+    else:
+        return f'"{ids}"'
+
+
+def sq(string: Union[str, List]):
+    """Return single-quoted strings that are safe for HTML."""
+    return (
+        [chr(39) + str(elem) + chr(39) for elem in string]
+        if isinstance(string, (list, tuple))
+        else chr(39) + str(string) + chr(39)
+    )
+
+
+def to_lwu(s, keep_colons=True, keep_minus=False, keep_double_underscores=False):
+    """Convert string to lowercase_with_underscores format.
+
+    Also replace dots and hyphens with underscores for Postgres table name compatibility. Maintaining or removing
+    colons is optional, since some Nexus identifiers may contain these (such as GeoServer layers) whereas other
+    identifiers are not allowed to have this (e.g. Postgres colnames)
+    """
+    # Order to_replace matters!
+    to_replace = {
+        "<>": "_uneq_",
+        ">=": "_gte_",
+        "=>": "_gte_",
+        "<=": "_lte_",
+        "=<": "_lte_",
+        ">": "_gt_",
+        "<": "_lt_",
+        "!=": "_uneq_",
+        "==": "_eq_",
+        "=": "_eq_",
+        "%": "_pct_",
+        "°": "_deg_",
+        "&": "_and_",
+    }
+
+    # Make sure that the space is always replaced between the minuses
+    to_underscore = [" "] if keep_minus else [" - ", " ", "-"]
+    to_underscore.extend([".", "+", ",", "/"])
+
+    if not keep_double_underscores:
+        to_underscore.append("__")
+
+    to_underscore.extend(["___", "____"])  # Order here matters, replace duplicate underscores last
+    to_remove = [
+        "[",
+        "]",
+        "(",
+        ")",
+        "{",
+        "}",
+        "#",
+        ";",
+        "'",
+        '"',
+        "?",
+        "!",
+        "*",
+        "@",
+        "$",
+        "|",
+    ]
+
+    if not keep_colons:
+        to_remove.append(":")
+
+    for substr, replacement in to_replace.items():
+        s = s.replace(substr, replacement)
+
+    for substr in to_underscore:
+        s = s.replace(substr, "_")
+
+    for substr in to_remove:
+        s = s.replace(substr, "")
+
+    # Ensure that final string does not have _ at the end or start
+    s = s.strip("_")
+    s = unidecode.unidecode(s)  # Remove any accents, convert greek, cyrillic or chinese characters
+
+    return s.lower()
+
+
+def is_float(string: str) -> bool:
+    """Quickly check if string is also a valid number."""
+    try:
+        float(string)
+        return True
+    except ValueError:
+        return False
+
+
+def parse_time_placeholders(s: str):
+    """Substitute time placeholders.
+
+    Substitute the following placeholders with current year, month and days respectively (possibly with a subtraction):
+     - {-30:%Y-%m-%d}
+     - {%Y}
+     - {%Y/%m/%d}
+
+    https://www.programiz.com/python-programming/datetime/strftime
+    """
+    # Find fields that contain placeholders with percent signs (datetime-like)
+    fields = re.findall(r"{([-|%|\d].+?)}", s)
+    contains_any = ("%",)
+    fields = [field for field in fields if any(substr in field for substr in contains_any)]
+    if not fields:
+        return s
+
+    now = datetime.now()
+    for field in fields:
+        if ":" in field:
+            days = 0
+            seconds = 0
+            if "day" in field:
+                field_sanitized = re.sub(r"[a-zA-Z]", "", field.split("day")[0]).strip()
+                days = int(eval(field_sanitized))
+            elif "year" in field:
+                field_sanitized = re.sub(r"[a-zA-Z]", "", field.split("year")[0]).strip()
+                years = int(eval(field_sanitized))
+                days = get_days_offset(now.year, now.month, years_offset=years)
+            elif "second" in field:
+                field_sanitized = re.sub(r"[a-zA-Z]", "", field.split("second")[0]).strip()
+                seconds = int(eval(field_sanitized))
+            else:
+                raise ValueError("Unknown time offset")
+
+            timestamp = now + timedelta(days=days, seconds=seconds)
+            pos = field.find(":")
+            if field[pos + 1 :] == "%unix":  # noqa
+                s = s.replace("{" + field + "}", str(int(timestamp.timestamp())))
+            else:
+                s = s.replace("{" + field + "}", eval(f"{timestamp: f'{field[pos+1:]}'}"))
+        else:
+            if field == "%unix":
+                s = s.replace("{" + field + "}", str(int(now.timestamp())))
+            else:
+                s = s.replace("{" + field + "}", eval(f"{now: f'{field}'}"))
+
+    return s
+
+
+def get_days_offset(
+    year: int,
+    month: int,
+    years_offset: int = 0,
+    months_offset: int = 0,
+    days_offset: int = 0,
+) -> int:
+    """Get offset in days, counting from the given year and current month.
+
+    In case of a net-negative offset, the returned number of days will be negative. Vise versa.
+    """
+    # To account for leap years, also add the years offset to the months, we calculate the amount of days in one go
+    months_offset = months_offset + (12 * years_offset)
+
+    days = 0
+    for _ in range(0, abs(months_offset)):
+        if months_offset < 0:
+            if month == 1:
+                year = year - 1
+                month = 12
+            else:
+                month = month - 1
+            days = days - monthrange(year, month)[1]
+        else:
+            if month == 12:
+                year = year + 1
+                month = 1
+            else:
+                month = month + 1
+            days = days + monthrange(year, month)[1]
+
+    days = days + days_offset
+
+    return days
+
+
+def ensure_tz_aware(datetime_str: str) -> str:
+    """Ensure that datetime string is iso-formatted and is timezone aware."""
+    datetime_obj = datetime.fromisoformat(datetime_str)
+    is_tz_aware = datetime_obj.tzinfo is not None and datetime_obj.tzinfo.utcoffset(datetime_obj) is not None
+    if is_tz_aware:
+        return datetime_str
+    datetime_obj_tz = datetime_obj.replace(tzinfo=pytz.utc)  # Make timezone aware (UTC)
+    return datetime_obj_tz.isoformat()

stellaspark-utils-0.1/stellaspark_utils.egg-info/PKG-INFO

@@ -0,0 +1,125 @@
+Metadata-Version: 2.1
+Name: stellaspark-utils
+Version: 0.1
+Summary: A collection of python utilities for StellaSpark Nexus Digital Twin
+Home-page: https://github.com/StellaSpark/stellaspark_utils
+Download-URL: https://github.com/StellaSpark/stellaspark_utils/archive/v0.1.tar.gz
+Author: StellaSpark
+Author-email: support@stellaspark.com
+Maintainer: StellaSpark
+Maintainer-email: support@stellaspark.com
+License: MIT
+Keywords: stellaspark,nexus,utils,calculation,python
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Topic :: Software Development :: Build Tools
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Provides-Extra: test
+License-File: LICENSE
+
+[Nexus Digital Twin]: https://www.stellaspark.com/
+
+### Description
+A collection of python utilities for StellaSpark [Nexus Digital Twin] technology.
+
+
+### Usage
+```
+TODO
+```
+
+### Development
+
+###### Create an environment:
+```
+# Install virtualenv if you didn't do that already
+pip install virtualenv
+
+# Navigate to the project root directory
+cd <project_root>
+
+# Create your new environment (called 'venv' here)
+virtualenv venv
+
+# Enter the virtual environment
+.\venv\Scripts\activate
+       
+# Install the requirements in the current environment
+pip install -r requirements.txt
+
+# Install the development requirements in the current environment
+pip install -r requirements_dev.txt   
+```
+
+###### Run tests
+```
+TODO
+```
+
+###### Autoformat your code with:
+```
+# Navigate to the project root directory
+cd <project_root>
+
+# Enter the virtual environment
+.\venv\Scripts\activate
+
+# Make the code look nice              
+black .
+
+# Sort the import statements
+isort .
+
+# Validate the code syntax
+flake8
+```
+
+###### Prepare release
+```
+0. You need a Pypi account with an API token (https://pypi.org/manage/account/)
+1. Update version and change message in CHANGES.md
+2. Update the 'version' number in version.txt
+3. Autoformat code (see above)
+4. Optionally, create a pull request in a branch "release <version>"
+5. Optionally, Add commit message "release <version>"
+6. Optionally, Merge PR in main branch
+7. Optionally, Checkout main branch and pull
+```
+
+###### Release automatically
+```
+cd <project_root>
+.\venv\Scripts\activate
+python release.py
+```
+
+###### Release manually
+```
+# Navigate to the project root directory
+cd <project_root>
+
+# Enter the virtual environment
+.\venv\Scripts\activate
+
+# Create distribution (with a '.tar.gz' in it)
+python setup.py sdist
+
+# Validate all distibutions in stellaspark_utils/dist
+twine check dist/*
+
+# Upload distribution to pypi.org
+twine upload dist/stellaspark_utils-<version>.tar.gz
+
+# You will be prompted for a username and password. 
+# - for the username, use __token__ (yes literally '__token__')
+# - for the password, use the pypi token value, including the pypi- prefix
+```

stellaspark-utils-0.1/stellaspark_utils.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.rst
+pyproject.toml
+setup.cfg
+setup.py
+stellaspark_utils/__init__.py
+stellaspark_utils/conftest.py
+stellaspark_utils/db.py
+stellaspark_utils/text.py
+stellaspark_utils.egg-info/PKG-INFO
+stellaspark_utils.egg-info/SOURCES.txt
+stellaspark_utils.egg-info/dependency_links.txt
+stellaspark_utils.egg-info/not-zip-safe
+stellaspark_utils.egg-info/requires.txt
+stellaspark_utils.egg-info/top_level.txt

stellaspark-utils-0.1/stellaspark_utils.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

stellaspark-utils-0.1/stellaspark_utils.egg-info/not-zip-safe

@@ -0,0 +1 @@
+

stellaspark-utils-0.1/stellaspark_utils.egg-info/requires.txt

@@ -0,0 +1,5 @@
+pytz
+unidecode
+
+[test]
+pytest

stellaspark-utils-0.1/stellaspark_utils.egg-info/top_level.txt

@@ -0,0 +1 @@
+stellaspark_utils