archaic 0.1.0__py3-none-any.whl

archaic/__init__.py

@@ -0,0 +1,3 @@
+# flake8: noqa
+
+from archaic.feature_class import FeatureClass

archaic/feature_class.py

@@ -0,0 +1,210 @@
+import arcpy
+from typing import Any, Callable, Generic, Iterable, List, Optional, Set, TypeVar, Union
+from archaic.info import Info
+from archaic.predicate import to_sql
+
+T = TypeVar("T")
+
+
+class FeatureClass(Generic[T]):
+    def __init__(self, data_path: str, **mapping: str) -> None:
+        """Initializes the feature class.  e.g.
+
+            class City:
+                objectid: int
+                city_name: str
+                shape: arcpy.PointGeometry
+
+            cities_fc = FeatureClass [City] ('world.gdb/cities')
+
+            for city in cities_fc.read():
+                print(city.city_name, city.shape.WKT)
+
+        Args:
+            data_path (str): Feature class path.
+            mapping: Custom mapping of property to field.
+        """
+        self._data_path = data_path
+        self._mapping = mapping
+
+    @property
+    def info(self):
+        if not hasattr(self, "_info"):
+            self._info = Info[T](self)
+        return self._info
+
+    def read(
+        self,
+        filter: Union[
+            str, Callable[[T], bool], Iterable[int], Iterable[str], None
+        ] = None,
+        wkid: Optional[int] = None,
+        **kwargs: Any,
+    ) -> Iterable[T]:
+        """Queries the feature class.
+
+        Args:
+            filter: Where clause, lambda expression, object ids or global ids.  Defaults to None.
+            wkid: Well-known id (e.g. 4326).  Defaults to None.
+
+        Returns:
+            Iterable[T]: Strongly typed items.
+        """
+        if wkid is not None:
+            kwargs["spatial_reference"] = arcpy.SpatialReference(wkid)
+        data_path = self.info.data_path
+        fields = list(self.info.properties.values())
+        properties = self.info.properties
+        for where_clause in self._get_where_clauses_from_filter(filter):
+            with arcpy.da.SearchCursor(data_path, fields, where_clause, **kwargs) as cursor:  # type: ignore
+                for row in cursor:
+                    d = dict(zip(fields, row))
+                    yield self._create(
+                        **{p: d.get(f) if f else None for p, f in properties.items()}
+                    )
+
+    def get(self, id: Union[int, str], wkid: Optional[int] = None) -> Optional[T]:
+        """Gets an item from the feature class.
+
+        Args:
+            id: Object id or global id.
+            wkid: Well-known id (e.g. 4326).  Defaults to None.
+
+        Returns:
+            Optional[T]: Strongly typed item if found.
+        """
+        for where_clause in self._get_where_clauses_from_ids(id):
+            for item in self.read(where_clause, wkid):
+                return item
+        return None
+
+    def insert_many(self, items: Iterable[T], **kwargs: Any) -> List[int]:
+        data_path = self.info.data_path
+        fields = list(self.info.edit_properties.values())
+        properties = self.info.edit_properties
+        with arcpy.da.InsertCursor(data_path, fields, **kwargs) as cursor:  # type: ignore
+            return [
+                cursor.insertRow(self._get_values(item, properties)) for item in items
+            ]
+
+    def insert(self, item: T) -> T:
+        return self.get(self.insert_many([item])[0])  # type: ignore
+
+    def update_where(
+        self,
+        filter: Union[str, Callable[[T], bool], Iterable[int], Iterable[str], None],
+        update: Callable[[T], Union[None, T]],
+        **kwargs: Any,
+    ) -> List[int]:
+        data_path = self.info.data_path
+        fields = list(self.info.edit_properties.values())
+        properties = self.info.edit_properties
+        ids: Set[int] = set()
+        for where_clause in self._get_where_clauses_from_filter(filter):
+            with arcpy.da.UpdateCursor(data_path, fields, where_clause, **kwargs) as cursor:  # type: ignore
+                for row in cursor:
+                    d = dict(zip(fields, row))
+                    before = self._create(
+                        **{p: d.get(f) if f else None for p, f in properties.items()}
+                    )
+                    result = update(before)
+                    after = before if result is None else result
+                    cursor.updateRow(self._get_values(after, properties))
+                    ids.add(self._get_oid(before))
+        return list(ids)
+
+    def update(self, items: Union[T, List[T]]) -> List[int]:
+        items = list(items) if isinstance(items, Iterable) else [items]
+        cache = {self._get_oid(x): x for x in items}
+        ids: Set[int] = set()
+        for where_clause in self._get_where_clauses_from_ids(items):
+            for id in self.update_where(
+                where_clause, lambda x: cache[self._get_oid(x)]
+            ):
+                ids.add(id)
+        return list(ids)
+
+    def delete_where(self, filter: Union[str, Callable[[T], bool], None]) -> List[int]:
+        data_path = self.info.data_path
+        ids: Set[int] = set()
+        for where_clause in self._get_where_clauses_from_filter(filter):
+            with arcpy.da.UpdateCursor(data_path, self.info.oid_field, where_clause) as cursor:  # type: ignore
+                for row in cursor:
+                    cursor.deleteRow()
+                    ids.add(row[0])
+        return list(ids)
+
+    def delete(
+        self, items: Union[T, int, str, Iterable[T], Iterable[int], Iterable[str]]
+    ) -> List[int]:
+        ids: Set[int] = set()
+        for where_clause in self._get_where_clauses_from_ids(items):
+            for id in self.delete_where(where_clause):
+                ids.add(id)
+        return list(ids)
+
+    def _create(self, **kwargs: Any) -> T:
+        if self.info.has_default_constructor:
+            item = self.info.model()
+            for property in self.info.properties:
+                setattr(item, property, kwargs.get(property))
+            return item
+        return self.info.model(
+            **{k: v for k, v in kwargs.items() if k in self.info.properties}
+        )
+
+    def _get_values(self, item: T, properties: Iterable[str]) -> List[Any]:
+        values: List[Any] = []
+        for property in properties:
+            values.append(getattr(item, property) if hasattr(item, property) else None)
+        return values
+
+    def _get_where_clauses_from_ids(
+        self, obj: Union[T, int, str, Iterable[T], Iterable[int], Iterable[str]]
+    ) -> List[str]:
+        where_clauses: List[str] = []
+        ids = list(self._get_ids(obj))
+        n = 1000
+        for chunk in [ids[i : i + n] for i in range(0, len(ids), n)]:
+            first = chunk[0]
+            if isinstance(first, int):
+                where_clauses.append(
+                    f"{self.info.oid_field} IN ({','.join(map(str, chunk))})"
+                )
+            elif isinstance(first, str):
+                where_clauses.append(
+                    f"GlobalID IN ({','.join(map(self._quote, chunk))})"
+                )
+        return where_clauses
+
+    def _get_where_clauses_from_filter(
+        self,
+        filter: Union[str, Callable[[T], bool], Iterable[int], Iterable[str], None],
+    ) -> List[str]:
+        if filter is None:
+            return [""]
+        if isinstance(filter, str):
+            return [filter]
+        if callable(filter):
+            return [to_sql(filter, self.info.properties)]
+        return self._get_where_clauses_from_ids(filter)
+
+    def _quote(self, value: Any) -> str:
+        return f"'{value}'"
+
+    def _get_ids(self, obj) -> Iterable[Union[int, str]]:
+        if isinstance(obj, int) or isinstance(obj, str):
+            yield obj
+        elif isinstance(obj, self.info.model):
+            yield self._get_oid(obj)
+        else:
+            for o in obj:
+                for id in self._get_ids(o):
+                    yield id
+
+    def _get_oid(self, item) -> int:
+        if not self.info.oid_property:
+            raise TypeError(
+                f"'{self.info.model.__name__}' is missing the OID property."
+            )
+        return getattr(item, self.info.oid_property)

archaic/info.py

@@ -0,0 +1,82 @@
+import arcpy
+import re
+
+from inspect import signature
+from itertools import chain
+from types import SimpleNamespace
+from typing import TYPE_CHECKING, Dict, Generic, Set, Type, TypeVar
+
+if TYPE_CHECKING:
+    from archaic.feature_class import FeatureClass
+
+T = TypeVar("T")
+
+
+class Info(Generic[T]):
+    def __init__(self, feature_class: "FeatureClass[T]") -> None:
+        if hasattr(feature_class, "__orig_class__"):
+            model = feature_class.__orig_class__.__args__[0]  # type: ignore
+        else:
+            model = SimpleNamespace
+
+        keys = chain(
+            signature(model.__init__).parameters.keys(),
+            signature(model.__new__).parameters.keys(),
+        )
+
+        description = arcpy.Describe(feature_class._data_path)
+
+        # Members.
+        self.model: Type[T] = model  # type: ignore
+        self.has_default_constructor = len(set(keys)) == 3
+        self.data_path: str = description.catalogPath  # type: ignore
+        self.oid_field: str
+        self.oid_property: str
+        self.properties: Dict[str, str] = {}
+        self.edit_properties: Dict[str, str] = {}
+
+        # Inspect the fields.
+        upper_fields: Dict[str, str] = {}
+        upper_read_only_fields: Set[str] = set()
+        for field in description.fields:  # type: ignore
+            if re.match(r"^(?!\d)[\w$]+$", field.name):
+                upper_fields[field.name.upper()] = field.name
+                if field.type == "OID":
+                    self.oid_field = field.name
+                elif not field.editable:
+                    upper_read_only_fields.add(field.name.upper())
+
+        def resolve_fields():
+            if model == SimpleNamespace:
+                upper_field_to_property: Dict[str, str] = {
+                    f.upper(): p for p, f in feature_class._mapping.items()
+                }
+                for upper_field, field in upper_fields.items():
+                    property = upper_field_to_property.get(upper_field) or field
+                    if upper_field == "SHAPE":
+                        field = "SHAPE@"
+                    yield property, field
+            else:
+                for model_type in reversed(model.mro()):
+                    if hasattr(model_type, "__annotations__"):
+                        for property in model_type.__annotations__:
+                            field = feature_class._mapping.get(property) or property
+                            upper_field = field.upper()
+                            if upper_field == "SHAPE":
+                                field = "SHAPE@"
+                            elif upper_field.startswith("SHAPE_"):
+                                field = upper_field.replace("SHAPE_", "SHAPE@")
+                            elif upper_field not in upper_fields:
+                                raise ValueError(
+                                    f"Field '{field}' not found in {self.data_path}."
+                                )
+                            else:
+                                field = upper_fields[upper_field]
+                            yield property, field
+
+        for property, field in resolve_fields():
+            self.properties[property] = field
+            if field == self.oid_field:
+                self.oid_property = property
+            if field.upper() not in upper_read_only_fields:
+                self.edit_properties[property] = field

archaic/predicate.py

@@ -0,0 +1,155 @@
+import ast
+from _ast import Attribute, BoolOp, Call, Compare, Constant, Name
+from datetime import datetime
+from inspect import getsource
+from typing import Any, Callable, Dict, List, TypeVar, Union
+
+T = TypeVar("T")
+
+
+def to_sql(predicate: Callable[[T], bool], properties: Dict[str, str]) -> str:
+    class LambdaFinder(ast.NodeVisitor):
+        def __init__(self, expression: Any) -> None:
+            super().__init__()
+
+            self.freevars: Dict[str, Any] = {}
+
+            # Check globals.
+            for name in expression.__code__.co_names:
+                if name in expression.__globals__:
+                    self.freevars[name] = expression.__globals__[name]
+
+            # Capture closure variables.
+            closure = expression.__closure__
+            if closure:
+                for name, value in zip(
+                    expression.__code__.co_freevars, [x.cell_contents for x in closure]
+                ):
+                    self.freevars[name] = value
+
+            line = getsource(expression).strip()
+
+            if line.endswith(":"):
+                line = f"{line}\n    pass"
+
+            self.visit(ast.parse(line))
+
+        def visit_Lambda(self, node: ast.Lambda) -> Any:  # pylint: disable-all
+            self.expression = node
+
+        @staticmethod
+        def find(expression: Any):  # pylint: disable-all
+            visitor = LambdaFinder(expression)
+            return visitor.expression, visitor.freevars
+
+    class LambdaVisitor(ast.NodeVisitor):
+        def __init__(self, expression: ast.expr, freevars: Dict[str, Any]) -> None:
+            super().__init__()
+            self._expressions: List[Union[LambdaVisitor, str]] = []
+            self._freevars = freevars
+            self.visit(expression)
+
+        def visit_Attribute(self, node: Attribute) -> Any:
+            attr = node.attr
+            value: Any = node.value
+            if value.id in self._freevars:
+                self._expressions.append(
+                    self._get_sql_value(getattr(self._freevars[value.id], attr))
+                )
+            else:
+                self._expressions.append(properties[attr])
+
+        def visit_BoolOp(self, node: BoolOp) -> Any:
+            self._expressions.append("(")
+            expressions: List[Union[LambdaVisitor, str]] = []
+            for value in node.values:
+                expressions.append(LambdaVisitor(value, self._freevars))
+                expressions.append(self._convert_op(node.op))
+            expressions.pop()
+            self._expressions.extend(expressions)
+            self._expressions.append(")")
+
+        def visit_Call(self, node: Call) -> Any:
+            if not hasattr(node.func, "attr"):
+                self.generic_visit(node)
+                return
+            attr = node.func.attr  # type: ignore
+            if attr == "startswith":
+                field_name = properties[node.func.value.attr]  # type: ignore
+                self._expressions.append(
+                    f"{field_name} LIKE '{self._get_value(node.args[0])}%'"
+                )
+            elif attr == "endswith":
+                field_name = properties[node.func.value.attr]  # type: ignore
+                self._expressions.append(
+                    f"{field_name} LIKE '%{self._get_value(node.args[0])}'"
+                )
+
+        def visit_Compare(self, node: Compare) -> Any:
+            op = node.ops[0]
+            if isinstance(op, ast.In):
+                field_name = properties[node.comparators[0].attr]  # type: ignore
+                self._expressions.append(
+                    f"{field_name} LIKE '%{self._get_value(node.left)}%'"
+                )
+            else:
+                self._expressions.append(LambdaVisitor(node.left, self._freevars))
+                self._expressions.append(self._convert_op(node.ops[0]))
+                self._expressions.append(
+                    LambdaVisitor(node.comparators[0], self._freevars)
+                )
+
+        def visit_Constant(self, node: Constant) -> Any:
+            self._expressions.append(self._get_sql_value(node.value))
+
+        def visit_Name(self, node: Name) -> Any:
+            self._expressions.append(self._get_sql_value(self._freevars[node.id]))
+
+        def _get_sql_value(self, value: Any) -> str:
+            if value is None:
+                return "NULL"
+            if isinstance(value, str):
+                return f"'{value}'"
+            if isinstance(value, datetime):
+                return f"timestamp '{value:%Y-%m-%d %H:%M:%S}'"
+            return str(value)
+
+        def _get_value(self, node: Any) -> Any:
+            return self._freevars[node.id] if isinstance(node, Name) else node.value
+
+        def _convert_op(self, op: Any) -> str:
+            if isinstance(op, ast.And):
+                return "AND"
+            if isinstance(op, ast.Or):
+                return "OR"
+            if isinstance(op, ast.Is):
+                return "IS"
+            if isinstance(op, ast.IsNot):
+                return "IS NOT"
+            if isinstance(op, ast.Eq):
+                return "="
+            if isinstance(op, ast.NotEq):
+                return "<>"
+            if isinstance(op, ast.Gt):
+                return ">"
+            if isinstance(op, ast.GtE):
+                return ">="
+            if isinstance(op, ast.Lt):
+                return "<"
+            if isinstance(op, ast.LtE):
+                return "<="
+            return type(op).__name__
+
+        def to_sql(self) -> str:
+            text = ""
+            for e in self._expressions:
+                text += e.to_sql() if isinstance(e, LambdaVisitor) else f" {e}"
+            return text
+
+    # Find the lambda expression and any free variables encapsulated in it.
+    expression, freevars = LambdaFinder.find(predicate)
+
+    # Generate a where clause.
+    where_clause = LambdaVisitor(expression, freevars).to_sql().strip()
+
+    return where_clause

archaic-0.1.0.dist-info/METADATA

@@ -0,0 +1,14 @@
+Metadata-Version: 2.1
+Name: archaic
+Version: 0.1.0
+Summary: Simplifies handling of ArcPy rows
+Author-email: Jiro Shirota <jshirota@gmail.com>
+Project-URL: Homepage, https://github.com/jshirota/archaic
+Project-URL: Bug Tracker, https://github.com/jshirota/archaic/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# archaic

archaic-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+archaic/__init__.py,sha256=nwSLYBqzXoFULI9Kq8Ac0Q1QpQLj8a7r1-gMn1zV8w0,63
+archaic/feature_class.py,sha256=iUKrmFOdIt51qY1CLA8H_vMTDjmOtObt1T4rKrJdrbY,8123
+archaic/info.py,sha256=cWwh271vWg47Z1WVd98CTx3ApkBiNb6Iat17iO-BxcU,3465
+archaic/predicate.py,sha256=pS1iy7z0914GgW4hg40cK8_69Q2Eto9uPSfctOyLSyw,6052
+archaic-0.1.0.dist-info/METADATA,sha256=dgin4C5wH4EK8xjSodXNkJG-ldXH9IG0Az1QgBPWNlg,504
+archaic-0.1.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+archaic-0.1.0.dist-info/top_level.txt,sha256=8OZUWuQkNdNWUgch_zC_PdHqKZHLXm_e9CXi88bS4os,8
+archaic-0.1.0.dist-info/RECORD,,

archaic-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.43.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

archaic-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+archaic