@graphql-codegen/python 0.0.0-stage → 0.0.1

package/dist/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@graphql-codegen/python",
+  "version": "0.0.1",
+  "description": "GraphQL Code Generator plugin that emits Python types",
+  "sideEffects": false,
+  "peerDependencies": {
+    "graphql": "^0.8.0 || ^0.9.0 || ^0.10.0 || ^0.11.0 || ^0.12.0 || ^0.13.0 || ^14.0.0 || ^15.0.0 || ^16.0.0"
+  },
+  "dependencies": {
+    "@graphql-codegen/plugin-helpers": "^6.3.0",
+    "@graphql-codegen/python-common": "0.0.1",
+    "@graphql-codegen/visitor-plugin-common": "^6.3.0",
+    "auto-bind": "~4.0.0",
+    "tslib": "^2.8.1"
+  },
+  "repository": "git@github.com:dotansimha/graphql-code-generator-community.git",
+  "license": "MIT",
+  "engines": {
+    "node": ">= 16.0.0"
+  },
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "typings": "typings/index.d.ts",
+  "typescript": {
+    "definition": "typings/index.d.ts"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "require": {
+        "types": "./typings/index.d.cts",
+        "default": "./cjs/index.js"
+      },
+      "import": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "default": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      }
+    },
+    "./package.json": "./package.json"
+  }
+}

package/dist/typings/config.d.cts

@@ -0,0 +1,110 @@
+import { RawTypesConfig } from '@graphql-codegen/visitor-plugin-common';
+/**
+ * @description This plugin generates Python types based on your `GraphQLSchema`.
+ *
+ * It generates idiomatic Python for your entire schema:
+ * - object & interface types become [pydantic](https://docs.pydantic.dev)
+ *   `BaseModel` classes with snake_case attributes; each field whose Python name
+ *   differs from the GraphQL key is pinned with `Field(alias=...)` so pydantic
+ *   hydrates the wire (camelCase) key onto the attribute,
+ * - input types become `TypedDict`s keyed by the WIRE (GraphQL) name — inputs
+ *   are sent to the server as-is, so their keys are never snake-cased,
+ * - enums become `str, Enum` classes,
+ * - scalars are mapped to native Python types.
+ *
+ * By default object / interface field names are converted to snake_case (see
+ * `namingConvention`). Every annotation is quoted so forward / recursive
+ * references resolve without ordering constraints.
+ */
+export interface PythonPluginConfig extends RawTypesConfig {
+    /**
+     * @description The base class that generated object and interface types extend.
+     * @default "BaseModel"
+     *
+     * @exampleMarkdown
+     * ```ts filename="codegen.ts"
+     *  import type { CodegenConfig } from '@graphql-codegen/cli';
+     *
+     *  const config: CodegenConfig = {
+     *    generates: {
+     *      'schema.py': {
+     *        plugins: ['@graphql-codegen/python'],
+     *        config: {
+     *          baseModel: 'BaseModel',
+     *        },
+     *      },
+     *    },
+     *  };
+     *  export default config;
+     * ```
+     */
+    baseModel?: string;
+    /**
+     * @description The module the base model is imported from. Emitted as
+     * `from {runtimeImport} import {baseModel}` (with `ConfigDict` / `Field`
+     * appended when the generated types use aliases). Defaults to `pydantic`; if
+     * you override it, point it at a module that re-exports a pydantic-compatible
+     * `BaseModel`, `ConfigDict`, and `Field`.
+     * @default "pydantic"
+     *
+     * @exampleMarkdown
+     * ```ts filename="codegen.ts"
+     *  import type { CodegenConfig } from '@graphql-codegen/cli';
+     *
+     *  const config: CodegenConfig = {
+     *    generates: {
+     *      'schema.py': {
+     *        plugins: ['@graphql-codegen/python'],
+     *        config: {
+     *          runtimeImport: 'pydantic',
+     *        },
+     *      },
+     *    },
+     *  };
+     *  export default config;
+     * ```
+     */
+    runtimeImport?: string;
+    /**
+     * @description Controls how GraphQL OBJECT / INTERFACE field names are turned
+     * into Python class attributes. Input-type keys are unaffected — they always
+     * keep the wire (GraphQL) name because the runtime forwards the input dict to
+     * the server as-is.
+     *
+     * - `'snakeCase'` (default): field names are converted from camelCase to
+     *   snake_case and Python reserved keywords are suffixed with `_`. This is the
+     *   idiomatic-Python choice; each renamed field is pinned with `Field(alias=...)`
+     *   (e.g. `from` -> `from_` with `alias='from'`) so pydantic hydrates the
+     *   original wire key onto the attribute.
+     * - `'keep'`: object / interface field names are used verbatim; a keyword /
+     *   non-identifier field falls back to a trailing `_` for just that field.
+     *
+     * @default "snakeCase"
+     *
+     * @exampleMarkdown
+     * ```ts filename="codegen.ts"
+     *  import type { CodegenConfig } from '@graphql-codegen/cli';
+     *
+     *  const config: CodegenConfig = {
+     *    generates: {
+     *      'schema.py': {
+     *        plugins: ['@graphql-codegen/python'],
+     *        config: {
+     *          namingConvention: 'snakeCase',
+     *        },
+     *      },
+     *    },
+     *  };
+     *  export default config;
+     * ```
+     */
+    namingConvention?: 'keep' | 'snakeCase';
+    /**
+     * @description Does not add a `__typename` field to the generated types.
+     * For the Python types plugin `__typename` is not emitted by default, so this
+     * option is accepted for parity but has no additional effect unless you opt in
+     * elsewhere.
+     * @default true
+     */
+    skipTypename?: boolean;
+}

package/dist/typings/config.d.ts

@@ -0,0 +1,110 @@
+import { RawTypesConfig } from '@graphql-codegen/visitor-plugin-common';
+/**
+ * @description This plugin generates Python types based on your `GraphQLSchema`.
+ *
+ * It generates idiomatic Python for your entire schema:
+ * - object & interface types become [pydantic](https://docs.pydantic.dev)
+ *   `BaseModel` classes with snake_case attributes; each field whose Python name
+ *   differs from the GraphQL key is pinned with `Field(alias=...)` so pydantic
+ *   hydrates the wire (camelCase) key onto the attribute,
+ * - input types become `TypedDict`s keyed by the WIRE (GraphQL) name — inputs
+ *   are sent to the server as-is, so their keys are never snake-cased,
+ * - enums become `str, Enum` classes,
+ * - scalars are mapped to native Python types.
+ *
+ * By default object / interface field names are converted to snake_case (see
+ * `namingConvention`). Every annotation is quoted so forward / recursive
+ * references resolve without ordering constraints.
+ */
+export interface PythonPluginConfig extends RawTypesConfig {
+    /**
+     * @description The base class that generated object and interface types extend.
+     * @default "BaseModel"
+     *
+     * @exampleMarkdown
+     * ```ts filename="codegen.ts"
+     *  import type { CodegenConfig } from '@graphql-codegen/cli';
+     *
+     *  const config: CodegenConfig = {
+     *    generates: {
+     *      'schema.py': {
+     *        plugins: ['@graphql-codegen/python'],
+     *        config: {
+     *          baseModel: 'BaseModel',
+     *        },
+     *      },
+     *    },
+     *  };
+     *  export default config;
+     * ```
+     */
+    baseModel?: string;
+    /**
+     * @description The module the base model is imported from. Emitted as
+     * `from {runtimeImport} import {baseModel}` (with `ConfigDict` / `Field`
+     * appended when the generated types use aliases). Defaults to `pydantic`; if
+     * you override it, point it at a module that re-exports a pydantic-compatible
+     * `BaseModel`, `ConfigDict`, and `Field`.
+     * @default "pydantic"
+     *
+     * @exampleMarkdown
+     * ```ts filename="codegen.ts"
+     *  import type { CodegenConfig } from '@graphql-codegen/cli';
+     *
+     *  const config: CodegenConfig = {
+     *    generates: {
+     *      'schema.py': {
+     *        plugins: ['@graphql-codegen/python'],
+     *        config: {
+     *          runtimeImport: 'pydantic',
+     *        },
+     *      },
+     *    },
+     *  };
+     *  export default config;
+     * ```
+     */
+    runtimeImport?: string;
+    /**
+     * @description Controls how GraphQL OBJECT / INTERFACE field names are turned
+     * into Python class attributes. Input-type keys are unaffected — they always
+     * keep the wire (GraphQL) name because the runtime forwards the input dict to
+     * the server as-is.
+     *
+     * - `'snakeCase'` (default): field names are converted from camelCase to
+     *   snake_case and Python reserved keywords are suffixed with `_`. This is the
+     *   idiomatic-Python choice; each renamed field is pinned with `Field(alias=...)`
+     *   (e.g. `from` -> `from_` with `alias='from'`) so pydantic hydrates the
+     *   original wire key onto the attribute.
+     * - `'keep'`: object / interface field names are used verbatim; a keyword /
+     *   non-identifier field falls back to a trailing `_` for just that field.
+     *
+     * @default "snakeCase"
+     *
+     * @exampleMarkdown
+     * ```ts filename="codegen.ts"
+     *  import type { CodegenConfig } from '@graphql-codegen/cli';
+     *
+     *  const config: CodegenConfig = {
+     *    generates: {
+     *      'schema.py': {
+     *        plugins: ['@graphql-codegen/python'],
+     *        config: {
+     *          namingConvention: 'snakeCase',
+     *        },
+     *      },
+     *    },
+     *  };
+     *  export default config;
+     * ```
+     */
+    namingConvention?: 'keep' | 'snakeCase';
+    /**
+     * @description Does not add a `__typename` field to the generated types.
+     * For the Python types plugin `__typename` is not emitted by default, so this
+     * option is accepted for parity but has no additional effect unless you opt in
+     * elsewhere.
+     * @default true
+     */
+    skipTypename?: boolean;
+}

package/dist/typings/index.d.cts

@@ -0,0 +1,5 @@
+import { PluginFunction, Types } from '@graphql-codegen/plugin-helpers';
+import { PythonPluginConfig } from './config.cjs';
+export * from './config.cjs';
+export * from './visitor.cjs';
+export declare const plugin: PluginFunction<PythonPluginConfig, Types.ComplexPluginOutput>;

package/dist/typings/index.d.ts

@@ -0,0 +1,5 @@
+import { PluginFunction, Types } from '@graphql-codegen/plugin-helpers';
+import { PythonPluginConfig } from './config.js';
+export * from './config.js';
+export * from './visitor.js';
+export declare const plugin: PluginFunction<PythonPluginConfig, Types.ComplexPluginOutput>;

package/dist/typings/visitor.d.cts

@@ -0,0 +1,96 @@
+import { EnumTypeDefinitionNode, FieldDefinitionNode, GraphQLSchema, InputObjectTypeDefinitionNode, InputValueDefinitionNode, InterfaceTypeDefinitionNode, ListTypeNode, NamedTypeNode, NonNullTypeNode, ObjectTypeDefinitionNode, UnionTypeDefinitionNode } from 'graphql';
+import { PYTHON_SCALARS } from '@graphql-codegen/python-common';
+import { BaseTypesVisitor, ParsedTypesConfig } from '@graphql-codegen/visitor-plugin-common';
+import { PythonPluginConfig } from './config.cjs';
+export { PYTHON_SCALARS };
+export type PythonNamingConvention = 'keep' | 'snakeCase';
+export interface PythonPluginParsedConfig extends ParsedTypesConfig {
+    baseModel: string;
+    runtimeImport: string;
+    pyNamingConvention: PythonNamingConvention;
+}
+export declare class PythonVisitor<TRawConfig extends PythonPluginConfig = PythonPluginConfig, TParsedConfig extends PythonPluginParsedConfig = PythonPluginParsedConfig> extends BaseTypesVisitor<TRawConfig, TParsedConfig> {
+    private _usesEnum;
+    private _usesTypedDict;
+    private _usesBaseModel;
+    private _usesUnion;
+    constructor(schema: GraphQLSchema, pluginConfig: TRawConfig);
+    /** Python has no `export` keyword; disable the C-family export prefix. */
+    protected getExportPrefix(): string;
+    protected _getScalar(name: string, type: 'input' | 'output'): string;
+    NamedType(node: NamedTypeNode, key: any, parent: any, path: any, ancestors: any): string;
+    ListType(node: ListTypeNode, key: any, parent: any, path: any, ancestors: any): string;
+    protected wrapWithListType(str: string): string;
+    NonNullType(node: NonNullTypeNode): string;
+    private snakeFieldName;
+    /**
+     * Field key for a `TypedDict` (input type). Input types are what the caller
+     * SENDS — the runtime forwards the dict to the server as-is — so they ALWAYS
+     * keep the wire (GraphQL) name regardless of `namingConvention`. If the name
+     * is a keyword / non-identifier the containing `TypedDict` is later emitted
+     * with functional syntax (see `buildTypedDict`).
+     */
+    private dictFieldName;
+    /**
+     * Field key for an object / interface type (a class attribute). Under `'keep'`
+     * a keyword / non-identifier name cannot be a class attribute and BaseModel
+     * cannot use functional `TypedDict` syntax, so we fall back to appending `_`
+     * for just that field.
+     */
+    private objectFieldName;
+    FieldDefinition(node: FieldDefinitionNode): string;
+    InputValueDefinition(node: InputValueDefinitionNode): string;
+    private buildClass;
+    /**
+     * Build a base-model subclass. Fields are class-level annotations; if any field
+     * pins a wire key with `Field(alias=...)`, a
+     * `model_config = ConfigDict(populate_by_name=True)` line is prepended so the
+     * class can be constructed by attribute name as well as by alias.
+     */
+    private buildBaseModelClass;
+    /**
+     * Split a rendered `key: 'annotation'` field back into its parts. The key is
+     * always a GraphQL Name (no `: '`) and the annotation is always single-quoted,
+     * so splitting on the first `: '` is unambiguous.
+     */
+    private splitField;
+    /**
+     * Build a `TypedDict`. If every key is a valid Python attribute, the readable
+     * class syntax is used; otherwise (a key is a keyword / non-identifier under
+     * `'keep'`) the functional `TypedDict('Name', { 'key': 'annotation' })` syntax
+     * is emitted so the offending keys remain valid.
+     */
+    private buildTypedDict;
+    ObjectTypeDefinition(node: ObjectTypeDefinitionNode): string;
+    InterfaceTypeDefinition(node: InterfaceTypeDefinitionNode): string;
+    InputObjectTypeDefinition(node: InputObjectTypeDefinitionNode): string;
+    EnumTypeDefinition(node: EnumTypeDefinitionNode): string;
+    /** Scalars are handled inline via the scalar map; no standalone class. */
+    ScalarTypeDefinition(): string;
+    /**
+     * `union Foo = A | B` -> `Foo = Union['A', 'B']`.
+     *
+     * Must be overridden: `BaseTypesVisitor`'s implementation emits TypeScript
+     * (`export type Foo = A | B;`), and it dereferences the node description
+     * unguarded, so an undocumented union crashes the generator outright. A schema
+     * merely *containing* a union is enough to hit this, even when no operation
+     * selects one.
+     *
+     * Member names come from `parent[key]` — the original, un-visited node — the
+     * same way `typescript`'s visitor reads them. By `leave` time `node.types`
+     * has already been rendered into annotations (`Optional[Foo]`) and would
+     * otherwise be mangled. Members are quoted so a union declared before its
+     * members still resolves, matching how every other annotation in this plugin
+     * is emitted.
+     *
+     * Note this only makes a union *declaration* valid Python. Actually selecting
+     * union members in an operation needs inline-fragment support, which
+     * `python-operations` does not implement yet (it throws).
+     */
+    UnionTypeDefinition(node: UnionTypeDefinitionNode, key: string | number | undefined, parent: any): string;
+    /**
+     * Build the `prepend` import lines, emitting only what the generated
+     * `content` actually references.
+     */
+    getImports(content: string): string[];
+}

package/dist/typings/visitor.d.ts

@@ -0,0 +1,96 @@
+import { EnumTypeDefinitionNode, FieldDefinitionNode, GraphQLSchema, InputObjectTypeDefinitionNode, InputValueDefinitionNode, InterfaceTypeDefinitionNode, ListTypeNode, NamedTypeNode, NonNullTypeNode, ObjectTypeDefinitionNode, UnionTypeDefinitionNode } from 'graphql';
+import { PYTHON_SCALARS } from '@graphql-codegen/python-common';
+import { BaseTypesVisitor, ParsedTypesConfig } from '@graphql-codegen/visitor-plugin-common';
+import { PythonPluginConfig } from './config.js';
+export { PYTHON_SCALARS };
+export type PythonNamingConvention = 'keep' | 'snakeCase';
+export interface PythonPluginParsedConfig extends ParsedTypesConfig {
+    baseModel: string;
+    runtimeImport: string;
+    pyNamingConvention: PythonNamingConvention;
+}
+export declare class PythonVisitor<TRawConfig extends PythonPluginConfig = PythonPluginConfig, TParsedConfig extends PythonPluginParsedConfig = PythonPluginParsedConfig> extends BaseTypesVisitor<TRawConfig, TParsedConfig> {
+    private _usesEnum;
+    private _usesTypedDict;
+    private _usesBaseModel;
+    private _usesUnion;
+    constructor(schema: GraphQLSchema, pluginConfig: TRawConfig);
+    /** Python has no `export` keyword; disable the C-family export prefix. */
+    protected getExportPrefix(): string;
+    protected _getScalar(name: string, type: 'input' | 'output'): string;
+    NamedType(node: NamedTypeNode, key: any, parent: any, path: any, ancestors: any): string;
+    ListType(node: ListTypeNode, key: any, parent: any, path: any, ancestors: any): string;
+    protected wrapWithListType(str: string): string;
+    NonNullType(node: NonNullTypeNode): string;
+    private snakeFieldName;
+    /**
+     * Field key for a `TypedDict` (input type). Input types are what the caller
+     * SENDS — the runtime forwards the dict to the server as-is — so they ALWAYS
+     * keep the wire (GraphQL) name regardless of `namingConvention`. If the name
+     * is a keyword / non-identifier the containing `TypedDict` is later emitted
+     * with functional syntax (see `buildTypedDict`).
+     */
+    private dictFieldName;
+    /**
+     * Field key for an object / interface type (a class attribute). Under `'keep'`
+     * a keyword / non-identifier name cannot be a class attribute and BaseModel
+     * cannot use functional `TypedDict` syntax, so we fall back to appending `_`
+     * for just that field.
+     */
+    private objectFieldName;
+    FieldDefinition(node: FieldDefinitionNode): string;
+    InputValueDefinition(node: InputValueDefinitionNode): string;
+    private buildClass;
+    /**
+     * Build a base-model subclass. Fields are class-level annotations; if any field
+     * pins a wire key with `Field(alias=...)`, a
+     * `model_config = ConfigDict(populate_by_name=True)` line is prepended so the
+     * class can be constructed by attribute name as well as by alias.
+     */
+    private buildBaseModelClass;
+    /**
+     * Split a rendered `key: 'annotation'` field back into its parts. The key is
+     * always a GraphQL Name (no `: '`) and the annotation is always single-quoted,
+     * so splitting on the first `: '` is unambiguous.
+     */
+    private splitField;
+    /**
+     * Build a `TypedDict`. If every key is a valid Python attribute, the readable
+     * class syntax is used; otherwise (a key is a keyword / non-identifier under
+     * `'keep'`) the functional `TypedDict('Name', { 'key': 'annotation' })` syntax
+     * is emitted so the offending keys remain valid.
+     */
+    private buildTypedDict;
+    ObjectTypeDefinition(node: ObjectTypeDefinitionNode): string;
+    InterfaceTypeDefinition(node: InterfaceTypeDefinitionNode): string;
+    InputObjectTypeDefinition(node: InputObjectTypeDefinitionNode): string;
+    EnumTypeDefinition(node: EnumTypeDefinitionNode): string;
+    /** Scalars are handled inline via the scalar map; no standalone class. */
+    ScalarTypeDefinition(): string;
+    /**
+     * `union Foo = A | B` -> `Foo = Union['A', 'B']`.
+     *
+     * Must be overridden: `BaseTypesVisitor`'s implementation emits TypeScript
+     * (`export type Foo = A | B;`), and it dereferences the node description
+     * unguarded, so an undocumented union crashes the generator outright. A schema
+     * merely *containing* a union is enough to hit this, even when no operation
+     * selects one.
+     *
+     * Member names come from `parent[key]` — the original, un-visited node — the
+     * same way `typescript`'s visitor reads them. By `leave` time `node.types`
+     * has already been rendered into annotations (`Optional[Foo]`) and would
+     * otherwise be mangled. Members are quoted so a union declared before its
+     * members still resolves, matching how every other annotation in this plugin
+     * is emitted.
+     *
+     * Note this only makes a union *declaration* valid Python. Actually selecting
+     * union members in an operation needs inline-fragment support, which
+     * `python-operations` does not implement yet (it throws).
+     */
+    UnionTypeDefinition(node: UnionTypeDefinitionNode, key: string | number | undefined, parent: any): string;
+    /**
+     * Build the `prepend` import lines, emitting only what the generated
+     * `content` actually references.
+     */
+    getImports(content: string): string[];
+}

package/package.json

@@ -1,6 +1,55 @@
 {
   "name": "@graphql-codegen/python",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.0.1",
+  "type": "module",
+  "description": "GraphQL Code Generator plugin that emits Python types",
+  "repository": "git@github.com:dotansimha/graphql-code-generator-community.git",
+  "license": "MIT",
+  "engines": {
+    "node": ">= 16.0.0"
+  },
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.js",
+  "exports": {
+    ".": {
+      "require": {
+        "types": "./dist/typings/index.d.cts",
+        "default": "./dist/cjs/index.js"
+      },
+      "import": {
+        "types": "./dist/typings/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "default": {
+        "types": "./dist/typings/index.d.ts",
+        "default": "./dist/esm/index.js"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "typings": "dist/typings/index.d.ts",
+  "scripts": {
+    "lint": "eslint **/*.ts"
+  },
+  "peerDependencies": {
+    "graphql": "^0.8.0 || ^0.9.0 || ^0.10.0 || ^0.11.0 || ^0.12.0 || ^0.13.0 || ^14.0.0 || ^15.0.0 || ^16.0.0"
+  },
+  "dependencies": {
+    "@graphql-codegen/plugin-helpers": "^6.3.0",
+    "@graphql-codegen/python-common": "0.0.1",
+    "@graphql-codegen/visitor-plugin-common": "^6.3.0",
+    "auto-bind": "~4.0.0",
+    "tslib": "^2.8.1"
+  },
+  "devDependencies": {
+    "@graphql-codegen/testing": "4.0.5"
+  },
+  "publishConfig": {
+    "directory": "dist",
+    "access": "public"
+  },
+  "sideEffects": false,
+  "typescript": {
+    "definition": "dist/typings/index.d.ts"
+  }
+}

package/src/config.ts

@@ -0,0 +1,111 @@
+import { RawTypesConfig } from '@graphql-codegen/visitor-plugin-common';
+
+/**
+ * @description This plugin generates Python types based on your `GraphQLSchema`.
+ *
+ * It generates idiomatic Python for your entire schema:
+ * - object & interface types become [pydantic](https://docs.pydantic.dev)
+ *   `BaseModel` classes with snake_case attributes; each field whose Python name
+ *   differs from the GraphQL key is pinned with `Field(alias=...)` so pydantic
+ *   hydrates the wire (camelCase) key onto the attribute,
+ * - input types become `TypedDict`s keyed by the WIRE (GraphQL) name — inputs
+ *   are sent to the server as-is, so their keys are never snake-cased,
+ * - enums become `str, Enum` classes,
+ * - scalars are mapped to native Python types.
+ *
+ * By default object / interface field names are converted to snake_case (see
+ * `namingConvention`). Every annotation is quoted so forward / recursive
+ * references resolve without ordering constraints.
+ */
+export interface PythonPluginConfig extends RawTypesConfig {
+  /**
+   * @description The base class that generated object and interface types extend.
+   * @default "BaseModel"
+   *
+   * @exampleMarkdown
+   * ```ts filename="codegen.ts"
+   *  import type { CodegenConfig } from '@graphql-codegen/cli';
+   *
+   *  const config: CodegenConfig = {
+   *    generates: {
+   *      'schema.py': {
+   *        plugins: ['@graphql-codegen/python'],
+   *        config: {
+   *          baseModel: 'BaseModel',
+   *        },
+   *      },
+   *    },
+   *  };
+   *  export default config;
+   * ```
+   */
+  baseModel?: string;
+  /**
+   * @description The module the base model is imported from. Emitted as
+   * `from {runtimeImport} import {baseModel}` (with `ConfigDict` / `Field`
+   * appended when the generated types use aliases). Defaults to `pydantic`; if
+   * you override it, point it at a module that re-exports a pydantic-compatible
+   * `BaseModel`, `ConfigDict`, and `Field`.
+   * @default "pydantic"
+   *
+   * @exampleMarkdown
+   * ```ts filename="codegen.ts"
+   *  import type { CodegenConfig } from '@graphql-codegen/cli';
+   *
+   *  const config: CodegenConfig = {
+   *    generates: {
+   *      'schema.py': {
+   *        plugins: ['@graphql-codegen/python'],
+   *        config: {
+   *          runtimeImport: 'pydantic',
+   *        },
+   *      },
+   *    },
+   *  };
+   *  export default config;
+   * ```
+   */
+  runtimeImport?: string;
+  /**
+   * @description Controls how GraphQL OBJECT / INTERFACE field names are turned
+   * into Python class attributes. Input-type keys are unaffected — they always
+   * keep the wire (GraphQL) name because the runtime forwards the input dict to
+   * the server as-is.
+   *
+   * - `'snakeCase'` (default): field names are converted from camelCase to
+   *   snake_case and Python reserved keywords are suffixed with `_`. This is the
+   *   idiomatic-Python choice; each renamed field is pinned with `Field(alias=...)`
+   *   (e.g. `from` -> `from_` with `alias='from'`) so pydantic hydrates the
+   *   original wire key onto the attribute.
+   * - `'keep'`: object / interface field names are used verbatim; a keyword /
+   *   non-identifier field falls back to a trailing `_` for just that field.
+   *
+   * @default "snakeCase"
+   *
+   * @exampleMarkdown
+   * ```ts filename="codegen.ts"
+   *  import type { CodegenConfig } from '@graphql-codegen/cli';
+   *
+   *  const config: CodegenConfig = {
+   *    generates: {
+   *      'schema.py': {
+   *        plugins: ['@graphql-codegen/python'],
+   *        config: {
+   *          namingConvention: 'snakeCase',
+   *        },
+   *      },
+   *    },
+   *  };
+   *  export default config;
+   * ```
+   */
+  namingConvention?: 'keep' | 'snakeCase';
+  /**
+   * @description Does not add a `__typename` field to the generated types.
+   * For the Python types plugin `__typename` is not emitted by default, so this
+   * option is accepted for parity but has no additional effect unless you opt in
+   * elsewhere.
+   * @default true
+   */
+  skipTypename?: boolean;
+}

package/src/index.ts

@@ -0,0 +1,32 @@
+import { GraphQLSchema } from 'graphql';
+import {
+  getCachedDocumentNodeFromSchema,
+  oldVisit,
+  PluginFunction,
+  Types,
+} from '@graphql-codegen/plugin-helpers';
+import { PythonPluginConfig } from './config.js';
+import { PythonVisitor } from './visitor.js';
+
+export * from './config.js';
+export * from './visitor.js';
+
+export const plugin: PluginFunction<PythonPluginConfig, Types.ComplexPluginOutput> = (
+  schema: GraphQLSchema,
+  _documents: Types.DocumentFile[],
+  config: PythonPluginConfig,
+) => {
+  const astNode = getCachedDocumentNodeFromSchema(schema);
+  const visitor = new PythonVisitor(schema, config);
+
+  const visitorResult = oldVisit(astNode, { leave: visitor });
+
+  const content = (visitorResult.definitions as unknown[])
+    .filter((def): def is string => typeof def === 'string' && def.length > 0)
+    .join('\n\n\n');
+
+  return {
+    prepend: visitor.getImports(content),
+    content,
+  };
+};