albert 1.12.0__tar.gz → 1.13.0b1__tar.gz

{albert-1.12.0 → albert-1.13.0b1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: albert
-Version: 1.12.0
+Version: 1.13.0b1
 Summary: The official Python SDK for the Albert Invent platform.
 Project-URL: Homepage, https://www.albertinvent.com/
 Project-URL: Documentation, https://docs.developer.albertinvent.com/albert-python

{albert-1.12.0 → albert-1.13.0b1}/scripts/validate_version_bump.py

@@ -1,7 +1,6 @@
 import argparse
-import re
-import subprocess
 import sys
+from os import popen
 from pathlib import Path
 
 from packaging import version
@@ -20,15 +19,8 @@ def main(base_branch: str):
     local_path = Path(__file__).parents[1] / version_file
     local_version = extract_version(local_path.read_text())
 
-    if not re.fullmatch(r"[A-Za-z0-9._/-]+", base_branch) or base_branch.startswith("-"):
-        raise ValueError(f"Invalid base branch ref: {base_branch!r}")
-
-    subprocess.run(["git", "fetch", "origin"], check=True)
-    base_contents = subprocess.check_output(
-        ["git", "show", f"{base_branch}:{version_file}"],
-        text=True,
-    )
-    base_version = extract_version(base_contents)
+    with popen(f"git fetch origin && git show {base_branch}:{version_file}") as fh:
+        base_version = extract_version(fh.read())
 
     if is_version_bump(local_version, base_version):
         print(f"Version bump detected: {base_version} -> {local_version}")

{albert-1.12.0 → albert-1.13.0b1}/src/albert/__init__.py

@@ -4,4 +4,4 @@ from albert.core.auth.sso import AlbertSSOClient
 
 __all__ = ["Albert", "AlbertClientCredentials", "AlbertSSOClient"]
 
-__version__ = "1.12.0"
+__version__ = "1.13.0b1"

{albert-1.12.0 → albert-1.13.0b1}/src/albert/collections/attachments.py

@@ -152,30 +152,20 @@ class AttachmentCollection(BaseCollection):
             The name of the file, by default ""
         upload_key : str | None, optional
             Override the storage key used when signing and uploading the file.
-            Defaults to ``{parent_id}/{note_id}/{file_name}``.
+            Defaults to the provided ``file_name``.
 
         Returns
         -------
         Note
             The created note.
         """
-        if not (upload_key or file_name):
+        upload_name = upload_key or file_name
+        if not upload_name:
             raise ValueError("A file name or upload key must be provided for attachment upload.")
 
-        note_collection = self._get_note_collection()
-        note = Note(
-            parent_id=parent_id,
-            note=note_text,
-        )
-        registered_note = note_collection.create(note=note)
-        if upload_key:
-            attachment_name = file_name or Path(upload_key).name
-            upload_name = upload_key
-        else:
-            attachment_name = file_name
-            upload_name = f"{parent_id}/{registered_note.id}/{file_name}"
-        file_type = mimetypes.guess_type(attachment_name or upload_name)[0]
+        file_type = mimetypes.guess_type(file_name or upload_name)[0]
         file_collection = self._get_file_collection()
+        note_collection = self._get_note_collection()
 
         file_collection.sign_and_upload_file(
             data=file_data,
@@ -186,12 +176,16 @@ class AttachmentCollection(BaseCollection):
         file_info = file_collection.get_by_name(
             name=upload_name, namespace=FileNamespace.RESULT.value
         )
+        note = Note(
+            parent_id=parent_id,
+            note=note_text,
+        )
+        registered_note = note_collection.create(note=note)
         self.attach_file_to_note(
             note_id=registered_note.id,
-            file_name=attachment_name,
+            file_name=file_name or Path(upload_name).name,
             file_key=file_info.name,
         )
-
         return note_collection.get_by_id(id=registered_note.id)
 
     @validate_call

{albert-1.12.0 → albert-1.13.0b1}/src/albert/core/auth/_listener.py

@@ -31,10 +31,6 @@ class RequestHandler(BaseHTTPRequestHandler):
         status = "successful" if self.server.token else "failed (no token found)"
         self.send_response(200)
         self.send_header("Content-Type", "text/html")
-        self.send_header(
-            "Content-Security-Policy",
-            "default-src 'none'; frame-ancestors 'none'; base-uri 'none';",
-        )
         self.end_headers()
         self.wfile.write(
             f"""
@@ -42,6 +38,8 @@ class RequestHandler(BaseHTTPRequestHandler):
             <body>
                 <h1>Authentication {status}</h1>
                 <p>You can close this window now.</p>
+                <script>window.close()</script>
+                <button onclick="window.close()">Close Window</button>
             </body>
             </html>
             """.encode()

{albert-1.12.0 → albert-1.13.0b1}/src/albert/resources/inventory.py

@@ -14,6 +14,7 @@ from albert.resources._mixins import HydrationMixin
 from albert.resources.acls import ACL
 from albert.resources.cas import Cas
 from albert.resources.companies import Company
+from albert.resources.lists import ListItem
 from albert.resources.locations import Location
 from albert.resources.tagged_base import BaseTaggedResource
 from albert.resources.tags import Tag
@@ -75,6 +76,8 @@ class CasAmount(BaseAlbertModel):
         The SMILES string of the CAS Number resource. Obtained from the Cas object when provided.
     number: str | None
         The CAS number. Obtained from the Cas object when provided.
+    inventory_function: list[ListItem | EntityLink | str] | None
+        Business-controlled functions associated with the CAS in this inventory context.
 
     !!! tip
     ---
@@ -87,6 +90,9 @@ class CasAmount(BaseAlbertModel):
     target: float | None = Field(default=None, alias="inventoryValue")
     id: str | None = Field(default=None)
     cas_category: str | None = Field(default=None, alias="casCategory")
+    inventory_function: list[SerializeAsEntityLink[ListItem] | str] | None = Field(
+        default=None, alias="inventoryFunction"
+    )
     type: str | None = Field(default=None)
     classification_type: str | None = Field(default=None, alias="classificationType")
 

{albert-1.12.0 → albert-1.13.0b1}/src/albert/resources/lists.py

@@ -25,9 +25,11 @@ class ListItem(BaseResource):
     id : str | None
         The Albert ID of the list item. Set when the list item is retrieved from Albert.
     category : ListItemCategory | None
-        The category of the list item. Allowed values are `businessDefined`, `userDefined`, `projects`, and `extensions`.
+        The category of the list item. Allowed values are `businessDefined`, `userDefined`, `projects`, `extensions`,
+        and `inventory`.
     list_type : str | None
-        The type of the list item. Allowed values are `projectState` for `projects` and `extensions` for `extensions`.
+        The type of the list item. Allowed values are `projectState` for `projects`, `extensions` for `extensions`,
+        and `casCategory` or `inventoryFunction` for `inventory`.
     """
 
     name: str
@@ -37,14 +39,15 @@ class ListItem(BaseResource):
 
     @model_validator(mode="after")
     def validate_list_type(self) -> ListItem:
+        allowed_by_category = {
+            ListItemCategory.PROJECTS: {"projectState"},
+            ListItemCategory.EXTENSIONS: {"extensions"},
+            ListItemCategory.INVENTORY: {"casCategory", "inventoryFunction"},
+        }
         if (
-            self.category == ListItemCategory.PROJECTS
-            and self.list_type is not None
-            and self.list_type != "projectState"
-        ) or (
-            self.category == ListItemCategory.EXTENSIONS
-            and self.list_type is not None
-            and self.list_type != "extensions"
+            self.list_type is not None
+            and self.category in allowed_by_category
+            and self.list_type not in allowed_by_category[self.category]
         ):
             raise ValueError(
                 f"List type {self.list_type} is not allowed for category {self.category}"

{albert-1.12.0 → albert-1.13.0b1}/src/albert/utils/inventory.py

@@ -1,6 +1,7 @@
 from collections.abc import Iterable
 from typing import Any
 
+from albert.core.shared.models.base import BaseResource, EntityLink
 from albert.resources.inventory import CasAmount
 
 
@@ -56,6 +57,61 @@ def _build_cas_delete_operation(identifier: str) -> dict[str, Any]:
     }
 
 
+def _normalize_inventory_function_ids(
+    value: list[BaseResource | EntityLink | str] | None,
+) -> list[str]:
+    if not value:
+        return []
+    ids: list[str] = []
+    for item in value:
+        if isinstance(item, str):
+            if item:
+                ids.append(item)
+            continue
+        if isinstance(item, BaseResource):
+            if item.id:
+                ids.append(item.id)
+            continue
+        if isinstance(item, EntityLink):
+            if item.id:
+                ids.append(item.id)
+            continue
+    return ids
+
+
+def _build_inventory_function_operations(
+    *,
+    entity_id: str,
+    existing: list[BaseResource | EntityLink | str] | None,
+    updated: list[BaseResource | EntityLink | str] | None,
+) -> list[dict[str, Any]]:
+    existing_ids = set(_normalize_inventory_function_ids(existing))
+    updated_ids = set(_normalize_inventory_function_ids(updated))
+    to_add = sorted(updated_ids - existing_ids)
+    to_delete = sorted(existing_ids - updated_ids)
+
+    operations: list[dict[str, Any]] = []
+    if to_add:
+        operations.append(
+            {
+                "attribute": "inventoryFunction",
+                "entityId": entity_id,
+                "operation": "add",
+                "newValue": to_add,
+            }
+        )
+    if to_delete:
+        operations.append(
+            {
+                "attribute": "inventoryFunction",
+                "entityId": entity_id,
+                "operation": "delete",
+                "oldValue": to_delete,
+            }
+        )
+    return operations
+
+
 def _build_cas_scalar_operation(
     *,
     attribute: str,
@@ -117,6 +173,14 @@ def _build_cas_update_operations(existing: CasAmount, updated: CasAmount) -> lis
         if operation is not None:
             operations.append(operation)
 
+    operations.extend(
+        _build_inventory_function_operations(
+            entity_id=identifier,
+            existing=existing.inventory_function,
+            updated=updated.inventory_function,
+        )
+    )
+
     return operations
 
 
@@ -159,6 +223,13 @@ def _build_cas_patch_operations(
             )
             if target_operation is not None:
                 operations.append(target_operation)
+        operations.extend(
+            _build_inventory_function_operations(
+                entity_id=identifier,
+                existing=None,
+                updated=cas_amount.inventory_function,
+            )
+        )
 
     removals = [existing_lookup[key] for key in existing_lookup.keys() - updated_lookup.keys()]
     for cas_amount in removals:

{albert-1.12.0 → albert-1.13.0b1}/src/albert/utils/property_data.py

@@ -2,10 +2,7 @@
 
 from __future__ import annotations
 
-import ast
-import math
 import mimetypes
-import operator
 import re
 import uuid
 from collections.abc import Callable
@@ -576,63 +573,6 @@ def get_all_columns_used_in_calculations(*, first_row_data_column: list):
     return used_columns
 
 
-_ALLOWED_BINOPS = {
-    ast.Add: operator.add,
-    ast.Sub: operator.sub,
-    ast.Mult: operator.mul,
-    ast.Div: operator.truediv,
-    ast.Mod: operator.mod,
-    ast.Pow: operator.pow,
-}
-_ALLOWED_UNARYOPS = {
-    ast.UAdd: operator.pos,
-    ast.USub: operator.neg,
-}
-_ALLOWED_FUNCS: dict[str, tuple[Callable[..., float], int]] = {
-    "log10": (math.log10, 1),
-    "ln": (math.log, 1),
-    "sqrt": (math.sqrt, 1),
-    "pi": (lambda: math.pi, 0),
-}
-_ALLOWED_NAMES = {"pi": math.pi}
-
-
-def _safe_eval_math(*, expression: str) -> float:
-    """Safely evaluate supported math expressions."""
-    parsed = ast.parse(expression, mode="eval")
-
-    def _eval(node: ast.AST) -> float:
-        if isinstance(node, ast.Expression):
-            return _eval(node.body)
-        if isinstance(node, ast.Constant) and isinstance(node.value, (int | float)):
-            return node.value
-        if isinstance(node, ast.BinOp) and type(node.op) in _ALLOWED_BINOPS:
-            return _ALLOWED_BINOPS[type(node.op)](_eval(node.left), _eval(node.right))
-        if isinstance(node, ast.UnaryOp) and type(node.op) in _ALLOWED_UNARYOPS:
-            return _ALLOWED_UNARYOPS[type(node.op)](_eval(node.operand))
-        if isinstance(node, ast.Call):
-            if not isinstance(node.func, ast.Name):
-                raise ValueError("Unsupported function call.")
-            func_name = node.func.id
-            if func_name not in _ALLOWED_FUNCS:
-                raise ValueError("Unsupported function.")
-            if node.keywords:
-                raise ValueError("Keyword arguments are not supported.")
-            func, arity = _ALLOWED_FUNCS[func_name]
-            if len(node.args) != arity:
-                raise ValueError("Unsupported function arity.")
-            if arity == 0:
-                return func()
-            return func(_eval(node.args[0]))
-        if isinstance(node, ast.Name):
-            if node.id in _ALLOWED_NAMES:
-                return _ALLOWED_NAMES[node.id]
-            raise ValueError("Unsupported name.")
-        raise ValueError("Unsupported expression.")
-
-    return _eval(parsed)
-
-
 def evaluate_calculation(*, calculation: str, column_values: dict) -> float | None:
     """Evaluate a calculation expression against column values."""
     calculation = calculation.lstrip("=")
@@ -649,7 +589,7 @@ def evaluate_calculation(*, calculation: str, column_values: dict) -> float | No
             calculation = pattern.sub(repl, calculation)
 
         calculation = calculation.replace("^", "**")
-        return _safe_eval_math(expression=calculation)
+        return eval(calculation)
     except Exception as e:
         logger.info(
             "Error evaluating calculation '%s': %s. Likely do not have all values needed.",

{albert-1.12.0 → albert-1.13.0b1}/tests/collections/test_property_data.py

@@ -1,11 +1,4 @@
-from contextlib import suppress
-
-import pytest
-
 from albert import Albert
-from albert.exceptions import NotFoundError
-from albert.resources.data_columns import DataColumn
-from albert.resources.data_templates import DataColumnValue, DataTemplate
 from albert.resources.property_data import (
     BulkPropertyData,
     BulkPropertyDataColumn,
@@ -17,13 +10,7 @@ from albert.resources.property_data import (
     TaskPropertyCreate,
     TaskPropertyData,
 )
-from albert.resources.tasks import (
-    BaseTask,
-    Block,
-    PropertyTask,
-    TaskCategory,
-    TaskInventoryInformation,
-)
+from albert.resources.tasks import BaseTask, PropertyTask
 
 
 def _get_latest_row(task_properties: TaskPropertyData) -> int:
@@ -234,141 +221,3 @@ def test_add_and_update_property_data_on_inventory(
     assert r[0].inventory_id == inv.id
     assert r[0].data_columns[0].data_column_id == seeded_data_columns[0].id
     assert r[0].data_columns[0].value == "55.5"
-
-
-def test_task_property_calculation_evaluation(
-    client: Albert,
-    seed_prefix: str,
-    seeded_inventory,
-    seeded_lots,
-    seeded_locations,
-    seeded_projects,
-    seeded_workflows,
-):
-    calc_task_id = None
-    calc_dt_id = None
-    calc_dc_ids = []
-
-    try:
-        dc_one = client.data_columns.create(
-            data_column=DataColumn(name=f"{seed_prefix} - calc col one")
-        )
-        dc_two = client.data_columns.create(
-            data_column=DataColumn(name=f"{seed_prefix} - calc col two")
-        )
-        dc_calc = client.data_columns.create(
-            data_column=DataColumn(name=f"{seed_prefix} - calc col result")
-        )
-        calc_dc_ids = [dc_one.id, dc_two.id, dc_calc.id]
-
-        calc_dt = client.data_templates.create(
-            data_template=DataTemplate(
-                name=f"{seed_prefix} - calc dt",
-                description="Integration test template for calculated columns.",
-                data_column_values=[
-                    DataColumnValue(
-                        data_column=dc_one,
-                    ),
-                    DataColumnValue(
-                        data_column=dc_two,
-                    ),
-                ],
-            )
-        )
-        calc_dt_id = calc_dt.id
-        sequence_by_id = {col.data_column_id: col.sequence for col in calc_dt.data_column_values}
-        seq_one = sequence_by_id[dc_one.id]
-        seq_two = sequence_by_id[dc_two.id]
-        calc_dt = client.data_templates.add_data_columns(
-            data_template_id=calc_dt.id,
-            data_columns=[
-                DataColumnValue(
-                    data_column=dc_calc,
-                    calculation=f"={seq_one}+sqrt({seq_two})",
-                )
-            ],
-        )
-        sequence_by_id = {col.data_column_id: col.sequence for col in calc_dt.data_column_values}
-        seq_calc = sequence_by_id[dc_calc.id]
-
-        lot = next(
-            (l for l in seeded_lots if l.inventory_id == seeded_inventory[0].id),
-            None,
-        )
-        workflow = seeded_workflows[0]
-        interval_id = (
-            workflow.interval_combinations[0].interval_id
-            if workflow.interval_combinations
-            else "default"
-        )
-
-        calc_task = client.tasks.create(
-            task=PropertyTask(
-                name=f"{seed_prefix} - calc task",
-                category=TaskCategory.PROPERTY,
-                inventory_information=[
-                    TaskInventoryInformation(
-                        inventory_id=seeded_inventory[0].id,
-                        lot_id=lot.id if lot else None,
-                    )
-                ],
-                parent_id=seeded_inventory[0].id,
-                location=seeded_locations[0],
-                project=seeded_projects[0],
-                blocks=[
-                    Block(
-                        workflow=[workflow],
-                        data_template=[calc_dt],
-                    )
-                ],
-            )
-        )
-        calc_task_id = calc_task.id
-        calc_task = client.tasks.get_by_id(id=calc_task_id)
-        block_id = calc_task.blocks[0].id
-
-        result = client.property_data.add_properties_to_task(
-            task_id=calc_task_id,
-            inventory_id=seeded_inventory[0].id,
-            block_id=block_id,
-            lot_id=lot.id if lot else None,
-            properties=[
-                TaskPropertyCreate(
-                    interval_combination=interval_id,
-                    data_template=calc_dt,
-                    data_column=TaskDataColumn(
-                        data_column_id=dc_one.id,
-                        column_sequence=seq_one,
-                    ),
-                    value="5",
-                ),
-                TaskPropertyCreate(
-                    interval_combination=interval_id,
-                    data_template=calc_dt,
-                    data_column=TaskDataColumn(
-                        data_column_id=dc_two.id,
-                        column_sequence=seq_two,
-                    ),
-                    value="16",
-                ),
-            ],
-            return_scope="block",
-        )
-
-        trial = max(
-            (t for t in result[0].data[0].trials if t.data_columns[0].property_data is not None),
-            key=lambda t: t.trial_number,
-        )
-        calc_column = next(c for c in trial.data_columns if c.sequence == seq_calc)
-        assert calc_column.property_data is not None
-        assert float(calc_column.property_data.value) == pytest.approx(9.0)
-    finally:
-        if calc_task_id:
-            with suppress(NotFoundError):
-                client.tasks.delete(id=calc_task_id)
-        if calc_dt_id:
-            with suppress(NotFoundError):
-                client.data_templates.delete(id=calc_dt_id)
-        for dc_id in calc_dc_ids:
-            with suppress(NotFoundError):
-                client.data_columns.delete(id=dc_id)

{albert-1.12.0 → albert-1.13.0b1}/tests/resources/test_inventory.py

@@ -29,6 +29,7 @@ def test_cas_amount_attributes():
         "target",
         "id",
         "cas_category",
+        "inventory_function",
         "created",
         "updated",
         "classification_type",