dycw-utilities 0.125.3__py3-none-any.whl → 0.125.4__py3-none-any.whl

{dycw_utilities-0.125.3.dist-info → dycw_utilities-0.125.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dycw-utilities
-Version: 0.125.3
+Version: 0.125.4
 Author-email: Derek Wan <d.wan@icloud.com>
 License-File: LICENSE
 Requires-Python: >=3.12
@@ -10,7 +10,7 @@ Requires-Dist: hypothesis<6.132,>=6.131.27; extra == 'test'
 Requires-Dist: pytest-asyncio<0.27,>=0.26.0; extra == 'test'
 Requires-Dist: pytest-cov<6.2,>=6.1.1; extra == 'test'
 Requires-Dist: pytest-instafail<0.6,>=0.5.0; extra == 'test'
-Requires-Dist: pytest-lazy-fixtures<1.2,>=1.1.2; extra == 'test'
+Requires-Dist: pytest-lazy-fixtures<1.2,>=1.1.3; extra == 'test'
 Requires-Dist: pytest-only<2.2,>=2.1.2; extra == 'test'
 Requires-Dist: pytest-randomly<3.17,>=3.16.0; extra == 'test'
 Requires-Dist: pytest-regressions<2.8,>=2.7.0; extra == 'test'
@@ -174,7 +174,7 @@ Requires-Dist: scipy<1.16,>=1.15.3; extra == 'zzz-test-scipy'
 Provides-Extra: zzz-test-sentinel
 Provides-Extra: zzz-test-shelve
 Provides-Extra: zzz-test-slack-sdk
-Requires-Dist: aiohttp<3.12,>=3.11.16; extra == 'zzz-test-slack-sdk'
+Requires-Dist: aiohttp<3.13,>=3.12.0; extra == 'zzz-test-slack-sdk'
 Requires-Dist: slack-sdk<3.36,>=3.35.0; extra == 'zzz-test-slack-sdk'
 Provides-Extra: zzz-test-socket
 Provides-Extra: zzz-test-sqlalchemy

{dycw_utilities-0.125.3.dist-info → dycw_utilities-0.125.4.dist-info}/RECORD

@@ -1,4 +1,4 @@
-utilities/__init__.py,sha256=S9hi5nUNGrmUoeHSNNw9CdOdoY68OUGHaOm0V7chzZo,60
+utilities/__init__.py,sha256=O9WCgPzIqylIlRxvuTI9h_FJzryWHiUMdYDZGV6Rhj8,60
 utilities/altair.py,sha256=Gpja-flOo-Db0PIPJLJsgzAlXWoKUjPU1qY-DQ829ek,9156
 utilities/asyncio.py,sha256=gr2eUx0E6LiCup6VKgUGwh8lAUriGdX2TlK-PZdlvfo,28284
 utilities/atomicwrites.py,sha256=geFjn9Pwn-tTrtoGjDDxWli9NqbYfy3gGL6ZBctiqSo,5393
@@ -28,6 +28,7 @@ utilities/importlib.py,sha256=mV1xT_O_zt_GnZZ36tl3xOmMaN_3jErDWY54fX39F6Y,429
 utilities/ipython.py,sha256=V2oMYHvEKvlNBzxDXdLvKi48oUq2SclRg5xasjaXStw,763
 utilities/iterables.py,sha256=prKXBdF5QfLTGC-q4567DwO8xzUng_Z-2a4wBkMqyDo,45360
 utilities/jupyter.py,sha256=ft5JA7fBxXKzP-L9W8f2-wbF0QeYc_2uLQNFDVk4Z-M,2917
+utilities/libcst.py,sha256=jGLm2vTwUFcCIghN66mDSUXesgZZ6Pw2BbixkUf-PHA,5062
 utilities/lightweight_charts.py,sha256=vyVOzarYhBIOZj2xDhqdbP85qbSKUjdc6Au91rc1W4M,2814
 utilities/logging.py,sha256=gwo3pusPjnWO1ollrtn1VKYyRAQJTue4SkCbMeNvec4,25715
 utilities/loguru.py,sha256=MEMQVWrdECxk1e3FxGzmOf21vWT9j8CAir98SEXFKPA,3809
@@ -87,7 +88,7 @@ utilities/warnings.py,sha256=un1LvHv70PU-LLv8RxPVmugTzDJkkGXRMZTE2-fTQHw,1771
 utilities/whenever.py,sha256=jS31ZAY5OMxFxLja_Yo5Fidi87Pd-GoVZ7Vi_teqVDA,16743
 utilities/zipfile.py,sha256=24lQc9ATcJxHXBPc_tBDiJk48pWyRrlxO2fIsFxU0A8,699
 utilities/zoneinfo.py,sha256=-5j7IQ9nb7gR43rdgA7ms05im-XuqhAk9EJnQBXxCoQ,1874
-dycw_utilities-0.125.3.dist-info/METADATA,sha256=vMdoTZVKyi-BNSOGgeJYjY6uY-icfbVmvUlAo_SwJmM,12852
-dycw_utilities-0.125.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-dycw_utilities-0.125.3.dist-info/licenses/LICENSE,sha256=gppZp16M6nSVpBbUBrNL6JuYfvKwZiKgV7XoKKsHzqo,1066
-dycw_utilities-0.125.3.dist-info/RECORD,,
+dycw_utilities-0.125.4.dist-info/METADATA,sha256=dwOemW5k0Dz8lVM3bRKczDGMMkRNTW41Np8Bi_13dEU,12851
+dycw_utilities-0.125.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+dycw_utilities-0.125.4.dist-info/licenses/LICENSE,sha256=gppZp16M6nSVpBbUBrNL6JuYfvKwZiKgV7XoKKsHzqo,1066
+dycw_utilities-0.125.4.dist-info/RECORD,,

utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.125.3"
+__version__ = "0.125.4"

utilities/libcst.py

@@ -0,0 +1,184 @@
+from __future__ import annotations
+
+from collections.abc import Sequence
+from dataclasses import dataclass
+from subprocess import check_output
+from typing import assert_never, override
+
+from libcst import (
+    AsName,
+    Attribute,
+    BaseExpression,
+    FormattedString,
+    FormattedStringExpression,
+    FormattedStringText,
+    Import,
+    ImportAlias,
+    ImportFrom,
+    ImportStar,
+    Module,
+    Name,
+)
+
+
+def generate_from_import(
+    module: str, name: str, /, *, asname: str | None = None
+) -> ImportFrom:
+    """Generate an `ImportFrom` object."""
+    alias = ImportAlias(
+        name=Name(name), asname=AsName(Name(asname)) if asname else None
+    )
+    return ImportFrom(module=split_dotted_str(module), names=[alias])
+
+
+def generate_f_string(var: str, suffix: str, /) -> FormattedString:
+    """Generate an f-string."""
+    return FormattedString([
+        FormattedStringExpression(expression=Name(var)),
+        FormattedStringText(suffix),
+    ])
+
+
+def generate_import(module: str, /, *, asname: str | None = None) -> Import:
+    """Generate an `Import` object."""
+    alias = ImportAlias(
+        name=split_dotted_str(module), asname=AsName(Name(asname)) if asname else None
+    )
+    return Import(names=[alias])
+
+
+##
+
+
+@dataclass(kw_only=True, slots=True)
+class _ParseImportOutput:
+    module: str
+    name: str | None = None
+
+
+def parse_import(import_: Import | ImportFrom, /) -> Sequence[_ParseImportOutput]:
+    """Parse an import."""
+    match import_:
+        case Import():
+            return [_parse_import_one(n) for n in import_.names]
+        case ImportFrom():
+            if (attr_or_name := import_.module) is None:
+                raise _ParseImportEmptyModuleError(import_=import_)
+            module = join_dotted_str(attr_or_name)
+            match import_.names:
+                case Sequence() as names:
+                    return [_parse_import_from_one(module, n) for n in names]
+                case ImportStar():
+                    return [_ParseImportOutput(module=module, name="*")]
+                case _ as never:
+                    assert_never(never)
+        case _ as never:
+            assert_never(never)
+
+
+def _parse_import_one(alias: ImportAlias, /) -> _ParseImportOutput:
+    return _ParseImportOutput(module=join_dotted_str(alias.name))
+
+
+def _parse_import_from_one(module: str, alias: ImportAlias, /) -> _ParseImportOutput:
+    match alias.name:
+        case Name(name):
+            return _ParseImportOutput(module=module, name=name)
+        case Attribute() as attr:
+            raise _ParseImportAliasError(module=module, attr=attr)
+        case _ as never:
+            assert_never(never)
+
+
+@dataclass(kw_only=True, slots=True)
+class ParseImportError(Exception): ...
+
+
+@dataclass(kw_only=True, slots=True)
+class _ParseImportEmptyModuleError(ParseImportError):
+    import_: ImportFrom
+
+    @override
+    def __str__(self) -> str:
+        return f"Module must not be None; got {self.import_}"
+
+
+@dataclass(kw_only=True, slots=True)
+class _ParseImportAliasError(ParseImportError):
+    module: str
+    attr: Attribute
+
+    @override
+    def __str__(self) -> str:
+        attr = self.attr
+        return f"Invalid alias name; got module {self.module!r} and attribute '{attr.value.value}.{attr.attr.value}'"
+
+
+##
+
+
+def split_dotted_str(dotted: str, /) -> Name | Attribute:
+    """Split a dotted string into a name/attribute."""
+    parts = dotted.split(".")
+    node = Name(parts[0])
+    for part in parts[1:]:
+        node = Attribute(value=node, attr=Name(part))
+    return node
+
+
+def join_dotted_str(name_or_attr: Name | Attribute, /) -> str:
+    """Join a dotted from from a name/attribute."""
+    parts: Sequence[str] = []
+    curr: BaseExpression | Name | Attribute = name_or_attr
+    while True:
+        match curr:
+            case Name(value=value):
+                parts.append(value)
+                break
+            case Attribute(value=value, attr=Name(value=attr_value)):
+                parts.append(attr_value)
+                curr = value
+            case BaseExpression() as expr:
+                raise JoinDottedStrError(name_or_attr=name_or_attr, expr=expr)
+            case _ as never:
+                assert_never(never)
+    return ".".join(reversed(parts))
+
+
+@dataclass(kw_only=True, slots=True)
+class JoinDottedStrError(Exception):
+    name_or_attr: Name | Attribute
+    expr: BaseExpression
+
+    @override
+    def __str__(self) -> str:
+        return f"Only names & attributes allowed; got {self.expr}"
+
+
+##
+
+
+def render_module(source: str | Module, /) -> str:
+    """Render a module."""
+    match source:  # skipif-ci
+        case str() as text:
+            return check_output(["ruff", "format", "-"], input=text, text=True)
+        case Module() as module:
+            return render_module(module.code)
+        case _ as never:
+            assert_never(never)
+
+
+##
+
+
+__all__ = [
+    "ParseImportError",
+    "generate_f_string",
+    "generate_from_import",
+    "generate_import",
+    "join_dotted_str",
+    "parse_import",
+    "render_module",
+    "split_dotted_str",
+]