sqlalchemy-upsert-kit 0.1.1__py3-none-any.whl

sqlalchemy_upsert_kit/sqlite/insert_or_ignore.py

@@ -0,0 +1,156 @@
+# -*- coding: utf-8 -*-
+
+import typing as T
+import dataclasses
+
+import sqlalchemy as sa
+
+from ..exc import UpsertTestError
+
+from .executor import UpsertExecutor
+
+
+@dataclasses.dataclass
+class InsertOrIgnoreExecutor(UpsertExecutor):
+    def apply_strategy(
+        self,
+        conn: sa.Connection,
+        trans: sa.Transaction,
+    ):
+        if self._raise_on_target_insert:  # Testing flag
+            raise UpsertTestError("error on target insertion")
+        stmt = self.table.insert().from_select(
+            list(self._temp_table.columns.keys()),
+            sa.select(self._temp_table)
+            .select_from(
+                self._temp_table.outerjoin(  # LEFT JOIN to find non-matches
+                    self.table,
+                    self._temp_table.c[self.pk_name] == self.table.c[self.pk_name],
+                )
+            )
+            .where(
+                self.table.c[self.pk_name].is_(None)
+            ),  # Only insert where no match exists
+        )
+        res = conn.execute(stmt)
+        try:
+            self._inserted_rows = res.rowcount if res.rowcount is not None else 0
+            self._ignored_rows = len(self.values) - self._inserted_rows
+        except:  # pragma: no cover
+            self._inserted_rows = 0
+            self._ignored_rows = len(self.values)
+
+
+def insert_or_ignore(
+    engine: sa.Engine,
+    table: sa.Table,
+    values: list[dict[str, T.Any]],
+    metadata: T.Optional[sa.MetaData] = None,
+    temp_table_name: T.Optional[str] = None,
+    conn: T.Optional[sa.Connection] = None,
+    trans: T.Optional[sa.Transaction] = None,
+    _raise_on_temp_table_create: bool = False,
+    _raise_on_temp_data_insert: bool = False,
+    _raise_on_target_insert: bool = False,
+    _raise_on_temp_table_drop: bool = False,
+) -> tuple[int, int]:
+    """
+    Perform high-performance bulk INSERT-IF-NOT-EXISTS operation using temporary table.
+
+    This function performs conditional bulk insertion: only inserts records whose
+    primary keys don't already exist in the target table. This is equivalent to
+    "INSERT IGNORE" or "INSERT ... ON CONFLICT DO NOTHING" but works more
+    efficiently.
+
+    **Algorithm**:
+
+    1. Creates temporary table and loads all candidate data
+    2. Uses LEFT JOIN to identify records not in target table
+    3. Bulk inserts only the non-conflicting records
+    4. Cleans up temporary resources
+
+    This approach is ideal for:
+
+    - Incremental data loading where duplicates should be ignored
+    - ETL processes that need idempotent behavior
+    - Syncing data from external sources
+
+    **Transaction Management**:
+
+    This function supports both auto-managed and user-managed transaction modes.
+    See the module-level documentation for detailed explanations of each mode.
+
+    :param engine: SQLAlchemy engine for database connection
+    :param table: Target table for conditional insertion
+    :param values: Records to insert if they don't exist.
+        Must include primary key values for conflict detection.
+    :param metadata: Optional metadata instance for temporary table isolation.
+        If None, a new MetaData instance is created for clean separation.
+    :param temp_table_name: Optional custom name for temporary table.
+        If None, generates unique name with timestamp to avoid conflicts.
+    :param conn: Optional database connection for user-managed transaction mode.
+        Must be provided together with ``trans`` parameter.
+    :param trans: Optional transaction for user-managed transaction mode.
+        Must be provided together with ``conn`` parameter.
+
+    :returns: Tuple of (ignored_rows, inserted_rows):
+        - ignored_rows: Number of records that were not inserted (already existed)
+        - inserted_rows: Number of new records successfully inserted
+
+    :raises ValueError: When conn and trans parameters are provided inconsistently
+        (one is None while the other is not)
+    :raises UpsertTestError: When testing flags are enabled and corresponding operations fail
+
+    **Examples**:
+
+        Auto-managed transaction (default mode)::
+
+            # Function manages its own transaction
+            ignored, inserted = insert_or_ignore(engine, users_table, new_data)
+
+        User-managed transaction mode::
+
+            # Operation is part of larger transaction
+            with engine.connect() as conn:
+                with conn.begin() as trans:
+                    # Other operations...
+                    ignored, inserted = insert_or_ignore(
+                        engine, users_table, new_data, conn=conn, trans=trans
+                    )
+                    # More operations...
+
+        Conflict detection example::
+
+            # Target table has records with id=1,2,3
+            new_data = [
+                {'id': 2, 'name': 'Bob'},      # Exists - will be ignored
+                {'id': 4, 'name': 'Charlie'},  # New - will be inserted
+                {'id': 5, 'name': 'David'},    # New - will be inserted
+            ]
+            ignored, inserted = insert_or_ignore(engine, users_table, new_data)
+            # Result: ignored=1, inserted=2
+
+    .. note::
+
+        Parameters prefixed with ``_raise_on_`` are exclusively for testing error
+        handling and cleanup behavior. Never use these in production code.
+    """
+    if not values:  # pragma: no cover
+        return 0, 0  # No-op for empty data
+
+    executor = InsertOrIgnoreExecutor.new(
+        engine=engine,
+        table=table,
+        values=values,
+        metadata=metadata,
+        temp_table_name=temp_table_name,
+        conn=conn,
+        trans=trans,
+        _raise_on_temp_table_create=_raise_on_temp_table_create,
+        _raise_on_temp_data_insert=_raise_on_temp_data_insert,
+        _raise_on_target_insert=_raise_on_target_insert,
+        _raise_on_temp_table_drop=_raise_on_temp_table_drop,
+    )
+    executor.run()
+    ignored_rows, inserted_rows = executor._ignored_rows, executor._inserted_rows
+    return ignored_rows, inserted_rows

sqlalchemy_upsert_kit/sqlite/insert_or_merge.py

@@ -0,0 +1,254 @@
+# -*- coding: utf-8 -*-
+
+import typing as T
+import dataclasses
+
+import sqlalchemy as sa
+
+from ..exc import UpsertTestError
+
+from .executor import UpsertExecutor
+
+
+@dataclasses.dataclass
+class InsertOrMergeExecutor(UpsertExecutor):
+    def apply_strategy(
+        self,
+        conn: sa.Connection,
+        trans: sa.Transaction,
+    ):
+        """
+        Apply merge strategy: update existing records with selected columns, insert new records.
+
+        This implementation follows the merge algorithm:
+        1. Create temp table t3 with merged data (existing records with selective updates)
+        2. Delete conflicting records from target table t1
+        3. Insert both updated records (from t3) and new records (from t2) into t1
+        """
+        if self._raise_on_target_delete:  # Testing flag
+            raise UpsertTestError("error on target deletion")
+
+        # Step 1: Create merge temp table (t3) with updated data for existing records
+        merge_temp_table_name = f"{self.temp_table_name}_merge"
+        merge_temp_table = sa.Table(
+            merge_temp_table_name,
+            self.metadata,
+            *[
+                sa.Column(col.name, col.type, nullable=col.nullable)
+                for col in self.table.columns
+            ],
+            prefixes=["TEMPORARY"],
+        )
+        merge_temp_table.create(conn)
+
+        try:
+            if self._raise_on_merge_update:  # Testing flag
+                raise UpsertTestError("error on merge update")
+
+            # Build the merge query: existing records with selective column updates
+            # For columns in self.columns: use values from temp table (t2)
+            # For columns not in self.columns: use values from target table (t1)
+            select_cols = []
+            for col in self.table.columns:
+                if col.name in self.columns:
+                    # Use new value from temp table
+                    select_cols.append(self._temp_table.c[col.name].label(col.name))
+                else:
+                    # Preserve existing value from target table
+                    select_cols.append(self.table.c[col.name].label(col.name))
+
+            # Create merged records for existing/conflicting records
+            merge_stmt = merge_temp_table.insert().from_select(
+                [col.name for col in self.table.columns],
+                sa.select(*select_cols).select_from(
+                    self.table.join(
+                        self._temp_table,
+                        self.table.c[self.pk_name] == self._temp_table.c[self.pk_name],
+                    )
+                ),
+            )
+            merge_result = conn.execute(merge_stmt)
+            self._updated_rows = (
+                merge_result.rowcount if merge_result.rowcount is not None else 0
+            )
+
+            # Step 2: Delete existing records that will be replaced with merged data
+            inner = sa.select(self.table.c[self.pk_name]).join(
+                self._temp_table,
+                self.table.c[self.pk_name] == self._temp_table.c[self.pk_name],
+            )
+            delete_stmt = self.table.delete().where(
+                self.table.c[self.pk_name].in_(inner)
+            )
+            conn.execute(delete_stmt)
+
+            # Step 3: Insert merged records (updated existing records)
+            if self._raise_on_target_insert:  # Testing flag
+                raise UpsertTestError("error on target insertion")
+
+            if self._updated_rows > 0:
+                insert_merged_stmt = self.table.insert().from_select(
+                    list(merge_temp_table.columns.keys()),
+                    sa.select(*list(merge_temp_table.columns.values())),
+                )
+                conn.execute(insert_merged_stmt)
+
+            # Step 4: Insert new records (records that don't exist in target table)
+            # Use LEFT JOIN to find records in temp table that don't exist in target
+            new_records_stmt = self.table.insert().from_select(
+                list(self._temp_table.columns.keys()),
+                sa.select(*list(self._temp_table.columns.values()))
+                .select_from(
+                    self._temp_table.outerjoin(
+                        self.table,
+                        self._temp_table.c[self.pk_name] == self.table.c[self.pk_name],
+                    )
+                )
+                .where(self.table.c[self.pk_name].is_(None)),
+            )
+            insert_result = conn.execute(new_records_stmt)
+            self._inserted_rows = (
+                insert_result.rowcount if insert_result.rowcount is not None else 0
+            )
+
+        finally:
+            # Clean up merge temp table
+            merge_temp_table.drop(conn)
+            self.metadata.remove(merge_temp_table)
+
+
+def insert_or_merge(
+    engine: sa.Engine,
+    table: sa.Table,
+    values: list[dict[str, T.Any]],
+    columns: list[str],
+    metadata: T.Optional[sa.MetaData] = None,
+    temp_table_name: T.Optional[str] = None,
+    conn: T.Optional[sa.Connection] = None,
+    trans: T.Optional[sa.Transaction] = None,
+    _raise_on_temp_table_create: bool = False,
+    _raise_on_temp_data_insert: bool = False,
+    _raise_on_target_delete: bool = False,
+    _raise_on_target_insert: bool = False,
+    _raise_on_temp_table_drop: bool = False,
+    _raise_on_merge_update: bool = False,
+) -> tuple[int, int]:
+    """
+    Perform high-performance bulk INSERT-OR-MERGE operation using temporary table.
+
+    This function performs bulk merge operations: updates specific columns of existing
+    records while preserving other columns, and inserts records that don't exist.
+    This is ideal for incremental data updates where only certain fields need updating.
+
+    **Algorithm**:
+
+    1. Creates temporary table (t2) and loads all candidate data
+    2. Creates merge temporary table (t3) with selective column updates
+    3. Generates merged records by combining existing data with new values for specified columns
+    4. Deletes conflicting records from target table (t1)
+    5. Inserts merged records and new records into target table
+    6. Cleans up temporary resources
+
+    This approach is ideal for:
+
+    - Selective column updates (e.g., updating timestamps while preserving descriptions)
+    - Incremental data synchronization
+    - Preserving historical data in non-updated columns
+
+    **Transaction Management**:
+
+    This function supports both auto-managed and user-managed transaction modes.
+    See the module-level documentation for detailed explanations of each mode.
+
+    :param engine: SQLAlchemy engine for database connection
+    :param table: Target table for upsert operation
+    :param values: Records to merge.
+        Must include primary key values for conflict detection.
+    :param columns: List of columns to update with new values. Other columns will
+        remain unchanged for existing records. This is required, otherwise user should use
+        insert_or_ignore or insert_or_replace strategy.
+    :param metadata: Optional metadata instance for temporary table isolation.
+        If None, a new MetaData instance is created for clean separation.
+    :param temp_table_name: Optional custom name for temporary table.
+        If None, generates unique name with timestamp to avoid conflicts.
+    :param conn: Optional database connection for user-managed transaction mode.
+        Must be provided together with ``trans`` parameter.
+    :param trans: Optional transaction for user-managed transaction mode.
+        Must be provided together with ``conn`` parameter.
+
+    :returns: Tuple of (updated_rows, inserted_rows):
+        - updated_rows: Number of existing records that were updated with new column values
+        - inserted_rows: Number of new records that were inserted
+
+    :raises ValueError: When conn and trans parameters are provided inconsistently
+        or when columns parameter is empty
+    :raises UpsertTestError: When testing flags are enabled and corresponding operations fail
+
+    **Examples**:
+
+        Auto-managed transaction (default mode)::
+
+            # Function manages its own transaction
+            updated, inserted = merge(engine, users_table, new_data, columns=["update_at"])
+
+        User-managed transaction mode::
+
+            # Operation is part of larger transaction
+            with engine.connect() as conn:
+                with conn.begin() as trans:
+                    # Other operations...
+                    updated, inserted = merge(
+                        engine, users_table, new_data, columns=["update_at"],
+                        conn=conn, trans=trans
+                    )
+                    # More operations...
+
+        Selective column update example::
+
+            # Target table has records with id=1,2,3
+            new_data = [
+                {'id': 2, 'name': 'Bob', 'update_at': '2024-01-02'},    # Exists - will be merged
+                {'id': 4, 'name': 'Charlie', 'update_at': '2024-01-02'}, # New - will be inserted
+            ]
+            updated, inserted = merge(engine, users_table, new_data, columns=["update_at"])
+            # Result: updated=1, inserted=1
+            # Record id=2 will have new update_at but original name preserved
+
+    .. note::
+
+        Parameters prefixed with ``_raise_on_`` are exclusively for testing error
+        handling and cleanup behavior. Never use these in production code.
+
+    .. warning::
+
+        The columns parameter must not be empty. If you want to update all columns,
+        use insert_or_replace instead. If you want to ignore conflicts, use
+        insert_or_ignore instead.
+    """
+    if not values:  # pragma: no cover
+        return 0, 0  # No-op for empty data
+
+    if not columns:  # pragma: no cover
+        raise ValueError(
+            "columns parameter cannot be empty. Use insert_or_replace for full updates or insert_or_ignore for conflict-free inserts."
+        )
+
+    executor = InsertOrMergeExecutor.new(
+        engine=engine,
+        table=table,
+        values=values,
+        metadata=metadata,
+        temp_table_name=temp_table_name,
+        conn=conn,
+        trans=trans,
+        columns=columns,
+        _raise_on_temp_table_create=_raise_on_temp_table_create,
+        _raise_on_temp_data_insert=_raise_on_temp_data_insert,
+        _raise_on_target_delete=_raise_on_target_delete,
+        _raise_on_target_insert=_raise_on_target_insert,
+        _raise_on_temp_table_drop=_raise_on_temp_table_drop,
+        _raise_on_merge_update=_raise_on_merge_update,
+    )
+    executor.run()
+    updated_rows, inserted_rows = executor._updated_rows, executor._inserted_rows
+    return updated_rows, inserted_rows

sqlalchemy_upsert_kit/sqlite/insert_or_replace.py

@@ -0,0 +1,177 @@
+# -*- coding: utf-8 -*-
+
+import typing as T
+import dataclasses
+
+import sqlalchemy as sa
+
+from ..exc import UpsertTestError
+
+from .executor import UpsertExecutor
+
+
+@dataclasses.dataclass
+class InsertOrReplaceExcutor(UpsertExecutor):
+    def apply_strategy(
+        self,
+        conn: sa.Connection,
+        trans: sa.Transaction,
+    ):
+        # Step 3: Delete existing records that will be replaced
+        # Uses JOIN to identify conflicting records for optimal performance
+        if self._raise_on_target_delete:  # Testing flag
+            raise UpsertTestError("error on target deletion")
+        inner = sa.select(self.table.c[self.pk_name]).join(
+            self._temp_table,
+            self.table.c[self.pk_name] == self._temp_table.c[self.pk_name],
+        )
+        stmt = self.table.delete().where(self.table.c[self.pk_name].in_(inner))
+        res = conn.execute(stmt)
+        try:
+            self._replaced_rows = res.rowcount if res.rowcount is not None else 0
+        except:  # pragma: no cover
+            self._replaced_rows = 0
+
+        # Step 4: Insert all records from temp table (both replacements and new)
+        # This includes records that replace deleted ones and completely new records
+        if self._raise_on_target_insert:  # Testing flag
+            raise UpsertTestError("error on target insertion")
+        stmt = self.table.insert().from_select(
+            list(self._temp_table.columns.keys()),
+            sa.select(*list(self._temp_table.columns.values())),
+        )
+        res = conn.execute(stmt)
+        try:
+            total_inserted = res.rowcount if res.rowcount is not None else 0
+            self._inserted_rows = total_inserted - self._replaced_rows
+        except:  # pragma: no cover
+            self._inserted_rows = len(self.values) - self._replaced_rows
+
+
+def insert_or_replace(
+    engine: sa.Engine,
+    table: sa.Table,
+    values: list[dict[str, T.Any]],
+    metadata: T.Optional[sa.MetaData] = None,
+    temp_table_name: T.Optional[str] = None,
+    conn: T.Optional[sa.Connection] = None,
+    trans: T.Optional[sa.Transaction] = None,
+    _raise_on_temp_table_create: bool = False,
+    _raise_on_temp_data_insert: bool = False,
+    _raise_on_target_delete: bool = False,
+    _raise_on_target_insert: bool = False,
+    _raise_on_temp_table_drop: bool = False,
+) -> tuple[int, int]:
+    """
+    Perform high-performance bulk INSERT-OR-REPLACE operation using temporary table.
+
+    This function performs bulk upsert operations: replaces existing records entirely
+    with new data and inserts records that don't exist. This is equivalent to
+    "INSERT OR REPLACE" or complete record replacement but works more efficiently
+    for large datasets.
+
+    **Algorithm**:
+
+    1. Creates temporary table and loads all candidate data
+    2. Uses JOIN to identify conflicting records in target table
+    3. Deletes conflicting records from target table
+    4. Bulk inserts all records from temporary table (both new and replacement)
+    5. Cleans up temporary resources
+
+    This approach is ideal for:
+
+    - Full synchronization from authoritative data source
+    - Complete data refresh scenarios
+    - When new data should completely replace existing records
+
+    **Transaction Management**:
+
+    This function supports both auto-managed and user-managed transaction modes.
+    See the module-level documentation for detailed explanations of each mode.
+
+    :param engine: SQLAlchemy engine for database connection
+    :param table: Target table for upsert operation
+    :param values: Records to insert or replace.
+        Must include primary key values for conflict detection.
+    :param metadata: Optional metadata instance for temporary table isolation.
+        If None, a new MetaData instance is created for clean separation.
+    :param temp_table_name: Optional custom name for temporary table.
+        If None, generates unique name with timestamp to avoid conflicts.
+    :param conn: Optional database connection for user-managed transaction mode.
+        Must be provided together with ``trans`` parameter.
+    :param trans: Optional transaction for user-managed transaction mode.
+        Must be provided together with ``conn`` parameter.
+
+    :returns: Tuple of (replaced_rows, inserted_rows):
+        - replaced_rows: Number of existing records that were replaced
+        - inserted_rows: Number of new records that were inserted
+
+    :raises ValueError: When conn and trans parameters are provided inconsistently
+        (one is None while the other is not)
+    :raises UpsertTestError: When testing flags are enabled and corresponding operations fail
+
+    **Examples**:
+
+        Auto-managed transaction (default mode)::
+
+            # Function manages its own transaction
+            updated, inserted = insert_or_replace(engine, users_table, new_data)
+
+        User-managed transaction mode::
+
+            # Operation is part of larger transaction
+            with engine.connect() as conn:
+                with conn.begin() as trans:
+                    # Other operations...
+                    updated, inserted = insert_or_replace(
+                        engine, users_table, new_data, conn=conn, trans=trans
+                    )
+                    # More operations...
+
+        Complete replacement example::
+
+            # Target table has records with id=1,2,3
+            new_data = [
+                {'id': 2, 'name': 'Bob Updated'},    # Exists - will be replaced
+                {'id': 4, 'name': 'Charlie'},        # New - will be inserted
+                {'id': 5, 'name': 'David'},          # New - will be inserted
+            ]
+            updated, inserted = insert_or_replace(engine, users_table, new_data)
+            # Result: updated=1, inserted=2
+
+    **Performance Comparison**:
+        Traditional row-by-row approach (100K records): ~300 seconds
+        This method (100K records): ~15 seconds
+        Performance gain: ~20x faster
+
+    .. note::
+
+        Parameters prefixed with ``_raise_on_`` are exclusively for testing error
+        handling and cleanup behavior. Never use these in production code.
+
+    .. warning::
+
+        This operation completely replaces existing records. All fields of
+        conflicting records (including historical fields like timestamps) will
+        be overwritten with new data.
+    """
+    if not values:  # pragma: no cover
+        return 0, 0  # No-op for empty data
+
+    executor = InsertOrReplaceExcutor.new(
+        engine=engine,
+        table=table,
+        values=values,
+        metadata=metadata,
+        temp_table_name=temp_table_name,
+        conn=conn,
+        trans=trans,
+        _raise_on_temp_table_create=_raise_on_temp_table_create,
+        _raise_on_temp_data_insert=_raise_on_temp_data_insert,
+        _raise_on_target_delete=_raise_on_target_delete,
+        _raise_on_target_insert=_raise_on_target_insert,
+        _raise_on_temp_table_drop=_raise_on_temp_table_drop,
+    )
+    executor.run()
+    replaced_rows, inserted_rows = executor._replaced_rows, executor._inserted_rows
+    return replaced_rows, inserted_rows

sqlalchemy_upsert_kit/utils.py

@@ -0,0 +1,92 @@
+# -*- coding: utf-8 -*-
+
+import typing as T
+from datetime import datetime, timezone
+
+import sqlalchemy as sa
+
+
+def get_utc_now() -> datetime:
+    return datetime.now(tz=timezone.utc)
+
+
+def get_pk_name(table: sa.Table) -> str:
+    """
+    Extract the primary key column name from a SQLAlchemy table.
+
+    This function ensures the table has exactly one primary key column,
+    which is required for the bulk operations to work correctly.
+
+    Args:
+        table: SQLAlchemy table object
+
+    Returns:
+        Name of the primary key column
+
+    Raises:
+        ValueError: If table has zero or multiple primary key columns
+
+    Example:
+        >>> table = sa.Table(
+        ...     'users',
+        ...     metadata,
+        ...     sa.Column('id', sa.Integer, primary_key=True)
+        ... )
+        >>> get_pk_name(table)
+        'id'
+    """
+    pks = list(table.primary_key)
+    if len(pks) != 1:  # pragma: no cover
+        pk_names = [pk.name for pk in pks]
+        raise ValueError(
+            f"Table must have exactly one primary key, but found: {pk_names}"
+        )
+    pk_name = pks[0].name
+    return pk_name
+
+
+def get_temp_table_name(original_table_name: str) -> str:
+    dt = get_utc_now().strftime("%Y%m%d%H%M%S")
+    temp_table_name = f"temp_{dt}_" + original_table_name
+    return temp_table_name
+
+
+def clone_temp_table(
+    original_table: sa.Table,
+    metadata: sa.MetaData,
+    temp_table_name: T.Optional[str] = None,
+) -> sa.Table:
+    """
+    Create a temporary table with the same schema as the original table.
+
+    This function clones the structure of an existing table to create a temporary
+    table for bulk operations. The temporary table inherits all columns, types,
+    and constraints from the original table.
+
+    Args:
+        original_table: The table to clone
+        metadata: Metadata object for the temporary table.
+            Should be a separate instance from the original table's metadata
+            to avoid conflicts and enable proper cleanup.
+        temp_table_name: Custom name for the temporary table.
+            If None, generates a unique name with timestamp to avoid conflicts
+            in concurrent environments.
+
+    Returns:
+        New temporary table with identical schema
+
+    .. note::
+
+        - Use a separate MetaData instance to isolate the temporary table
+        - In high-concurrency scenarios, consider providing unique temp_table_name
+        - The temporary table is not automatically bound to any engine
+
+    Example:
+        >>> metadata = sa.MetaData()
+        >>> _temp_table = clone_temp_table(users_table, metadata)
+        >>> # _temp_table has same columns as users_table but different metadata
+    """
+    if temp_table_name is None:
+        temp_table_name = get_temp_table_name(original_table.name)
+    temp_table = original_table.to_metadata(metadata, name=temp_table_name)
+    return temp_table

sqlalchemy_upsert_kit/vendor/__init__.py

@@ -0,0 +1,2 @@
+# -*- coding: utf-8 -*-
+