naas-abi-core 1.4.1__py3-none-any.whl

naas_abi_core/utils/String.py

@@ -0,0 +1,52 @@
+from urllib.parse import quote
+import hashlib
+import uuid
+from uuid import UUID
+import unicodedata
+import re
+
+def create_id_from_string(string: str) -> str:
+    """Create a URL-safe ID from a string.
+
+    Args:
+        string (str): Input string to convert
+
+    Returns:
+        str: URL-safe string with spaces replaced by hyphens
+    """
+    return quote(string.replace(" ", "-").lower(), safe="")
+
+def string_to_uuid(input_string: str) -> UUID:
+    """Convert a string to a UUID.
+
+    Args:
+        input_string (str): Input string to convert
+
+    Returns:
+        str: UUID
+    """
+    hash_object = hashlib.sha256(input_string.encode())
+    hex_hash = hash_object.hexdigest()
+    uuid_obj = uuid.UUID(hex_hash[:32])
+    return uuid_obj
+
+def create_hash_from_string(input_string: str) -> str:
+    """Convert a string to a UUID.
+
+    Args:
+        input_string (str): Input string to convert
+
+    Returns:
+        str: UUID
+    """
+    hash_object = hashlib.sha256(input_string.encode())
+    hex_hash = hash_object.hexdigest()
+    return hex_hash
+
+def normalize(text: str) -> str:
+    """Normalize text by removing accents, punctuation, and converting to lowercase."""
+    text = text.lower()
+    text = unicodedata.normalize('NFKD', text)
+    text = re.sub(r'[^\w\s]', '', text)
+    text = ''.join(c for c in text if not unicodedata.combining(c))
+    return text

naas_abi_core/utils/Workers.py

@@ -0,0 +1,114 @@
+import uuid
+from enum import Enum
+from queue import Empty, Queue
+from threading import Event, Lock, Thread
+from typing import Callable, List, Optional
+
+from naas_abi_core import logger
+
+
+class JobStatus(Enum):
+    PENDING = "pending"
+    RUNNING = "running"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    RESULT_FETCHED = "result_fetched"
+
+
+class Job:
+    def __init__(self, queue: Optional[Queue], func: Callable, *args, **kwargs):
+        self.id = str(uuid.uuid4())
+        self.queue = queue
+        self.func = func
+        self.args = args
+        self.kwargs = kwargs
+        self.status = JobStatus.PENDING
+        self.result = None
+        self.error = None
+        self._completion_event = Event()
+        self._lock = Lock()  # For thread-safe status updates
+
+    def execute(self):
+        """Execute the job - called by worker thread"""
+        with self._lock:
+            self.status = JobStatus.RUNNING
+
+        try:
+            self.result = self.func(*self.args, **self.kwargs)
+            with self._lock:
+                self.status = JobStatus.COMPLETED
+        except Exception as e:
+            self.error = e
+            import traceback
+
+            logger.error(f"Job {self.id} failed: {e}\n{traceback.format_exc()}")
+            with self._lock:
+                self.status = JobStatus.FAILED
+        finally:
+            self._completion_event.set()
+            if self.queue:
+                self.queue.put(self)
+
+    def wait(self, timeout: Optional[float] = None) -> bool:
+        """Wait for the job to complete"""
+        return self._completion_event.wait(timeout)
+
+    def is_completed(self) -> bool:
+        """Check if the job is completed (successfully or with failure)"""
+        return self.status in (JobStatus.COMPLETED, JobStatus.FAILED)
+
+    def get_result(self):
+        """Get the job result, raising any error that occurred"""
+        with self._lock:
+            self.status = JobStatus.RESULT_FETCHED
+
+        if self.error:
+            raise self.error
+
+        return self.result
+
+
+class WorkerPool:
+    def __init__(self, num_workers: int):
+        self.job_queue: Queue[Job] = Queue()
+        self.workers: List[Thread] = []
+        self.shutdown_event = Event()
+
+        # Start worker threads
+        for _ in range(num_workers):
+            worker = Thread(target=self._worker_loop)
+            worker.daemon = True
+            worker.start()
+            self.workers.append(worker)
+
+    def _worker_loop(self):
+        while not self.shutdown_event.is_set():
+            try:
+                # Get job from queue with timeout to check shutdown periodically
+                job = self.job_queue.get(timeout=1.0)
+                job.execute()
+                self.job_queue.task_done()
+            except Empty:
+                continue
+
+    def submit(self, job: Job):
+        """Submit a job to the worker pool"""
+        self.job_queue.put(job)
+
+    def submit_all(self, jobs: List[Job]) -> Queue[Job]:
+        """Submit multiple jobs to the worker pool"""
+        queue: Queue[Job] = Queue(maxsize=len(jobs))
+
+        for job in jobs:
+            if job.queue is None:
+                job.queue = queue
+            self.submit(job)
+
+        return queue
+
+    def shutdown(self):
+        """Shutdown the worker pool"""
+        logger.debug("Shutting down worker pool")
+        self.shutdown_event.set()
+        for worker in self.workers:
+            worker.join()

naas_abi_core/utils/onto2py/__init__.py

@@ -0,0 +1,10 @@
+"""
+TTL to Python converter
+
+Convert TTL (Turtle) files to Python Pydantic classes.
+"""
+
+from .onto2py import onto2py
+
+__version__ = "0.1.0"
+__all__ = ["onto2py"] 

naas_abi_core/utils/onto2py/__main__.py

@@ -0,0 +1,29 @@
+"""
+Main entry point for running onto2py as a module.
+
+Usage: python -m onto2py <ttl_file> <output_file>
+"""
+
+import sys
+from .onto2py import onto2py
+
+def main():
+    if len(sys.argv) < 3:
+        print("Usage: python -m onto2py <ttl_file> <output_file>")
+        sys.exit(1)
+    
+    # take a ttl file as input
+    ttl_file = sys.argv[1]
+    output_file = sys.argv[2]
+    
+    try:
+        python_code = onto2py(ttl_file)
+        with open(output_file, "w") as f:
+            f.write(python_code)
+        print(f"✅ Python code written to {output_file}")
+    except Exception as e:
+        print(f"❌ Error converting TTL file: {e}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()