multiconn_archicad 0.2.0__tar.gz

multiconn_archicad-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Szamosi Máté
+
+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.

multiconn_archicad-0.2.0/PKG-INFO

@@ -0,0 +1,249 @@
+Metadata-Version: 2.4
+Name: multiconn_archicad
+Version: 0.2.0
+Summary: MultiConn ArchiCAD is a connection object for ArchiCAD’s JSON API and its Python wrapper, designed to manage multiple open instances of ArchiCAD simultaneously.
+Author-email: SzamosiMate <szamimate@yahoo.com>
+License-File: LICENSE
+Requires-Python: >=3.12
+Requires-Dist: aiohttp>=3.11.11
+Requires-Dist: archicad>=28.3000
+Requires-Dist: psutil>=6.1.1
+Requires-Dist: pywinauto>=0.6.9
+Provides-Extra: dialog-handlers
+Requires-Dist: pywinauto>=0.6.9; extra == 'dialog-handlers'
+Description-Content-Type: text/markdown
+
+<img src="https://github.com/user-attachments/assets/370ad589-117c-44cb-9a4a-80bfcb734445" width="400px" />
+
+## 
+
+**MultiConn ArchiCAD** is a Python-based connection object for ArchiCAD's JSON API and its Python wrapper. It is designed to manage multiple open instances of Archicad simultaneously, making it easier to execute commands across multiple instances.
+
+[![Latest Release](https://img.shields.io/github/v/release/SzamosiMate/multiconn_archicad)](https://github.com/SzamosiMate/multiconn_archicad/releases/latest) 
+![License](https://img.shields.io/github/license/SzamosiMate/multiconn_archicad) 
+![Issues](https://img.shields.io/github/issues/SzamosiMate/multiconn_archicad) 
+![Forks](https://img.shields.io/github/forks/SzamosiMate/multiconn_archicad) 
+![Stars](https://img.shields.io/github/stars/SzamosiMate/multiconn_archicad)
+
+## Features
+
+- **Multi-connection Support**: Connect to one, multiple, or all open instances of Archicad.
+- **Seamless Integration**: Utilizes ArchiCAD's official Python package.
+- **Tapir Add-On Support**: Run commands from the Tapir Archicad Add-On.
+- **Efficient I/O Operations**: Handles connection management using concurrent or asynchronous code.
+- **Project Management**: Find and open ArchiCAD projects programmatically.
+
+## Installation
+
+You can install the latest version of the package from the following link using `pip`:
+
+```bash
+pip install https://github.com/SzamosiMate/multiconn_archicad/releases/latest/download/multiconn_archicad-0.1.2-py3-none-any.whl
+```
+
+The package depends on the [Tapir Archicad Add-On](https://github.com/ENZYME-APD/tapir-archicad-automation?tab=readme-ov-file). It is recommended to install the latest version of Tapir to access all features. While some functionality may work without the add-on, all tests have been conducted with it installed.
+
+## Usage
+
+**Disclaimer:** The connection object is functional but in the early stages of development. It is not thoroughly tested, and its interfaces may change in future updates.
+
+### Actions - managing the connection
+Actions allow you to manage the state of the connection object. You can connect to or disconnect from Archicad instances, quit instances, or refresh ports. All actions can have multiple types of inputs. For each type of input you have to call the corresponding method of the action. To connect to all available ArchiCAD instances, you have to call the .all() method on .connect ( e.g. `conn.connect.all()`). The aim of this method is to provide better autocompletion.
+
+#### Example: Connection Management
+```python 
+from multiconn_archicad import MultiConn, Port
+
+conn = MultiConn()
+
+# connect all ArchiCAD instances that were running at instantiation / the last refresh
+conn.connect.all()
+
+# disconnect from the instance at port 19723   
+conn.disconnect.from_ports(Port(19723))
+
+# refresh all closed ports - ports with no running archicad instance   
+conn.refresh.closed_ports()
+
+# close, and remove from the dict of open port headers the archicad instance specified by ConnHeader
+conn.quit.from_headers(conn.open_port_headers[Port(19735)])
+```
+
+### Project Management
+
+The MultiConn object provides actions to find and open ArchiCAD projects programmatically.
+
+#### Finding ArchiCAD Instances
+
+You can use the `find_archicad` action to locate a specific ArchiCAD instance from a `ConnHeader`.
+
+```python
+from multiconn_archicad import MultiConn, ConnHeader
+
+conn = MultiConn()
+conn_header = ConnHeader(Port(19723))
+
+# Find the port for a specific connection header
+port = conn.find_archicad.from_header(conn_header)
+if port:
+    print(f"Found ArchiCAD instance at port: {port}")
+```
+
+#### Opening Projects
+
+The `open_project` action allows you to programmatically open ArchiCAD projects.
+
+```python
+from multiconn_archicad import MultiConn, ConnHeader, TeamworkCredentials
+
+conn = MultiConn()
+
+# Open a project using a connection header
+conn_header = ConnHeader.from_dict(saved_header_data)
+port = conn.open_project.from_header(conn_header)
+
+# For teamwork projects, you can provide credentials
+credentials = TeamworkCredentials("username", "password")
+port = conn.open_project.with_teamwork_credentials(conn_header, credentials)
+```
+
+### Dialog Handling
+
+MultiConn can automatically handle most dialog windows that appear when opening ArchiCAD projects. This is particularly useful for batch operations and automation scripts.
+
+```python
+from multiconn_archicad import MultiConn, WinDialogHandler, win_int_handler_factory
+
+# Create a MultiConn instance with a dialog handler
+conn = MultiConn(dialog_handler=WinDialogHandler(win_int_handler_factory))
+
+# Dialog windows will be automatically handled when opening projects
+conn.open_project.from_header(conn_header)
+```
+
+The current implementation includes:
+- `EmptyDialogHandler`: Does nothing (default)
+- `WinDialogHandler`: Waits for ArchiCAD to start, and monitors appearing dialogs. If dialog appears, searches for appropriate handler in win_int_handler factory. Only works on windows.
+- `win_int_handler_factory`: Provides dialog handleing logic on a dialog by dialog basis for the INT language version. It is an example you should customize for your specific project needs. Even if you end up not modifying it, you should definitely know what it does for what dialog.
+
+### Serialization
+
+The MultiConn package allows you to save and load connection configurations, making it easier to work with specific projects across multiple sessions.
+
+#### Saving Connection Headers
+
+```python
+from multiconn_archicad import MultiConn, Port
+
+conn = MultiConn()
+conn.connect.all()
+
+# Get a connection header
+conn_header = conn.open_port_headers[Port(19723)]
+
+# Convert to dictionary for serialization
+header_dict = conn_header.to_dict()
+
+# Save to file using your preferred method
+import json
+with open('conn_header.json', 'w') as f:
+    json.dump(header_dict, f)
+```
+
+#### Loading Connection Headers
+
+```python
+from multiconn_archicad import ConnHeader, TeamworkCredentials
+
+# Load from file
+import json
+with open('conn_header.json', 'r') as f:
+    header_dict = json.load(f)
+
+# Create a header from the dictionary
+conn_header = ConnHeader.from_dict(header_dict)
+
+# For teamwork projects, you need to provide credentials
+if isinstance(conn_header.archicad_id, TeamworkProjectID):
+    credentials = TeamworkCredentials("username", "password")
+    # Use the credentials when opening the project
+    port = conn.open_project.with_teamwork_credentials(conn_header, credentials)
+```
+
+Note: Passwords are not stored in serialized connection headers for security reasons. You must provide them when loading teamwork projects.
+
+### Running Commands
+
+#### Single Archicad Instance
+
+To run commands on one chosen ArchiCAD instance the `MultiConn` object has a connection called `primary`. Calling a command directly from the MultiConn object will send it to the `primary` instance. The `primary` connection can be changed by assigning any valid `Port`, or `ConnHeader` object to `MultiConn.primary`.
+
+#### Example: Running Commands on a Single Archicad Instance
+```python
+from multiconn_archicad import MultiConn, Port
+
+# After instantiation the primary connection will be the instance with the lowest port number (probably 19723)
+conn = MultiConn()
+
+# Set the primary connection to the instance running on port 19725
+conn.primary = Port(19725)
+
+# Prints project info from the instance on port 19725
+print(conn.core.post_tapir_command("GetProjectInfo"))
+```
+
+#### Multiple Archicad Instances
+
+The MultiConn object stores references to `ConnHeaders` for all open ports (ports, with a running ArchiCAD instance). The references are stored in a dictionary at `.open_port_headers`. This dictionary maps each port to its corresponding connection. Each `ConnHeader` object has its own command objects for each used command namespace. The MultiConn objects has properties to access 3 subsets of open ports based on the status of the `ConnHeaders`: 
+
+- **`active`**: Successfully connected instances.
+- **`failed`**: Instances where the connection attempt failed.
+- **`pending`**: Instances with no connection attempt made or disconnected.
+
+#### Example: Running Commands on Multiple Archicad Instances
+
+```python
+from multiconn_archicad import MultiConn
+
+conn = MultiConn()
+conn.connect.all()
+
+# Explicit loop to gather elements from all active connections
+elements = {}
+for port, conn_header in conn.active.items():
+    elements[port] = conn_header.standard.commands.GetAllElements()
+
+# Using dictionary comprehension
+elements = {
+    port: conn_header.standard.commands.GetAllElements()
+    for port, conn_header in conn.active.items()
+}
+```
+
+### Namespaces
+
+The aim of the module is to incorporate all solutions that let users automate ArchiCAD from python. The different solutions are separated into namespaces, accessed from properties of the connection object. One of the planned features is letting users supply a list of namespaces they want to use when creating the connections. At the moment there are only two namespaces:
+
+- **`standard`**: The official ArchiCAD python wrapper
+- **`core`**: A simple JSON based module that lets the users post official and tapir commands based on Tapir's ["aclib"](https://github.com/ENZYME-APD/tapir-archicad-automation/tree/main/archicad-addon/Examples/aclib)
+
+#### Example: Using two namespaces together
+```python
+def run(conn: MultiConn | ConnHeader) -> dict[str, Any]:
+    elements = conn.standard.commands.GetAllElements()
+    command_parameters = {
+        "elements": [element.to_dict() for element in elements],
+        "highlightedColors": [[50, 255, 100, 100] for _ in range(len(elements))],
+        "wireframe3D": True,
+        "nonHighlightedColor": [0, 0, 255, 128],
+    }
+    return conn.core.post_tapir_command('HighlightElements', command_parameters)
+```
+
+## Contributing
+
+Contributions are welcome! Feel free to submit issues, feature requests, or pull requests to help improve MultiConn ArchiCAD.
+
+## License
+
+This project is licensed under the MIT License. See the LICENSE file for details.

multiconn_archicad-0.2.0/README.md

@@ -0,0 +1,234 @@
+<img src="https://github.com/user-attachments/assets/370ad589-117c-44cb-9a4a-80bfcb734445" width="400px" />
+
+## 
+
+**MultiConn ArchiCAD** is a Python-based connection object for ArchiCAD's JSON API and its Python wrapper. It is designed to manage multiple open instances of Archicad simultaneously, making it easier to execute commands across multiple instances.
+
+[![Latest Release](https://img.shields.io/github/v/release/SzamosiMate/multiconn_archicad)](https://github.com/SzamosiMate/multiconn_archicad/releases/latest) 
+![License](https://img.shields.io/github/license/SzamosiMate/multiconn_archicad) 
+![Issues](https://img.shields.io/github/issues/SzamosiMate/multiconn_archicad) 
+![Forks](https://img.shields.io/github/forks/SzamosiMate/multiconn_archicad) 
+![Stars](https://img.shields.io/github/stars/SzamosiMate/multiconn_archicad)
+
+## Features
+
+- **Multi-connection Support**: Connect to one, multiple, or all open instances of Archicad.
+- **Seamless Integration**: Utilizes ArchiCAD's official Python package.
+- **Tapir Add-On Support**: Run commands from the Tapir Archicad Add-On.
+- **Efficient I/O Operations**: Handles connection management using concurrent or asynchronous code.
+- **Project Management**: Find and open ArchiCAD projects programmatically.
+
+## Installation
+
+You can install the latest version of the package from the following link using `pip`:
+
+```bash
+pip install https://github.com/SzamosiMate/multiconn_archicad/releases/latest/download/multiconn_archicad-0.1.2-py3-none-any.whl
+```
+
+The package depends on the [Tapir Archicad Add-On](https://github.com/ENZYME-APD/tapir-archicad-automation?tab=readme-ov-file). It is recommended to install the latest version of Tapir to access all features. While some functionality may work without the add-on, all tests have been conducted with it installed.
+
+## Usage
+
+**Disclaimer:** The connection object is functional but in the early stages of development. It is not thoroughly tested, and its interfaces may change in future updates.
+
+### Actions - managing the connection
+Actions allow you to manage the state of the connection object. You can connect to or disconnect from Archicad instances, quit instances, or refresh ports. All actions can have multiple types of inputs. For each type of input you have to call the corresponding method of the action. To connect to all available ArchiCAD instances, you have to call the .all() method on .connect ( e.g. `conn.connect.all()`). The aim of this method is to provide better autocompletion.
+
+#### Example: Connection Management
+```python 
+from multiconn_archicad import MultiConn, Port
+
+conn = MultiConn()
+
+# connect all ArchiCAD instances that were running at instantiation / the last refresh
+conn.connect.all()
+
+# disconnect from the instance at port 19723   
+conn.disconnect.from_ports(Port(19723))
+
+# refresh all closed ports - ports with no running archicad instance   
+conn.refresh.closed_ports()
+
+# close, and remove from the dict of open port headers the archicad instance specified by ConnHeader
+conn.quit.from_headers(conn.open_port_headers[Port(19735)])
+```
+
+### Project Management
+
+The MultiConn object provides actions to find and open ArchiCAD projects programmatically.
+
+#### Finding ArchiCAD Instances
+
+You can use the `find_archicad` action to locate a specific ArchiCAD instance from a `ConnHeader`.
+
+```python
+from multiconn_archicad import MultiConn, ConnHeader
+
+conn = MultiConn()
+conn_header = ConnHeader(Port(19723))
+
+# Find the port for a specific connection header
+port = conn.find_archicad.from_header(conn_header)
+if port:
+    print(f"Found ArchiCAD instance at port: {port}")
+```
+
+#### Opening Projects
+
+The `open_project` action allows you to programmatically open ArchiCAD projects.
+
+```python
+from multiconn_archicad import MultiConn, ConnHeader, TeamworkCredentials
+
+conn = MultiConn()
+
+# Open a project using a connection header
+conn_header = ConnHeader.from_dict(saved_header_data)
+port = conn.open_project.from_header(conn_header)
+
+# For teamwork projects, you can provide credentials
+credentials = TeamworkCredentials("username", "password")
+port = conn.open_project.with_teamwork_credentials(conn_header, credentials)
+```
+
+### Dialog Handling
+
+MultiConn can automatically handle most dialog windows that appear when opening ArchiCAD projects. This is particularly useful for batch operations and automation scripts.
+
+```python
+from multiconn_archicad import MultiConn, WinDialogHandler, win_int_handler_factory
+
+# Create a MultiConn instance with a dialog handler
+conn = MultiConn(dialog_handler=WinDialogHandler(win_int_handler_factory))
+
+# Dialog windows will be automatically handled when opening projects
+conn.open_project.from_header(conn_header)
+```
+
+The current implementation includes:
+- `EmptyDialogHandler`: Does nothing (default)
+- `WinDialogHandler`: Waits for ArchiCAD to start, and monitors appearing dialogs. If dialog appears, searches for appropriate handler in win_int_handler factory. Only works on windows.
+- `win_int_handler_factory`: Provides dialog handleing logic on a dialog by dialog basis for the INT language version. It is an example you should customize for your specific project needs. Even if you end up not modifying it, you should definitely know what it does for what dialog.
+
+### Serialization
+
+The MultiConn package allows you to save and load connection configurations, making it easier to work with specific projects across multiple sessions.
+
+#### Saving Connection Headers
+
+```python
+from multiconn_archicad import MultiConn, Port
+
+conn = MultiConn()
+conn.connect.all()
+
+# Get a connection header
+conn_header = conn.open_port_headers[Port(19723)]
+
+# Convert to dictionary for serialization
+header_dict = conn_header.to_dict()
+
+# Save to file using your preferred method
+import json
+with open('conn_header.json', 'w') as f:
+    json.dump(header_dict, f)
+```
+
+#### Loading Connection Headers
+
+```python
+from multiconn_archicad import ConnHeader, TeamworkCredentials
+
+# Load from file
+import json
+with open('conn_header.json', 'r') as f:
+    header_dict = json.load(f)
+
+# Create a header from the dictionary
+conn_header = ConnHeader.from_dict(header_dict)
+
+# For teamwork projects, you need to provide credentials
+if isinstance(conn_header.archicad_id, TeamworkProjectID):
+    credentials = TeamworkCredentials("username", "password")
+    # Use the credentials when opening the project
+    port = conn.open_project.with_teamwork_credentials(conn_header, credentials)
+```
+
+Note: Passwords are not stored in serialized connection headers for security reasons. You must provide them when loading teamwork projects.
+
+### Running Commands
+
+#### Single Archicad Instance
+
+To run commands on one chosen ArchiCAD instance the `MultiConn` object has a connection called `primary`. Calling a command directly from the MultiConn object will send it to the `primary` instance. The `primary` connection can be changed by assigning any valid `Port`, or `ConnHeader` object to `MultiConn.primary`.
+
+#### Example: Running Commands on a Single Archicad Instance
+```python
+from multiconn_archicad import MultiConn, Port
+
+# After instantiation the primary connection will be the instance with the lowest port number (probably 19723)
+conn = MultiConn()
+
+# Set the primary connection to the instance running on port 19725
+conn.primary = Port(19725)
+
+# Prints project info from the instance on port 19725
+print(conn.core.post_tapir_command("GetProjectInfo"))
+```
+
+#### Multiple Archicad Instances
+
+The MultiConn object stores references to `ConnHeaders` for all open ports (ports, with a running ArchiCAD instance). The references are stored in a dictionary at `.open_port_headers`. This dictionary maps each port to its corresponding connection. Each `ConnHeader` object has its own command objects for each used command namespace. The MultiConn objects has properties to access 3 subsets of open ports based on the status of the `ConnHeaders`: 
+
+- **`active`**: Successfully connected instances.
+- **`failed`**: Instances where the connection attempt failed.
+- **`pending`**: Instances with no connection attempt made or disconnected.
+
+#### Example: Running Commands on Multiple Archicad Instances
+
+```python
+from multiconn_archicad import MultiConn
+
+conn = MultiConn()
+conn.connect.all()
+
+# Explicit loop to gather elements from all active connections
+elements = {}
+for port, conn_header in conn.active.items():
+    elements[port] = conn_header.standard.commands.GetAllElements()
+
+# Using dictionary comprehension
+elements = {
+    port: conn_header.standard.commands.GetAllElements()
+    for port, conn_header in conn.active.items()
+}
+```
+
+### Namespaces
+
+The aim of the module is to incorporate all solutions that let users automate ArchiCAD from python. The different solutions are separated into namespaces, accessed from properties of the connection object. One of the planned features is letting users supply a list of namespaces they want to use when creating the connections. At the moment there are only two namespaces:
+
+- **`standard`**: The official ArchiCAD python wrapper
+- **`core`**: A simple JSON based module that lets the users post official and tapir commands based on Tapir's ["aclib"](https://github.com/ENZYME-APD/tapir-archicad-automation/tree/main/archicad-addon/Examples/aclib)
+
+#### Example: Using two namespaces together
+```python
+def run(conn: MultiConn | ConnHeader) -> dict[str, Any]:
+    elements = conn.standard.commands.GetAllElements()
+    command_parameters = {
+        "elements": [element.to_dict() for element in elements],
+        "highlightedColors": [[50, 255, 100, 100] for _ in range(len(elements))],
+        "wireframe3D": True,
+        "nonHighlightedColor": [0, 0, 255, 128],
+    }
+    return conn.core.post_tapir_command('HighlightElements', command_parameters)
+```
+
+## Contributing
+
+Contributions are welcome! Feel free to submit issues, feature requests, or pull requests to help improve MultiConn ArchiCAD.
+
+## License
+
+This project is licensed under the MIT License. See the LICENSE file for details.

multiconn_archicad-0.2.0/pyproject.toml

@@ -0,0 +1,54 @@
+[project]
+name = "multiconn_archicad"
+version = "0.2.0"
+description = "MultiConn ArchiCAD is a connection object for ArchiCAD’s JSON API and its Python wrapper, designed to manage multiple open instances of ArchiCAD simultaneously."
+readme = "README.md"
+authors = [
+    { name = "SzamosiMate", email = "szamimate@yahoo.com" }
+]
+requires-python = ">=3.12"
+dependencies = [
+    "aiohttp>=3.11.11",
+    "archicad>=28.3000",
+    "psutil>=6.1.1",
+    "pywinauto>=0.6.9",
+]
+
+[project.optional-dependencies]
+dialog-handlers = [
+    "pywinauto>=0.6.9",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+[tool.hatch.build.targets.sdist]
+include = [
+  "pkg/*.py",
+  "/src",
+]
+
+[dependency-groups]
+dev = [
+    "mypy>=1.14.0",
+    "pytest>=8.3.4",
+    "ruff>=0.8.4",
+]
+
+[[tool.mypy.overrides]]
+module = ["archicad.versioning",
+          "archicad.connection",
+          "archicad.releases",
+          "pywinauto",
+          "pywinauto.controls.uiawrapper",
+          "psutil"]
+follow_untyped_imports = true
+
+[tool.ruff]
+line-length = 120
+
+[tool.ruff.format]
+indent-style = "space"
+quote-style = "double"
+line-ending = "lf"
+docstring-code-format = true

multiconn_archicad-0.2.0/src/multiconn_archicad/__init__.py

@@ -0,0 +1,43 @@
+from .multi_conn import MultiConn
+from .conn_header import ConnHeader
+from .basic_types import (
+    ArchiCadID,
+    TeamworkProjectID,
+    SoloProjectID,
+    UntitledProjectID,
+    TeamworkCredentials,
+    ProductInfo,
+    ArchicadLocation,
+    Port,
+    APIResponseError,
+    FromAPIResponse,
+)
+from .standard_connection import StandardConnection
+from .core_commands import CoreCommands
+from .dialog_handlers import (
+    DialogHandlerBase,
+    WinDialogHandler,
+    win_int_handler_factory,
+    UnhandledDialogError,
+)
+
+__all__: tuple[str, ...] = (
+    "MultiConn",
+    "ConnHeader",
+    "ArchiCadID",
+    "APIResponseError",
+    "FromAPIResponse",
+    "ProductInfo",
+    "Port",
+    "StandardConnection",
+    "CoreCommands",
+    "TeamworkCredentials",
+    "DialogHandlerBase",
+    "WinDialogHandler",
+    "win_int_handler_factory",
+    "UnhandledDialogError",
+    "TeamworkProjectID",
+    "SoloProjectID",
+    "UntitledProjectID",
+    "ArchicadLocation",
+)

multiconn_archicad-0.2.0/src/multiconn_archicad/actions/__init__.py

@@ -0,0 +1,12 @@
+from .connection_manager import Connect, QuitAndDisconnect, Disconnect
+from .project_handler import FindArchicad, OpenProject
+from .refresh import Refresh
+
+__all__: tuple[str, ...] = (
+    "Connect",
+    "Disconnect",
+    "QuitAndDisconnect",
+    "Refresh",
+    "FindArchicad",
+    "OpenProject",
+)

multiconn_archicad-0.2.0/src/multiconn_archicad/actions/connection_manager.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from multiconn_archicad.conn_header import ConnHeader
+    from multiconn_archicad.multi_conn import MultiConn
+    from multiconn_archicad.basic_types import Port
+
+
+class ConnectionManager(ABC):
+    def __init__(self, multi_conn: MultiConn):
+        self.multi_conn: MultiConn = multi_conn
+
+    def from_ports(self, *args: Port) -> list[ConnHeader]:
+        return self.execute_action(
+            [
+                self.multi_conn.open_port_headers[port]
+                for port in args
+                if port in self.multi_conn.open_port_headers.keys()
+            ]
+        )
+
+    def from_headers(self, *args: ConnHeader) -> list[ConnHeader]:
+        return self.execute_action([*args])
+
+    def all(self) -> list[ConnHeader]:
+        return self.execute_action(list(self.multi_conn.open_port_headers.values()))
+
+    @abstractmethod
+    def execute_action(self, conn_headers: list[ConnHeader]) -> list[ConnHeader]: ...
+
+
+class Connect(ConnectionManager):
+    def execute_action(self, conn_headers: list[ConnHeader]) -> list[ConnHeader]:
+        for conn_header in conn_headers:
+            print(f"connecting {conn_header.product_info}")
+            conn_header.connect()
+        return conn_headers
+
+    def failed(self) -> None:
+        self.execute_action(list(self.multi_conn.failed.values()))
+
+
+class Disconnect(ConnectionManager):
+    def execute_action(self, conn_headers: list[ConnHeader]) -> list[ConnHeader]:
+        for conn_header in conn_headers:
+            conn_header.disconnect()
+        return conn_headers
+
+
+class QuitAndDisconnect(ConnectionManager):
+    def execute_action(self, conn_headers: list[ConnHeader]) -> list[ConnHeader]:
+        for conn_header in conn_headers:
+            if conn_header.port:
+                conn_header.core.post_tapir_command("QuitArchicad")
+                self.multi_conn.open_port_headers.pop(conn_header.port)
+            conn_header.unassign()
+        return conn_headers