pyaccesskit 0.1.0__py3-none-any.whl

pyaccesskit/units.py

@@ -0,0 +1,301 @@
+# pyright: reportUnnecessaryIsInstance=false
+# (operators and parse() deliberately type-check arguments at runtime)
+"""Physical lengths for form and report layout.
+
+Access measures positions and sizes in **twips** (1/1440 inch, 1/20 point). PyAccessKit lets you work in
+familiar units instead and converts exactly once, when talking to Access::
+
+    from pyaccesskit.units import cm, mm, inch
+
+    width = cm(6) + mm(5)       # Length(twips=3685)
+    width.cm                    # 6.5 (approximately; lengths are whole twips)
+
+A :class:`Length` is an immutable whole number of twips. In specs it serializes to a readable string such
+as ``"6.5cm"`` and parses from strings (``"2cm"``, ``"10mm"``, ``"1.5in"``, ``"12pt"``, ``"300tw"``) or plain
+integers (twips).
+"""
+
+from __future__ import annotations
+
+import math
+import re
+from typing import TYPE_CHECKING, Any, SupportsFloat
+
+from pydantic_core import core_schema
+
+if TYPE_CHECKING:
+    from pydantic import GetCoreSchemaHandler, GetJsonSchemaHandler
+    from pydantic.json_schema import JsonSchemaValue
+
+__all__ = [
+    "TWIPS_PER_CM",
+    "TWIPS_PER_INCH",
+    "TWIPS_PER_MM",
+    "TWIPS_PER_POINT",
+    "Length",
+    "cm",
+    "inch",
+    "mm",
+    "pt",
+    "twips",
+]
+
+TWIPS_PER_INCH = 1440
+TWIPS_PER_POINT = 20
+TWIPS_PER_CM = TWIPS_PER_INCH / 2.54
+TWIPS_PER_MM = TWIPS_PER_CM / 10
+
+_UNIT_FACTORS: dict[str, float] = {
+    "tw": 1,
+    "twip": 1,
+    "twips": 1,
+    "pt": TWIPS_PER_POINT,
+    "point": TWIPS_PER_POINT,
+    "points": TWIPS_PER_POINT,
+    "mm": TWIPS_PER_MM,
+    "cm": TWIPS_PER_CM,
+    "in": TWIPS_PER_INCH,
+    "inch": TWIPS_PER_INCH,
+    "inches": TWIPS_PER_INCH,
+    '"': TWIPS_PER_INCH,
+}
+_PATTERN = re.compile(r"^\s*([+-]?(?:\d+(?:\.\d*)?|\.\d+))\s*([a-zA-Z\"]*)\s*$")
+
+
+def _to_twips(value: SupportsFloat, factor: float) -> int:
+    number = float(value)
+    if not math.isfinite(number):
+        raise ValueError(f"length must be finite, got {value!r}")
+    return round(number * factor)
+
+
+class Length:
+    """An immutable length, stored as a whole number of twips.
+
+    Construct lengths with the helper functions :func:`twips`, :func:`pt`, :func:`mm`, :func:`cm` and
+    :func:`inch`, or parse text with :meth:`parse`.
+    """
+
+    __slots__ = ("_twips",)
+
+    _twips: int
+
+    def __init__(self, twips: int) -> None:
+        if isinstance(twips, bool) or not isinstance(twips, int):
+            raise TypeError(
+                f"Length expects an integer number of twips, got {type(twips).__name__}"
+            )
+        object.__setattr__(self, "_twips", twips)
+
+    # --------------------------------------------------------------------------------------- access
+    @property
+    def twips(self) -> int:
+        """The length in twips (the unit Access uses)."""
+        return self._twips
+
+    @property
+    def points(self) -> float:
+        """The length in typographic points."""
+        return self._twips / TWIPS_PER_POINT
+
+    @property
+    def mm(self) -> float:
+        """The length in millimetres."""
+        return self._twips / TWIPS_PER_MM
+
+    @property
+    def cm(self) -> float:
+        """The length in centimetres."""
+        return self._twips / TWIPS_PER_CM
+
+    @property
+    def inches(self) -> float:
+        """The length in inches."""
+        return self._twips / TWIPS_PER_INCH
+
+    # ---------------------------------------------------------------------------------- conversion
+    @classmethod
+    def parse(cls, value: str | int | Length) -> Length:
+        """Parse ``"2cm"``, ``"10 mm"``, ``"1.5in"``, ``"12pt"``, ``"300tw"`` or an integer number of twips.
+
+        Raises:
+            ValueError: If the text is not a recognised length.
+        """
+        if isinstance(value, Length):
+            return value
+        if isinstance(value, bool):
+            raise TypeError("a boolean is not a length")
+        if isinstance(value, int):
+            return cls(value)
+        match = _PATTERN.match(value)
+        if match is None:
+            raise ValueError(
+                f"not a length: {value!r} (expected e.g. '2cm', '10mm', '1.5in', '12pt')"
+            )
+        number, unit = match.group(1), match.group(2).lower()
+        if not unit:
+            if "." in number:
+                raise ValueError(
+                    f"a unitless length must be a whole number of twips, got {value!r}"
+                )
+            return cls(int(number))
+        factor = _UNIT_FACTORS.get(unit)
+        if factor is None:
+            raise ValueError(f"unknown length unit {unit!r} in {value!r}")
+        return cls(_to_twips(float(number), factor))
+
+    def format(self, unit: str = "cm") -> str:
+        """Format in ``unit`` (``"cm"``, ``"mm"``, ``"in"``, ``"pt"`` or ``"tw"``).
+
+        The result is the *shortest* decimal that parses back to exactly the same number of twips:
+        ``cm(1.5).format() == "1.5cm"`` and ``Length.parse(x.format(unit)) == x`` for every length and unit.
+        """
+        key = unit.lower()
+        factor = _UNIT_FACTORS.get(key)
+        if factor is None:
+            raise ValueError(f"unknown length unit {unit!r}")
+        if factor == 1:
+            return f"{self._twips}tw"
+        value = self._twips / factor
+        text = f"{value:.6f}"
+        for decimals in range(7):
+            text = f"{value:.{decimals}f}"
+            if _to_twips(float(text), factor) == self._twips:
+                break
+        text = text.rstrip("0").rstrip(".") if "." in text else text
+        return f"{'0' if text in ('', '-0') else text}{key}"
+
+    # ---------------------------------------------------------------------------------- arithmetic
+    def __add__(self, other: Length) -> Length:
+        if not isinstance(other, Length):
+            return NotImplemented
+        return Length(self._twips + other._twips)
+
+    def __sub__(self, other: Length) -> Length:
+        if not isinstance(other, Length):
+            return NotImplemented
+        return Length(self._twips - other._twips)
+
+    def __mul__(self, factor: float) -> Length:
+        if isinstance(factor, bool) or not isinstance(factor, (int, float)):
+            return NotImplemented
+        return Length(_to_twips(self._twips, factor))
+
+    __rmul__ = __mul__
+
+    def __truediv__(self, other: float | Length) -> Any:
+        if isinstance(other, Length):
+            return self._twips / other._twips
+        if isinstance(other, bool) or not isinstance(other, (int, float)):
+            return NotImplemented
+        return Length(_to_twips(self._twips, 1 / other))
+
+    def __neg__(self) -> Length:
+        return Length(-self._twips)
+
+    def __pos__(self) -> Length:
+        return self
+
+    def __abs__(self) -> Length:
+        return Length(abs(self._twips))
+
+    def __bool__(self) -> bool:
+        return self._twips != 0
+
+    # ---------------------------------------------------------------------------------- comparison
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Length):
+            return NotImplemented
+        return self._twips == other._twips
+
+    def __lt__(self, other: Length) -> bool:
+        if not isinstance(other, Length):
+            return NotImplemented
+        return self._twips < other._twips
+
+    def __le__(self, other: Length) -> bool:
+        if not isinstance(other, Length):
+            return NotImplemented
+        return self._twips <= other._twips
+
+    def __gt__(self, other: Length) -> bool:
+        if not isinstance(other, Length):
+            return NotImplemented
+        return self._twips > other._twips
+
+    def __ge__(self, other: Length) -> bool:
+        if not isinstance(other, Length):
+            return NotImplemented
+        return self._twips >= other._twips
+
+    def __hash__(self) -> int:
+        return hash(("Length", self._twips))
+
+    def __setattr__(self, name: str, value: object) -> None:
+        raise AttributeError("Length is immutable")
+
+    def __repr__(self) -> str:
+        return f"Length(twips={self._twips})"
+
+    def __str__(self) -> str:
+        return self.format("cm")
+
+    # ------------------------------------------------------------------------------------- pydantic
+    @classmethod
+    def __get_pydantic_core_schema__(
+        cls, _source: Any, _handler: GetCoreSchemaHandler
+    ) -> core_schema.CoreSchema:
+        def validate(value: Any) -> Length:
+            if isinstance(value, (Length, str, int)):
+                return cls.parse(value)
+            # ValueError (not TypeError) so Pydantic reports a normal ValidationError.
+            raise ValueError(
+                f"expected a Length, a string like '2cm', or an integer of twips; got {value!r}"
+            )
+
+        return core_schema.no_info_plain_validator_function(
+            validate,
+            serialization=core_schema.plain_serializer_function_ser_schema(
+                lambda length: length.format("cm"), when_used="json"
+            ),
+        )
+
+    @classmethod
+    def __get_pydantic_json_schema__(
+        cls, _schema: core_schema.CoreSchema, _handler: GetJsonSchemaHandler
+    ) -> JsonSchemaValue:
+        return {
+            "anyOf": [
+                {
+                    "type": "string",
+                    "pattern": r"^\s*[+-]?(\d+(\.\d*)?|\.\d+)\s*(tw|twips?|pt|points?|mm|cm|in|inch|inches)\s*$",
+                },
+                {"type": "integer", "description": "twips"},
+            ],
+            "description": "A length such as '2cm', '10mm', '1.5in', '12pt', or an integer number of twips.",
+        }
+
+
+def twips(value: int) -> Length:
+    """A length of ``value`` twips (1/1440 inch)."""
+    return Length(value)
+
+
+def pt(value: float) -> Length:
+    """A length of ``value`` typographic points (20 twips each)."""
+    return Length(_to_twips(value, TWIPS_PER_POINT))
+
+
+def mm(value: float) -> Length:
+    """A length of ``value`` millimetres."""
+    return Length(_to_twips(value, TWIPS_PER_MM))
+
+
+def cm(value: float) -> Length:
+    """A length of ``value`` centimetres."""
+    return Length(_to_twips(value, TWIPS_PER_CM))
+
+
+def inch(value: float) -> Length:
+    """A length of ``value`` inches."""
+    return Length(_to_twips(value, TWIPS_PER_INCH))

pyaccesskit-0.1.0.dist-info/METADATA

@@ -0,0 +1,201 @@
+Metadata-Version: 2.5
+Name: pyaccesskit
+Version: 0.1.0
+Summary: A modern, typed, Pythonic toolkit for building and modifying Microsoft Access databases and applications.
+Project-URL: Homepage, https://github.com/ariedotcodotnz/PyAccessKit
+Project-URL: Documentation, https://ariedotcodotnz.github.io/PyAccessKit/
+Project-URL: Changelog, https://github.com/ariedotcodotnz/PyAccessKit/blob/HEAD/CHANGELOG.md
+Project-URL: Issues, https://github.com/ariedotcodotnz/PyAccessKit/issues
+Project-URL: Source, https://github.com/ariedotcodotnz/PyAccessKit
+Author: Arie Joe
+License-Expression: MIT
+License-File: LICENSE
+Keywords: accdb,access,automation,com,dao,database,microsoft-access,pywin32
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Database
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: pydantic<3,>=2.7
+Requires-Dist: pywin32>=306; sys_platform == 'win32'
+Requires-Dist: typer>=0.12
+Description-Content-Type: text/markdown
+
+# PyAccessKit
+
+A modern, typed, Pythonic toolkit for building and modifying Microsoft Access databases (`.accdb`) and,
+progressively, whole Access applications without raw `pywin32` calls, DAO magic numbers or orphaned
+`MSACCESS.EXE` processes.
+
+```python
+from pyaccesskit import AccessDatabase, Column, Expr, Vba, cm
+
+with AccessDatabase.create("crm.accdb") as db:
+    db.tables.create(
+        "Customers",
+        columns=[
+            Column.autonumber("CustomerID", primary_key=True),
+            Column.text("CustomerName", length=200, required=True),
+            Column.text("Email", length=255, unique=True),
+            Column.date_time("CreatedAt", default=Expr("Now()")),
+        ],
+    )
+    db.tables.create(
+        "Orders",
+        columns=[
+            Column.autonumber("OrderID", primary_key=True),
+            Column.number("CustomerID", required=True),  # Long Integer, as in Access
+            Column.currency("Total", default=0),
+        ],
+    )
+    db.relationships.create("Customers.CustomerID", "Orders.CustomerID", cascade_delete=True)
+    db.queries.create("qryCustomers", "SELECT * FROM Customers ORDER BY CustomerName;")
+
+    with db.forms.create("frmCustomers", record_source="Customers", caption="Customers") as form:
+        form.textbox("CustomerName", label="Customer name", width=cm(8))
+        form.textbox("Email")
+        form.button("cmdClose", caption="Close", on_click=Vba("DoCmd.Close acForm, Me.Name"))
+```
+
+When the `with` block ends, the database file appears at `crm.accdb`, and any Access process PyAccessKit
+started is closed. If the block raises, no file is created and nothing is left running.
+
+> **Status:** alpha (`0.1.0`). The API may still change between 0.x releases.
+
+## Installation
+
+```console
+pip install pyaccesskit
+```
+
+Requirements:
+
+- Windows 10 or 11 and CPython 3.11–3.14 (64- or 32-bit; free-threaded builds are not supported).
+- Microsoft Access 2016 or later, including Microsoft 365. Alternatively, the Microsoft 365 Access Runtime
+  with a Python of the same bitness, for schema and data work only.
+
+Check your machine with:
+
+```console
+pyaccesskit doctor          # which engines work here, and why not
+pyaccesskit doctor --probe  # also builds a scratch database end to end
+```
+
+The spec models (`TableSpec`, `Column`, `FormSpec`, units, layout…) are pure Python and also import on
+Linux and macOS, so you can validate specs in CI without Access.
+
+## What you can do in 0.1
+
+| Area | Highlights | Stability |
+|---|---|---|
+| Lifecycle | Atomic `create()`, `open()` (read-only/shared, exclusive, password), guaranteed cleanup, `db.raw` escape hatch | stable-track |
+| Tables | Every common column type, defaults as Python values or `Expr`, validation rules, captions, formats, input masks; indexes (composite, descending, unique, primary); add, drop and rename columns and indexes; `to_spec()` round-trips | stable-track |
+| Relationships | Single and composite keys, referential integrity, cascades, join types, all checked before Access sees them | stable-track |
+| Queries & data | Saved queries (select, action, union, crosstab, pass-through), parameters bound by name, `execute()` / `fetch_all()` | stable-track |
+| Forms | Labels, text boxes, check boxes, combo boxes and buttons; stacked or tabular layout; VBA event procedures; atomic build-then-swap replacement | provisional |
+| Modules & text I/O | Standard and class modules; `SaveAsText`/`LoadFromText` for forms, reports, macros, queries and modules, stored as UTF-8 | provisional |
+| Decimal columns | `Column.decimal(precision=…, scale=…)` via ADO DDL | provisional |
+
+Reports, linked tables, VBA references, and the declarative `build`/`plan`/`apply` workflow are planned
+(see the [roadmap](https://ariedotcodotnz.github.io/PyAccessKit/#roadmap)).
+
+## Engines
+
+PyAccessKit reaches the database in one of three ways and picks one for you (`engine="auto"`):
+
+| Engine | When | Notes |
+|---|---|---|
+| In-process DAO | Python and Office have the **same bitness** | Fastest; never starts `MSACCESS.EXE`; enough for tables, relationships, queries and data |
+| Access-hosted DAO | Bitness differs, or `engine="access"` | A hidden Access instance that PyAccessKit owns hosts DAO; the database is **not** opened in the Access UI, so no startup code runs |
+| Design session | First use of forms, modules or text I/O | The database becomes Access's current database; handles such as `db.tables["X"]` keep working across the switch |
+
+| Python | Office | In-process DAO | Access transports |
+|---|---|---|---|
+| 64-bit | 64-bit | ✅ | ✅ |
+| 32-bit | 32-bit | ✅ | ✅ |
+| 64-bit | 32-bit (common with Microsoft 365) | ❌ | ✅ |
+| 32-bit | 64-bit | ❌ | ✅ |
+
+`pyaccesskit doctor` explains what applies to your machine.
+
+## Safety guarantees
+
+- **Never touches your own Access windows.** PyAccessKit always starts a *new* Access instance
+  (`CoCreateInstanceEx`, local server). It never attaches to a running Access (which `Dispatch()` does),
+  so it can never close your work.
+- **No orphaned `MSACCESS.EXE`.** Every Access process it starts is identified by PID, creation time and
+  image, and placed in a kill-on-close job object. If Python crashes, Windows ends the process. The process
+  is also recorded in an ownership ledger: `pyaccesskit cleanup` ends leftovers from crashed sessions, and
+  only when their Python owner is gone. Processes it did not start are never touched.
+- **Exceptions clean up too.** Closing runs every cleanup step even if one fails. Cleanup failures are
+  attached as notes to the exception that caused the close, never masking it.
+- **Atomic creation.** `AccessDatabase.create()` builds in a hidden sibling file and moves it into place
+  only on success. Tables are created all-or-nothing, and forms are built under a temporary name and
+  swapped in.
+- **No hangs on hidden dialogs.** A watchdog watches the windows of *our* Access process. Unexpected
+  dialogs are dismissed and reported as `AccessDialogError` with their text. Calls that exceed
+  `call_timeout` end the owned process, and Ctrl+C works during long calls.
+- **No startup code by default.** Databases are opened with macros disabled. Read-only sessions never open
+  the database in the Access UI, so `AutoExec` and startup forms do not run.
+
+## Errors you can act on
+
+COM errors are translated into specific exceptions. Each one carries what PyAccessKit was doing, the
+object involved, and the original Access or DAO error:
+
+```python
+from pyaccesskit import AccessDatabase, IntegrityViolationError
+
+with AccessDatabase.open("crm.accdb") as db:
+    try:
+        db.execute("INSERT INTO Orders (CustomerID, Total) VALUES (999, 10)")
+    except IntegrityViolationError as exc:
+        print(exc)  # what failed, with Access's own explanation
+        print(exc.details.number)  # 3201: there is no related record in Customers
+```
+
+Most mistakes are caught before Access is involved at all. A duplicate table name, an unknown column in a
+relationship, or incompatible key types each raise a precise `ObjectExistsError`, `SpecError` or
+`RelationshipError`.
+
+## Command line
+
+```console
+pyaccesskit doctor [--json] [--probe]      # environment report (exit code 3 if nothing works)
+pyaccesskit inspect DB [--json] [--counts] # tables, relationships, queries, objects; read-only
+pyaccesskit cleanup [--dry-run] [--json]   # end orphaned Access processes started by PyAccessKit
+pyaccesskit guide [--path]                 # the guide for AI coding agents
+pyaccesskit schema [KIND]                  # JSON Schema of the specs
+```
+
+Exit codes: `0` success, `1` error, `2` usage error, `3` environment unusable.
+
+## Documentation
+
+- [Getting started](https://ariedotcodotnz.github.io/PyAccessKit/getting-started/) and [recipes](https://ariedotcodotnz.github.io/PyAccessKit/guides/recipes/)
+- **[Building with AI agents](https://ariedotcodotnz.github.io/PyAccessKit/agents/)**: `pyaccesskit guide` prints a version-matched guide
+  that lets coding agents write Access applications with PyAccessKit; `pyaccesskit schema` prints the
+  JSON Schemas of the specs; the site publishes `llms.txt` and `llms-full.txt`.
+- Concepts: [engines](https://ariedotcodotnz.github.io/PyAccessKit/concepts/engines/), [lifecycle](https://ariedotcodotnz.github.io/PyAccessKit/concepts/lifecycle/),
+  [specs](https://ariedotcodotnz.github.io/PyAccessKit/concepts/specs/)
+- Guides: [tables](https://ariedotcodotnz.github.io/PyAccessKit/guides/tables/), [relationships](https://ariedotcodotnz.github.io/PyAccessKit/guides/relationships/),
+  [queries](https://ariedotcodotnz.github.io/PyAccessKit/guides/queries/), [forms](https://ariedotcodotnz.github.io/PyAccessKit/guides/forms/), [modules](https://ariedotcodotnz.github.io/PyAccessKit/guides/modules/),
+  [text I/O](https://ariedotcodotnz.github.io/PyAccessKit/guides/text-io/)
+- Reference: [errors](https://ariedotcodotnz.github.io/PyAccessKit/reference/errors/), [data types](https://ariedotcodotnz.github.io/PyAccessKit/reference/data-types/),
+  [command line](https://ariedotcodotnz.github.io/PyAccessKit/reference/cli/), and an API reference generated from the docstrings
+- [Environment & troubleshooting](https://ariedotcodotnz.github.io/PyAccessKit/environment/), [FAQ](https://ariedotcodotnz.github.io/PyAccessKit/faq/),
+  [contributing](https://ariedotcodotnz.github.io/PyAccessKit/contributing/), [architecture decisions](https://github.com/ariedotcodotnz/PyAccessKit/tree/HEAD/docs/adr)
+- Examples: [`examples/`](https://github.com/ariedotcodotnz/PyAccessKit/tree/HEAD/examples) (`04_inventory_app.py` is the complete, tested application the agent
+  guide walks through)
+
+## License
+
+MIT. See [LICENSE](https://github.com/ariedotcodotnz/PyAccessKit/blob/HEAD/LICENSE).

pyaccesskit-0.1.0.dist-info/RECORD

@@ -0,0 +1,86 @@
+pyaccesskit/AGENT_GUIDE.md,sha256=aoLu67-zUau0vFG5o_98ZFnnVLeIOKSlmysuG_033m8,23262
+pyaccesskit/__init__.py,sha256=mWCH8BYs6BCaIyOy0I52j6UAmtaJRLeB4YupitMVdoQ,3714
+pyaccesskit/__main__.py,sha256=-wO3_oGdJ1BGc_y9RMNWRX1MOPhFqZcY-fCWgXu1cZU,138
+pyaccesskit/_ledger.py,sha256=9q3UKnn_xC5qQ5TgyJw1CExByqieEGY22sIA4-ne0h4,5472
+pyaccesskit/_version.py,sha256=Y_2bqYDoRNq0PnhUrLbcwDTa_O-tiNwjoBWEyVHCbyk,97
+pyaccesskit/database.py,sha256=6iSzKwTWcfhYB6xtCkCl8Xguvvfv4apa-6F1aCfROIE,11135
+pyaccesskit/diagnostics.py,sha256=uloHujGHFtKH8v-1F-pHu09JGy11cb54Z3pL1u87fQQ,11372
+pyaccesskit/enums.py,sha256=VPmMAv1stpjOEXLMScQL7t4AOXk4EjSI1DLe7bw6NWw,7405
+pyaccesskit/errors.py,sha256=rN3rTHE2svxomhX33WrCJ9sB30gxv51-RtwcGYXMsGU,13220
+pyaccesskit/maintenance.py,sha256=I2s7OMT-ZgXIJAMnZC3_TwZxZlBPWj80LlbhCavtZiQ,1267
+pyaccesskit/modules.py,sha256=nEvOq96BRZ1l-t5KS1I8zBJRl5dqd4_WUWNPj1IL2rE,3670
+pyaccesskit/objects.py,sha256=5FnK5CZWDBx79zWYecNK4R8FXrTXMjlTU6bLB3erQGo,3242
+pyaccesskit/options.py,sha256=zcm_yezWvdbVmVN-RfjdjQlHi6cab-XGdhp_qb2nzOY,1871
+pyaccesskit/properties.py,sha256=EWEExLazI8SMuOCTJHea_7LAtJnRlFWCQSvmhOBrCqg,2820
+pyaccesskit/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyaccesskit/queries.py,sha256=YGBF5i_ykKZMWJfKfQqeZsUp-0KOtA5uf7-2assqi_s,6629
+pyaccesskit/relationships.py,sha256=-7gW36qpvQCYgTkFevlu7b8ZzqVevXZRaDMaXvulQAg,4754
+pyaccesskit/tables.py,sha256=eWNsJj6MJdvBBLt2T-Fy8UDtKHEU2tqRYF7I6eZ4w-A,11619
+pyaccesskit/units.py,sha256=GNN6qcPspZEjGlrSK7A5-7A2wH1gojt2mxUWAfcxb7Y,10125
+pyaccesskit/_backends/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyaccesskit/_backends/protocols.py,sha256=-dmQTGpvyZ2gD78-FK_3KN-7CoqDEulo-HGLkpgzNSw,10475
+pyaccesskit/_backends/access/__init__.py,sha256=XoP3TE17S_WWjVhanyMrmZ1Wnj6nUuH2Uk-2oYst7BA,72
+pyaccesskit/_backends/access/design.py,sha256=_MMXPz-IiaVdA-Kdr_M_uHdmo92qnLp-uBX5LlWVUOA,17368
+pyaccesskit/_backends/dao/__init__.py,sha256=pdzTRkF-LVtPiuGfRJBl4zAs8eZiweby26Tteg9fvJo,57
+pyaccesskit/_backends/dao/profile.py,sha256=hHxKK_lnN58a96_qZoA_9ZwEUylrBGciQNboEc7bwUc,1640
+pyaccesskit/_backends/dao/schema.py,sha256=vWe892shAl5HSF7MrCnHoWlBrD3fNC3Qfpa_ybAY6Ck,33780
+pyaccesskit/_backends/dao/typemap.py,sha256=KaGCKcD3ZlcBh7atIaPvkgcchIjSdibi4DrunDZfT8o,12918
+pyaccesskit/_backends/fake/__init__.py,sha256=VDcYa1B2vZAWMnoJW9qG6di9rMYy_8j5MJZGkUx9zOU,86
+pyaccesskit/_backends/fake/backend.py,sha256=rI39xSbgc_kC-XvGLO80cYati-aibi64gMOd3pGsIc0,27386
+pyaccesskit/_com/__init__.py,sha256=2yeD-cfAEkAQtCJCFIuH-OkjfHV3ehT8U892SwS0LU4,89
+pyaccesskit/_com/constants.py,sha256=PrTiwyb_Jd-LpL4qpkjzE05Z6B9ou3b6UlZiZqhjEwk,10145
+pyaccesskit/_com/dispatch.py,sha256=lGblOMRuLM4KlZ0Qmyick8-jhviIRZHjo1gsEdvPwow,2054
+pyaccesskit/_com/errors.py,sha256=uu4ihD7JbZubK0AW52hs3usp-9J2yC6MrZqL4rrikzw,6747
+pyaccesskit/_com/gateway.py,sha256=N6KThEiPnge8OWOPQ_i_jQKNkBB961IdCCMycSZTnKg,7209
+pyaccesskit/_com/raw.py,sha256=xj-Uxqnw9JyE1FWphJH3pP_3B0YAYPK7lz2lEKPzw8s,6472
+pyaccesskit/_com/runtime.py,sha256=Oulp7DBjGOXBaWy2YtYAXIpBkR2FjKiRc10OxTspFEc,1365
+pyaccesskit/_com/variants.py,sha256=CbgD9HSbc1Vr5CkwYyWWfIvEgmq8YlLBWLG16p5_fGw,2606
+pyaccesskit/_engines/__init__.py,sha256=EEwx_0Z3Efbk7Tj7aGruRSx5e2sw5ZvmhkxTKVCHuAo,1539
+pyaccesskit/_engines/access.py,sha256=XH0wjqYUTYL4_nB7Xf8nGGwlWZbXttZPzv8ygq0nVEc,11536
+pyaccesskit/_engines/inproc.py,sha256=vbDYUjE93E6G4g2_8JMPY4iehg3cruO888Uc44qeXHw,5632
+pyaccesskit/_engines/probe.py,sha256=VhmFQCRgRTIGErUrFVg9xdL47W0TWPuuiaWkufFYWg8,7800
+pyaccesskit/_ops/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyaccesskit/_ops/design.py,sha256=3FQV_q6KXvG-2qtp1_7gEteNmGCnfa8wojwJi_sfU2Y,5261
+pyaccesskit/_ops/schema.py,sha256=w1JaKpKgGLrqK3y9sfa2Px_p849Jq5dhADp2ZfdpKO8,18765
+pyaccesskit/_session/__init__.py,sha256=COEPkJJZ211VBdtL1hKrSBjpQw4aHABRzJig0u61HEk,37
+pyaccesskit/_session/protocols.py,sha256=Rmra7Q40_ifzaXzTHG6LZ9Om2r0GFFTcNqtSRJQ0JG8,2281
+pyaccesskit/_session/session.py,sha256=QfNJl3FXEX_xkIzvFqjlBxY3412_E_tQafyOHtmA57M,13910
+pyaccesskit/_text/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyaccesskit/_text/codec.py,sha256=mtNijZTAkLb_N1p-dWs9oPJ0j_Pru4DP9Hs9fc6VtiY,4542
+pyaccesskit/_win/__init__.py,sha256=fVmdNR3LqQ4yO5uXmMMqpNse2y8Doh1HerNESLFRvaI,74
+pyaccesskit/_win/access_process.py,sha256=PyNNgJciGvyS4M_DeOfbtnW1M6_3j--0DYl0W6X6Mww,13918
+pyaccesskit/_win/console.py,sha256=aJNJdSr5QGVvK-goiFRzEockVeodsPTQ9IkHACNuUjs,1987
+pyaccesskit/_win/inspector.py,sha256=iCpo8gpO_f7g0Xhl3NgIds_JnSjT449BmU9HqtwQLZY,1654
+pyaccesskit/_win/job.py,sha256=lSORBjfLv5DvsPFCC9VsD3COkSJ6gOXqgjAzdbNHXEE,2419
+pyaccesskit/_win/processes.py,sha256=RCrQtuyOVl8kStgXPsMVWnMeLLRJN7WN8OSvfygcg2k,5087
+pyaccesskit/_win/watchdog.py,sha256=fdD1gpWnlgK-EJ_KnkGsC5h_JuTPwV6_6-g8FhHwrIs,10176
+pyaccesskit/cli/__init__.py,sha256=UYgcIpZjVC72lvjjTrFpORxIo2aGcelRxGxMQ6XdOyk,319
+pyaccesskit/cli/_output.py,sha256=zOB2OqiLRghfQLy7jAkmKNMTqDVQlO38M4MzX0rqd-U,3170
+pyaccesskit/cli/agent.py,sha256=JTLOFjfoR-IDXyqEi1QncTFieuLvCGpKleNx1FnLZNY,3012
+pyaccesskit/cli/app.py,sha256=EEF0ETLx9aKCaL4ELMc9ecsrTeONw-2GJUhY2DOgs7I,1435
+pyaccesskit/cli/cleanup.py,sha256=6lNbgp3BvOe7dvBpemaf_36rlfQfL3sgpmLCTaBSqWo,2127
+pyaccesskit/cli/doctor.py,sha256=OUyE7evPd6RBMl4i4SzFoQGS_iPkuuG5CA5HzqbqU-w,3956
+pyaccesskit/cli/inspection.py,sha256=qnghAMfDkyyXxc5Ghsrtdy1G6Aq14l1t78ONeVkrF6o,8812
+pyaccesskit/forms/__init__.py,sha256=UvUDMCrJK5YFdEi5Le18nTDS3tyHIsJlTmtzWuOL2RE,967
+pyaccesskit/forms/builder.py,sha256=IVHn6g3ERgabLpVbELfplG2BCWipm4_14FpYQKWRT0k,10135
+pyaccesskit/forms/collection.py,sha256=bR09O_C5y1McwHOGNYvv-F-tkTPdAdideyxStkHPKTo,4427
+pyaccesskit/forms/controls.py,sha256=PnmqgffPL0ruTpiI_dQTFnaQOop0L0uP87ME67ivVIU,5330
+pyaccesskit/forms/layout.py,sha256=7IshbmwQ-d7Wh-4fNTjlKJnbiL5DQ1lwPv7NzbIFmwg,10892
+pyaccesskit/forms/spec.py,sha256=LoamddafCn_Do3B71u-x-2C0HDQR4F82Jm-JlmGRCh0,7170
+pyaccesskit/forms/vba.py,sha256=XCvNZ2QmEgYJ-KZjBzoJj1VJElCzfDaBIYi6C8k1hw8,4928
+pyaccesskit/schema/__init__.py,sha256=uerme7BX7U3obaLBHyt5iYHrb8oLH-_lUJUZegxHh0s,1878
+pyaccesskit/schema/_base.py,sha256=lEKSozfcCcq8ZU0YEQv9ZgvyrXfXFWUTTZTU1gACcEw,2070
+pyaccesskit/schema/_reserved_words.py,sha256=49auHhwSN7113MHDYtIVt40JW3b3y_nZ0BOPIURVqa0,4308
+pyaccesskit/schema/columns.py,sha256=v8VwVxeE3Eo7_o7f3Pdkt9-8oRj72gko30mtqpzmXFE,20979
+pyaccesskit/schema/compat.py,sha256=euH8zFW8fU1eguOPnfv2wPbk044Av4mOqefAJEBgDN0,1829
+pyaccesskit/schema/expressions.py,sha256=83RIyxqaN9QVp3UOw-mhc9JRmrm8oydcC4yz3_NgUPE,5859
+pyaccesskit/schema/indexes.py,sha256=eWMrHmM6yPoB6sQz4zG-8PDk8-aPuyf3wY6JDuOon58,3964
+pyaccesskit/schema/names.py,sha256=FDPxz-bOyzG2oL3ny5cy0-5xKRiY9vQkhu0NGnQzKRM,4179
+pyaccesskit/schema/queries.py,sha256=K-zGSnp0nk8KWaiu-rfAdIc8FgW6OOBKb_x5s7Bl4E4,6352
+pyaccesskit/schema/relationships.py,sha256=S8VOkf-CqMd3CT5Kr7M6wzYOPU6i32pX8rb6XPu6Uhw,5632
+pyaccesskit/schema/tables.py,sha256=HPr0b_PwoAq9wn4BL1NjcWDWDDk-khx8XoWfOg5ehNA,7344
+pyaccesskit-0.1.0.dist-info/METADATA,sha256=3YoLUOx13Cgq-rwvQQJnsmqpk0K9AuqXGy1nf9wlMK8,11165
+pyaccesskit-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+pyaccesskit-0.1.0.dist-info/entry_points.txt,sha256=uej_q9QiApCGzSHB_jdp8YsIEGZfVmeAMomSeH8bASo,53
+pyaccesskit-0.1.0.dist-info/licenses/LICENSE,sha256=k6V4ZLGuzf_kqxWbvrJwgbHBIW52My0HV-aYARZJULw,1065
+pyaccesskit-0.1.0.dist-info/RECORD,,

pyaccesskit-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

pyaccesskit-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pyaccesskit = pyaccesskit.cli:main

pyaccesskit-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Arie Joe
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.