zepben.ewb 1.0.0b9__py3-none-any.whl → 1.0.1__py3-none-any.whl

zepben/ewb/auth/client/zepben_token_fetcher.py

@@ -7,12 +7,13 @@
 __all__ = ["ZepbenTokenFetcher", "create_token_fetcher", "get_token_fetcher", "create_token_fetcher_managed_identity"]
 
 import warnings
+from dataclasses import dataclass, Field, field, InitVar
 from datetime import datetime
-from typing import Optional, Union, Callable, Dict
+from typing import Optional, Callable
 
 import jwt
 import requests
-from dataclassy import dataclass
+from requests import Response
 from urllib3.exceptions import InsecureRequestWarning
 
 from zepben.ewb.auth.common.auth_exception import AuthException
@@ -21,11 +22,15 @@ from zepben.ewb.auth.common.auth_method import AuthMethod
 from zepben.ewb.auth.common.auth_provider_config import AuthProviderConfig, create_auth_provider_config, fetch_provider_details
 
 
-def _fetch_token_generator(is_entraid: bool, use_identity: bool, identity_url: Optional[str] = None) -> Callable[
-    [Dict, Dict, str, bool, bool], requests.Response]:
+def _fetch_token_generator(
+    is_entraid: bool,
+    use_identity: bool,
+    identity_url: Optional[str] = None
+) -> Callable[[dict, dict, str, Optional[bool], Optional[bool]], Response]:
+
     def post(
-        refresh_request_data: Dict,
-        token_request_data: Dict,
+        refresh_request_data: dict,
+        token_request_data: dict,
         token_endpoint: str,
         refresh: bool,
         verify: bool
@@ -48,7 +53,14 @@ def _fetch_token_generator(is_entraid: bool, use_identity: bool, identity_url: O
             verify=verify
         )
 
-    def _get_token_response(refresh_request_data: Dict, token_request_data: Dict, token_endpoint: str, refresh: bool, verify: bool) -> requests.Response:
+    def _get_token_response(
+        refresh_request_data: dict,
+        token_request_data: dict,
+        token_endpoint: str,
+        refresh: bool,
+        verify: bool
+    ) -> requests.Response:
+
         refresh = not is_entraid and refresh  # At the moment Azure auth doesn't support refresh tokens. So we always force new tokens.
 
         return post(
@@ -59,53 +71,59 @@ def _fetch_token_generator(is_entraid: bool, use_identity: bool, identity_url: O
             verify
         )
 
-    def _get_token_response_from_identity(refresh_request_data: Dict, token_request_data: Dict, token_endpoint: str, refresh: bool = False,
-                                          verify: bool = False) -> requests.Response:
+    def _get_token_response_from_identity(
+        refresh_request_data: dict,
+        token_request_data: dict,
+        token_endpoint: str,
+        refresh: Optional[bool] = False,
+        verify: Optional[bool] = False
+    ) -> requests.Response:
+
         return requests.get(identity_url, headers={"Metadata": "true"}, verify=verify)
 
     if use_identity:
         if not identity_url:
-            raise ValueError("Misconfiguration dectected - if use_identity is true, identity_url must also be provided. This is a bug, contact Zepben.")
+            raise ValueError("Misconfiguration detected - if use_identity is true, identity_url must also be provided. This is a bug, contact Zepben.")
         return _get_token_response_from_identity
     else:
         return _get_token_response
 
 
-@dataclass
-class ZepbenTokenFetcher(object):
+@dataclass(init=True, repr=True, eq=True)
+class ZepbenTokenFetcher:
     """
     Fetches access tokens from an authentication provider using the OAuth 2.0 protocol.
-    """
 
-    auth_method: AuthMethod = AuthMethod.OAUTH
-    """ Deprecated. Kept for backwards compatibility, but this is now unused. """
+    :param audience: Audience to use when requesting tokens
+    :param token_endpoint: The domain of the token issuer.
+    :param token_request_data: Data to pass in token requests.
+    :param refresh_request_data: Data to pass in refresh token requests.
+    :param verify: Passed through to requests.post(). When this is a boolean, it determines whether to verify the HTTPS
+        certificate of the OAUTH service or not. When this is a string, it is used as the filename of the certificate
+        truststore to use when verifying the OAUTH service.
+    :param auth_method:  Deprecated. Kept for backwards compatibility, but this is now unused.
+    """
 
     audience: str
-    """ Audience to use when requesting tokens """
-
-    token_endpoint: str
-    """ The domain of the token issuer. """
-
-    token_request_data = {}
-    """ Data to pass in token requests. """
-
-    refresh_request_data = {}
-    """ Data to pass in refresh token requests. """
+    issuer: Optional[str] = None
+    token_endpoint: Optional[str] = None
+    token_request_data: Optional[dict] = field(default_factory=dict)
+    refresh_request_data: Optional[dict] = field(default_factory=dict)
+    verify: Optional[bool | str] = None
+    auth_method: Optional[AuthMethod] = None
 
-    verify: Union[bool, str] = True
-    """
-    Passed through to requests.post(). When this is a boolean, it determines whether or not to verify the HTTPS certificate of the OAUTH service.
-    When this is a string, it is used as the filename of the certificate truststore to use when verifying the OAUTH service.
-    """
+    _request_token: InitVar[Callable[[dict, dict, str, Optional[bool], Optional[bool]], requests.Response]] = None
 
-    _request_token: Callable[[Dict, Dict, str, bool, bool], requests.Response] = _fetch_token_generator(False, False)
+    _access_token: Optional[str] = None
+    _refresh_token: Optional[str] = None
+    _token_expiry: Optional[datetime] = datetime.min
+    token_type: Optional[str] = None
 
-    _access_token = None
-    _refresh_token = None
-    _token_expiry = datetime.min
-    _token_type = None
+    def __post_init__(self, _request_token):
+        if _request_token is None:
+            _request_token = _fetch_token_generator(False, False)
+        self._request_token = _request_token
 
-    def __init__(self):
         self.token_request_data["audience"] = self.audience
         self.refresh_request_data["audience"] = self.audience
 
@@ -134,7 +152,7 @@ class ZepbenTokenFetcher(object):
 
         return f"{self._token_type} {self._access_token}"
 
-    def _fetch_token(self, refresh: bool = False):
+    def _fetch_token(self, refresh: Optional[bool] = False):
         if refresh:
             self.refresh_request_data["refresh_token"] = self._refresh_token
 
@@ -174,11 +192,11 @@ class ZepbenTokenFetcher(object):
 
 def create_token_fetcher(
     conf_address: str,
-    verify_conf: Union[bool, str] = True,
-    verify_auth: Union[bool, str] = True,
-    auth_type_field: str = "authType",
-    audience_field: str = "audience",
-    issuer_field: str = "issuer",
+    verify_conf: Optional[bool | str] = True,
+    verify_auth: Optional[bool | str] = True,
+    auth_type_field: Optional[str] = "authType",
+    audience_field: Optional[str] = "audience",
+    issuer_field: Optional[str] = "issuer",
 ) -> Optional[ZepbenTokenFetcher]:
     """
     Helper method to fetch auth related configuration from `conf_address` and create a :class:`ZepbenTokenFetcher`
@@ -194,6 +212,7 @@ def create_token_fetcher(
 
     :returns: A :class:`ZepbenTokenFetcher` if the server reported authentication was configured, otherwise None.
     """
+
     with warnings.catch_warnings():
         if not verify_conf:
             warnings.filterwarnings("ignore", category=InsecureRequestWarning)
@@ -264,6 +283,7 @@ def create_token_fetcher_managed_identity(identity_url: str, verify_auth: bool)
     "http://169.254.169.254/metadata/identity/oauth2/token?api-version=2018-02-01&resource=5ffcfee6-34cd-4c5c-bb7e-c5261d739341"
     :param verify_auth: Whether to verify certificates for the identity_url. Only applies for https URLs.
     """
+
     return ZepbenTokenFetcher(
         audience="",
         issuer="",

zepben/ewb/database/sqlite/common/base_cim_reader.py

@@ -53,12 +53,12 @@ class BaseCimReader(ABC):
         :return: True if the `Document` was successfully read from the database and added to the service.
         :raises SQLException: For any errors encountered reading from the database.
         """
-        document.title = result_set.get_string(table.title.query_index, on_none="")
+        document.title = result_set.get_string(table.title.query_index, on_none=None)
         document.created_date_time = result_set.get_instant(table.created_date_time.query_index, on_none=None)
-        document.author_name = result_set.get_string(table.author_name.query_index, on_none="")
-        document.type = result_set.get_string(table.type.query_index, on_none="")
-        document.status = result_set.get_string(table.status.query_index, on_none="")
-        document.comment = result_set.get_string(table.comment.query_index, on_none="")
+        document.author_name = result_set.get_string(table.author_name.query_index, on_none=None)
+        document.type = result_set.get_string(table.type.query_index, on_none=None)
+        document.status = result_set.get_string(table.status.query_index, on_none=None)
+        document.comment = result_set.get_string(table.comment.query_index, on_none=None)
 
         return self._load_identified_object(document, table, result_set)
 
@@ -111,8 +111,8 @@ class BaseCimReader(ABC):
         :return: True if the `IdentifiedObject` was successfully read from the database and added to the service.
         :raises SQLException: For any errors encountered reading from the database.
         """
-        identified_object.name = result_set.get_string(table.name_.query_index, on_none="")
-        identified_object.description = result_set.get_string(table.description.query_index, on_none="")
+        identified_object.name = result_set.get_string(table.name_.query_index, on_none=None)
+        identified_object.description = result_set.get_string(table.description.query_index, on_none=None)
         # Currently unused
         # identified_object.num_diagram_objects = result_set.get_int(table.num_diagram_objects.query_index)
 

zepben/ewb/database/sqlite/common/base_database_writer.py

@@ -11,7 +11,7 @@ from abc import ABC
 from contextlib import closing
 from pathlib import Path
 from sqlite3 import Connection, Cursor, OperationalError
-from typing import Callable, Union
+from typing import Callable, Union, Optional
 
 from zepben.ewb.database.sqlite.common.base_database_tables import BaseDatabaseTables
 from zepben.ewb.database.sqlite.common.base_service_writer import BaseServiceWriter
@@ -66,7 +66,7 @@ class BaseDatabaseWriter(ABC):
         Provider of the connection to the specified database.
         """
 
-        self._save_connection: Connection
+        self._save_connection: Optional[Connection] = None
         self._has_been_used: bool = False
 
     def save(self) -> bool:

zepben/ewb/database/sqlite/network/network_cim_reader.py

@@ -1070,22 +1070,22 @@ class NetworkCimReader(BaseCimReader):
 
     def _load_street_address(self, table: TableStreetAddresses, result_set: ResultSet) -> StreetAddress:
         return StreetAddress(
-            result_set.get_string(table.postal_code.query_index, on_none=""),
+            result_set.get_string(table.postal_code.query_index, on_none=None),
             self._load_town_detail(table, result_set),
-            result_set.get_string(table.po_box.query_index, on_none=""),
+            result_set.get_string(table.po_box.query_index, on_none=None),
             self._load_street_detail(table, result_set)
         )
 
     @staticmethod
     def _load_street_detail(table: TableStreetAddresses, result_set: ResultSet) -> Optional[StreetDetail]:
         sd = StreetDetail(
-            result_set.get_string(table.building_name.query_index, on_none=""),
-            result_set.get_string(table.floor_identification.query_index, on_none=""),
-            result_set.get_string(table.street_name.query_index, on_none=""),
-            result_set.get_string(table.number.query_index, on_none=""),
-            result_set.get_string(table.suite_number.query_index, on_none=""),
-            result_set.get_string(table.type.query_index, on_none=""),
-            result_set.get_string(table.display_address.query_index, on_none="")
+            result_set.get_string(table.building_name.query_index, on_none=None),
+            result_set.get_string(table.floor_identification.query_index, on_none=None),
+            result_set.get_string(table.street_name.query_index, on_none=None),
+            result_set.get_string(table.number.query_index, on_none=None),
+            result_set.get_string(table.suite_number.query_index, on_none=None),
+            result_set.get_string(table.type.query_index, on_none=None),
+            result_set.get_string(table.display_address.query_index, on_none=None)
         )
 
         return sd if not sd.all_fields_empty() else None
@@ -1178,7 +1178,7 @@ class NetworkCimReader(BaseCimReader):
         """
         pole = Pole(mrid=set_identifier(result_set.get_string(table.mrid.query_index)))
 
-        pole.classification = result_set.get_string(table.classification.query_index, on_none="")
+        pole.classification = result_set.get_string(table.classification.query_index, on_none=None)
 
         return self._load_structure(pole, table, result_set) and self._add_or_throw(pole)
 
@@ -1232,7 +1232,7 @@ class NetworkCimReader(BaseCimReader):
             result_set.get_string(table.location_mrid.query_index, on_none=None),
             Location
         )
-        usage_point.is_virtual = result_set.get_boolean(table.is_virtual.query_index)
+        usage_point.is_virtual = result_set.get_boolean(table.is_virtual.query_index, on_none=None)
         usage_point.connection_category = result_set.get_string(table.connection_category.query_index, on_none=None)
         usage_point.rated_power = result_set.get_int(table.rated_power.query_index, on_none=None)
         usage_point.approved_inverter_capacity = result_set.get_int(table.approved_inverter_capacity.query_index, on_none=None)
@@ -1472,7 +1472,7 @@ class NetworkCimReader(BaseCimReader):
             result_set.get_string(table.location_mrid.query_index, on_none=None),
             Location
         )
-        power_system_resource.num_controls = result_set.get_int(table.num_controls.query_index)
+        power_system_resource.num_controls = result_set.get_int(table.num_controls.query_index, on_none=None)
 
         return self._load_identified_object(power_system_resource, table, result_set)
 
@@ -1686,7 +1686,7 @@ class NetworkCimReader(BaseCimReader):
         """
         meas = Analog(mrid=set_identifier(result_set.get_string(table.mrid.query_index)))
 
-        meas.positive_flow_in = result_set.get_boolean(table.positive_flow_in.query_index)
+        meas.positive_flow_in = result_set.get_boolean(table.positive_flow_in.query_index, on_none=None)
 
         return self._load_measurement(meas, table, result_set) and self._add_or_throw(meas)
 
@@ -1956,7 +1956,7 @@ class NetworkCimReader(BaseCimReader):
         energy_consumer = EnergyConsumer(mrid=set_identifier(result_set.get_string(table.mrid.query_index)))
 
         energy_consumer.customer_count = result_set.get_int(table.customer_count.query_index, on_none=None)
-        energy_consumer.grounded = result_set.get_boolean(table.grounded.query_index)
+        energy_consumer.grounded = result_set.get_boolean(table.grounded.query_index, on_none=None)
         energy_consumer.p = result_set.get_float(table.p.query_index, on_none=None)
         energy_consumer.q = result_set.get_float(table.q.query_index, on_none=None)
         energy_consumer.p_fixed = result_set.get_float(table.p_fixed.query_index, on_none=None)
@@ -2018,7 +2018,7 @@ class NetworkCimReader(BaseCimReader):
         energy_source.x = result_set.get_float(table.x.query_index, on_none=None)
         energy_source.x0 = result_set.get_float(table.x0.query_index, on_none=None)
         energy_source.xn = result_set.get_float(table.xn.query_index, on_none=None)
-        energy_source.is_external_grid = result_set.get_boolean(table.is_external_grid.query_index)
+        energy_source.is_external_grid = result_set.get_boolean(table.is_external_grid.query_index, on_none=None)
         energy_source.r_min = result_set.get_float(table.r_min.query_index, on_none=None)
         energy_source.rn_min = result_set.get_float(table.rn_min.query_index, on_none=None)
         energy_source.r0_min = result_set.get_float(table.r0_min.query_index, on_none=None)
@@ -2488,7 +2488,7 @@ class NetworkCimReader(BaseCimReader):
         return self._load_protected_switch(recloser, table, result_set) and self._add_or_throw(recloser)
 
     def _load_regulating_cond_eq(self, regulating_cond_eq: RegulatingCondEq, table: TableRegulatingCondEq, result_set: ResultSet) -> bool:
-        regulating_cond_eq.control_enabled = result_set.get_boolean(table.control_enabled.query_index)
+        regulating_cond_eq.control_enabled = result_set.get_boolean(table.control_enabled.query_index, on_none=None)
         # We use a resolver here because there is an ordering conflict between terminals, RegulatingCondEq, and RegulatingControls
         # We check this resolver has actually been resolved in the postLoad of the database read and throw there if it hasn't.
         self._service.resolve_or_defer_reference(
@@ -2556,7 +2556,7 @@ class NetworkCimReader(BaseCimReader):
             ShuntCompensatorInfo
         )
 
-        shunt_compensator.grounded = result_set.get_boolean(table.grounded.query_index)
+        shunt_compensator.grounded = result_set.get_boolean(table.grounded.query_index, on_none=None)
         shunt_compensator.nom_u = result_set.get_int(table.nom_u.query_index, on_none=None)
         shunt_compensator.phase_connection = PhaseShuntConnectionKind[result_set.get_string(table.phase_connection.query_index)]
         shunt_compensator.sections = result_set.get_float(table.sections.query_index, on_none=None)
@@ -2610,7 +2610,7 @@ class NetworkCimReader(BaseCimReader):
 
         synchronous_machine.base_q = result_set.get_float(table.base_q.query_index, on_none=None)
         synchronous_machine.condenser_p = result_set.get_int(table.condenser_p.query_index, on_none=None)
-        synchronous_machine.earthing = result_set.get_boolean(table.earthing.query_index)
+        synchronous_machine.earthing = result_set.get_boolean(table.earthing.query_index, on_none=None)
         synchronous_machine.earthing_star_point_r = result_set.get_float(table.earthing_star_point_r.query_index, on_none=None)
         synchronous_machine.earthing_star_point_x = result_set.get_float(table.earthing_star_point_x.query_index, on_none=None)
         synchronous_machine.ikk = result_set.get_float(table.ikk.query_index, on_none=None)
@@ -2633,7 +2633,7 @@ class NetworkCimReader(BaseCimReader):
         return self._load_rotating_machine(synchronous_machine, table, result_set) and self._add_or_throw(synchronous_machine)
 
     def _load_tap_changer(self, tap_changer: TapChanger, table: TableTapChangers, result_set: ResultSet) -> bool:
-        tap_changer.control_enabled = result_set.get_boolean(table.control_enabled.query_index)
+        tap_changer.control_enabled = result_set.get_boolean(table.control_enabled.query_index, on_none=None)
         tap_changer.high_step = result_set.get_int(table.high_step.query_index, on_none=None)
         tap_changer.low_step = result_set.get_int(table.low_step.query_index, on_none=None)
         tap_changer.neutral_step = result_set.get_int(table.neutral_step.query_index, on_none=None)
@@ -2681,7 +2681,7 @@ class NetworkCimReader(BaseCimReader):
             result_set.get_string(table.base_voltage_mrid.query_index, on_none=None),
             BaseVoltage
         )
-        transformer_end.grounded = result_set.get_boolean(table.grounded.query_index)
+        transformer_end.grounded = result_set.get_boolean(table.grounded.query_index, on_none=None)
         transformer_end.r_ground = result_set.get_float(table.r_ground.query_index, on_none=None)
         transformer_end.x_ground = result_set.get_float(table.x_ground.query_index, on_none=None)
         transformer_end.star_impedance = self._ensure_get(

zepben/ewb/database/sqlite/network/network_database_reader.py

@@ -154,9 +154,11 @@ class NetworkDatabaseReader(BaseDatabaseReader):
         feeder_start_points = set(map(head_conducting_equipment_mrid, self.service.objects(Feeder)))
 
         def has_been_assigned_to_feeder(energy_source: EnergySource) -> bool:
-            return energy_source.is_external_grid \
-                and self._is_on_feeder(energy_source) \
+            return (
+                energy_source.is_external_grid
+                and self._is_on_feeder(energy_source)
                 and feeder_start_points.isdisjoint({it.to_equip.mrid for it in connected_equipment(energy_source) if it.to_equip})
+            )
 
         for es in self.service.objects(EnergySource):
             if has_been_assigned_to_feeder(es):

zepben/ewb/database/sqlite/tables/iec61968/common/table_documents.py

@@ -15,9 +15,9 @@ class TableDocuments(TableIdentifiedObjects, ABC):
 
     def __init__(self):
         super().__init__()
-        self.title: Column = self._create_column("title", "TEXT", Nullable.NOT_NULL)
+        self.title: Column = self._create_column("title", "TEXT", Nullable.NULL)
         self.created_date_time: Column = self._create_column("created_date_time", "TEXT", Nullable.NULL)
-        self.author_name: Column = self._create_column("author_name", "TEXT", Nullable.NOT_NULL)
-        self.type: Column = self._create_column("type", "TEXT", Nullable.NOT_NULL)
-        self.status: Column = self._create_column("status", "TEXT", Nullable.NOT_NULL)
-        self.comment: Column = self._create_column("comment", "TEXT", Nullable.NOT_NULL)
+        self.author_name: Column = self._create_column("author_name", "TEXT", Nullable.NULL)
+        self.type: Column = self._create_column("type", "TEXT", Nullable.NULL)
+        self.status: Column = self._create_column("status", "TEXT", Nullable.NULL)
+        self.comment: Column = self._create_column("comment", "TEXT", Nullable.NULL)

zepben/ewb/database/sqlite/tables/iec61968/common/table_street_addresses.py

@@ -15,7 +15,7 @@ class TableStreetAddresses(TableTownDetails, ABC):
 
     def __init__(self):
         super().__init__()
-        self.postal_code: Column = self._create_column("postal_code", "TEXT", Nullable.NOT_NULL)
+        self.postal_code: Column = self._create_column("postal_code", "TEXT", Nullable.NULL)
         self.po_box: Column = self._create_column("po_box", "TEXT", Nullable.NULL)
         self.building_name: Column = self._create_column("building_name", "TEXT", Nullable.NULL)
         self.floor_identification: Column = self._create_column("floor_identification", "TEXT", Nullable.NULL)

zepben/ewb/database/sqlite/tables/iec61968/infiec61968/infassets/table_poles.py

@@ -13,7 +13,7 @@ class TablePoles(TableStructures):
 
     def __init__(self):
         super().__init__()
-        self.classification: Column = self._create_column("classification", "TEXT", Nullable.NOT_NULL)
+        self.classification: Column = self._create_column("classification", "TEXT", Nullable.NULL)
 
     @property
     def name(self) -> str:

zepben/ewb/database/sqlite/tables/iec61970/base/core/table_identified_objects.py

@@ -16,9 +16,9 @@ class TableIdentifiedObjects(SqliteTable, ABC):
 
     def __init__(self):
         self.mrid: Column = self._create_column("mrid", "TEXT", Nullable.NOT_NULL)
-        self.name_: Column = self._create_column("name", "TEXT", Nullable.NOT_NULL)
-        self.description: Column = self._create_column("description", "TEXT", Nullable.NOT_NULL)
-        self.num_diagram_objects: Column = self._create_column("num_diagram_objects", "INTEGER", Nullable.NOT_NULL)
+        self.name_: Column = self._create_column("name", "TEXT", Nullable.NULL)
+        self.description: Column = self._create_column("description", "TEXT", Nullable.NULL)
+        self.num_diagram_objects: Column = self._create_column("num_diagram_objects", "INTEGER", Nullable.NULL)
 
     @property
     def unique_index_columns(self) -> Generator[List[Column], None, None]:

zepben/ewb/database/sqlite/tables/iec61970/base/core/table_power_system_resources.py

@@ -16,4 +16,4 @@ class TablePowerSystemResources(TableIdentifiedObjects, ABC):
     def __init__(self):
         super().__init__()
         self.location_mrid: Column = self._create_column("location_mrid", "TEXT", Nullable.NULL)
-        self.num_controls: Column = self._create_column("num_controls", "INTEGER", Nullable.NOT_NULL)
+        self.num_controls: Column = self._create_column("num_controls", "INTEGER", Nullable.NULL)

zepben/ewb/database/sqlite/tables/iec61970/base/meas/table_analogs.py

@@ -13,7 +13,7 @@ class TableAnalogs(TableMeasurements):
 
     def __init__(self):
         super().__init__()
-        self.positive_flow_in: Column = self._create_column("positive_flow_in", "BOOLEAN", Nullable.NOT_NULL)
+        self.positive_flow_in: Column = self._create_column("positive_flow_in", "BOOLEAN", Nullable.NULL)
 
     @property
     def name(self) -> str:

zepben/ewb/database/sqlite/tables/iec61970/base/wires/table_energy_consumers.py

@@ -14,7 +14,7 @@ class TableEnergyConsumers(TableEnergyConnections):
     def __init__(self):
         super().__init__()
         self.customer_count: Column = self._create_column("customer_count", "INTEGER", Nullable.NULL)
-        self.grounded: Column = self._create_column("grounded", "BOOLEAN", Nullable.NOT_NULL)
+        self.grounded: Column = self._create_column("grounded", "BOOLEAN", Nullable.NULL)
         self.p: Column = self._create_column("p", "NUMBER", Nullable.NULL)
         self.q: Column = self._create_column("q", "NUMBER", Nullable.NULL)
         self.p_fixed: Column = self._create_column("p_fixed", "NUMBER", Nullable.NULL)

zepben/ewb/database/sqlite/tables/iec61970/base/wires/table_energy_sources.py

@@ -25,7 +25,7 @@ class TableEnergySources(TableEnergyConnections):
         self.x: Column = self._create_column("x", "NUMBER", Nullable.NULL)
         self.x0: Column = self._create_column("x0", "NUMBER", Nullable.NULL)
         self.xn: Column = self._create_column("xn", "NUMBER", Nullable.NULL)
-        self.is_external_grid: Column = self._create_column("is_external_grid", "BOOLEAN", Nullable.NOT_NULL)
+        self.is_external_grid: Column = self._create_column("is_external_grid", "BOOLEAN", Nullable.NULL)
         self.r_min: Column = self._create_column("r_min", "NUMBER", Nullable.NULL)
         self.rn_min: Column = self._create_column("rn_min", "NUMBER", Nullable.NULL)
         self.r0_min: Column = self._create_column("r0_min", "NUMBER", Nullable.NULL)

zepben/ewb/database/sqlite/tables/iec61970/base/wires/table_regulating_cond_eq.py

@@ -15,5 +15,5 @@ class TableRegulatingCondEq(TableEnergyConnections, ABC):
 
     def __init__(self):
         super().__init__()
-        self.control_enabled: Column = self._create_column("control_enabled", "BOOLEAN", Nullable.NOT_NULL)
+        self.control_enabled: Column = self._create_column("control_enabled", "BOOLEAN", Nullable.NULL)
         self.regulating_control_mrid: Column = self._create_column("regulating_control_mrid", "TEXT", Nullable.NULL)

zepben/ewb/database/sqlite/tables/iec61970/base/wires/table_shunt_compensators.py

@@ -16,7 +16,7 @@ class TableShuntCompensators(TableRegulatingCondEq, ABC):
     def __init__(self):
         super().__init__()
         self.shunt_compensator_info_mrid: Column = self._create_column("shunt_compensator_info_mrid", "TEXT", Nullable.NULL)
-        self.grounded: Column = self._create_column("grounded", "BOOLEAN", Nullable.NOT_NULL)
+        self.grounded: Column = self._create_column("grounded", "BOOLEAN", Nullable.NULL)
         self.nom_u: Column = self._create_column("nom_u", "INTEGER", Nullable.NULL)
         self.phase_connection: Column = self._create_column("phase_connection", "TEXT", Nullable.NOT_NULL)
         self.sections: Column = self._create_column("sections", "NUMBER", Nullable.NULL)

zepben/ewb/database/sqlite/tables/iec61970/base/wires/table_tap_changers.py

@@ -15,7 +15,7 @@ class TableTapChangers(TablePowerSystemResources, ABC):
 
     def __init__(self):
         super().__init__()
-        self.control_enabled: Column = self._create_column("control_enabled", "BOOLEAN", Nullable.NOT_NULL)
+        self.control_enabled: Column = self._create_column("control_enabled", "BOOLEAN", Nullable.NULL)
         self.high_step: Column = self._create_column("high_step", "INTEGER", Nullable.NULL)
         self.low_step: Column = self._create_column("low_step", "INTEGER", Nullable.NULL)
         self.neutral_step: Column = self._create_column("neutral_step", "INTEGER", Nullable.NULL)

zepben/ewb/database/sqlite/tables/iec61970/base/wires/table_transformer_ends.py

@@ -19,7 +19,7 @@ class TableTransformerEnds(TableIdentifiedObjects, ABC):
         self.end_number: Column = self._create_column("end_number", "INTEGER", Nullable.NOT_NULL)
         self.terminal_mrid: Column = self._create_column("terminal_mrid", "TEXT", Nullable.NULL)
         self.base_voltage_mrid: Column = self._create_column("base_voltage_mrid", "TEXT", Nullable.NULL)
-        self.grounded: Column = self._create_column("grounded", "BOOLEAN", Nullable.NOT_NULL)
+        self.grounded: Column = self._create_column("grounded", "BOOLEAN", Nullable.NULL)
         self.r_ground: Column = self._create_column("r_ground", "NUMBER", Nullable.NULL)
         self.x_ground: Column = self._create_column("x_ground", "NUMBER", Nullable.NULL)
         self.star_impedance_mrid: Column = self._create_column("star_impedance_mrid", "TEXT", Nullable.NULL)

zepben/ewb/model/cim/iec61968/common/document.py

@@ -16,21 +16,21 @@ class Document(IdentifiedObject):
     Parent class for different groupings of information collected and managed as a part of a business process.
     It will frequently contain references to other objects, such as assets, people and power system resources.
     """
-    title: str = ""
+    title: Optional[str] = None
     """Document title."""
 
     created_date_time: Optional[datetime] = None
     """Date and time that this document was created."""
 
-    author_name: str = ""
+    author_name: Optional[str] = None
     """Name of the author of this document."""
 
-    type: str = ""
+    type: Optional[str] = None
     """Utility-specific classification of this document, according to its corporate standards, practices, 
     and existing IT systems (e.g., for management of assets, maintenance, work, outage, customers, etc.)."""
 
-    status: str = ""
+    status: Optional[str] = None
     """Status of subject matter (e.g., Agreement, Work) this document represents."""
 
-    comment: str = ""
+    comment: Optional[str] = None
     """Free text comment"""

zepben/ewb/model/cim/iec61968/common/street_address.py

@@ -18,11 +18,11 @@ class StreetAddress(object):
     General purpose street and postal address information.
     """
 
-    postal_code: str = ""
+    postal_code: Optional[str] = None
     """Postal code for the address."""
     town_detail: Optional[TownDetail] = None
     """Optional `TownDetail` for this address."""
-    po_box: str = ""
+    po_box: Optional[str] = None
     """Post office box for the address."""
     street_detail: Optional[StreetDetail] = None
     """Optional `StreetDetail` for this address."""

zepben/ewb/model/cim/iec61968/common/street_detail.py

@@ -6,6 +6,7 @@
 __all__ = ["StreetDetail"]
 
 from dataclasses import dataclass
+from typing import Optional
 
 
 @dataclass
@@ -14,22 +15,22 @@ class StreetDetail(object):
     Street details, in the context of address.
     """
 
-    building_name: str = ""
+    building_name: Optional[str] = None
     """
     (if applicable) In certain cases the physical location of the place of interest does not have a direct point of entry from the street, 
     but may be located inside a larger structure such as a building, complex, office block, apartment, etc.
     """
-    floor_identification: str = ""
+    floor_identification: Optional[str] = None
     """The identification by name or number, expressed as text, of the floor in the building as part of this address."""
-    name: str = ""
+    name: Optional[str] = None
     """Name of the street."""
-    number: str = ""
+    number: Optional[str] = None
     """Designator of the specific location on the street."""
-    suite_number: str = ""
+    suite_number: Optional[str] = None
     """Number of the apartment or suite."""
-    type: str = ""
+    type: Optional[str] = None
     """Type of street. Examples include: street, circle, boulevard, avenue, road, drive, etc."""
-    display_address: str = ""
+    display_address: Optional[str] = None
     """The address as it should be displayed to a user."""
 
     def all_fields_empty(self):

zepben/ewb/model/cim/iec61968/infiec61968/infassets/pole.py

@@ -19,7 +19,7 @@ if TYPE_CHECKING:
 class Pole(Structure):
     """A Pole Asset"""
 
-    classification: str = ""
+    classification: Optional[str] = None
     """Pole class: 1, 2, 3, 4, 5, 6, 7, H1, H2, Other, Unknown."""
 
     _streetlights: Optional[List[Streetlight]] = None

zepben/ewb/model/cim/iec61968/metering/meter.py

@@ -5,6 +5,8 @@
 
 __all__ = ["Meter"]
 
+from typing import Optional
+
 from zepben.ewb.model.cim.iec61968.metering.end_device import EndDevice
 
 
@@ -14,12 +16,12 @@ class Meter(EndDevice):
     """
 
     @property
-    def company_meter_id(self):
+    def company_meter_id(self) -> Optional[str]:
         """ Returns this `Meter`s ID. Currently stored in `IdentifiedObject.name` """
         return self.name
 
     @company_meter_id.setter
-    def company_meter_id(self, meter_id):
+    def company_meter_id(self, meter_id: Optional[str]):
         """
         `meter_id` The ID to set for this Meter. Will use `IdentifiedObject.name` as a backing field.
         """

zepben/ewb/model/cim/iec61968/metering/usage_point.py

@@ -28,7 +28,7 @@ class UsagePoint(IdentifiedObject):
     usage_point_location: Optional[Location] = None
     """Service `zepben.ewb.model.cim.iec61968.common.location.Location` where the service delivered by this `UsagePoint` is consumed."""
 
-    is_virtual: bool = False
+    is_virtual: Optional[bool] = None
     """
     If true, this usage point is virtual, i.e., no physical location exists in the network where a meter could be located to
     collect the meter readings. For example, one may define a virtual usage point to serve as an aggregation of usage for all