apexdevkit 1.18.5__tar.gz → 1.18.7__tar.gz

{apexdevkit-1.18.5 → apexdevkit-1.18.7}/PKG-INFO

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

apexdevkit-1.18.7/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.5 → apexdevkit-1.18.7}/apexdevkit/query/generator.py

@@ -2,6 +2,7 @@ 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.error import ForbiddenError
@@ -150,6 +151,10 @@ class MsSqlQueryBuilder:
     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()]
+
     def with_source(self, value: str) -> MsSqlQueryBuilder:
         self.source = value
 
@@ -176,10 +181,10 @@ class MsSqlQueryBuilder:
     def filter(self, options: QueryOptions) -> DatabaseCommand:
         return MsSqlQuery(
             user=MsSqlUserGenerator(self.username),
-            selection=MsSqlSelectionGenerator(self.translations),
+            selection=MsSqlSelectionGenerator(self._fields),
             filter=MsSqlSourceGenerator(self.source, options.filter),
             condition=MsSqlConditionGenerator(options.condition, self.translations),
-            ordering=MsSqlOrderGenerator(options.ordering, self.translations),
+            ordering=MsSqlOrderGenerator(options.ordering, self._fields),
             paging=MsSqlPagingGenerator(options.paging),
         ).generate()
 
@@ -192,17 +197,35 @@ class MsSqlUserGenerator:
         return f"EXECUTE AS USER = '{self.username}'"
 
 
+@dataclass
+class MsSqlField:
+    name: str
+
+    alias: str = ""
+
+    def as_select_part(self) -> str:
+        result = f"[{self.name}]"
+
+        if self.alias:
+            result += f" AS [{self.alias}]"
+
+        return result
+
+    def as_order_part(self, is_descending: bool = False) -> str:
+        result = self.alias or self.name
+
+        if is_descending:
+            result += " DESC"
+
+        return result
+
+
 @dataclass
 class MsSqlSelectionGenerator:
-    translations: dict[str, str]
+    fields: list[MsSqlField] = field(default_factory=list)
 
     def generate(self) -> str:
-        fields = ", ".join(
-            [
-                f"[{self.translations[key]}] AS [{key}]"
-                for key in self.translations.keys()
-            ]
-        )
+        fields = ", ".join([f.as_select_part() for f in self.fields])
 
         return f"SELECT {fields}"
 
@@ -242,18 +265,17 @@ class MsSqlSourceGenerator:
         return f"FROM {self.source}{self._argument_list()}"
 
     def _argument_list(self) -> str:
-        if self.filter is not None:
-            return (
-                "("
-                + ",".join(
-                    arg.as_arg() if arg is not None else "null"
-                    for arg in self.filter.args
-                )
-                + ")"
-            )
-        else:
+        if self.filter is None:
             return ""
 
+        return (
+            "("
+            + ",".join(
+                arg.as_arg() if arg is not None else "null" for arg in self.filter.args
+            )
+            + ")"
+        )
+
 
 @dataclass
 class MsSqlConditionGenerator:
@@ -304,27 +326,26 @@ class MsSqlConditionGenerator:
 @dataclass
 class MsSqlOrderGenerator:
     ordering: list[Sort]
-    translations: dict[str, str]
+
+    fields: list[MsSqlField] = field(default_factory=list)
 
     def generate(self) -> str:
         if not self.ordering:
             return ""
-        self._validate()
 
-        order_clause = ", ".join(
-            f"{self.translations[item.name]} DESC"
-            if item.is_descending
-            else self.translations[item.name]
-            for item in self.ordering
-        )
+        clause = ", ".join(self.generate_one(item) for item in self.ordering)
 
-        return f"ORDER BY {order_clause}"
+        return f"ORDER BY {clause}"
 
-    def _validate(self) -> None:
-        if self.translations.keys():
-            for order in self.ordering:
-                if order.name not in self.translations.keys():
-                    raise ForbiddenError(message=f"Invalid field name: {order.name}")
+    def generate_one(self, item: Sort) -> str:
+        return self.field_for(item.name).as_order_part(item.is_descending)
+
+    def field_for(self, name: str) -> MsSqlField:
+        for f in self.fields:
+            if f.name == name:
+                return f
+
+        raise ForbiddenError(message=f"Invalid field name: {name}")
 
 
 @dataclass

{apexdevkit-1.18.5 → apexdevkit-1.18.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "apexdevkit"
-version = "1.18.5"
+version = "1.18.7"
 description = "Apex Development Tools for python."
 authors = ["Apex Dev <dev@apex.ge>"]
 readme = "README.md"
@@ -16,7 +16,9 @@ python-dotenv = "*"
 pymssql = "^2.3.1"
 
 [tool.poetry.group.dev.dependencies]
+approvaltests = "*"
 pytest = "*"
+pytest-approvaltests = "*"
 pytest-cov = "*"
 pytest-recording = "*"
 coverage = "*"
@@ -61,9 +63,6 @@ source = [
     "apexdevkit",
     "tests",
 ]
-omit = [
-    "apexdevkit/server.py",
-]
 
 [tool.coverage.report]
 skip_empty = true