apexdevkit 1.18.6__tar.gz → 1.18.8__tar.gz

{apexdevkit-1.18.6 → apexdevkit-1.18.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: apexdevkit
-Version: 1.18.6
+Version: 1.18.8
 Summary: Apex Development Tools for python.
 Author: Apex Dev
 Author-email: dev@apex.ge

apexdevkit-1.18.8/apexdevkit/id.py

@@ -0,0 +1,54 @@
+import os
+from threading import Lock
+from time import time
+
+
+class ApexID:
+    last_timestamp: int = -1
+    sequence: int = 0
+    lock: Lock = Lock()
+
+    _metadata_bitmask: int = 0x0FFF
+    _sequence_bitmask: int = 0x03FF
+    _timestamp_bitmask: int = 0x03FFFFFFFFFF
+
+    @classmethod
+    def id(cls) -> int:
+        """
+        Generates a unique identifier with the following structure
+        from most significant to least significant:
+        1 bit reserved
+        41 bits for unix timestamp (millisecond precision)
+        12 bits for metadata
+        10 bits for sequence
+        """
+        with cls.lock:
+            current_timestamp = cls._get_timestamp()
+            if cls.last_timestamp == current_timestamp:
+                cls.sequence += 1
+            else:
+                cls.sequence = 0
+
+            if cls.sequence > cls._sequence_bitmask:
+                raise DuplicateIDException("Duplicate ID Generated")
+
+            cls.last_timestamp = current_timestamp
+
+        return (
+            (0 << 63)
+            | ((cls.last_timestamp & cls._timestamp_bitmask) << 22)
+            | ((cls._metadata() & cls._metadata_bitmask) << 10)
+            | (cls.sequence & cls._sequence_bitmask)
+        )
+
+    @classmethod
+    def _get_timestamp(cls) -> int:
+        return int(time() * 1000)
+
+    @classmethod
+    def _metadata(cls) -> int:
+        return int(os.getenv("APEX_ID_METADATA", "0"))
+
+
+class DuplicateIDException(Exception):
+    pass

{apexdevkit-1.18.6 → apexdevkit-1.18.8}/apexdevkit/query/generator.py

@@ -2,11 +2,12 @@ from __future__ import annotations
 
 from collections import defaultdict
 from dataclasses import dataclass, field
-from functools import cached_property
 from typing import Any, ClassVar, Generic, Iterable, Protocol, TypeVar
 
+from apexdevkit.annotation import deprecated
 from apexdevkit.error import ForbiddenError
 from apexdevkit.query.query import (
+    Aggregation,
     AggregationOption,
     Filter,
     FooterOptions,
@@ -149,11 +150,7 @@ class MsSqlQuery:
 class MsSqlQueryBuilder:
     source: str = field(init=False)
     username: str = field(init=False)
-    translations: dict[str, str] = field(init=False)
-
-    @cached_property
-    def _fields(self) -> list[MsSqlField]:
-        return [MsSqlField(name, alias) for alias, name in self.translations.items()]
+    _fields: list[MsSqlField] = field(init=False)
 
     def with_source(self, value: str) -> MsSqlQueryBuilder:
         self.source = value
@@ -165,17 +162,23 @@ class MsSqlQueryBuilder:
 
         return self
 
+    def with_fields(self, values: list[MsSqlField]) -> MsSqlQueryBuilder:
+        self._fields = values
+
+        return self
+
+    @deprecated(".with_translations is deprecated, use .with_fields instead")
     def with_translations(self, value: dict[str, str]) -> MsSqlQueryBuilder:
-        self.translations = value
+        self._fields = [MsSqlField(name, alias) for alias, name in value.items()]
 
         return self
 
     def aggregate(self, footer: FooterOptions) -> DatabaseCommand:
         return MsSqlQuery(
             user=MsSqlUserGenerator(self.username),
-            selection=MsSqlFooterGenerator(footer.aggregations, self.translations),
+            selection=MsSqlFooterGenerator(footer.aggregations, self._fields),
             filter=MsSqlSourceGenerator(self.source, footer.filter),
-            condition=MsSqlConditionGenerator(footer.condition, self.translations),
+            condition=MsSqlConditionGenerator(footer.condition, self._fields),
         ).generate()
 
     def filter(self, options: QueryOptions) -> DatabaseCommand:
@@ -183,7 +186,7 @@ class MsSqlQueryBuilder:
             user=MsSqlUserGenerator(self.username),
             selection=MsSqlSelectionGenerator(self._fields),
             filter=MsSqlSourceGenerator(self.source, options.filter),
-            condition=MsSqlConditionGenerator(options.condition, self.translations),
+            condition=MsSqlConditionGenerator(options.condition, self._fields),
             ordering=MsSqlOrderGenerator(options.ordering, self._fields),
             paging=MsSqlPagingGenerator(options.paging),
         ).generate()
@@ -219,6 +222,9 @@ class MsSqlField:
 
         return result
 
+    def as_aggregation_part(self, option: Aggregation) -> str:
+        return f"{option.value}({self.name}) AS {self.alias}_{option.value.lower()}"
+
 
 @dataclass
 class MsSqlSelectionGenerator:
@@ -233,27 +239,27 @@ class MsSqlSelectionGenerator:
 @dataclass
 class MsSqlFooterGenerator:
     aggregations: list[AggregationOption]
-    translations: dict[str, str]
+    fields: list[MsSqlField]
 
     def generate(self) -> str:
-        self._validate()
         fields = ", ".join(
             [
-                f"{footer.aggregation.value}"
-                f"({self.translations[footer.name] if footer.name else '*'}) AS "
-                f"{footer.name if footer.name else 'general'}"
-                f"_{footer.aggregation.value.lower()}"
+                self.field_for(footer.name).as_aggregation_part(footer.aggregation)
                 for footer in self.aggregations
             ]
         )
 
         return f"SELECT {fields}"
 
-    def _validate(self) -> None:
-        if self.translations.keys():
-            for footer in self.aggregations:
-                if footer.name and footer.name not in self.translations.keys():
-                    raise ForbiddenError(message=f"Invalid field name: {footer.name}")
+    def field_for(self, name: str | None) -> MsSqlField:
+        if name is None:
+            return MsSqlField("*", alias="general")
+
+        for f in self.fields:
+            if f.alias == name:
+                return f
+
+        raise ForbiddenError(message=f"Invalid field name: {name}")
 
 
 @dataclass
@@ -280,12 +286,11 @@ class MsSqlSourceGenerator:
 @dataclass
 class MsSqlConditionGenerator:
     condition: Operator | None
-    translations: dict[str, str]
+    fields: list[MsSqlField]
 
     def generate(self) -> str:
         if self.condition is None:
             return ""
-        self._validate(self.condition)
 
         return f"WHERE ({self._traverse(self.condition)})"
 
@@ -306,22 +311,12 @@ class MsSqlConditionGenerator:
                 assert len(node.operands) == 1
 
                 return OperationEvaluator(
-                    node.operation, self.translations
+                    node.operation,
+                    fields=self.fields,
                 ).evaluate_for(
                     node.operands[0],  # type: ignore
                 )
 
-    def _validate(self, condition: Operator | None) -> None:
-        if condition is not None and self.translations:
-            for operand in condition.operands:
-                if isinstance(operand, Operator):
-                    self._validate(operand)
-                else:
-                    if operand.name not in self.translations.keys():
-                        raise ForbiddenError(
-                            message=f"Invalid field name: {operand.name}"
-                        )
-
 
 @dataclass
 class MsSqlOrderGenerator:
@@ -365,7 +360,7 @@ class MsSqlPagingGenerator:
 @dataclass
 class OperationEvaluator:
     operation: Operation
-    translations: dict[str, str]
+    fields: list[MsSqlField]
 
     _TEMPLATES: ClassVar[dict[Operation, str]] = defaultdict(
         lambda: "[{column}] {operation} {a}",
@@ -385,13 +380,20 @@ class OperationEvaluator:
     def evaluate_for(self, node: Leaf) -> str:
         return self._TEMPLATES[self.operation].format(
             operation=self.operation.value,
-            column=self.translations[node.name],
+            column=self._column_for(node),
             raw_a=self._get_raw_value(node),
             a=self._get_value(node, 0),
             b=self._get_value(node, 1),
             values=", ".join(val.eval() for val in node.values),
         )
 
+    def _column_for(self, node: Leaf) -> str:
+        for f in self.fields:
+            if f.alias == node.name:
+                return f.name
+
+        raise ForbiddenError(message=f"Invalid field name: {node.name}")
+
     def _get_raw_value(self, node: Leaf) -> str | None:
         raw_a = self._get_value(node, 0)
         return (

{apexdevkit-1.18.6 → apexdevkit-1.18.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "apexdevkit"
-version = "1.18.6"
+version = "1.18.8"
 description = "Apex Development Tools for python."
 authors = ["Apex Dev <dev@apex.ge>"]
 readme = "README.md"