@alloy-js/python 0.3.0-dev.0 → 0.3.0-dev.2

package/test/dataclassdeclarations.test.tsx

@@ -0,0 +1,585 @@
+import { Prose, namekey } from "@alloy-js/core";
+import { d } from "@alloy-js/core/testing";
+import { describe, expect, it } from "vitest";
+import { dataclassesModule } from "../src/builtins/python.js";
+import * as py from "../src/index.js";
+import { toSourceText } from "./utils.jsx";
+
+describe("DataclassDeclaration", () => {
+  it("Creates a dataclass with a class doc", () => {
+    const doc = (
+      <py.ClassDoc description={[<Prose>Represents a user.</Prose>]} />
+    );
+    const res = toSourceText(
+      [
+        <py.SourceFile path="user.py">
+          <py.DataclassDeclaration name="User" doc={doc} />
+        </py.SourceFile>,
+      ],
+      { externals: [dataclassesModule] },
+    );
+
+    expect(res).toRenderTo(
+      d`
+        from dataclasses import dataclass
+
+        @dataclass
+        class User:
+            """
+            Represents a user.
+            """
+
+            pass
+
+
+      `,
+    );
+  });
+
+  it("Creates a dataclass with fields and defaults", () => {
+    const res = toSourceText(
+      [
+        <py.SourceFile path="user.py">
+          <py.DataclassDeclaration name="User">
+            <py.VariableDeclaration
+              instanceVariable
+              omitNone
+              name="id"
+              type="int"
+            />
+            <py.VariableDeclaration
+              instanceVariable
+              name={namekey("_", { ignoreNamePolicy: true })}
+              type={dataclassesModule["."].KW_ONLY}
+              omitNone
+            />
+            <py.VariableDeclaration
+              instanceVariable
+              name="name"
+              type="str"
+              initializer={"Anonymous"}
+            />
+          </py.DataclassDeclaration>
+        </py.SourceFile>,
+      ],
+      { externals: [dataclassesModule] },
+    );
+
+    expect(res).toRenderTo(
+      d`
+        from dataclasses import dataclass
+        from dataclasses import KW_ONLY
+
+        @dataclass
+        class User:
+            id: int
+            _: KW_ONLY
+            name: str = "Anonymous"
+
+
+      `,
+    );
+  });
+
+  it("Creates a dataclass with keyword arguments", () => {
+    const res = toSourceText(
+      [
+        <py.SourceFile path="user.py">
+          <py.DataclassDeclaration name="User" frozen slots kwOnly>
+            <py.VariableDeclaration
+              instanceVariable
+              omitNone
+              name="id"
+              type="int"
+            />
+          </py.DataclassDeclaration>
+        </py.SourceFile>,
+      ],
+      { externals: [dataclassesModule] },
+    );
+
+    expect(res).toRenderTo(
+      d`
+        from dataclasses import dataclass
+
+        @dataclass(frozen=True, slots=True, kw_only=True)
+        class User:
+            id: int
+
+
+      `,
+    );
+  });
+
+  it("Creates a dataclass with all keyword arguments", () => {
+    const res = toSourceText(
+      [
+        <py.SourceFile path="user.py">
+          <py.DataclassDeclaration
+            name="User"
+            init
+            repr={false}
+            eq
+            order={false}
+            unsafeHash
+            frozen
+            matchArgs={false}
+            kwOnly
+            slots
+            weakrefSlot={false}
+          />
+        </py.SourceFile>,
+      ],
+      { externals: [dataclassesModule] },
+    );
+
+    expect(res).toRenderTo(
+      d`
+        from dataclasses import dataclass
+
+        @dataclass(init=True, repr=False, eq=True, order=False, unsafe_hash=True, frozen=True, match_args=False, kw_only=True, slots=True, weakref_slot=False)
+        class User:
+            pass
+
+
+      `,
+    );
+  });
+
+  it("Throws error when weakref_slot=True without slots=True", () => {
+    expect(() =>
+      toSourceText(
+        [
+          <py.SourceFile path="user.py">
+            <py.DataclassDeclaration name="User" weakrefSlot />
+          </py.SourceFile>,
+        ],
+        { externals: [dataclassesModule] },
+      ),
+    ).toThrowError(
+      /weakref_slot=True requires slots=True in @dataclass decorator/,
+    );
+  });
+
+  it("Allows weakref_slot=True when slots=True", () => {
+    const res = toSourceText(
+      [
+        <py.SourceFile path="user.py">
+          <py.DataclassDeclaration name="User" slots weakrefSlot />
+        </py.SourceFile>,
+      ],
+      { externals: [dataclassesModule] },
+    );
+    expect(res).toRenderTo(
+      d`
+        from dataclasses import dataclass
+
+        @dataclass(slots=True, weakref_slot=True)
+        class User:
+            pass
+
+
+      `,
+    );
+  });
+
+  it("Throws error when order=True and eq=False", () => {
+    expect(() =>
+      toSourceText(
+        [
+          <py.SourceFile path="user.py">
+            <py.DataclassDeclaration name="User" order eq={false} />
+          </py.SourceFile>,
+        ],
+        { externals: [dataclassesModule] },
+      ),
+    ).toThrowError(/order=True requires eq=True/);
+  });
+
+  it("Creates a dataclass with order=True and no conflicting methods", () => {
+    const res = toSourceText(
+      [
+        <py.SourceFile path="user.py">
+          <py.DataclassDeclaration name="User" order />
+        </py.SourceFile>,
+      ],
+      { externals: [dataclassesModule] },
+    );
+    expect(res).toRenderTo(
+      d`
+        from dataclasses import dataclass
+
+        @dataclass(order=True)
+        class User:
+            pass
+
+
+      `,
+    );
+  });
+
+  it("Throws error when order=True and class defines __lt__", () => {
+    expect(() =>
+      toSourceText(
+        [
+          <py.SourceFile path="user.py">
+            <py.DataclassDeclaration name="User" order>
+              <py.DunderMethodDeclaration name="__lt__" />
+            </py.DataclassDeclaration>
+          </py.SourceFile>,
+        ],
+        { externals: [dataclassesModule] },
+      ),
+    ).toThrowError(
+      /Cannot specify order=True when the class already defines __lt__\(\)/,
+    );
+  });
+
+  it("Throws error when order=True and class defines __le__", () => {
+    expect(() =>
+      toSourceText(
+        [
+          <py.SourceFile path="user.py">
+            <py.DataclassDeclaration name="User" order>
+              <py.DunderMethodDeclaration name="__le__" />
+            </py.DataclassDeclaration>
+          </py.SourceFile>,
+        ],
+        { externals: [dataclassesModule] },
+      ),
+    ).toThrowError(
+      /Cannot specify order=True when the class already defines __le__\(\)/,
+    );
+  });
+
+  it("Throws error when order=True and class defines __gt__", () => {
+    expect(() =>
+      toSourceText(
+        [
+          <py.SourceFile path="user.py">
+            <py.DataclassDeclaration name="User" order>
+              <py.DunderMethodDeclaration name="__gt__" />
+            </py.DataclassDeclaration>
+          </py.SourceFile>,
+        ],
+        { externals: [dataclassesModule] },
+      ),
+    ).toThrowError(
+      /Cannot specify order=True when the class already defines __gt__\(\)/,
+    );
+  });
+
+  it("Throws error when order=True and class defines __ge__", () => {
+    expect(() =>
+      toSourceText(
+        [
+          <py.SourceFile path="user.py">
+            <py.DataclassDeclaration name="User" order>
+              <py.DunderMethodDeclaration name="__ge__" />
+            </py.DataclassDeclaration>
+          </py.SourceFile>,
+        ],
+        { externals: [dataclassesModule] },
+      ),
+    ).toThrowError(
+      /Cannot specify order=True when the class already defines __ge__\(\)/,
+    );
+  });
+
+  it("Throws error when order=True and a wrapper defines __lt__", () => {
+    function Wrapper() {
+      return <py.DunderMethodDeclaration name="__lt__" />;
+    }
+    expect(() =>
+      toSourceText(
+        [
+          <py.SourceFile path="user.py">
+            <py.DataclassDeclaration name="User" order>
+              <Wrapper />
+            </py.DataclassDeclaration>
+          </py.SourceFile>,
+        ],
+        { externals: [dataclassesModule] },
+      ),
+    ).toThrowError(
+      /Cannot specify order=True when the class already defines __lt__\(\)/,
+    );
+  });
+
+  it("Throws error when unsafe_hash=True and class defines __hash__", () => {
+    expect(() =>
+      toSourceText(
+        [
+          <py.SourceFile path="user.py">
+            <py.DataclassDeclaration name="User" unsafeHash>
+              <py.DunderMethodDeclaration name="__hash__" />
+            </py.DataclassDeclaration>
+          </py.SourceFile>,
+        ],
+        { externals: [dataclassesModule] },
+      ),
+    ).toThrowError(
+      /Cannot specify unsafe_hash=True when the class already defines __hash__\(\)/,
+    );
+  });
+
+  it("Throws error when frozen=True and class defines __setattr__", () => {
+    expect(() =>
+      toSourceText(
+        [
+          <py.SourceFile path="user.py">
+            <py.DataclassDeclaration name="User" frozen>
+              <py.DunderMethodDeclaration name="__setattr__" />
+            </py.DataclassDeclaration>
+          </py.SourceFile>,
+        ],
+        { externals: [dataclassesModule] },
+      ),
+    ).toThrowError(
+      /Cannot specify frozen=True when the class already defines __setattr__\(\)/,
+    );
+  });
+
+  it("Throws errorwhen frozen=True and class defines __delattr__", () => {
+    expect(() =>
+      toSourceText(
+        [
+          <py.SourceFile path="user.py">
+            <py.DataclassDeclaration name="User" frozen>
+              <py.DunderMethodDeclaration name="__delattr__" />
+            </py.DataclassDeclaration>
+          </py.SourceFile>,
+        ],
+        { externals: [dataclassesModule] },
+      ),
+    ).toThrowError(
+      /Cannot specify frozen=True when the class already defines __delattr__\(\)/,
+    );
+  });
+
+  it("Throws error when slots=True and class defines __slots__", () => {
+    expect(() =>
+      toSourceText(
+        [
+          <py.SourceFile path="user.py">
+            <py.DataclassDeclaration name="User" slots>
+              <py.DunderMethodDeclaration name="__slots__" />
+            </py.DataclassDeclaration>
+          </py.SourceFile>,
+        ],
+        { externals: [dataclassesModule] },
+      ),
+    ).toThrowError(
+      /Cannot specify slots=True when the class already defines __slots__\(\)/,
+    );
+  });
+
+  it("Creates a dataclass with kw_only=True on decorator (sentinel not used)", () => {
+    const res = toSourceText(
+      [
+        <py.SourceFile path="user.py">
+          <py.DataclassDeclaration name="User" kwOnly>
+            <py.VariableDeclaration
+              instanceVariable
+              omitNone
+              name="id"
+              type="int"
+            />
+          </py.DataclassDeclaration>
+        </py.SourceFile>,
+      ],
+      { externals: [dataclassesModule] },
+    );
+    expect(res).toRenderTo(
+      d`
+        from dataclasses import dataclass
+
+        @dataclass(kw_only=True)
+        class User:
+            id: int
+
+
+      `,
+    );
+  });
+
+  it("Creates a dataclass with base classes", () => {
+    const res = toSourceText(
+      [
+        <py.SourceFile path="user.py">
+          <py.DataclassDeclaration name="User" bases={["Base"]} />
+        </py.SourceFile>,
+      ],
+      { externals: [dataclassesModule] },
+    );
+
+    expect(res).toRenderTo(
+      d`
+        from dataclasses import dataclass
+
+        @dataclass
+        class User(Base):
+            pass
+
+
+      `,
+    );
+  });
+
+  it("Throws error when more than one KW_ONLY sentinel is present", () => {
+    expect(() =>
+      toSourceText(
+        [
+          <py.SourceFile path="user.py">
+            <py.DataclassDeclaration name="User">
+              <py.VariableDeclaration
+                instanceVariable
+                name={namekey("_", { ignoreNamePolicy: true })}
+                type={dataclassesModule["."].KW_ONLY}
+                omitNone
+              />
+              <py.VariableDeclaration
+                instanceVariable
+                name={namekey("_", { ignoreNamePolicy: true })}
+                type={dataclassesModule["."].KW_ONLY}
+                omitNone
+              />
+            </py.DataclassDeclaration>
+          </py.SourceFile>,
+        ],
+        { externals: [dataclassesModule] },
+      ),
+    ).toThrowError(/Only one KW_ONLY sentinel is allowed per dataclass body/);
+  });
+
+  it("Will raise arg validation errors first over member conflicts", () => {
+    expect(() =>
+      toSourceText(
+        [
+          <py.SourceFile path="user.py">
+            <py.DataclassDeclaration name="User" order eq={false}>
+              <py.DunderMethodDeclaration name="__lt__" />
+            </py.DataclassDeclaration>
+          </py.SourceFile>,
+        ],
+        { externals: [dataclassesModule] },
+      ),
+    ).toThrowError(/order=True requires eq=True/);
+  });
+
+  it("Does not raise errors for member conflict checks without the equivalent kwargs", () => {
+    expect(() =>
+      toSourceText(
+        [
+          <py.SourceFile path="user.py">
+            <py.DataclassDeclaration name="User">
+              <py.DunderMethodDeclaration name="__lt__" />
+              <py.DunderMethodDeclaration name="__slots__" />
+              <py.DunderMethodDeclaration name="__hash__" />
+              <py.DunderMethodDeclaration name="__setattr__" />
+              <py.DunderMethodDeclaration name="__delattr__" />
+            </py.DataclassDeclaration>
+          </py.SourceFile>,
+        ],
+        { externals: [dataclassesModule] },
+      ),
+    ).not.toThrow();
+  });
+
+  it("Allows unsafe_hash=True when no __hash__ is defined", () => {
+    const res = toSourceText(
+      [
+        <py.SourceFile path="user.py">
+          <py.DataclassDeclaration name="User" unsafeHash />
+        </py.SourceFile>,
+      ],
+      { externals: [dataclassesModule] },
+    );
+    expect(res).toRenderTo(
+      d`
+        from dataclasses import dataclass
+
+        @dataclass(unsafe_hash=True)
+        class User:
+            pass
+
+
+      `,
+    );
+  });
+
+  it("Counts KW_ONLY sentinels through wrappers (symbol-level)", () => {
+    function Wrapper() {
+      return (
+        <py.VariableDeclaration
+          instanceVariable
+          name={namekey("_", { ignoreNamePolicy: true })}
+          type={dataclassesModule["."].KW_ONLY}
+          omitNone
+        />
+      );
+    }
+    expect(() =>
+      toSourceText(
+        [
+          <py.SourceFile path="user.py">
+            <py.DataclassDeclaration name="User">
+              <py.VariableDeclaration
+                instanceVariable
+                name={namekey("_", { ignoreNamePolicy: true })}
+                type={dataclassesModule["."].KW_ONLY}
+                omitNone
+              />
+              <Wrapper />
+            </py.DataclassDeclaration>
+          </py.SourceFile>,
+        ],
+        { externals: [dataclassesModule] },
+      ),
+    ).toThrowError(/Only one KW_ONLY sentinel is allowed per dataclass body/);
+  });
+
+  it("Allows frozen=True when no conflicting dunders exist", () => {
+    const res = toSourceText(
+      [
+        <py.SourceFile path="user.py">
+          <py.DataclassDeclaration name="User" frozen />
+        </py.SourceFile>,
+      ],
+      { externals: [dataclassesModule] },
+    );
+    expect(res).toRenderTo(
+      d`
+        from dataclasses import dataclass
+
+        @dataclass(frozen=True)
+        class User:
+            pass
+
+
+      `,
+    );
+  });
+
+  it("Allows slots=True when no __slots__ is defined", () => {
+    const res = toSourceText(
+      [
+        <py.SourceFile path="user.py">
+          <py.DataclassDeclaration name="User" slots />
+        </py.SourceFile>,
+      ],
+      { externals: [dataclassesModule] },
+    );
+    expect(res).toRenderTo(
+      d`
+        from dataclasses import dataclass
+
+        @dataclass(slots=True)
+        class User:
+            pass
+
+
+      `,
+    );
+  });
+});

package/test/pydocs.test.tsx

@@ -104,11 +104,7 @@ describe("PyDocExample", () => {
         <py.PyDoc>
           <Prose>This is an example of a docstring with a code sample.</Prose>
           <py.PyDocExample>
-            print("Hello world!")
-            <br />
-            x = "Hello"
-            <br />
-            print(x)
+            {`print("Hello world!")\nx = "Hello"\nprint(x)`}
           </py.PyDocExample>
         </py.PyDoc>,
       ],
@@ -136,12 +132,14 @@ describe("SimpleCommentBlock", () => {
   it("renders simple comment block", () => {
     const res = toSourceText([
       <py.SimpleCommentBlock>
-        This is a simple comment block that spans multiple lines.
+        This is a simple comment block that spans multiple lines and should be
+        split automatically.
       </py.SimpleCommentBlock>,
     ]);
     expect(res).toRenderTo(
       d`
-          # This is a simple comment block that spans multiple lines.
+          # This is a simple comment block that spans multiple lines and should be split
+          # automatically.
           
           `,
     );
@@ -150,14 +148,13 @@ describe("SimpleCommentBlock", () => {
   it("renders comment block with line breaks", () => {
     const res = toSourceText([
       <py.SimpleCommentBlock>
-        First line of comment.
-        <br />
-        Second line of comment.
+        First line of comment.\nSecond line of comment.
       </py.SimpleCommentBlock>,
     ]);
     expect(res).toRenderTo(
       d`
-          # First line of comment. Second line of comment.
+          # First line of comment.
+          # Second line of comment.
           
           `,
     );
@@ -877,9 +874,7 @@ describe("New Documentation Components", () => {
             Generators have a Yields section instead of a Returns section.
           </Prose>,
           <py.PyDocExample>
-            print([i for i in example_generator(4)])
-            <br />
-            [0, 1, 2, 3]
+            {`print([i for i in example_generator(4)])\n[0, 1, 2, 3]`}
           </py.PyDocExample>,
         ]}
         parameters={[
@@ -928,11 +923,7 @@ describe("Full example", () => {
             We will also render another paragraph after this one.
           </Prose>,
           <py.PyDocExample>
-            print("Hello world!")
-            <br />
-            x = "Hello"
-            <br />
-            print(x)
+            {`print("Hello world!")\nx = "Hello"\nprint(x)`}
           </py.PyDocExample>,
         ]}
         attributes={[
@@ -1050,11 +1041,7 @@ describe("Full example", () => {
             We will also render another paragraph after this one.
           </Prose>,
           <py.PyDocExample>
-            print("Hello world!")
-            <br />
-            x = "Hello"
-            <br />
-            print(x)
+            {`print("Hello world!")\nx = "Hello"\nprint(x)`}
           </py.PyDocExample>,
         ]}
         parameters={[
@@ -1397,23 +1384,18 @@ describe("Full example", () => {
       </py.ClassDeclaration>,
     ]);
 
-    expect(result).toRenderTo(
-      d`
-        class Person:
-            @property
-            def full_name(self) -> str:
-                """
-                The full name of the person, combining first and last name. This
-                property automatically formats the name with proper capitalization.
-                """
-                return "John Doe"
-
-
-
-
-
-        `,
-    );
+    expect(result).toRenderTo(`
+      class Person:
+          @property
+          def full_name(self) -> str:
+              """
+              The full name of the person, combining first and last name. This
+              property automatically formats the name with proper capitalization.
+              """
+              return "John Doe"
+      
+      
+    `);
   });
 
   it("MethodDoc with FunctionDeclaration (inside class) integration", () => {