sep2tools 0.1.0__py3-none-any.whl

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/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/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/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/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/version.py

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

sep2tools-0.1.0.dist-info/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.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,10 @@
+sep2tools/__init__.py,sha256=QKj6hnzYzIhdOLn0gJrJt5x1oFfhtfPU3ZcU6uOR4VE,360
+sep2tools/cert_create.py,sha256=eKLolPMGEPpBjqJG2dazYiex07jhAiJpsMnKuXF19YA,5985
+sep2tools/cert_id.py,sha256=2krUXeExPGn56l0Hn9fDNn0nOBKZ9SGC9T75IoCXuLI,2895
+sep2tools/hexmaps.py,sha256=8Qk98sfCD4h_hB9fakY_A4oI1b2LsTinWBaOQlAEouM,6926
+sep2tools/ids.py,sha256=o2KfrWDYwi7s5xuJpT0j1bSs63YxxW7BSoq5ckUtAVc,1083
+sep2tools/version.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+sep2tools-0.1.0.dist-info/LICENSE,sha256=iLry15lbsTDTiEPjqk639lVNnA8zDDEjpWAlhobgr0M,1069
+sep2tools-0.1.0.dist-info/WHEEL,sha256=jPMR_Dzkc4X4icQtmz81lnNY_kAsfog7ry7qoRvYLXw,81
+sep2tools-0.1.0.dist-info/METADATA,sha256=qHrQHN6bRWYJgLgrIPhMCQn0AW9j8tlB8vvnoQH5ESc,999
+sep2tools-0.1.0.dist-info/RECORD,,

sep2tools-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: flit 3.6.0
+Root-Is-Purelib: true
+Tag: py3-none-any