js7-client-python 2.0.1__py3-none-any.whl

js7/model/public/client/filter/tasks_filter.py

@@ -0,0 +1,50 @@
+from datetime import datetime
+from typing import List, Literal, Optional
+from pydantic import BaseModel
+
+from .....model.public.client.filter.element.folder import Folder
+
+
+class TasksFilter(BaseModel):
+    date_from: Optional[datetime] = None
+    """Filters items starting from a date."""
+    
+    date_to: Optional[datetime] = None
+    """Filters items ending before a date."""
+    
+    completed_date_from: Optional[datetime] = None
+    """Filters items starting from a date."""
+    
+    completed_date_to: Optional[datetime] = None
+    """Filters items ending before a date."""
+    
+    job_name: Optional[str] = None
+    """
+    Limits result to a specified glob pattern of a Job name that supports '*' and '?' as wildcards where
+    - '*' : match zero or more characters
+    - '?' : match any single character
+    """
+    
+    workflow_name: Optional[str] = None
+    """
+    Limits result to a specified glob pattern of a Workflow name that supports '*' and '?' as wildcards where
+    - '*' : match zero or more characters
+    - '?' : match any single character
+    """
+    
+    workflow_paths: Optional[str] = None
+    """
+    Limits result to a specified glob pattern of a Workflow path that supports '*' and '?' as wildcards where
+    - '*' : match zero or more characters
+    - '?' : match any single character
+    """
+    
+    folders: Optional[List[Folder]] = None
+    """Limits the result to a collection of folders."""
+    
+    history_states: Optional[List[Literal["FAILED", "INCOMPLETE", "SUCCESSFUL"]]] = None
+    """Limits result to specified states."""
+    
+    criticalities: Optional[List[Literal["CRITICAL", "NORMAL"]]] = None
+    """Possible values are NORMAL and NORMAL Only records with these criticalities are responsed."""
+

js7/model/public/client/input/__init__.py

@@ -0,0 +1,2 @@
+from .add_order import Order, PlanID
+__all__ = ["Order", "PlanID"]

js7/model/public/client/input/add_order.py

@@ -0,0 +1,50 @@
+from typing import Any, Dict, List, Optional, Union
+from pydantic import BaseModel
+
+from .....model.public.client.common.schedule_time import ScheduleTime
+
+from ..enum.order_priority import OrderPriority
+
+
+class PlanID(BaseModel):    
+    notice_space_key: str
+    """Schema ID of a plan, e.g. 'DailyPlan'."""
+    
+    plan_schema_id: str
+    """Plan key of the plan."""
+
+
+class Order(BaseModel):
+    arguments: Optional[Dict[str, Any]] = None
+    """An object with key-value pairs. The value can be a string, number or boolean."""
+
+    block_position: Optional[Union[List[Union[int, str]], str]] = None
+    """The order runs only inside the specified block instruction. The position can also be specified by the label of the block instruction."""
+    
+    end_positions: Optional[List[Union[List[Union[int, str]], str]]] = None
+    """The order ends on one of these positions. The position can also be specified by the label of the instruction."""
+
+    force_job_admission: bool = False
+    """If true then any admission times at a Job instruction will be ignored."""
+    
+    open_closed_plan: bool = False
+    """If true then a closed plan will be reopen automatically."""
+    
+    order_name: Optional[str]
+    """`order_name` is only a part of the `order_id` in the form "#<date>#T<uniqueId>-<orderName>"."""
+    
+    plan_id: Optional[PlanID] = None
+    
+    priority: Optional[Union[OrderPriority, int]] = None
+    """Priority of the order."""
+    
+    scheduled_for: Optional[ScheduleTime] = None
+    """Sets the start time of the order execution."""
+
+    start_position: Optional[Union[List[Union[int, str]], str]] = None
+    """The order starts with the first instruction per default. The position can also be specified by the label of the instruction."""
+
+    tags: Optional[List[str]] = None
+
+    workflow_path: str
+    """e. g. `/folder/my-workflow`"""

js7/service/http_service.py

@@ -0,0 +1,206 @@
+import gzip
+import mimetypes
+from pathlib import Path
+import http.client, ssl, time
+from typing import Callable, Optional, Union, Dict
+from ssl import SSLContext
+import uuid
+
+from ..model.configuration.http_configuration import HTTPConfiguration
+
+
+class HTTPService:
+    """
+    Functionality:
+    - Uses `time.monotonic` to obtain a monotonically increasing time source and
+    avoid issues caused by system time changes (e.g. daylight saving time)
+    - Closes the connection to the server after 30 seconds of inactivity and reopen the connection after the next use again.
+    """
+    
+    IDLE_TIMEOUT = 30 # Reconnects after 30 seconds of inactivity
+    
+    def __init__(
+        self, 
+        *, 
+        configuration: HTTPConfiguration,
+        response_validator: Optional[Callable[[str, int, bytes], None]] = None
+    ):
+    
+        self._config = configuration
+        self._response_validator = response_validator
+        
+        self._conn: Union[http.client.HTTPSConnection, http.client.HTTPConnection, None] = None
+        self._https_ctx: Optional[SSLContext] = None
+        self._last_used: float = 0.0
+
+        # These variables can be modified at runtime by other methods to adjust the SSL context
+        self.auth_certfile_path: Optional[Union[Path, str]] = None
+        self.auth_keyfile_path:  Optional[Union[Path, str]] = None
+        
+    def __enter__(self):
+        self._ensure_connection()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):  # type: ignore
+        if exc_type is not None:
+            self.close()
+
+    def _ensure_connection(self):
+        now = time.monotonic()
+        if self._conn is None or (now - self._last_used) > self.IDLE_TIMEOUT:
+            self._open_connection()
+    
+    # Creates the context for the ssl connection
+    def _create_ssl_context(self) -> SSLContext:
+        if self._https_ctx:
+            return self._https_ctx
+        
+        ctx = ssl.create_default_context(ssl.Purpose.SERVER_AUTH)
+
+        # Sets fixed tls version
+        ctx.minimum_version = ssl.TLSVersion.TLSv1_2
+        
+        # Optional: Server Certificate
+        if self._config.cafile_path:
+            ctx.load_verify_locations(cafile=self._config.cafile_path)
+
+        # Optional: Client certificate
+        if self.auth_certfile_path and not self.auth_keyfile_path:
+            raise ValueError("client certificate provided without private key")
+        
+        if self.auth_certfile_path and self.auth_keyfile_path:
+            ctx.load_cert_chain(
+                certfile=self.auth_certfile_path,
+                keyfile=self.auth_keyfile_path
+            )
+
+        # Ensures security
+        ctx.verify_mode = ssl.CERT_REQUIRED
+        ctx.check_hostname = True
+        self._https_ctx = ctx
+        return self._https_ctx
+
+    def _open_connection(self):
+        self.close()
+        
+        if self._config.ssl:
+            self._conn = http.client.HTTPSConnection(
+                host=self._config.host,
+                port=self._config.port,
+                timeout=30,
+                context=self._create_ssl_context()
+            )
+        else:
+            self._conn = http.client.HTTPConnection(
+                host=self._config.host, 
+                port=self._config.port, 
+                timeout=30
+            )
+        
+        self._last_used = time.monotonic()
+
+    def _request(self, method: str, path: str, headers: Dict[str, str], body: Optional[str]) -> http.client.HTTPResponse:
+        self._ensure_connection()
+        
+        conn = self._conn
+        if conn is None:
+            raise RuntimeError("Connection not initialized.")
+        
+        response: Optional[http.client.HTTPResponse] = None
+        
+        # Reconnects and retries the request once on connection failure
+        try:
+            conn.request(method=method, url=path, body=body, headers=headers)
+            response = conn.getresponse()
+        except (BrokenPipeError, ConnectionResetError, TimeoutError):
+            self.close()
+            
+            time.sleep(3) # Waits for 3 seconds
+            
+            self._open_connection()
+            conn = self._conn
+            if conn is None:
+                raise RuntimeError("Connection not initialized after reconnect.")
+            conn.request(method=method, url=path, body=body, headers=headers)
+            response = conn.getresponse()
+        
+        return response
+    
+    def _decode_response(self, path:str, response: http.client.HTTPResponse) -> bytes:
+        raw_bytes = response.read()
+        
+        # Raises a error for the given statuscode
+        if self._response_validator:
+            self._response_validator(path, response.status, raw_bytes)
+        
+        if "gzip" in (response.headers.get("Content-Encoding", "")).lower():
+            return gzip.decompress(raw_bytes)
+        
+        return raw_bytes
+    
+    # (i) close method
+    def close(self):
+        if self._conn:
+            self._conn.close()
+            self._conn = None
+            self._https_ctx = None
+        
+    # (i) POST method
+    def post(self, path: str, body: Optional[str], headers: Dict[str, str]) -> bytes:
+        response = self._request("POST", path, headers, body)
+        return self._decode_response(path, response)
+    
+    # (i) GET method
+    def get(self, path: str, headers: Dict[str, str]) -> bytes:
+        response = self._request(method="GET", path=path, headers=headers, body=None)
+        return self._decode_response(path, response)
+    
+    # (i) Upload file
+    def upload_file(self, path: str, access_token: str, file: bytes, filename: str, form_fields: Optional[Dict[str, str]] = None) -> bytes:
+        self._ensure_connection()
+        conn = self._conn
+        if conn is None:
+            raise RuntimeError("Connection not initialized.")
+
+        boundary = "----Boundary" + uuid.uuid4().hex
+        content_type = mimetypes.guess_type(filename)[0] or "application/octet-stream"
+
+        body = bytearray()
+
+        def add_field(name: str, value: str) -> None:
+            body.extend(f"--{boundary}\r\n".encode())
+            body.extend(
+                f'Content-Disposition: form-data; name="{name}"\r\n\r\n'.encode()
+            )
+            body.extend(value.encode("utf-8"))
+            body.extend(b"\r\n")
+
+        # optional form fields first
+        if form_fields:
+            for k, v in form_fields.items():
+                add_field(k, v)
+
+        # file part
+        body.extend(f"--{boundary}\r\n".encode())
+        body.extend(
+            (
+                f'Content-Disposition: form-data; name="file"; filename="{filename}"\r\n'
+                f"Content-Type: {content_type}\r\n\r\n"
+            ).encode()
+        )
+        body.extend(file)
+        body.extend(b"\r\n")
+
+        # closing boundary
+        body.extend(f"--{boundary}--\r\n".encode())
+
+        headers = {
+            "Content-Type": f"multipart/form-data; boundary={boundary}",
+            "Content-Length": str(len(body)),
+            "X-Access-Token": access_token,
+        }
+
+        conn.request("POST", path, body=body, headers=headers)
+        response = conn.getresponse()
+
+        return self._decode_response(path=path, response=response)

js7/util/bytes_converter/bytes_to_archive_bytes.py

@@ -0,0 +1,52 @@
+from typing import List, Literal, Tuple
+from io import BytesIO
+import zipfile
+import tarfile
+import posixpath
+
+
+def bytes_to_archive_bytes(
+    *,
+    archive_format: Literal["ZIP", "TAR_GZ"],
+    files: List[Tuple[str, bytes]],  # path, content bytes
+) -> bytes:
+
+    # Validate: archive_format
+    if archive_format not in ("ZIP", "TAR_GZ"):
+        raise ValueError("'archive_format' must be 'ZIP' or 'TAR_GZ'.")
+
+    # Validate: files
+    if not files:
+        raise ValueError("'files' is required.")
+
+    for path, content in files:
+        if not path:
+            raise ValueError("File path must not be empty.")
+
+        if not content:
+            raise ValueError("File content must not be empty.")
+
+    # Normalize paths (no leading slash, POSIX-style)
+    normalized_files = [
+        (posixpath.normpath(path.lstrip("/")), bytes(content))
+        for path, content in files
+    ]
+
+    buffer = BytesIO()
+
+    # Build: ZIP 
+    if archive_format == "ZIP":
+        with zipfile.ZipFile(buffer, mode="w", compression=zipfile.ZIP_DEFLATED) as zf:
+            for path, content in normalized_files:
+                zf.writestr(path, content)
+
+    # Build: TAR.GZ
+    elif archive_format == "TAR_GZ":
+        with tarfile.open(fileobj=buffer, mode="w:gz") as tf:
+            for path, content in normalized_files:
+                info = tarfile.TarInfo(name=path)
+                info.size = len(content)
+                tf.addfile(info, BytesIO(content))
+
+    buffer.seek(0)
+    return buffer.read()

js7/util/bytes_converter/bytes_to_file.py

@@ -0,0 +1,12 @@
+from pathlib import Path
+
+
+def bytes_to_file(*, data: bytes, out_path: Path) -> bool:
+    """out_path: /my-file.zip"""
+    
+    try:
+        out_path.parent.mkdir(parents=True, exist_ok=True)
+        out_path.write_bytes(data)
+        return True
+    except OSError:
+        return False

js7/util/bytes_converter/files_to_bytes.py

@@ -0,0 +1,52 @@
+from pathlib import Path
+from typing import List, Optional, Tuple
+
+
+def files_to_bytes(
+    *,
+    file_path: Path,
+    filter_suffixes: Optional[List[str]] = None,
+) -> List[Tuple[str, bytes]]:
+    """
+    Reads a file or directory into memory.
+
+    Input:
+        - file: File or directory to read from.
+        - filter_suffixes: If set, only files with one of these suffixes (e.g. [".json", ".yaml"]) are included.
+
+    Result:
+        - List of (relative_posix_path, file_content_bytes).
+    """
+
+    if not file_path.exists():
+        raise ValueError(f"File path does not exist: {file_path}")
+
+    # Normalize filter suffixes
+    suffixes: Optional[Tuple[str, ...]] = (
+        tuple(filter_suffixes) if filter_suffixes else None
+    )
+
+    result: List[Tuple[str, bytes]] = []
+
+    def is_allowed(path: Path) -> bool:
+        return suffixes is None or path.name.endswith(suffixes)
+
+    if file_path.is_dir():
+        for p in file_path.rglob("*"):
+            if not p.is_file():
+                continue
+
+            if not is_allowed(p):
+                continue
+
+            relative_path = p.relative_to(file_path).as_posix()
+            result.append((relative_path, p.read_bytes()))
+
+    elif file_path.is_file():
+        if is_allowed(file_path):
+            result.append((file_path.name, file_path.read_bytes()))
+
+    else:
+        raise ValueError(f"Invalid file input: {file_path}")
+
+    return result

js7/util/bytes_converter/read_bytes_archive_files_to_bytes.py

@@ -0,0 +1,69 @@
+from typing import List, Optional, Tuple
+import zipfile
+import tarfile
+from io import BytesIO
+
+from ..detect_archive_type import detect_archive_type
+
+
+def read_bytes_archive_files_to_bytes(
+    file: bytes,
+    filter_suffixes: Optional[List[str]] = None
+) -> Optional[List[Tuple[str, bytes]]]:
+    """Returns POSIX path and file as bytes or None if not an archive or no files found."""
+
+    if not file:
+        return None
+
+    archive_type = detect_archive_type(file)
+    if archive_type is None:
+        return None
+
+    # Normalize suffix filter
+    suffixes = None
+    if filter_suffixes:
+        suffixes = tuple(s.lower() for s in filter_suffixes)
+
+    result: List[Tuple[str, bytes]] = []
+
+    # ZIP
+    if archive_type == "ZIP":
+        try:
+            with zipfile.ZipFile(BytesIO(file), "r") as zf:
+                for info in zf.infolist():
+                    if info.is_dir():
+                        continue
+
+                    posix_path = info.filename.replace("\\", "/")
+
+                    if suffixes and not posix_path.lower().endswith(suffixes):
+                        continue
+
+                    data = zf.read(info)
+                    result.append((posix_path, data))
+        except (zipfile.BadZipFile, OSError):
+            return None
+
+    # TAR.GZ
+    elif archive_type == "TAR_GZ":
+        try:
+            with tarfile.open(fileobj=BytesIO(file), mode="r:gz") as tf:
+                for member in tf.getmembers():
+                    if not member.isfile():
+                        continue
+
+                    posix_path = member.name.replace("\\", "/")
+
+                    if suffixes and not posix_path.lower().endswith(suffixes):
+                        continue
+
+                    extracted = tf.extractfile(member)
+                    if extracted is None:
+                        continue
+
+                    data = extracted.read()
+                    result.append((posix_path, data))
+        except (tarfile.TarError, OSError):
+            return None
+
+    return result or None

js7/util/bytes_converter/sign_to_bytes.py

@@ -0,0 +1,106 @@
+from pathlib import Path
+from typing import List, Optional, Tuple, Union
+import base64
+
+from cryptography.hazmat.primitives import hashes, serialization
+from cryptography.hazmat.primitives.asymmetric import padding, rsa, ec
+from cryptography.exceptions import InvalidSignature
+from cryptography.hazmat.primitives.asymmetric.types import PublicKeyTypes
+
+from cryptography.hazmat.backends import default_backend
+
+
+def _verify_signature(
+    *,
+    data: bytes,
+    signature: bytes,
+    public_key: Union[rsa.RSAPublicKey, ec.EllipticCurvePublicKey],
+    hash_alg: hashes.HashAlgorithm,
+) -> bool:
+    try:
+        if isinstance(public_key, rsa.RSAPublicKey):
+            public_key.verify(
+                signature,
+                data,
+                padding.PKCS1v15(),
+                hash_alg,
+            )
+        else:
+            public_key.verify(
+                signature,
+                data,
+                ec.ECDSA(hash_alg),
+            )
+        return True
+    except InvalidSignature:
+        return False
+
+def sign_to_bytes(
+    *,
+    files: List[Tuple[str, bytes]],
+    private_key_file: Path,
+    public_key_file: Optional[Path],
+    key_password: Optional[bytes],
+    hash_alg: hashes.HashAlgorithm
+) -> List[Tuple[str, bytes]]:
+    
+    if not private_key_file or not hash_alg:
+        raise ValueError("'private_key_file' and 'hash_alg' is required")
+
+    # ---- load private key ----
+    with open(private_key_file, "rb") as f:
+        private_key = serialization.load_pem_private_key(
+            f.read(),
+            password=key_password,
+            backend=default_backend(),
+        )
+
+    if not isinstance(private_key, (rsa.RSAPrivateKey, ec.EllipticCurvePrivateKey)):
+        raise TypeError("Only RSA and ECDSA private keys are supported")
+
+    # ---- load public key ----
+    public_key: Optional[PublicKeyTypes] = None
+
+    if public_key_file:
+        with open(public_key_file, "rb") as f:
+            public_key = serialization.load_pem_public_key(
+                f.read(),
+                backend=default_backend(),
+            )
+
+        if not isinstance(public_key, (rsa.RSAPublicKey, ec.EllipticCurvePublicKey)):
+            raise TypeError("Unsupported public key type.")
+
+    # ---- sign ----
+    result: List[Tuple[str, bytes]] = []
+
+    for path, data in files:
+        if isinstance(private_key, rsa.RSAPrivateKey):
+            signature = private_key.sign(
+                data,
+                padding.PKCS1v15(),
+                hash_alg,
+            )
+        else:
+            signature = private_key.sign(
+                data,
+                ec.ECDSA(hash_alg),
+            )
+
+        signature_b64_bytes = base64.b64encode(signature)
+        
+        sig_path = f"{path}.sig"
+        
+        # ---- optional verification ----
+        if public_key:
+            if not _verify_signature(
+                data=data,
+                signature=signature,
+                public_key=public_key,
+                hash_alg=hash_alg,
+            ):
+                raise ValueError(f"Signature verification failed for '{sig_path}'")
+
+        result.append((sig_path, signature_b64_bytes))
+
+    return result

js7/util/check_matching_version.py

@@ -0,0 +1,20 @@
+from typing import Tuple
+
+
+def _version_to_tuple(input: str) -> Tuple[int, int, int]:
+    try:
+        ep_major, ep_minor, ep_patch = input.split(".")
+        return int(ep_major), int(ep_minor), int(ep_patch)
+    except Exception as e:
+        raise ValueError(f"Invalid version string '{input}'. Error: {e}")
+            
+def check_matching_version(*, min: str, max: str, check: str) -> bool:
+    # Normalize to MAJOR.MINOR.PATCH
+    check = check.split("-", 1)[0]
+    check = ".".join(check.split(".")[:3])
+    
+    min_version:   Tuple[int, int, int] = _version_to_tuple(min)
+    max_version:   Tuple[int, int, int] = _version_to_tuple(max)
+    check_version: Tuple[int, int, int] = _version_to_tuple(check)
+
+    return min_version <= check_version <= max_version

js7/util/detect_archive_type.py

@@ -0,0 +1,37 @@
+from pathlib import Path
+from typing import Literal, Optional, Union
+
+
+def _detect_from_bytes(data: bytes) -> Optional[Literal["ZIP", "TAR_GZ"]]:
+    if len(data) < 4:
+        return None
+
+    # ZIP
+    if data.startswith((b"PK\x03\x04", b"PK\x05\x06", b"PK\x07\x08")):
+        return "ZIP"
+
+    # GZIP (tar.gz)
+    if data.startswith(b"\x1f\x8b"):
+        return "TAR_GZ"
+
+    return None
+
+
+def detect_archive_type(file: Union[bytes, Path]) -> Optional[Literal["ZIP", "TAR_GZ"]]:
+    """Detect archive type from raw bytes or file path using magic bytes."""
+
+    if isinstance(file, bytes):
+        return _detect_from_bytes(file)
+
+    if isinstance(file, Path):
+        if not file.exists() or not file.is_file():
+            return None
+
+        try:
+            with file.open("rb") as f:
+                head = f.read(4)
+            return _detect_from_bytes(head)
+        except OSError:
+            return None
+
+    return None

js7/util/str_converter/order_id_to_order_name.py

@@ -0,0 +1,5 @@
+from typing import Optional
+
+
+def order_id_to_order_name(s: Optional[str]) -> Optional[str]:
+    return s.rsplit("#", 1)[-1].split("-", 1)[1] if s and "-" in s else None