c-two 0.1.0__tar.gz

c_two-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 world-in-progress
+
+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.

c_two-0.1.0/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.3
+Name: c-two
+Version: 0.1.0
+Summary: A python server to support IPC between CRM and Component processes.
+License: MIT
+Author: YcSoku
+Author-email: dsssyc02@gmail.com
+Requires-Python: >=3.12
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Description-Content-Type: text/markdown
+
+# C-Two
+
+<p align="center">
+<img align="center" width="150px" src="https://raw.githubusercontent.com/world-in-progress/c-two/main/doc/images/logo.png">
+</p>
+
+C-Two (C.C.) is a python server to support IPC between CRM and Component processes.
+

c_two-0.1.0/README.md

@@ -0,0 +1,7 @@
+# C-Two
+
+<p align="center">
+<img align="center" width="150px" src="https://raw.githubusercontent.com/world-in-progress/c-two/main/doc/images/logo.png">
+</p>
+
+C-Two (C.C.) is a python server to support IPC between CRM and Component processes.

c_two-0.1.0/pyproject.toml

@@ -0,0 +1,17 @@
+[project]
+name = "c-two"
+version = "0.1.0"
+description = "A python server to support IPC between CRM and Component processes."
+authors = [
+    {name = "YcSoku",email = "dsssyc02@gmail.com"}
+]
+license = {text = "MIT license"}
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+]
+
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"

c_two-0.1.0/src/c_two/__init__.py

@@ -0,0 +1,116 @@
+import os
+import sys
+import subprocess
+
+class CRMServer:
+    def __init__(self, crm_module: str, crm_class: str, poetry_env_path: str):
+        self.crm_module = crm_module
+        self.crm_class = crm_class
+        self.crm_proc = self._start_crm(crm_module, crm_class, poetry_env_path)
+        self.component_proc_map: dict[str, subprocess.Popen] = {}
+
+    def _start_crm(self, crm_module: str, crm_class: str, poetry_env_path: str) -> subprocess.Popen:
+        """Start the CRM service in a separate process using Poetry environment."""
+        python_path = os.path.join(poetry_env_path, "bin", "python" if sys.platform != "win32" else "Scripts", "python.exe")
+        if not os.path.exists(python_path):
+            raise FileNotFoundError(f"Poetry Python executable not found at {python_path}")
+        
+        cmd = [python_path, "-m", "c_two.service", crm_module, crm_class]
+        proc = subprocess.Popen(
+            cmd,
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            bufsize=0
+        )
+        # Check if process started successfully
+        if proc.poll() is not None:
+            error = proc.stderr.read().decode().strip()
+            raise RuntimeError(f"Failed to start CRM process: {error}")
+        return proc
+
+    def _start_component(self, component_path: str, component_args: list[str] = None) -> subprocess.Popen:
+        """Start the component script in a separate process with optional arguments."""
+        cmd = [sys.executable, component_path]
+        if component_args:
+            cmd.extend(component_args)
+        env = os.environ.copy()
+        proc = subprocess.Popen(
+            cmd,
+            env=env,
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            bufsize=0
+        )
+        if proc.poll() is not None:
+            error = proc.stderr.read().decode().strip()
+            raise RuntimeError(f"Failed to start Component process: {error}")
+        return proc
+
+    def invoke_component(self, uuid: str, component_path: str, component_args: list[str] = None) -> tuple[bool, str, str]:
+        """Start a Component process, wait for it to finish, and return its result."""
+        if uuid in self.component_proc_map:
+            raise ValueError(f"Component with UUID {uuid} already running")
+        
+        component_proc = self._start_component(component_path, component_args)
+        component_proc.__crm_process__ = self.crm_proc
+        self.component_proc_map[uuid] = component_proc
+
+        # Wait for Component to finish and capture output
+        component_proc.wait()
+        stdout_output = component_proc.stdout.read().decode().strip()
+        stderr_output = component_proc.stderr.read().decode().strip()
+        
+        # Clean up Component resources
+        component_proc.stdin.close()
+        component_proc.stdout.close()
+        component_proc.stderr.close()
+        del self.component_proc_map[uuid]
+        
+        return component_proc.returncode == 0, stderr_output, stdout_output
+
+    def stop(self):
+        """Stop the CRM and any running Component processes gracefully."""
+        if self.crm_proc and self.crm_proc.poll() is None:
+            self.crm_proc.terminate()
+            try:
+                self.crm_proc.wait(timeout=5)
+                print("CRM process gracefully stopped.")
+            except subprocess.TimeoutExpired:
+                self.crm_proc.kill()
+                print("CRM process forcibly killed.")
+            finally:
+                self.crm_proc.stdin.close()
+                self.crm_proc.stdout.close()
+                self.crm_proc.stderr.close()
+        
+        for uuid, comp_proc in list(self.component_proc_map.items()):
+            if comp_proc.poll() is None:
+                comp_proc.terminate()
+                try:
+                    comp_proc.wait(timeout=5)
+                    print(f"Component {uuid} gracefully stopped.")
+                except subprocess.TimeoutExpired:
+                    comp_proc.kill()
+                    print(f"Component {uuid} forcibly killed.")
+                finally:
+                    comp_proc.stdin.close()
+                    comp_proc.stdout.close()
+                    comp_proc.stderr.close()
+            del self.component_proc_map[uuid]
+
+# Helper ##################################################
+def get_poetry_env_path(crm_project_path: str) -> str:
+    """Get the Poetry virtual environment path for the CRM project."""
+    try:
+        result = subprocess.run(
+            ["poetry", "env", "info", "--path"],
+            cwd=crm_project_path,
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        return result.stdout.strip()
+    except subprocess.CalledProcessError:
+        raise RuntimeError("Poetry not installed or CRM project path invalid")

c_two-0.1.0/src/c_two/client.py

@@ -0,0 +1,45 @@
+import subprocess
+import pickle
+import sys
+
+class CRMClient:
+    def __init__(self):
+        self.process: subprocess.Popen = sys.modules['__main__'].__crm_process__
+        if self.process.poll() is not None:
+            raise RuntimeError("CRM process is not running")
+
+    def _send_request(self, request_type: str, data):
+        """Send a request to the CRM service and get the response synchronously."""
+        if self.process.poll() is not None:
+            raise RuntimeError("CRM process has terminated unexpectedly")
+        
+        # Send request
+        request = pickle.dumps((request_type, data))
+        self.process.stdin.write(request + b'\n')
+        self.process.stdin.flush()
+        
+        # Wait for response synchronously
+        response = self.process.stdout.readline()
+        if not response:  # EOF or process closed stdout
+            raise RuntimeError("CRM process closed communication unexpectedly")
+        
+        status, result = pickle.loads(response)
+        if status == "ERROR":
+            raise RuntimeError(f"CRM error: {result}")
+        return result
+
+    def create(self, *args, **kwargs):
+        """Create a CRM instance with arbitrary arguments."""
+        self._send_request("CREATE", (args, kwargs))
+
+    def call(self, method_name: str, *args, **kwargs):
+        """Call a method on the CRM instance."""
+        return self._send_request("CALL", (method_name, (args, kwargs)))
+
+    def stop(self):
+        """Stop the CRM process."""
+        self._send_request("STOP", None)
+        self.process.wait()
+        self.process.stdin.close()
+        self.process.stdout.close()
+        self.process.stderr.close()

c_two-0.1.0/src/c_two/service.py

@@ -0,0 +1,43 @@
+import sys
+import pickle
+import importlib
+
+def run_crm_service(impl_module: str, impl_class: str):
+    """CRM service running in a separate process."""
+    module = importlib.import_module(impl_module)
+    crm_class = getattr(module, impl_class)
+    crm = None
+    
+    while True:
+        request = sys.stdin.buffer.readline()
+        if not request:
+            break
+        
+        try:
+            request_type, data = pickle.loads(request.strip())
+            
+            if request_type == 'STOP':
+                break
+            
+            if request_type == "CREATE":
+                args, kwargs = data
+                crm = crm_class(*args, **kwargs)
+                response = ("SUCCESS", None)
+            
+            elif request_type == "CALL":
+                if crm is None:
+                    response = ("ERROR", "CRM not initialized")
+                else:
+                    method_name, args, kwargs = data
+                    method = getattr(crm, method_name)
+                    result = method(*args, **kwargs)
+                    response = ("SUCCESS", result)
+            
+            else:
+                response = ("ERROR", "Unknown request type")
+            
+        except Exception as e:
+            response = ("ERROR", str(e))
+        
+        sys.stdout.buffer.write(pickle.dumps(response))
+        sys.stdout.buffer.flush()