liminal-orm 4.1.1__tar.gz → 4.2.0__tar.gz

liminal_orm-4.2.0/.gitignore

@@ -0,0 +1,20 @@
+# python generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+.mypy_cache
+.ruff_cache
+# venv
+.venv
+
+.DS_store
+**/*.ipynb
+
+# mkdocs documentation
+/site
+
+# for local testing
+/test_liminal

{liminal_orm-4.1.1 → liminal_orm-4.2.0}/PKG-INFO

@@ -1,32 +1,27 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: liminal-orm
-Version: 4.1.1
+Version: 4.2.0
 Summary: An ORM and toolkit that builds on top of Benchling's platform to keep your schemas and downstream code dependencies in sync.
-Home-page: https://github.com/dynotx/liminal-orm
-Author: DynoTx Open Source
-Author-email: opensource@dynotx.com
-Requires-Python: >=3.9,<4
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: benchling-sdk (>=1.21.2,<2.0.0)
-Requires-Dist: bs4 (>=0.0.2,<0.0.3)
-Requires-Dist: lxml (>=5.3.0,<6.0.0)
-Requires-Dist: numpy (>=1.23.5,<2.0.0)
-Requires-Dist: pandas (>=1.5.3,<2.0.0)
-Requires-Dist: psycopg2-binary (>=2.9.10,<3.0.0)
-Requires-Dist: pydantic (>=2,<=2.7)
-Requires-Dist: requests (>=2.32.3,<3.0.0)
-Requires-Dist: rich (>=13.9.2,<14.0.0)
-Requires-Dist: sqlalchemy (<2)
-Requires-Dist: tenacity (>=8,<10)
-Requires-Dist: tornado (==6.5.0)
-Requires-Dist: typer (>=0.12.5,<0.13.0)
-Project-URL: Bug Tracker, https://github.com/dynotx/liminal-orm/issues
-Project-URL: Documentation, https://dynotx.github.io/liminal-orm/
+Project-URL: Homepage, https://github.com/dynotx/liminal-orm
 Project-URL: Repository, https://github.com/dynotx/liminal-orm
+Project-URL: Documentation, https://dynotx.github.io/liminal-orm/
+Project-URL: Bug Tracker, https://github.com/dynotx/liminal-orm/issues
+Author-email: DynoTx Open Source <opensource@dynotx.com>
+License-File: LICENSE.md
+Requires-Python: <4,>=3.9
+Requires-Dist: benchling-sdk<2,>=1.21.2
+Requires-Dist: bs4<0.0.3,>=0.0.2
+Requires-Dist: lxml<6,>=5.3.0
+Requires-Dist: numpy<2,>=1.23.5
+Requires-Dist: pandas<2,>=1.5.3
+Requires-Dist: psycopg2-binary<3,>=2.9.10
+Requires-Dist: pydantic<=2.7,>=2
+Requires-Dist: requests<3,>=2.32.3
+Requires-Dist: rich<14,>=13.9.2
+Requires-Dist: sqlalchemy<2
+Requires-Dist: tenacity<10,>=8
+Requires-Dist: tornado==6.5.0
+Requires-Dist: typer<0.13,>=0.12.5
 Description-Content-Type: text/markdown
 
 # [Liminal ORM](#liminal-orm)
@@ -152,4 +147,3 @@ ORM<sup>1</sup>: Object-Relational Mapper. An ORM is a piece of software designe
 LIMS<sup>2</sup>: Laboratory Information Management System. A LIMS is a piece of software that allows you to effectively manage samples and associated data. [Benchling](https://www.benchling.com/) is an industry-leading LIMS software.
 
 CLI<sup>3</sup>: Command Line Interface. A CLI is a piece of software that allows you to interact with a software program via the command line. Liminal provides a CLI that allows you to interact with your Liminal environment. This project uses [Typer](https://github.com/fastapi/typer) to construct the CLI
-

{liminal_orm-4.1.1 → liminal_orm-4.2.0}/liminal/base/base_dropdown.py

@@ -1,6 +1,9 @@
 from abc import ABC
 from typing import Any
 
+from liminal.connection.benchling_service import BenchlingService
+from liminal.dropdowns.utils import get_benchling_dropdown_summaries
+
 
 class BaseDropdown(ABC):
     """_summary_
@@ -35,6 +38,30 @@ class BaseDropdown(ABC):
         cls._existing_benchling_names.add(cls.__benchling_name__)
         return super().__new__(cls, **kwargs)
 
+    @classmethod
+    def get_id(cls, benchling_service: BenchlingService) -> str:
+        """Connects to Benchling and returns the id of the dropdown using the __benchling_name__.
+
+        Parameters
+        ----------
+        benchling_service : BenchlingService
+            The Benchling service to use.
+
+        Returns
+        -------
+        str
+            The id of the dropdown.
+        """
+        all_dropdowns = get_benchling_dropdown_summaries(benchling_service)
+        dropdowns_found_by_name = [
+            d for d in all_dropdowns if d.name == cls.__benchling_name__
+        ]
+        if len(dropdowns_found_by_name) == 0:
+            raise ValueError(f"No dropdowns found with name '{cls.__benchling_name__}'")
+        else:
+            dropdown = dropdowns_found_by_name[0]
+            return dropdown.id
+
     @classmethod
     def validate(cls, *values: str | None) -> None:
         err_values = []

{liminal_orm-4.1.1 → liminal_orm-4.2.0}/liminal/cli/cli.py

@@ -83,7 +83,7 @@ connection = BenchlingConnection(
 
 @app.command(
     name="generate-files",
-    help="Generates the dropdown, entity schema, and results schema files from your Benchling tenant and writes to the given path. By default, this will overwrite any existing files within the {write_path}/dropdowns/, {write_path}/entity_schemas/, and {write_path}/results_schemas/ directories.",
+    help="Generates the dropdown, entity schema, and results schema files from your Benchling tenant and writes to the given path. By default, this will not overwrite existing files.",
 )
 def generate_files(
     benchling_tenant: str = typer.Argument(
@@ -117,7 +117,7 @@ def generate_files(
         False,
         "-o",
         "--overwrite",
-        help="Overwrite existing files within the {write_path}/dropdowns/, {write_path}/entity_schemas/, and {write_path}/results_schemas/ directories.",
+        help="Overwrite the whole write directory at the given path.",
     ),
 ) -> None:
     _, benchling_connection = read_local_liminal_dir(LIMINAL_DIR_PATH, benchling_tenant)

{liminal_orm-4.1.1 → liminal_orm-4.2.0}/liminal/dropdowns/generate_files.py

@@ -21,7 +21,7 @@ def generate_all_dropdown_files(
     write_path : Path
         The path to write the generated files to. dropdowns/ directory will be created within this path.
     overwrite : bool
-        Whether to overwrite existing the existing dropdowns/ directory.
+        Whether to overwrite existing files in the dropdowns/ directory.
     """
     write_path = write_path / "dropdowns"
     if write_path.exists() and overwrite:
@@ -33,6 +33,7 @@ def generate_all_dropdown_files(
 
     dropdowns = get_benchling_dropdowns_dict(benchling_service)
     file_names_to_classname = []
+    num_files_written = 0
     for dropdown_name, dropdown_options in dropdowns.items():
         dropdown_values = [option.name for option in dropdown_options.options]
         options_list = str(dropdown_values).replace("'", '"')
@@ -46,8 +47,10 @@ class {classname}(BaseDropdown):
     __allowed_values__ = {options_list}
 """
         filename = to_snake_case(dropdown_name) + ".py"
-        with open(write_path / filename, "w") as file:
-            file.write(dropdown_content)
+        if overwrite or not (write_path / filename).exists():
+            with open(write_path / filename, "w") as file:
+                file.write(dropdown_content)
+            num_files_written += 1
         file_names_to_classname.append((filename, classname))
 
     file_names_to_classname.sort(key=lambda x: x[0])
@@ -55,8 +58,13 @@ class {classname}(BaseDropdown):
         f"from .{filename[:-3]} import {classname}"
         for filename, classname in file_names_to_classname
     )
-    with open(write_path / "__init__.py", "w") as file:
-        file.write(import_statements)
+    if num_files_written > 0:
+        with open(write_path / "__init__.py", "w") as file:
+            file.write(import_statements)
         print(
-            f"[green]Generated {write_path / '__init__.py'} with {len(file_names_to_classname)} dropdown imports."
+            f"[green]Generated {write_path / '__init__.py'} with {len(file_names_to_classname)} dropdown imports. {num_files_written} dropdown files written."
+        )
+    else:
+        print(
+            "[green dim]No new dropdown files to be written. If you want to overwrite existing files, run with -o flag."
         )

{liminal_orm-4.1.1 → liminal_orm-4.2.0}/liminal/dropdowns/utils.py

@@ -1,3 +1,4 @@
+from functools import lru_cache
 from typing import Any
 
 import requests
@@ -6,7 +7,6 @@ from benchling_sdk.models import Dropdown, DropdownOption, DropdownSummary
 from pydantic import BaseModel
 
 from liminal.connection import BenchlingService
-from liminal.orm.base_model import BaseModel as BenchlingBaseModel
 
 
 class ArchiveRecord(BaseModel):
@@ -22,6 +22,7 @@ def get_benchling_dropdown_id_name_map(
     return {d.id: d.name for d in get_benchling_dropdown_summaries(benchling_service)}
 
 
+@lru_cache
 def get_benchling_dropdown_summaries(
     benchling_service: BenchlingService,
 ) -> list[DropdownSummary]:
@@ -110,6 +111,8 @@ def dropdown_exists_in_benchling(
 
 
 def get_schemas_with_dropdown(dropdown_name: str) -> list[str]:
+    from liminal.orm.base_model import BaseModel as BenchlingBaseModel
+
     schemas_with_dropdown = []
     for model in BenchlingBaseModel.get_all_subclasses():
         for props_dict in [

{liminal_orm-4.1.1 → liminal_orm-4.2.0}/liminal/entity_schemas/generate_files.py

@@ -63,7 +63,7 @@ def generate_all_entity_schema_files(
     write_path : Path
         The path to write the generated files to. entity_schemas/ directory will be created within this path.
     overwrite : bool
-        Whether to overwrite existing the existing entity_schemas/ directory.
+        Whether to overwrite existing files in the entity_schemas/ directory.
     """
     write_path = write_path / "entity_schemas"
     if write_path.exists() and overwrite:
@@ -76,6 +76,7 @@ def generate_all_entity_schema_files(
     models = get_converted_tag_schemas(benchling_service)
     has_date = False
     subdirectory_map: dict[str, list[tuple[str, str]]] = {}
+    subdirectory_num_files_written: dict[str, int] = {}
     dropdown_name_to_classname_map = _get_dropdown_name_to_classname_map(
         benchling_service
     )
@@ -188,39 +189,45 @@ class {classname}(BaseModel, {get_entity_mixin(schema_properties.entity_type)}):
 {init_string}
 
 """
-        write_directory_path = write_path / get_file_subdirectory(
-            schema_properties.entity_type
-        )
-        subdirectory_map[get_file_subdirectory(schema_properties.entity_type)] = (
-            subdirectory_map.get(
-                get_file_subdirectory(schema_properties.entity_type), []
-            )
-            + [(filename, classname)]
-        )
+        subdirectory_name = get_file_subdirectory(schema_properties.entity_type)
+        write_directory_path = write_path / subdirectory_name
+        if not subdirectory_map.get(subdirectory_name):
+            subdirectory_map[subdirectory_name] = []
+            subdirectory_num_files_written[subdirectory_name] = 0
+        subdirectory_map[subdirectory_name].append((filename, classname))
         write_directory_path.mkdir(exist_ok=True)
-        with open(write_directory_path / filename, "w") as file:
-            file.write(full_content)
+        if overwrite or not (write_directory_path / filename).exists():
+            with open(write_directory_path / filename, "w") as file:
+                file.write(full_content)
+            subdirectory_num_files_written[subdirectory_name] += 1
 
     for subdir, names in subdirectory_map.items():
-        init_content = (
-            "\n".join(
-                f"from .{filename[:-3]} import {classname}"
-                for filename, classname in names
+        if subdirectory_num_files_written[subdir] > 0:
+            init_content = (
+                "\n".join(
+                    f"from .{filename[:-3]} import {classname}"
+                    for filename, classname in names
+                )
+                + "\n"
             )
-            + "\n"
-        )
-        with open(write_path / subdir / "__init__.py", "w") as file:
-            file.write(init_content)
-
-    with open(write_path / "__init__.py", "w") as file:
-        file.write(
-            "\n".join(
-                f"from .{subdir} import * # noqa" for subdir in subdirectory_map.keys()
+            with open(write_path / subdir / "__init__.py", "w") as file:
+                file.write(init_content)
+
+    if sum(subdirectory_num_files_written.values()) > 0:
+        with open(write_path / "__init__.py", "w") as file:
+            file.write(
+                "\n".join(
+                    f"from .{subdir} import * # noqa"
+                    for subdir in subdirectory_map.keys()
+                )
+                + "\n"
             )
-            + "\n"
-        )
+            print(
+                f"[green]Generated {write_path / '__init__.py'} with {sum(subdirectory_num_files_written.values())} entity schema files written."
+            )
+    else:
         print(
-            f"[green]Generated {write_path / '__init__.py'} with {len(models)} entity schema imports."
+            "[green dim]No new entity schema files to be written. If you want to overwrite existing files, run with -o flag."
         )
 
 
@@ -237,8 +244,7 @@ def _get_dropdown_name_to_classname_map(
             for dropdown in BaseDropdown.get_all_subclasses()
         }
     benchling_dropdowns = get_benchling_dropdowns_dict(benchling_service)
-    if len(benchling_dropdowns) > 0:
-        raise Exception(
-            "No dropdowns found locally. Please ensure your env.py file imports your dropdown classes or generate dropdowns from your Benchling tenant first."
-        )
-    return {}
+    return {
+        dropdown_name: to_pascal_case(dropdown_name)
+        for dropdown_name in benchling_dropdowns.keys()
+    }

{liminal_orm-4.1.1 → liminal_orm-4.2.0}/liminal/entity_schemas/utils.py

@@ -1,3 +1,5 @@
+from functools import lru_cache
+
 from benchling_sdk.models import EntitySchema
 
 from liminal.base.properties.base_field_properties import BaseFieldProperties
@@ -136,6 +138,7 @@ def convert_tag_schema_field_to_field_properties(
     )
 
 
+@lru_cache
 def get_benchling_entity_schemas(
     benchling_service: BenchlingService,
 ) -> list[EntitySchema]:

{liminal_orm-4.1.1 → liminal_orm-4.2.0}/liminal/orm/base_model.py

@@ -13,6 +13,8 @@ from sqlalchemy.orm.decl_api import declared_attr
 
 from liminal.base.base_dropdown import BaseDropdown
 from liminal.base.base_validation_filters import BaseValidatorFilters
+from liminal.connection.benchling_service import BenchlingService
+from liminal.entity_schemas.utils import get_benchling_entity_schemas
 from liminal.enums import BenchlingNamingStrategy
 from liminal.enums.benchling_entity_type import BenchlingEntityType
 from liminal.enums.sequence_constraint import SequenceConstraint
@@ -279,6 +281,33 @@ class BaseModel(Generic[T], Base):
             query = query.filter(User.name.in_(base_filters.creator_full_names))
         return query
 
+    @classmethod
+    def get_id(cls, benchling_service: BenchlingService) -> str:
+        """Connects to Benchling and returns the id of the schema using the __schema_properties__.name.
+
+        Parameters
+        ----------
+        benchling_service : BenchlingService
+            The Benchling service to use.
+
+        Returns
+        -------
+        str
+            The id of the schema.
+        """
+        all_schemas = get_benchling_entity_schemas(benchling_service)
+
+        schemas_found_by_name = [
+            s for s in all_schemas if s.name == cls.__schema_properties__.name
+        ]
+        if len(schemas_found_by_name) == 0:
+            raise ValueError(
+                f"No schema found with name '{cls.__schema_properties__.name}'."
+            )
+        else:
+            schema = schemas_found_by_name[0]
+            return schema.id
+
     @classmethod
     def all(cls, session: Session) -> list[T]:
         """Uses the get_query method to retrieve all entities from the database.

{liminal_orm-4.1.1 → liminal_orm-4.2.0}/liminal/orm/base_results_model.py

@@ -12,9 +12,11 @@ from sqlalchemy.orm import Query, RelationshipProperty, Session, relationship
 from sqlalchemy.orm.decl_api import declared_attr
 
 from liminal.base.base_validation_filters import BaseValidatorFilters
+from liminal.connection.benchling_service import BenchlingService
 from liminal.orm.base import Base
 from liminal.orm.base_tables.user import User
 from liminal.orm.results_schema_properties import ResultsSchemaProperties
+from liminal.results_schemas.utils import get_benchling_results_schemas
 from liminal.validation import BenchlingValidatorReport
 
 T = TypeVar("T")
@@ -83,6 +85,33 @@ class BaseResultsModel(Generic[T], Base):
             query = query.filter(User.name.in_(base_filters.creator_full_names))
         return query
 
+    @classmethod
+    def get_id(cls, benchling_service: BenchlingService) -> str:
+        """Connects to Benchling and returns the id of the results schema using the __schema_properties__.name.
+
+        Parameters
+        ----------
+        benchling_service : BenchlingService
+            The Benchling service to use.
+
+        Returns
+        -------
+        str
+            The id of the results schema.
+        """
+        all_schemas = get_benchling_results_schemas(benchling_service)
+
+        schemas_found_by_name = [
+            s for s in all_schemas if s.name == cls.__schema_properties__.name
+        ]
+        if len(schemas_found_by_name) == 0:
+            raise ValueError(
+                f"No results schema found with name '{cls.__schema_properties__.name}'."
+            )
+        else:
+            schema = schemas_found_by_name[0]
+            return schema.id
+
     @classmethod
     def all(cls, session: Session) -> list[T]:
         """Uses the get_query method to retrieve all results schema rows from the database.

{liminal_orm-4.1.1 → liminal_orm-4.2.0}/liminal/results_schemas/generate_files.py

@@ -29,7 +29,7 @@ def generate_all_results_schema_files(
     write_path : Path
         The path to write the generated files to. results_schemas/ directory will be created within this path.
     overwrite : bool
-        Whether to overwrite existing the existing results_schemas/ directory.
+        Whether to overwrite existing files in the results_schemas/ directory.
     """
     write_path = write_path / "results_schemas"
     if write_path.exists() and overwrite:
@@ -47,6 +47,7 @@ def generate_all_results_schema_files(
         benchling_service
     )
     init_file_imports = []
+    num_files_written = 0
 
     for schema_properties, field_properties_dict in results_schemas:
         has_date = False
@@ -147,14 +148,21 @@ class {schema_name}(BaseResultsModel):
 {init_string}
 """
 
-        with open(write_path / file_name, "w") as file:
-            file.write(schema_content)
+        if overwrite or not (write_path / file_name).exists():
+            with open(write_path / file_name, "w") as file:
+                file.write(schema_content)
+            num_files_written += 1
 
-    with open(write_path / "__init__.py", "w") as file:
-        file.write("\n".join(init_file_imports))
-    print(
-        f"[green]Generated {write_path / '__init__.py'} with {len(results_schemas)} entity schema imports."
-    )
+    if num_files_written > 0:
+        with open(write_path / "__init__.py", "w") as file:
+            file.write("\n".join(init_file_imports))
+        print(
+            f"[green]Generated {write_path / '__init__.py'} with {len(results_schemas)} entity schema imports. {num_files_written} results schema files written."
+        )
+    else:
+        print(
+            "[green dim]No new results schema files to be written. If you want to overwrite existing files, run with -o flag."
+        )
 
 
 def _get_dropdown_name_to_classname_map(
@@ -170,11 +178,10 @@ def _get_dropdown_name_to_classname_map(
             for dropdown in BaseDropdown.get_all_subclasses()
         }
     benchling_dropdowns = get_benchling_dropdowns_dict(benchling_service)
-    if len(benchling_dropdowns) > 0:
-        raise Exception(
-            "No dropdowns found locally. Please ensure your env.py file imports your dropdown classes or generate dropdowns from your Benchling tenant first."
-        )
-    return {}
+    return {
+        dropdown_name: to_pascal_case(dropdown_name)
+        for dropdown_name in benchling_dropdowns.keys()
+    }
 
 
 def _get_entity_schemas_wh_name_to_classname(
@@ -190,8 +197,7 @@ def _get_entity_schemas_wh_name_to_classname(
             for s in BaseModel.get_all_subclasses()
         }
     tag_schemas = get_converted_tag_schemas(benchling_service)
-    if len(tag_schemas) > 0:
-        raise Exception(
-            "No entity schemas found locally. Please ensure your env.py file imports your entity schema classes or generate entity schemas from your Benchling tenant first."
-        )
-    return {}
+    return {
+        schema_props.warehouse_name: to_pascal_case(schema_props.warehouse_name)
+        for schema_props, _, _ in tag_schemas
+    }

{liminal_orm-4.1.1 → liminal_orm-4.2.0}/liminal/results_schemas/utils.py

@@ -1,3 +1,5 @@
+from functools import lru_cache
+
 from benchling_api_client.v2.stable.models.assay_result_schema import AssayResultSchema
 
 from liminal.base.properties.base_field_properties import BaseFieldProperties
@@ -35,14 +37,10 @@ def get_converted_results_schemas(
     return results_schemas_list
 
 
-def get_results_schemas_dict(
+@lru_cache
+def get_benchling_results_schemas(
     benchling_service: BenchlingService,
-) -> dict[str, AssayResultSchema]:
-    """This function gets all Results Schema schemas using the Benchling API and returns a dictionary of the schemas by their system name."""
-    flattened_schemas = [
-        s
-        for schemas in list(benchling_service.schemas.list_assay_result_schemas())
-        for s in schemas
+) -> list[AssayResultSchema]:
+    return [
+        s for loe in benchling_service.schemas.list_assay_result_schemas() for s in loe
     ]
-    schemas_dict = {s.system_name: s for s in flattened_schemas}
-    return schemas_dict

liminal_orm-4.2.0/pyproject.toml

@@ -0,0 +1,81 @@
+[project]
+name = "liminal-orm"
+version = "4.2.0"
+description = "An ORM and toolkit that builds on top of Benchling's platform to keep your schemas and downstream code dependencies in sync."
+authors = [{ name = "DynoTx Open Source", email = "opensource@dynotx.com" }]
+requires-python = ">=3.9,<4"
+readme = "README.md"
+dependencies = [
+    "benchling-sdk>=1.21.2,<2",
+    "bs4>=0.0.2,<0.0.3",
+    "numpy>=1.23.5,<2",
+    "pandas>=1.5.3,<2",
+    "pydantic>=2,<=2.7",
+    "requests>=2.32.3,<3",
+    "rich>=13.9.2,<14",
+    "sqlalchemy<2",
+    "tenacity>=8,<10",
+    "typer>=0.12.5,<0.13",
+    "lxml>=5.3.0,<6",
+    "psycopg2-binary>=2.9.10,<3",
+    "tornado==6.5.0",
+]
+
+[virtualenvs]
+in-project = true
+
+[[tool.uv.index]]
+name = "testpypi"
+url = "https://test.pypi.org/simple/"
+publish-url = "https://test.pypi.org/legacy/"
+explicit = true
+
+[project.urls]
+Homepage = "https://github.com/dynotx/liminal-orm"
+Repository = "https://github.com/dynotx/liminal-orm"
+Documentation = "https://dynotx.github.io/liminal-orm/"
+"Bug Tracker" = "https://github.com/dynotx/liminal-orm/issues"
+
+[project.scripts]
+liminal = "liminal.cli.cli:app"
+
+[dependency-groups]
+dev = [
+    "ipykernel>=6.29.5,<7",
+    "mkdocs-material>=9.5.41,<10",
+    "mypy>=1.1.1,<2",
+    "pre-commit>=4.0.1,<5",
+    "pytest>=8.3.3,<9",
+    "ruff>=0.6.9,<0.7",
+    "sqlalchemy==1.4.49",
+    "types-beautifulsoup4>=4.12.0.20240907,<5",
+    "types-requests>=2.32.0.20240914,<3",
+]
+
+[tool.hatch.build.targets.sdist]
+include = ["liminal"]
+
+[tool.hatch.build.targets.wheel]
+include = ["liminal"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.mypy]
+check_untyped_defs = true
+disallow_untyped_defs = true
+explicit_package_bases = true
+mypy_path = "$MYPY_CONFIG_FILE_DIR/"
+namespace_packages = true
+no_implicit_optional = true
+strict_optional = true
+packages = "liminal"
+plugins = ["pydantic.mypy", "numpy.typing.mypy_plugin"]
+show_error_codes = true
+warn_unused_ignores = true
+disable_error_code=["union-attr"]
+
+[[tool.mypy.overrides]]
+module = ["sqlalchemy.*"]
+ignore_missing_imports = true

liminal_orm-4.1.1/pyproject.toml

@@ -1,66 +0,0 @@
-[tool.poetry]
-name = "liminal-orm"
-version = "4.1.1"
-description = "An ORM and toolkit that builds on top of Benchling's platform to keep your schemas and downstream code dependencies in sync."
-authors = ["DynoTx Open Source <opensource@dynotx.com>"]
-readme = "README.md"
-homepage = "https://github.com/dynotx/liminal-orm"
-repository = "https://github.com/dynotx/liminal-orm"
-documentation = "https://dynotx.github.io/liminal-orm/"
-packages = [{include = "liminal"}]
-
-[tool.poetry.urls]
-"Bug Tracker" = "https://github.com/dynotx/liminal-orm/issues"
-
-[tool.poetry.dependencies]
-python = ">=3.9,<4"
-benchling-sdk = "^1.21.2"
-bs4 = "^0.0.2"
-numpy = "^1.23.5"
-pandas = "^1.5.3"
-pydantic = ">=2,<=2.7" # TODO: We need to assess this upgrade
-requests = "^2.32.3"
-rich = "^13.9.2"
-sqlalchemy = "<2" # TODO: We need to assess this upgrade
-tenacity = ">=8,<10"
-typer = "^0.12.5"
-lxml = "^5.3.0"
-psycopg2-binary = "^2.9.10"
-tornado = "6.5.0"
-
-[tool.poetry.group.dev.dependencies]
-ipykernel = "^6.29.5"
-mkdocs-material = "^9.5.41"
-mypy = "^1.1.1"
-pre-commit = "^4.0.1"
-pytest = "^8.3.3"
-ruff = "^0.6.9"
-sqlalchemy = "1.4.49"
-types-beautifulsoup4 = "^4.12.0.20240907"
-types-requests = "^2.32.0.20240914"
-
-
-[build-system]
-requires = ["poetry-core"]
-build-backend = "poetry.core.masonry.api"
-
-[tool.poetry.scripts]
-liminal = "liminal.cli.cli:app"
-
-[tool.mypy]
-check_untyped_defs = true
-disallow_untyped_defs = true
-explicit_package_bases = true
-mypy_path = "$MYPY_CONFIG_FILE_DIR/"
-namespace_packages = true
-no_implicit_optional = true
-strict_optional = true
-packages = "liminal"
-plugins = ["pydantic.mypy", "numpy.typing.mypy_plugin"]
-show_error_codes = true
-warn_unused_ignores = true
-disable_error_code=["union-attr"]
-
-[[tool.mypy.overrides]]
-module = ["sqlalchemy.*"]
-ignore_missing_imports = true