intersect-sdk 0.8.4__tar.gz → 0.9.1__tar.gz

{intersect_sdk-0.8.4 → intersect_sdk-0.9.1}/PKG-INFO

@@ -1,31 +1,28 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: intersect-sdk
-Version: 0.8.4
+Version: 0.9.1
 Summary: Python SDK to interact with INTERSECT
 Keywords: intersect
-Author-Email: Lance Drane <dranelt@ornl.gov>, Marshall McDonnell <mcdonnellmt@ornl.gov>, Seth Hitefield <hitefieldsd@ornl.gov>, Andrew Ayres <ayresaf@ornl.gov>, Gregory Cage <cagege@ornl.gov>, Jesse McGaha <mcgahajr@ornl.gov>, Robert Smith <smithrw@ornl.gov>, Gavin Wiggins <wigginsg@ornl.gov>, Michael Brim <brimmj@ornl.gov>, Rick Archibald <archibaldrk@ornl.gov>, Addi Malviya Thakur <malviyaa@ornl.gov>
+Author: Lance Drane, Marshall McDonnell, Seth Hitefield, Andrew Ayres, Gregory Cage, Jesse McGaha, Robert Smith, Gavin Wiggins, Michael Brim, Rick Archibald, Addi Malviya Thakur
+Author-email: Lance Drane <dranelt@ornl.gov>, Marshall McDonnell <mcdonnellmt@ornl.gov>, Seth Hitefield <hitefieldsd@ornl.gov>, Andrew Ayres <ayresaf@ornl.gov>, Gregory Cage <cagege@ornl.gov>, Jesse McGaha <mcgahajr@ornl.gov>, Robert Smith <smithrw@ornl.gov>, Gavin Wiggins <wigginsg@ornl.gov>, Michael Brim <brimmj@ornl.gov>, Rick Archibald <archibaldrk@ornl.gov>, Addi Malviya Thakur <malviyaa@ornl.gov>
 License: BSD-3-Clause
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: pydantic>=2.7.0
+Requires-Dist: intersect-sdk-common>=0.9.6,<0.10.0
+Requires-Dist: jsonschema[format-nongpl]>=4.21.1
+Requires-Dist: psutil>=7.0.0
+Requires-Dist: sphinx>=5.3.0 ; extra == 'docs'
+Requires-Dist: furo>=2023.3.27 ; extra == 'docs'
+Requires-Python: >=3.10, <4.0
 Project-URL: Homepage, https://github.com/INTERSECT-SDK/python-sdk/
 Project-URL: Changelog, https://github.com/INTERSECT-SDK/python-sdk/blob/main/CHANGELOG.md
 Project-URL: Documentation, https://intersect-python-sdk.readthedocs.io/en/latest/
 Project-URL: Issues, https://github.com/INTERSECT-SDK/python-sdk/issues
-Requires-Python: <4.0,>=3.8.10
-Requires-Dist: pydantic>=2.7.0
-Requires-Dist: retrying<2.0.0,>=1.3.4
-Requires-Dist: paho-mqtt<2.0.0,>=1.6.1
-Requires-Dist: minio>=7.2.3
-Requires-Dist: jsonschema[format-nongpl]>=4.21.1
-Requires-Dist: eval-type-backport>=0.1.3; python_version < "3.10"
-Provides-Extra: amqp
-Requires-Dist: pika<2.0.0,>=1.3.2; extra == "amqp"
 Provides-Extra: docs
-Requires-Dist: sphinx>=5.3.0; extra == "docs"
-Requires-Dist: furo>=2023.3.27; extra == "docs"
 Description-Content-Type: text/markdown
 
 [![Static Badge](https://img.shields.io/badge/DOI-10.11578%2Fdc.20240927.1-blue)](https://doi.org/10.11578/dc.20240927.1)
@@ -49,7 +46,8 @@ For a high-level overview, please see [the architecture website.](https://inters
 
 - Event-driven architecture
 - Support core interaction types: request/response, events, commands, statuses
-- Borrows several concepts from [AsyncAPI](https://www.asyncapi.com/docs/reference/specification/latest), and intends to support multiple different protocols. Currently, we support MQTT 3.1.1 and AMQP 0.9.1, but other protocols will be supported as well.
+- Borrows several concepts from [AsyncAPI](https://www.asyncapi.com/docs/reference/specification/latest), and intends to support multiple different protocols. Currently, we support MQTT 5.0 and AMQP 0.9.1, but other protocols will be supported as well.
+  - As a general rule, we will not support any protocols which do not support headers, do not allow for asynchronous messaging, or require the microservice itself to "keep alive" multiple connections.
 - Users automatically generate schema from code; schemas are part of the core contract of an INTERSECT microservice, and both external inputs and microservice outputs are required to uphold this contract.
 
 ## Authors

{intersect_sdk-0.8.4 → intersect_sdk-0.9.1}/README.md

@@ -19,7 +19,8 @@ For a high-level overview, please see [the architecture website.](https://inters
 
 - Event-driven architecture
 - Support core interaction types: request/response, events, commands, statuses
-- Borrows several concepts from [AsyncAPI](https://www.asyncapi.com/docs/reference/specification/latest), and intends to support multiple different protocols. Currently, we support MQTT 3.1.1 and AMQP 0.9.1, but other protocols will be supported as well.
+- Borrows several concepts from [AsyncAPI](https://www.asyncapi.com/docs/reference/specification/latest), and intends to support multiple different protocols. Currently, we support MQTT 5.0 and AMQP 0.9.1, but other protocols will be supported as well.
+  - As a general rule, we will not support any protocols which do not support headers, do not allow for asynchronous messaging, or require the microservice itself to "keep alive" multiple connections.
 - Users automatically generate schema from code; schemas are part of the core contract of an INTERSECT microservice, and both external inputs and microservice outputs are required to uphold this contract.
 
 ## Authors

intersect_sdk-0.9.1/pyproject.toml

@@ -0,0 +1,198 @@
+[project]
+name = "intersect-sdk"
+description = "Python SDK to interact with INTERSECT"
+authors = [
+  { name = "Lance Drane", email = "dranelt@ornl.gov" },
+  { name = "Marshall McDonnell", email = "mcdonnellmt@ornl.gov" },
+  { name = "Seth Hitefield", email = "hitefieldsd@ornl.gov" },
+  { name = "Andrew Ayres", email = "ayresaf@ornl.gov" },
+  { name = "Gregory Cage", email = "cagege@ornl.gov" },
+  { name = "Jesse McGaha", email = "mcgahajr@ornl.gov" },
+  { name = "Robert Smith", email = "smithrw@ornl.gov" },
+  { name = "Gavin Wiggins", email = "wigginsg@ornl.gov" },
+  { name = "Michael Brim", email = "brimmj@ornl.gov" },
+  { name = "Rick Archibald", email = "archibaldrk@ornl.gov" },
+  { name = "Addi Malviya Thakur", email = "malviyaa@ornl.gov" },
+]
+version = "0.9.1"
+readme = "README.md"
+license = { text = "BSD-3-Clause" }
+requires-python = ">=3.10,<4.0"
+keywords = ["intersect"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+]
+dependencies = [
+  "pydantic>=2.7.0",
+  "intersect-sdk-common>=0.9.6,<0.10.0",
+  "jsonschema[format-nongpl]>=4.21.1",   # extras necessary for enforcing formats
+  #"brotli>=1.1.0", # TODO - add this dependency when we add compression
+  "psutil>=7.0.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/INTERSECT-SDK/python-sdk/"
+Changelog = "https://github.com/INTERSECT-SDK/python-sdk/blob/main/CHANGELOG.md"
+Documentation = "https://intersect-python-sdk.readthedocs.io/en/latest/"
+Issues = "https://github.com/INTERSECT-SDK/python-sdk/issues"
+
+[project.optional-dependencies]
+docs = ["sphinx>=5.3.0", "furo>=2023.3.27"]
+
+[dependency-groups]
+dev = [
+  "pre-commit>=3.3.1",
+  "ruff==0.12.7",
+  "mypy>=1.10.0",
+  "codespell>=2.3.0",
+  "pytest>=7.3.2",
+  "pytest-cov>=4.1.0",
+  "httpretty>=1.1.4",
+]
+
+[build-system]
+requires = ["uv_build>=0.10.2,<0.11.0"]
+build-backend = "uv_build"
+
+[tool.ruff]
+line-length = 100
+format = { quote-style = 'single' }
+
+[tool.ruff.lint]
+isort = { known-first-party = ['src'] }
+pydocstyle = { convention = 'google' }
+flake8-quotes = { inline-quotes = 'single', multiline-quotes = 'double' }
+mccabe = { max-complexity = 20 }
+pylint = { max-args = 10, max-branches = 20, max-returns = 15, max-statements = 75 }
+# pyflakes and the relevant pycodestyle rules are already configured
+extend-select = [
+  'C90',   # mccabe complexity
+  'I',     # isort
+  'N',     # pep8-naming
+  'D',     # pydocstyle
+  'UP',    # pyupgrade
+  'YTT',   # flake8-2020
+  'ANN',   # flake8-annotations
+  'ASYNC', # flake8-async
+  'S',     # flake8-bandit
+  'BLE',   # flake8-blind-except
+  'B',     # flake8-bugbear
+  'A',     # flake8-builtins
+  'COM',   # flake8-commas
+  'C4',    # flake8-comprehensions
+  'DTZ',   # flake8-datetimez
+  'T10',   # flake8-debugger
+  'EM',    # flake8-error-message
+  'FA',    # flake8-future-annotations
+  'ISC',   # flake8-implicit-string-concat
+  'ICN',   # flake8-import-conventions
+  'G',     # flake8-logging-format
+  'INP',   # flake8-no-pep420
+  'PIE',   # flake8-PIE
+  'T20',   # flake8-T20
+  'PYI',   # flake8-pyi
+  'PT',    # flake8-pytest-style
+  'Q',     # flake8-quotes
+  'RSE',   # flake8-raise
+  'RET',   # flake8-return
+  'SLF',   # flake8-self
+  'SLOT',  # flake8-slots
+  'SIM',   # flake8-simplify
+  'TC',    # flake8-type-checking
+  'ARG',   # flake8-unused-arguments
+  'PTH',   # flake8-use-pathlib
+  'PGH',   # pygrep-hooks
+  'PL',    # pylint
+  'TRY',   # tryceratops
+  'FLY',   # flynt
+  'RUF',   # RUFF additional rules
+  'INT',   # flake8-gettext
+]
+# If you're seeking to disable a rule, first consider whether the rule is overbearing, or if it should only be turned off for your usecase.
+ignore = [
+  'COM812',  # formatter, handled by Ruff format
+  'ISC001',  # formatter, handled by Ruff format
+  'SIM105',  # "with contextlib.suppress():" is slower than try-except-pass
+  'ANN401',  # allow explicit "Any" typing, use with care
+  'PLR2004', # allow "magic numbers"
+]
+
+[tool.ruff.lint.flake8-type-checking]
+runtime-evaluated-base-classes = [
+  "pydantic.BaseModel",
+  "intersect_sdk.IntersectBaseCapabilityImplementation",
+]
+runtime-evaluated-decorators = [
+  "pydantic.dataclasses.dataclass",
+  "pydantic.validate_call",
+]
+
+[tool.ruff.lint.extend-per-file-ignores]
+'__init__.py' = [
+  'F401',  # __init__.py commonly has unused imports
+  'TC004', # do lazy imports when importing from the base module
+]
+'docs/*' = [
+  'D',      # the documentation folder does not need documentation
+  'INP001', # docs are not a namespace package
+]
+'examples/*' = [
+  'N999',   # module names for examples are not standard
+  'T20',    # allow print/pprint statements in examples
+  'S106',   # don't care about credentials in examples
+  'D100',   # documenting modules in examples is unhelpful
+  'D104',   # documenting packages in examples is unhelpful
+  'TRY002', # examples can raise their own exception
+]
+'tests/*' = [
+  'S101',   # allow assert statements in tests
+  'S106',   # don't care about credentials in tests
+  'S311',   # don't care about cryptographic security in tests
+  'SLF001', # allow private member access in tests
+  'ANN',    # tests in general don't need types, unless they are runtime types.
+  'ARG',    # allow unused parameters in tests
+  'D',      # ignore documentation in tests
+  'RUF012', # permit "mutable" class attributes to not be annotated with typing.ClassVar (these shouldn't be mutated anyways...)
+]
+
+# see https://mypy.readthedocs.io/en/stable/config_file.html for a complete reference
+[tool.mypy]
+strict = true
+ignore_missing_imports = true       # don't require typing for library stubs if they don't exist
+disallow_untyped_decorators = false # this is needed for library decorator compatibility, i.e. "retrying"
+plugins = ["pydantic.mypy"]
+
+[tool.pydantic-mypy]
+init_forbid_extra = true
+init_typed = true
+warn_required_dynamic_aliases = true
+warn_untyped_fields = true
+
+[tool.pytest.ini_options]
+log_cli = true
+addopts = "-ra"
+
+[tool.coverage.report]
+omit = [
+  '*__init__*',             # __init__ files should just re-export other classes and functions
+  '*/discovery_service.py', # currently unused
+]
+exclude_also = [
+  'pragma: no-cover',              # standard
+  'if (typing\\.)?TYPE_CHECKING:', # type checking blocks are not executed in coverage, but we don't care
+  '@(abc\\.)?abstractmethod',      # don't try to cover abstract methods
+  "class .*\\bProtocol\\):",       # don't cover protocol classes (similar to abstract classes)
+  'raise NotImplementedError',     # it's not implemented so shouldn't be covered
+  'except.* ImportError',          # these are usually used to throw a "friendlier" error and are not really worth testing
+]
+
+[tool.codespell]
+# Ref: https://github.com/codespell-project/codespell#using-a-config-file
+skip = '.git*,*.lock,.venv,.*cache/*,./docs/_build/*'
+check-hidden = true
+# ignore-regex = ''
+# ignore-words-list = ''

intersect_sdk-0.9.1/src/intersect_sdk/__init__.py

@@ -0,0 +1,162 @@
+"""The root module contains the intended public API for users of the INTERSECT-SDK.
+
+Users should not need to import anything outside of the root.
+
+In general, most breaking changes on version updates will relate to:
+  - Configuration classes (both adding and removing new config models). These configuration classes are relevant to the next point.
+  - When a new data service is integrated into INTERSECT, ALL adapters will need to update to support this data service, which will include new dependencies.
+"""
+
+from importlib import import_module
+from typing import TYPE_CHECKING
+
+# import everything eagerly for IDEs/LSPs
+if TYPE_CHECKING:
+    from intersect_sdk_common import (
+        ControlPlaneConfig,
+        ControlProvider,
+        DataStoreConfig,
+        DataStoreConfigMap,
+        HierarchyConfig,
+        IntersectDataHandler,
+        IntersectMimeType,
+        intersect_sdk_version_info,
+        intersect_sdk_version_string,
+    )
+
+    from .app_lifecycle import default_intersect_lifecycle_loop
+    from .capability.base import IntersectBaseCapabilityImplementation
+    from .client import IntersectClient
+    from .client_callback_definitions import (
+        INTERSECT_CLIENT_EVENT_CALLBACK_TYPE,
+        INTERSECT_CLIENT_RESPONSE_CALLBACK_TYPE,
+        IntersectClientCallback,
+    )
+    from .config.client import IntersectClientConfig
+    from .config.service import IntersectServiceConfig
+    from .exceptions import IntersectCapabilityError
+    from .schema import get_schema_from_capability_implementations
+    from .service import IntersectService
+    from .service_callback_definitions import (
+        INTERSECT_SERVICE_RESPONSE_CALLBACK_TYPE,
+    )
+    from .service_definitions import (
+        IntersectEventDefinition,
+        intersect_message,
+        intersect_status,
+    )
+    from .shared_callback_definitions import (
+        INTERSECT_JSON_VALUE,
+        INTERSECT_RESPONSE_VALUE,
+        IntersectDirectMessageParams,
+        IntersectEventMessageParams,
+    )
+    from .version import __version__
+
+__all__ = (
+    'INTERSECT_CLIENT_EVENT_CALLBACK_TYPE',
+    'INTERSECT_CLIENT_RESPONSE_CALLBACK_TYPE',
+    'INTERSECT_JSON_VALUE',
+    'INTERSECT_RESPONSE_VALUE',
+    'INTERSECT_SERVICE_RESPONSE_CALLBACK_TYPE',
+    'ControlPlaneConfig',
+    'ControlProvider',
+    'DataStoreConfig',
+    'DataStoreConfigMap',
+    'HierarchyConfig',
+    'IntersectBaseCapabilityImplementation',
+    'IntersectCapabilityError',
+    'IntersectClient',
+    'IntersectClientCallback',
+    'IntersectClientConfig',
+    'IntersectDataHandler',
+    'IntersectDirectMessageParams',
+    'IntersectEventDefinition',
+    'IntersectEventMessageParams',
+    'IntersectMimeType',
+    'IntersectService',
+    'IntersectServiceConfig',
+    '__version__',
+    'default_intersect_lifecycle_loop',
+    'get_schema_from_capability_implementations',
+    'intersect_message',
+    'intersect_sdk_version_info',
+    'intersect_sdk_version_string',
+    'intersect_status',
+)
+
+# PEP 562 stuff: do lazy imports for people who just want to import from the top-level module
+# [0] = package, [1] = path to module within package
+__lazy_imports = {
+    # COMMON: core types
+    'IntersectDataHandler': ('intersect_sdk_common', '.'),
+    'IntersectMimeType': ('intersect_sdk_common', '.'),
+    # COMMON: config types
+    'ControlPlaneConfig': ('intersect_sdk_common', '.'),
+    'ControlProvider': ('intersect_sdk_common', '.'),
+    'DataStoreConfig': ('intersect_sdk_common', '.'),
+    'DataStoreConfigMap': ('intersect_sdk_common', '.'),
+    'HierarchyConfig': ('intersect_sdk_common', '.'),
+    # COMMON: version
+    'intersect_sdk_version_info': ('intersect_sdk_common', '.'),
+    'intersect_sdk_version_string': ('intersect_sdk_common', '.'),
+    # imports not in common
+    'INTERSECT_CLIENT_EVENT_CALLBACK_TYPE': (
+        __spec__.parent,
+        '.client_callback_definitions',
+    ),
+    'INTERSECT_CLIENT_RESPONSE_CALLBACK_TYPE': (
+        __spec__.parent,
+        '.client_callback_definitions',
+    ),
+    'INTERSECT_JSON_VALUE': (__spec__.parent, '.shared_callback_definitions'),
+    'INTERSECT_RESPONSE_VALUE': (
+        __spec__.parent,
+        '.shared_callback_definitions',
+    ),
+    'INTERSECT_SERVICE_RESPONSE_CALLBACK_TYPE': (
+        __spec__.parent,
+        '.service_callback_definitions',
+    ),
+    'IntersectBaseCapabilityImplementation': (
+        __spec__.parent,
+        '.capability.base',
+    ),
+    'IntersectCapabilityError': (__spec__.parent, '.exceptions'),
+    'IntersectClient': (__spec__.parent, '.client'),
+    'IntersectClientCallback': (
+        __spec__.parent,
+        '.client_callback_definitions',
+    ),
+    'IntersectClientConfig': (__spec__.parent, '.config.client'),
+    'IntersectDirectMessageParams': (
+        __spec__.parent,
+        '.shared_callback_definitions',
+    ),
+    'IntersectEventDefinition': (__spec__.parent, '.service_definitions'),
+    'IntersectEventMessageParams': (
+        __spec__.parent,
+        '.shared_callback_definitions',
+    ),
+    'IntersectService': (__spec__.parent, '.service'),
+    'IntersectServiceConfig': (__spec__.parent, '.config.service'),
+    '__version__': (__spec__.parent, '.version'),
+    'default_intersect_lifecycle_loop': (__spec__.parent, '.app_lifecycle'),
+    'get_schema_from_capability_implementations': (__spec__.parent, '.schema'),
+    'intersect_message': (__spec__.parent, '.service_definitions'),
+    'intersect_status': (__spec__.parent, '.service_definitions'),
+}
+
+
+def __getattr__(attr_name: str) -> object:
+    attr_module = __lazy_imports.get(attr_name)
+    if attr_module:
+        module = import_module(attr_module[1], package=attr_module[0])
+        return getattr(module, attr_name)
+
+    msg = f'module {__name__!r} has no attribute {attr_name!r}'
+    raise AttributeError(msg)
+
+
+def __dir__() -> list[str]:
+    return list(__all__)

{intersect_sdk-0.8.4 → intersect_sdk-0.9.1}/src/intersect_sdk/_internal/constants.py

@@ -1,10 +1,8 @@
 BASE_RESPONSE_ATTR = '__is_intersect_response__'
 BASE_STATUS_ATTR = '__is_intersect_status__'
-BASE_EVENT_ATTR = '__is_intersect_event__'
 # in theory, as long as the next attributes are unique, they can be any string
 REQUEST_CONTENT = '__request_content_type__'
 RESPONSE_CONTENT = '__response_content_type__'
 RESPONSE_DATA = '__response_data_transfer_handler__'
 STRICT_VALIDATION = '__strict_validation__'
 SHUTDOWN_KEYS = '__ignore_message__'
-EVENT_ATTR_KEY = '__intersect_sdk_events__'

{intersect_sdk-0.8.4 → intersect_sdk-0.9.1}/src/intersect_sdk/_internal/event_metadata.py

@@ -15,10 +15,6 @@ class EventMetadata(NamedTuple):
     NOTE: both this class and all properties in it should remain immutable after creation
     """
 
-    operations: set[str]
-    """
-    A hash set of operations which advertise this event
-    """
     type: type
     """
     The actual type of the event
@@ -53,8 +49,8 @@ def definition_metadata_differences(
         differences.append(
             (
                 'content_type',
-                f'{definition.content_type.__class__.__name__}.{definition.content_type.name}',
-                f'{metadata.content_type.__class__.__name__}.{metadata.content_type.name}',
+                f'{definition.content_type}',
+                f'{metadata.content_type}',
             )
         )
     if definition.data_handler != metadata.data_transfer_handler:

intersect_sdk-0.9.1/src/intersect_sdk/_internal/function_metadata.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Literal, NamedTuple
+
+if TYPE_CHECKING:
+    from pydantic import TypeAdapter
+
+    from ..core_definitions import IntersectDataHandler, IntersectMimeType
+
+
+class FunctionMetadata(NamedTuple):
+    """Internal cache of public function metadata.
+
+    NOTE: both this class and all properties in it should remain immutable after creation
+    """
+
+    capability: type
+    """
+    The type of the class that implements the target method.
+    """
+    request_adapter: TypeAdapter[Any] | Literal[0] | None
+    """
+    Type adapter for serializing and validating requests.
+
+    Null if user did not specify a request parameter.
+    0 if user did specify a request parameter, but Content-Type does not require a TypeAdapter.
+    """
+    response_adapter: TypeAdapter[Any] | Literal[0]
+    """
+    Type adapter for serializing and validating responses.
+    0 if Content-Type does not require a TypeAdapter.
+    """
+    request_content_type: IntersectMimeType
+    """
+    Content-Type of the request value
+    """
+    response_content_type: IntersectMimeType
+    """
+    Content-Type of the response value
+    """
+    response_data_transfer_handler: IntersectDataHandler
+    """
+    How we intend on handling the response value
+    """
+    strict_validation: bool
+    """
+    Whether or not we're using lenient Pydantic validation (default, False) or strict
+    """
+    shutdown_keys: set[str]
+    """
+    keys which should cause the function to be skipped if set
+    """

intersect_sdk-0.9.1/src/intersect_sdk/_internal/generic_serializer.py

@@ -0,0 +1,5 @@
+from typing import Any
+
+from pydantic import TypeAdapter
+
+GENERIC_MESSAGE_SERIALIZER: TypeAdapter[Any] = TypeAdapter(Any)

{intersect_sdk-0.8.4 → intersect_sdk-0.9.1}/src/intersect_sdk/_internal/interfaces.py

@@ -5,8 +5,9 @@ from typing import TYPE_CHECKING, Any, Protocol
 if TYPE_CHECKING:
     from uuid import UUID
 
+    from intersect_sdk_common import HierarchyConfig
+
     from ..client_callback_definitions import INTERSECT_CLIENT_EVENT_CALLBACK_TYPE
-    from ..config.shared import HierarchyConfig
     from ..service_callback_definitions import (
         INTERSECT_SERVICE_RESPONSE_CALLBACK_TYPE,
     )
@@ -21,13 +22,13 @@ class IntersectEventObserver(Protocol):
     Used as the common interface for event emitters (i.e. CapabilityImplementations).
     """
 
-    def _on_observe_event(self, event_name: str, event_value: Any, operation: str) -> None:
+    def _on_observe_event(self, event_name: str, event_value: Any, capability_name: str) -> None:
         """How to react to an event being fired.
 
         Args:
             event_name: The key of the event which is fired.
             event_value: The value of the event which is fired.
-            operation: The source of the event (generally the function name, not directly invoked by application devs)
+            capability_name: The name of the capability which fired the event.
         """
         ...
 
@@ -52,6 +53,7 @@ class IntersectEventObserver(Protocol):
     def register_event(
         self,
         service: HierarchyConfig,
+        capability_name: str,
         event_name: str,
         response_handler: INTERSECT_CLIENT_EVENT_CALLBACK_TYPE,
     ) -> None:
@@ -59,6 +61,7 @@ class IntersectEventObserver(Protocol):
 
         Params:
           - service: HierarchyConfig of the service we want to talk to
+          - capability_name: name of capability which will fire off the event
           - event_name: name of event to subscribe to
           - response_handler: callback for how to handle the reception of an event
         """

{intersect_sdk-0.8.4 → intersect_sdk-0.9.1}/src/intersect_sdk/_internal/pydantic_schema_generator.py

@@ -3,10 +3,7 @@
 See: https://docs.pydantic.dev/latest/api/json_schema/#pydantic.json_schema.GenerateJsonSchema
 """
 
-from __future__ import annotations
-
 from typing import (
-    TYPE_CHECKING,
     Any,
 )
 
@@ -20,10 +17,7 @@ from pydantic.json_schema import (
     JsonSchemaValue,
 )
 from pydantic.type_adapter import _type_has_config
-from pydantic_core import PydanticSerializationError, to_jsonable_python
-
-if TYPE_CHECKING:
-    from pydantic_core import CoreSchema, core_schema
+from pydantic_core import CoreSchema, PydanticSerializationError, core_schema, to_jsonable_python
 
 
 # build nested dictionary from list of keys. i.e. if keys = ['one', 'two', 'three']