sep2tools 0.1.0__tar.gz

sep2tools-0.1.0/.github/workflows/pythonpackage.yml

@@ -0,0 +1,38 @@
+name: Python package
+
+on: ["pull_request"]
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.9", "3.10", "3.11", "3.12"]
+    steps:
+      - uses: actions/checkout@v3
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v4
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip wheel
+          if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
+          # install the local folder
+          python -m pip install -e .
+      - name: Test with ruff
+        run: |
+          pip install ruff
+          ruff check .
+      - name: Test with pytest
+        run: |
+          pip install pytest pytest-cov
+          pytest --cov-report=xml          
+      - name: Coveralls
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          COVERALLS_REPO_TOKEN: ${{ secrets.COVERALLS_REPO_TOKEN }}
+        run: |
+          pip install coveralls
+          coverage run --source=sep2tools -m pytest tests/
+          coveralls

sep2tools-0.1.0/.gitignore

@@ -0,0 +1,165 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+
+certs/

sep2tools-0.1.0/LICENSE

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

sep2tools-0.1.0/PKG-INFO

@@ -0,0 +1,27 @@
+Metadata-Version: 2.1
+Name: sep2tools
+Version: 0.1.0
+Summary: Useful functions for working with IEEE 2030.5 (SEP2)
+Author-email: Alex Guinman <alex@guinman.id.au>
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Operating System :: OS Independent
+Requires-Dist: cryptography
+Requires-Dist: asn1
+Requires-Dist: python-dateutil
+Requires-Dist: ruff ; extra == "test"
+Requires-Dist: pytest >=2.7.3 ; extra == "test"
+Requires-Dist: pytest-cov ; extra == "test"
+Requires-Dist: mypy ; extra == "test"
+Project-URL: Source, https://github.com/aguinane/SEP2-Tools
+Provides-Extra: test
+
+# SEP2-Tools
+This library provides some useful functions for working with IEEE 2030.5 (SEP2).
+

sep2tools-0.1.0/README.md

@@ -0,0 +1,2 @@
+# SEP2-Tools
+This library provides some useful functions for working with IEEE 2030.5 (SEP2).

sep2tools-0.1.0/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["flit_core >=3.2,<4"]
+build-backend = "flit_core.buildapi"
+
+[project]
+name = "sep2tools"
+authors = [{ name = "Alex Guinman", email = "alex@guinman.id.au" }]
+readme = "README.md"
+license = { file = "LICENSE" }
+classifiers = [
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.9",
+    "Operating System :: OS Independent",
+]
+requires-python = ">=3.9"
+dynamic = ["version", "description"]
+dependencies = ["cryptography", "asn1", "python-dateutil"]
+
+[project.optional-dependencies]
+test = ["ruff", "pytest >=2.7.3", "pytest-cov", "mypy"]
+
+[project.urls]
+Source = "https://github.com/aguinane/SEP2-Tools"
+
+[tool.pytest.ini_options]
+addopts = "-ra --failed-first --showlocals --durations=3 --cov=sep2tools"
+
+[tool.coverage.run]
+omit = ["*/version.py", '*/__main__.py']
+
+[tool.coverage.report]
+show_missing = true
+skip_empty = true
+fail_under = 80
+
+[tool.ruff.lint]
+select = ["A", "B", "E", "F", "I", "N", "SIM", "UP"]

sep2tools-0.1.0/sep2tools/__init__.py

@@ -0,0 +1,13 @@
+""" Useful functions for working with IEEE 2030.5 (SEP2)"""
+
+from .cert_id import get_der_certificate_lfdi, get_pem_certificate_lfdi
+from .ids import generate_mrid, proxy_device_lfdi
+from .version import __version__
+
+__all__ = [
+    "__version__",
+    "get_pem_certificate_lfdi",
+    "get_der_certificate_lfdi",
+    "proxy_device_lfdi",
+    "generate_mrid",
+]

sep2tools-0.1.0/sep2tools/cert_create.py

@@ -0,0 +1,175 @@
+import logging
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+import asn1
+from cryptography import x509
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric import ec
+from cryptography.hazmat.primitives.hashes import SHA256
+from cryptography.x509.oid import ObjectIdentifier
+from dateutil import tz
+
+log = logging.getLogger(__name__)
+
+DEFAULT_KEY_PATH = Path("key.pem")
+DEFAULT_CSR_PATH = Path("csr.pem")
+
+# IEEE 2030.5 device type assignments (Section 6.11.7.2)
+SEP2_DEV_GENERIC = ObjectIdentifier("1.3.6.1.4.1.40732.1.1")
+SEP2_DEV_MOBILE = ObjectIdentifier("1.3.6.1.4.1.40732.1.2")
+SEP2_DEV_POSTMANUF = ObjectIdentifier("1.3.6.1.4.1.40732.1.3")
+
+# IEEE 2030.5 policy assignments (Section 6.11.7.3)
+SEP2_TEST_CERT = ObjectIdentifier("1.3.6.1.4.1.40732.2.1")
+SEP2_TEST_SELFSIGNED = ObjectIdentifier("1.3.6.1.4.1.40732.2.2")
+SEP2_TEST_SERVPROV = ObjectIdentifier("1.3.6.1.4.1.40732.2.3")
+SEP2_TEST_BULK_CERT = ObjectIdentifier("1.3.6.1.4.1.40732.2.4")
+
+# HardwareModuleName (Section 6.11.7.4)
+SEP2_HARDWARE_MODULE_NAME = ObjectIdentifier("1.3.6.1.5.5.7.8.4")
+
+
+def generate_key_and_csr(
+    key_file: Path = DEFAULT_KEY_PATH, csr_file: Path = DEFAULT_CSR_PATH
+) -> tuple[Path, Path]:
+    """Generate a Private Key and Certificate Signing Request (CSR)"""
+    key = ec.generate_private_key(ec.SECP256R1)
+    key_pem = key.private_bytes(
+        encoding=serialization.Encoding.PEM,
+        format=serialization.PrivateFormat.PKCS8,
+        encryption_algorithm=serialization.NoEncryption(),
+    )
+    with open(key_file, "wb") as fh:
+        fh.write(key_pem)
+        log.info("Created Key at %s", key_file)
+
+    subject_name = ""
+    csr = (
+        x509.CertificateSigningRequestBuilder()
+        .subject_name(x509.Name(subject_name))
+        .sign(key, SHA256())
+    )
+    csr_pem = csr.public_bytes(serialization.Encoding.PEM)
+    with open(csr_file, "wb") as fh:
+        fh.write(csr_pem)
+        log.info("Created CSR at %s", csr_file)
+    return key_file, csr_file
+
+
+def convert_pem_to_der(filename: Path) -> Path:
+    """Convert a PEM file to DER Certificate"""
+    with open(filename, "rb") as pem_file:
+        cert_data = pem_file.read()
+    cert = x509.load_pem_x509_certificate(cert_data)
+    der_data = cert.public_bytes(encoding=serialization.Encoding.DER)
+    output_der_path = filename.with_suffix(".der")
+    with open(output_der_path, "wb") as fh:
+        fh.write(der_data)
+    return output_der_path
+
+
+def generate_device_certificate(
+    filename: Path,
+    csr_path: Path,
+    mica_cert_path: Path,
+    mica_key_path: Path,
+    hardware_type_oid: str,
+    hardware_serial_number: str,
+    policy_oids: list[ObjectIdentifier],
+    serca_cert_path: Optional[Path] = None,
+) -> Path:
+    """Use a CSR and MICA key pair to generate a SEP2 Certificate"""
+
+    with open(csr_path, "rb") as pem_file:
+        csr_data = pem_file.read()
+    csr = x509.load_pem_x509_csr(csr_data)
+    with open(mica_cert_path, "rb") as pem_file:
+        mica_pem_data = pem_file.read()
+    mica_cert = x509.load_pem_x509_certificate(mica_pem_data)
+    with open(mica_key_path, "rb") as pem_file:
+        pem_data = pem_file.read()
+    mica_key = serialization.load_pem_private_key(pem_data, password=None)
+    valid_from = datetime.now(tz=tz.UTC)
+    valid_to = datetime(9999, 12, 31, 23, 59, 59, 0)  # as per standard
+
+    policies = [x509.PolicyInformation(oid, None) for oid in policy_oids]
+
+    # SAN OtherName encoder
+    encoder = asn1.Encoder()
+    encoder.start()
+    encoder.enter(asn1.Numbers.Sequence)
+    encoder.write(str(hardware_type_oid), asn1.Numbers.ObjectIdentifier)
+    encoder.write(str(hardware_serial_number), asn1.Numbers.OctetString)
+    encoder.leave()
+    hw_module_name = encoder.output()
+
+    sname = x509.Name("")  # SubjectName should be blank
+
+    issuer_name = mica_cert.subject
+    iname = x509.Name(issuer_name)
+    cert = (
+        x509.CertificateBuilder()
+        .subject_name(sname)
+        .issuer_name(iname)
+        .public_key(csr.public_key())
+        .serial_number(x509.random_serial_number())
+        .not_valid_before(valid_from)
+        .not_valid_after(valid_to)
+        .add_extension(
+            x509.BasicConstraints(ca=False, path_length=None),
+            critical=True,
+        )
+        .add_extension(
+            x509.KeyUsage(
+                key_agreement=True,
+                key_cert_sign=False,
+                crl_sign=False,
+                digital_signature=True,
+                content_commitment=False,
+                key_encipherment=False,
+                data_encipherment=False,
+                encipher_only=False,
+                decipher_only=False,
+            ),
+            critical=True,
+        )
+        .add_extension(
+            x509.AuthorityKeyIdentifier.from_issuer_subject_key_identifier(
+                mica_cert.extensions.get_extension_for_class(
+                    x509.SubjectKeyIdentifier
+                ).value
+            ),
+            critical=False,
+        )
+        .add_extension(
+            x509.SubjectAlternativeName(
+                general_names=[
+                    x509.OtherName(SEP2_HARDWARE_MODULE_NAME, hw_module_name)
+                ]
+            ),
+            critical=True,
+        )
+        .add_extension(
+            x509.CertificatePolicies(policies=policies),
+            critical=True,
+        )
+        .sign(mica_key, SHA256())
+    )
+
+    serca_pem_data = ""
+    if serca_cert_path:
+        with open(serca_cert_path, "rb") as pem_file:
+            serca_pem_data = pem_file.read()
+
+    cert_pem = cert.public_bytes(encoding=serialization.Encoding.PEM)
+    with open(filename, "wb") as fh:
+        fh.write(cert_pem)
+        # Append the intermediate certificate
+        fh.write(mica_pem_data)
+        # Append the root certificate
+        if serca_pem_data:
+            fh.write(serca_pem_data)
+        log.info("Created Cert %s", filename)
+    return filename

sep2tools-0.1.0/sep2tools/cert_id.py

@@ -0,0 +1,87 @@
+import hashlib
+import logging
+from itertools import zip_longest
+from pathlib import Path
+
+from cryptography import x509
+from cryptography.hazmat.primitives import serialization
+
+log = logging.getLogger(__name__)
+
+
+def group_hex(item: str, group_size: int = 4) -> str:
+    """Group into groups of four"""
+
+    def grouper(iterable, n, fillvalue=None):
+        args = [iter(iterable)] * n
+        return zip_longest(*args, fillvalue=fillvalue)
+
+    return "-".join("".join(x) for x in grouper(item, n=group_size))
+
+
+def get_lfdi(fingerprint: str, group: bool = True) -> str:
+    """Long-form device identifier (LFDI)
+    The LFDI SHALL be the certificate fingerprint left-truncated to 160 bits.
+    For display purposes, this SHALL be expressed as 40 hexadecimal digits in
+    groups of four.
+    """
+    lfdi = fingerprint.replace("-", "")[0:40].upper()
+    if not group:
+        return lfdi
+    return group_hex(lfdi)
+
+
+def get_sfdi(fingerprint, group: bool = True) -> str:
+    """Short-form device identifier (SFDI)
+    The SFDI SHALL be the certificate fingerprint left-truncated to 36 bits.
+    For display purposes, this SHALL be expressed as 11 decimal (base 10) digits,
+    with an additional sum-of-digits checksum digit right concatenated.
+    """
+    trunc = fingerprint.replace("-", "")[0:9]
+    sfdi = int(trunc, base=16)  # Convert from Base 16 to Base 10
+    digits = map(int, str(sfdi))
+    checksum = 10 - sum(digits) % 10
+    if checksum == 10:
+        checksum = 0
+
+    full_sfdi = str(sfdi) + str(checksum)
+    if not group:
+        return full_sfdi
+    return group_hex(full_sfdi, 3)
+
+
+def get_fingerprint(cert_path: Path) -> str:
+    """Certificate fingerprint
+    The certificate fingerprint is the result of performing a SHA256 operation
+    over the whole DER-encoded certificate and is used to derive the SFDI and LFDI.
+    """
+    with open(cert_path, "rb") as f:
+        fbytes = f.read()  # read entire file as bytes
+        readable_hash = hashlib.sha256(fbytes).hexdigest().upper()
+        return readable_hash
+
+
+def get_der_certificate_lfdi(cert_path: Path, group: bool = True):
+    """Load X.509 DER Certificate and return LFDI"""
+
+    if not cert_path.exists():
+        raise ValueError(f"Cert not found at {cert_path}")
+
+    fingerprint = get_fingerprint(cert_path)
+    return get_lfdi(fingerprint, group=group)
+
+
+def get_pem_certificate_lfdi(cert_path: Path, group: bool = True):
+    """Load X.509 DER Certificate in PEM format and return LFDI"""
+
+    if not cert_path.exists():
+        raise ValueError(f"Cert not found at {cert_path}")
+
+    with open(cert_path, "rb") as pem_file:
+        cert_data = pem_file.read()
+
+    cert = x509.load_pem_x509_certificate(cert_data)
+    der_bytes = cert.public_bytes(serialization.Encoding.DER)
+    fingerprint = hashlib.sha256(der_bytes).hexdigest().upper()
+    lfdi = get_lfdi(fingerprint, group=group)
+    return lfdi

sep2tools-0.1.0/sep2tools/hexmaps.py

@@ -0,0 +1,177 @@
+def get_role_flag(
+    is_mirror=0, is_premise=0, is_pev=0, is_der=0, is_revenue=0, is_dc=0, is_submeter=0
+) -> tuple[str, str]:
+    """
+    RoleFlagsType object (HexBinary16)
+    Specifies the roles that apply to a usage point.
+    Bit 0—isMirror—SHALL be set if the server is not the measurement device
+    Bit 1—isPremisesAggregationPoint—SHALL be set if the UsagePoint is the
+        point of delivery for a premises
+    Bit 2—isPEV—SHALL be set if the usage applies to an electric vehicle
+    Bit 3—isDER—SHALL be set if the usage applies to a distributed energy resource,
+        capable of delivering
+    power to the grid
+    Bit 4—isRevenueQuality—SHALL be set if usage was measured by a device certified
+        as revenue quality
+    Bit 5—isDC—SHALL be set if the usage point measures direct current
+    Bit 6—isSubmeter—SHALL be set if the usage point is not a premises aggregation point
+    Bit 7 to 15—Reserved
+    """
+
+    a = is_mirror
+    b = is_premise
+    c = is_pev
+    d = is_der
+    e = is_revenue
+    f = is_dc
+    g = is_submeter
+
+    binary_str = f"000000000{g}{f}{e}{d}{c}{b}{a}"
+    val = int(binary_str, 2)
+    hex_str = str(hex(val))[2:].zfill(2).upper()
+    return binary_str, hex_str
+
+
+def get_quality_flag(
+    valid=0, manual=0, estimate=0, interpolated=0, questionable=0, derived=0, future=0
+) -> tuple[str, str]:
+    """
+    qualityFlags (HexBinary16)
+    Bit 0 - valid: data that has gone through all required validation
+    checks and either passed them all or has been verified
+    Bit 1 - manually edited: Replaced or approved by a human
+    Bit 2 - estimated using reference day: data value was replaced
+    by a machine computed value based on analysis of historical
+    data using the same type of measurement.
+    Bit 3 - estimated using linear interpolation: data value was
+    computed using linear interpolation based on the readings
+    before and after it
+    Bit 4 - questionable: data that has failed one or more checks
+    Bit 5 - derived: data that has been calculated (using logic or
+    mathematical operations), not necessarily measured directly
+    Bit 6 - projected (forecast): data that has been calculated as a
+    projection or forecast of future reading
+    """
+
+    a = valid
+    b = manual
+    c = estimate
+    d = interpolated
+    e = questionable
+    f = derived
+    g = future
+
+    binary_str = f"000000000{g}{f}{e}{d}{c}{b}{a}"
+    val = int(binary_str, 2)
+    hex_str = str(hex(val))[2:].zfill(2).upper()
+    return binary_str, hex_str
+
+
+def get_connect_status(
+    connected=0, available=0, operating=0, test=0, fault=0
+) -> tuple[str, str]:
+    """
+    ConnectStatusType object (HexBinary8)
+    0 = Connected
+    1 = Available
+    2 = Operating
+    3 = Test
+    4 = Fault/Error
+    """
+
+    a = connected
+    b = available
+    c = operating
+    d = test
+    e = fault
+
+    binary_str = f"000{e}{d}{c}{b}{a}"
+    val = int(binary_str, 2)
+    hex_str = str(hex(val))[2:].zfill(2).upper()
+    return binary_str, hex_str
+
+
+def get_modes_supported(modes: list[str]) -> tuple[str, str]:
+    """DERControlType object (HexBinary32)
+    Control modes supported by the DER. Bit positions SHALL be defined as follows:
+    0 = Charge mode
+    1 = Discharge mode
+    2 = opModConnect (connect/disconnect—implies galvanic isolation)
+    3 = opModEnergize (energize/de-energize)
+    4 = opModFixedPFAbsorbW (fixed power factor setpoint when absorbing active power)
+    5 = opModFixedPFInjectW (fixed power factor setpoint when injecting active power)
+    6 = opModFixedVar (reactive power setpoint)
+    7 = opModFixedW (charge/discharge setpoint)
+    8 = opModFreqDroop (Frequency-Watt Parameterized mode)
+    9 = opModFreqWatt (Frequency-Watt Curve mode)
+    10 = opModHFRTMayTrip (High Frequency Ride-Through, May Trip mode)
+    11 = opModHFRTMustTrip (High Frequency Ride-Through, Must Trip mode)
+    12 = opModHVRTMayTrip (High Voltage Ride-Through, May Trip mode)
+    13 = opModHVRTMomentaryCessation (HV Ride-Through, Momentary Cessation mode)
+    14 = opModHVRTMustTrip (High Voltage Ride-Through, Must Trip mode)
+    15 = opModLFRTMayTrip (Low Frequency Ride-Through, May Trip mode)
+    16 = opModLFRTMustTrip (Low Frequency Ride-Through, Must Trip mode)
+    17 = opModLVRTMayTrip (Low Voltage Ride-Through, May Trip mode)
+    18 = opModLVRTMomentaryCessation (LV Ride-Through, Momentary Cessation mode)
+    19 = opModLVRTMustTrip (Low Voltage Ride-Through, Must Trip mode)
+    20 = opModMaxLimW (maximum active power)
+    21 = opModTargetVar (target reactive power)
+    22 = opModTargetW (target active power)
+    23 = opModVoltVar (Volt-Var mode)
+    24 = opModVoltWatt (Volt-Watt mode)
+    25 = opModWattPF (Watt-Powerfactor mode)
+    26 = opModWattVar (Watt-Var mode)
+    """
+
+    a = 1 if "Charge mode" in modes else 0
+    b = 1 if "Discharge mode" in modes else 0
+    c = 1 if "opModConnect" in modes else 0
+    d = 1 if "opModEnergize" in modes else 0
+    e = 1 if "opModFixedPFAbsorbW" in modes else 0
+    f = 1 if "opModFixedPFInjectW" in modes else 0
+    g = 1 if "opModFixedVar" in modes else 0
+    h = 1 if "opModFixedW" in modes else 0
+    i = 1 if "opModFreqDroop" in modes else 0
+    j = 1 if "opModFreqWatt" in modes else 0
+    k = 1 if "opModHFRTMayTrip" in modes else 0
+    l = 1 if "opModHFRTMustTrip" in modes else 0  # noqa: E741
+    m = 1 if "opModHVRTMayTrip" in modes else 0
+    n = 1 if "opModHVRTMomentaryCessation" in modes else 0
+    o = 1 if "opModHVRTMustTrip" in modes else 0
+    p = 1 if "opModLFRTMayTrip" in modes else 0
+    q = 1 if "opModLFRTMustTrip" in modes else 0
+    r = 1 if "opModLVRTMayTrip" in modes else 0
+    s = 1 if "opModLVRTMomentaryCessation" in modes else 0
+    t = 1 if "opModLVRTMustTrip" in modes else 0
+    u = 1 if "opModMaxLimW" in modes else 0
+    v = 1 if "opModTargetVar" in modes else 0
+    w = 1 if "opModTargetW" in modes else 0
+    x = 1 if "opModVoltVar" in modes else 0
+    y = 1 if "opModVoltWatt" in modes else 0
+    z = 1 if "opModWattPF" in modes else 0
+    aa = 1 if "opModWattVar" in modes else 0
+
+    binary_str = f"00000{aa}{z}{y}{x}{w}{v}{u}{t}{s}{r}{q}"
+    binary_str += f"{p}{o}{n}{m}{l}{k}{j}{i}{h}{g}{f}{e}{d}{c}{b}{a}"
+    val = int(binary_str, 2)
+    hex_str = str(hex(val))[2:].zfill(8).upper()
+    return binary_str, hex_str
+
+
+def get_doe_modes_supported(modes: list[str]) -> tuple[str, str]:
+    """DERControlType object (HexBinary32)
+    Control modes supported by the DER. Bit positions SHALL be defined as follows:
+    0 = opModExpLimW
+    1 = opModImpLimW
+    2 = opModGenLimW
+    3 = opModLoadLimW
+    """
+    a = 1 if "opModExpLimW" in modes else 0
+    b = 1 if "opModImpLimW" in modes else 0
+    c = 1 if "opModGenLimW" in modes else 0
+    d = 1 if "opModLoadLimW" in modes else 0
+
+    binary_str = f"000000000000{d}{c}{b}{a}"
+    val = int(binary_str, 2)
+    hex_str = str(hex(val))[2:].zfill(8).upper()
+    return binary_str, hex_str

sep2tools-0.1.0/sep2tools/ids.py

@@ -0,0 +1,37 @@
+import hashlib
+import logging
+from itertools import zip_longest
+from uuid import uuid4
+
+log = logging.getLogger(__name__)
+
+# When generatating IDs, the PEN should always be used at the end
+# to ensure that there are no conflicts between entities
+
+
+def group_hex(item: str, group_size: int = 4) -> str:
+    """Group into groups of four"""
+
+    def grouper(iterable, n, fillvalue=None):
+        args = [iter(iterable)] * n
+        return zip_longest(*args, fillvalue=fillvalue)
+
+    return "-".join("".join(x) for x in grouper(item, n=group_size))
+
+
+def generate_mrid(pen: int, group: bool = True) -> str:
+    """Generate an random mRID"""
+    random_hex = uuid4().hex
+    mrid = f"{random_hex[0:24]}{pen:08}".upper()
+    if not group:
+        return mrid
+    return group_hex(mrid)
+
+
+def proxy_device_lfdi(pen: int, con_id: str, group: bool = True) -> str:
+    """Generate a LFDI for use by a cloud proxy"""
+    id_hash = hashlib.sha256(con_id.encode("utf-8")).hexdigest().upper()
+    lfdi = f"{id_hash[0:32]}{pen:08}"
+    if not group:
+        return lfdi
+    return group_hex(lfdi)

sep2tools-0.1.0/sep2tools/version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

sep2tools-0.1.0/tests/test_cert_create.py

@@ -0,0 +1,24 @@
+from pathlib import Path
+
+from sep2tools.cert_create import generate_key_and_csr
+
+CERT_DIR = Path("certs")
+CERT_DIR.mkdir(exist_ok=True)
+EXAMPLE_PEN = 1234
+
+
+def test_key_creation():
+    """Create Private Key and CSR"""
+
+    key, csr = generate_key_and_csr(CERT_DIR / "key.pem", CERT_DIR / "csr.pem")
+
+    with open(key) as fh:
+        lines = fh.readlines()
+        assert lines[0] == "-----BEGIN PRIVATE KEY-----\n"
+
+    with open(csr) as fh:
+        lines = fh.readlines()
+        assert lines[0] == "-----BEGIN CERTIFICATE REQUEST-----\n"
+
+    key.unlink()  # Delete to cleanup
+    csr.unlink()  # Delete to cleanup

sep2tools-0.1.0/tests/test_cert_ids.py

@@ -0,0 +1,34 @@
+from sep2tools import get_lfdi, get_sfdi
+
+EXAMPLE_FINGERPRINT = (
+    "3E4F-45AB-31ED-FE5B-67E3-43E5-E456-2E31-984E-23E5-349E-2AD7-4567-2ED1-45EE-213A"
+)
+
+
+
+def test_lfdi():
+    """Test the LFDI calculation"""
+    lfdi = get_lfdi(EXAMPLE_FINGERPRINT)
+    assert lfdi == "3E4F-45AB-31ED-FE5B-67E3-43E5-E456-2E31-984E-23E5"
+
+    lfdi = get_lfdi(EXAMPLE_FINGERPRINT, group=False)
+    assert lfdi == "3E4F45AB31EDFE5B67E343E5E4562E31984E23E5"
+
+
+def test_sfdi():
+    """Test the SFDI calculation"""
+
+    sfdi = get_sfdi(EXAMPLE_FINGERPRINT, group=False)
+    assert sfdi == "167261211391"
+
+    sfdi = get_sfdi(EXAMPLE_FINGERPRINT)
+    assert sfdi == "167-261-211-391"
+
+    # Ensure checksum is valid
+    digits = list(map(int, sfdi.replace("-", "")))
+    assert sum(digits) % 10 == 0
+
+    # Should also work if you pass the LFDI
+    lfdi = get_lfdi(EXAMPLE_FINGERPRINT)
+    sfdi = get_sfdi(lfdi)
+    assert sfdi == "167-261-211-391"

sep2tools-0.1.0/tests/test_example_cert.py

@@ -0,0 +1,15 @@
+from pathlib import Path
+
+from sep2tools.cert_create import convert_pem_to_der
+from sep2tools.cert_id import get_der_certificate_lfdi, get_pem_certificate_lfdi
+
+EXAMPLE_CERT = Path("certs/example_cert.pem")
+
+
+def test_example_cert_lfdi():
+    """Test the LFDI calculation"""
+
+    lfdi1 = get_pem_certificate_lfdi(EXAMPLE_CERT)
+    der = convert_pem_to_der(EXAMPLE_CERT)
+    lfdi2 = get_der_certificate_lfdi(der)
+    assert lfdi1 == lfdi2

sep2tools-0.1.0/tests/test_hexmaps.py

@@ -0,0 +1,71 @@
+from sep2tools.hexmaps import (
+    get_connect_status,
+    get_doe_modes_supported,
+    get_modes_supported,
+    get_quality_flag,
+    get_role_flag,
+)
+
+
+def test_role_flags():
+    """Test the role flag mappings"""
+
+    # Site Reading
+    binval, hexval = get_role_flag(is_mirror=1, is_premise=1)
+    assert hexval == "03"
+
+    # DER Reading
+    binval, hexval = get_role_flag(is_mirror=1, is_der=1, is_submeter=1)
+    assert hexval == "49"
+
+
+def test_quality_flags():
+    """Test the quality mappings"""
+
+    # Valid
+    binval, hexval = get_quality_flag(valid=1)
+    assert hexval == "01"
+
+    # Questionable
+    binval, hexval = get_quality_flag(questionable=1)
+    assert hexval == "10"
+
+
+def test_connect_status():
+    """Test the connect status mappings"""
+
+    # Connected
+    binval, hexval = get_connect_status(connected=1, available=1, operating=1)
+    assert hexval == "07"
+
+    # Offline
+    binval, hexval = get_connect_status(connected=0, available=0, operating=0)
+    assert hexval == "00"
+
+    # Fault
+    binval, hexval = get_connect_status(connected=1, fault=1)
+    assert hexval == "11"
+
+
+def test_modes_supported():
+    """Test the modes supported mappings"""
+
+    modes = ["opModMaxLimW"]
+    binval, hexval = get_modes_supported(modes=modes)
+    assert hexval == "00100000"
+
+    modes = ["opModEnergize", "opConnect"]
+    binval, hexval = get_modes_supported(modes=modes)
+    assert hexval == "00000008"
+
+
+def test_doe_modes_supported():
+    """Test the modes supported mappings"""
+
+    modes = ["opModExpLimW"]
+    binval, hexval = get_doe_modes_supported(modes=modes)
+    assert hexval == "00000001"
+
+    modes = ["opModExpLimW", "opModImpLimW", "opModGenLimW", "opModLoadLimW"]
+    binval, hexval = get_doe_modes_supported(modes=modes)
+    assert hexval == "0000000F"

sep2tools-0.1.0/tests/test_ids.py

@@ -0,0 +1,27 @@
+from sep2tools.ids import generate_mrid, proxy_device_lfdi
+
+EXAMPLE_PEN = 1234
+EXAMPLE_CPID = "NMI0001234"
+
+
+def test_proxy_lfdi():
+    """Test the LFDI used by a proxy"""
+    lfdi = proxy_device_lfdi(EXAMPLE_PEN, EXAMPLE_CPID)
+    assert lfdi == "B538-D994-2C7B-5B83-1AED-81A1-FEC4-6B3D-0000-1234"
+
+    lfdi = proxy_device_lfdi(EXAMPLE_PEN, EXAMPLE_CPID, group=False)
+    assert lfdi == "B538D9942C7B5B831AED81A1FEC46B3D00001234"
+
+
+def test_mrid_generation():
+    """Test the LFDI used by a proxy"""
+
+    mrid1 = generate_mrid(EXAMPLE_PEN)
+    assert mrid1[-9:] == "0000-1234"
+    mrid2 = generate_mrid(EXAMPLE_PEN)
+    assert mrid2[-9:] == "0000-1234"
+
+    assert mrid1 != mrid2
+
+    mrid3 = generate_mrid(EXAMPLE_PEN, group=False)
+    assert mrid3[-8:] == "00001234"