brynq-sdk-sage-100-france 1.2.1__py3-none-any.whl

brynq_sdk_sage_100_france/__init__.py

@@ -0,0 +1 @@
+from .sage_100_france import Sage100France 

brynq_sdk_sage_100_france/absence.py

@@ -0,0 +1,35 @@
+import pandas as pd
+from .schemas.absence import AbsenceSchema
+from brynq_sdk_functions import Functions
+
+class Absence:
+    """Class for interacting with Sage 100 France absence endpoints"""
+
+    # Get column names from schema
+    COLUMN_NAMES = list(AbsenceSchema.to_schema().columns.keys())
+    
+    def __init__(self, sage_100_france):
+        """Initialize Absence class
+        
+        Args:
+            sage_100_france: Parent Sage 100 France instance for authentication and configuration
+        """
+        self.sage_100_france = sage_100_france
+        self.db_table = "T_MOTIFDABSENCE"
+    
+    def get(self):
+        """Get all absence records
+        
+        Returns:
+            pandas.DataFrame: DataFrame containing absence data with schema validation
+        """
+        absence = self.sage_100_france.get(table_name=self.db_table, columns=self.COLUMN_NAMES)
+        try:
+            df = pd.DataFrame(absence)
+            if not df.empty:
+                df.columns = self.COLUMN_NAMES
+                valid_data, invalid_data = Functions.validate_data(df, AbsenceSchema)
+                return valid_data, invalid_data
+            return df
+        except Exception as e:
+            raise ValueError(f"There was an error processing the Absence data: {e}")

brynq_sdk_sage_100_france/address.py

@@ -0,0 +1,38 @@
+import pandas as pd
+from .schemas.address import AddressSchema
+from brynq_sdk_functions import Functions
+
+class Address:
+    """Class for interacting with Sage 100 France address history endpoints"""
+
+    # Get column names from schema
+    COLUMN_NAMES = list(AddressSchema.to_schema().columns.keys())
+    
+    def __init__(self, sage_100_france):
+        """Initialize Address class
+        
+        Args:
+            sage_100_france: Parent Sage 100 France instance for authentication and configuration
+        """
+        self.sage_100_france = sage_100_france
+        self.db_table = "T_HST_ADRESSE"
+    
+    def get(self):
+        """Get all address history records
+        
+        Returns:
+            pandas.DataFrame: DataFrame containing address history data with schema validation
+            
+        Raises:
+            ValueError: If there is an error processing the address data
+        """
+        address = self.sage_100_france.get(table_name=self.db_table, columns=self.COLUMN_NAMES)
+        try:
+            df = pd.DataFrame(address)
+            if not df.empty:
+                df.columns = self.COLUMN_NAMES
+                valid_data, invalid_data = Functions.validate_data(df, AddressSchema)
+                return valid_data, invalid_data
+            return df
+        except Exception as e:
+            raise ValueError(f"There was an error processing the Address data: {e}")

brynq_sdk_sage_100_france/bank_info.py

@@ -0,0 +1,40 @@
+import pandas as pd
+from brynq_sdk_functions import Functions
+
+from .schemas.bank_info import BankInfoSchema
+
+
+class BankInfo:
+    """Class for interacting with Sage 100 France bank information endpoints"""
+
+    # Get column names from schema
+    COLUMN_NAMES = list(BankInfoSchema.to_schema().columns.keys())
+
+    def __init__(self, sage_100_france):
+        """Initialize BankInfo class
+
+        Args:
+            sage_100_france: Parent Sage 100 France instance for authentication and configuration
+        """
+        self.sage_100_france = sage_100_france
+        self.db_table = "T_INFOBANQUE"
+
+    def get(self):
+        """Get all bank information records
+
+        Returns:
+            pandas.DataFrame: DataFrame containing bank information data with schema validation
+
+        Raises:
+            ValueError: If there is an error processing the bank information data
+        """
+        bank_info = self.sage_100_france.get(table_name=self.db_table, columns=self.COLUMN_NAMES)
+        try:
+            df = pd.DataFrame(bank_info)
+            if not df.empty:
+                df.columns = self.COLUMN_NAMES
+                valid_data, invalid_data = Functions.validate_data(df, BankInfoSchema)
+                return valid_data, invalid_data
+            return df
+        except Exception as e:
+            raise ValueError(f"There was an error processing the Bank Info data: {e}")

brynq_sdk_sage_100_france/company.py

@@ -0,0 +1,42 @@
+import pandas as pd
+import pandera as pa
+from pandera.typing import Series
+from typing import Union, List, Dict, Any
+from .schemas.company import CompanySchema
+from brynq_sdk_functions import Functions
+
+class Company:
+    """Class for interacting with Sage 100 France company endpoints"""
+
+    # Get column names from schema
+    COLUMN_NAMES = list(CompanySchema.to_schema().columns.keys())
+
+    def __init__(self, sage_100_france):
+        """Initialize Company class
+
+        Args:
+            sage_100_france: Parent Sage 100 France instance for authentication and configuration
+        """
+        self.sage_100_france = sage_100_france
+        self.db_table = "T_SOCIETE"
+
+    def get(self):
+        """Get company information
+
+        Returns:
+            pandas.DataFrame: DataFrame containing company data with schema validation
+
+        Raises:
+            ValueError: If there is an error processing the company data
+        """
+        company = self.sage_100_france.get(table_name=self.db_table, columns=self.COLUMN_NAMES)
+        try:
+            df = pd.DataFrame(company)
+            if not df.empty:
+                df.columns = self.COLUMN_NAMES
+                valid_data, invalid_data = Functions.validate_data(df, CompanySchema)
+                return valid_data, invalid_data
+            return df
+        except Exception as e:
+            raise ValueError(f"There was an error processing the Company data: {e}")
+

brynq_sdk_sage_100_france/contract.py

@@ -0,0 +1,37 @@
+import pandas as pd
+from .schemas.contract import ContractSchema
+from brynq_sdk_functions import Functions
+
+class Contract:
+    """Class for interacting with Sage 100 France contract endpoints"""
+
+    # Get column names from schema
+    COLUMN_NAMES = list(ContractSchema.to_schema().columns.keys())
+
+    def __init__(self, sage_100_france):
+        """Initialize Contract class
+
+        Args:
+            sage_100_france: Parent Sage 100 France instance for authentication and configuration
+        """
+        self.sage_100_france = sage_100_france
+        self.db_table = "T_HST_CONTRAT"
+
+    def get(self):
+        """Get all contract records
+
+        Returns:
+            pandas.DataFrame: DataFrame containing contract data with schema validation
+
+        Raises:
+            ValueError: If there is an error processing the contract data
+        """
+        contract = self.sage_100_france.get(table_name=self.db_table, columns=self.COLUMN_NAMES)
+        try:
+            df = pd.DataFrame(contract)
+            if not df.empty:
+                df.columns = self.COLUMN_NAMES
+                valid_data,  =  Functions.validate_data(df, ContractSchema)
+                return valid_data
+        except Exception as e:
+            raise ValueError(f"There was an error processing the Contract data: {e}")

brynq_sdk_sage_100_france/department.py

@@ -0,0 +1,36 @@
+import pandas as pd
+from typing import Union, List, Dict, Any
+from .schemas.department import DepartmentSchema
+from brynq_sdk_functions import Functions
+
+class Department:
+    """Class for interacting with Sage 100 France department endpoints"""
+
+    # Get column names from schema
+    COLUMN_NAMES = list(DepartmentSchema.to_schema().columns.keys())
+
+    def __init__(self, sage_100_france):
+        """Initialize Department class
+
+        Args:
+            sage_100_france: Parent Sage 100 France instance for authentication and configuration
+        """
+        self.sage_100_france = sage_100_france
+        self.db_table = "T_DEPARTEMENT"
+
+    def get(self):
+        """Get all department records
+
+        Returns:
+            pandas.DataFrame: DataFrame containing department data with schema validation
+        """
+        department = self.sage_100_france.get(table_name=self.db_table, columns=self.COLUMN_NAMES)
+        try:
+            df = pd.DataFrame(department)
+            if not df.empty:
+                df.columns = self.COLUMN_NAMES
+                valid_data, invalid_data = Functions.validate_data(df, DepartmentSchema)
+                return valid_data, invalid_data
+        except Exception as e:
+            raise ValueError(f"There was an error processing the Department data: {e}")
+

brynq_sdk_sage_100_france/employee.py

@@ -0,0 +1,255 @@
+import pandas as pd
+from typing import Dict, Any, Type
+from pydantic import BaseModel
+from brynq_sdk_functions import Functions
+from .schemas.employee import EmployeeSchema, EmployeeExcelImport
+from .schemas.employee import PersonnelRecordTimePageSchema
+from .schemas.employee import RegistrationSchema
+from .schemas.employee import CivilStatusSchema
+from .schemas.employee import DadsUSchema
+from .work import Work
+from .employee_insurance import EmployeeInsurance
+class Employee:
+    """Class for interacting with Sage 100 France employee endpoints"""
+
+    # Get column names from schema
+    COLUMN_NAMES = list(EmployeeSchema.to_schema().columns.keys())
+
+    def __init__(self, sage_100_france):
+        """Initialize Employees class
+
+        Args:
+            sage_100_france: Parent Sage 100 France instance for authentication and configuration
+        """
+        self.sage_100_france = sage_100_france
+        self.work = Work(self)
+        self.insurance = EmployeeInsurance(self)
+        self.db_table = "T_CONTACT"
+
+
+
+    def get(self):
+        """Get all employees
+
+        Returns:
+            pandas.DataFrame: DataFrame containing employee data with schema validation
+
+        Raises:
+            ValueError: If there is an error processing the employee data
+        """
+        employee = self.sage_100_france.get(table_name=self.db_table, columns=self.COLUMN_NAMES)
+        try:
+            df = pd.DataFrame(employee)
+            if not df.empty:
+                df.columns = self.COLUMN_NAMES
+                valid_data, invalid_data = Functions.validate_data(df, EmployeeSchema)
+                return valid_data, invalid_data
+            return df
+        except Exception as e:
+            raise ValueError(f"There was an error processing the Employee data: {e}")
+
+    def import_registration_data(self, df: pd.DataFrame):
+        """
+        Import registration data
+
+        Args:
+            df: DataFrame to import
+        """
+        # Add unique_code automatically - it's always "01" for Registration
+        df = df.copy()
+        df['unique_code'] = "01"
+
+        valid_data = RegistrationSchema(df)
+
+        rows = self.sage_100_france.prepare_formatted_rows(df=valid_data, schema=RegistrationSchema)
+
+        self.sage_100_france.add_rows_to_buffer(rows)
+
+
+    def export_to_excel(
+        self,
+        df: pd.DataFrame,
+        output_excel_path: str,
+        schema: Type[BaseModel] = EmployeeExcelImport
+    ):
+        """
+        Validate employee DataFrame with Pydantic schema and export to Excel.
+
+        Args:
+            df: pandas DataFrame with employee data
+            output_excel_path: Path to output Excel file
+            schema: Pydantic BaseModel schema for validation (default: EmployeeExcelImport)
+
+        Returns:
+            Tuple of (validated_df, error_count)
+        """
+
+        # Warning for custom schemas
+        if schema != EmployeeExcelImport:
+            print("⚠ WARNING: Using custom schema.")
+            print("⚠ For Sage 100 France import Excel:")
+            print("⚠ Field order in schema MUST match EXACTLY the format definition.")
+            print("⚠ Fields must be defined in schema in the same order as in the format.")
+            print()
+
+        records = df.to_dict("records")
+
+        validated_rows = []
+        error_count = 0
+
+        for i, rec in enumerate(records, start=1):
+            try:
+                m = schema.model_validate(rec)
+                validated_rows.append(m.model_dump(by_alias=True))
+            except Exception as e:
+                print(f"✗ Row {i} validation error: {e}")
+                error_count += 1
+
+        if not validated_rows:
+            raise ValueError("No valid rows found in data")
+
+        validated_df = pd.DataFrame(validated_rows)
+        validated_df.to_excel(output_excel_path, index=False, sheet_name="Employees")
+
+        print(f"✓ Validated {len(validated_rows)} rows successfully")
+        if error_count:
+            print(f"✗ {error_count} rows had validation errors")
+
+        return output_excel_path
+
+
+
+    def _generate_child_field_specs(self, max_children: int) -> dict:
+        """
+        Generate field specifications for child data dynamically.
+
+        Args:
+            max_children: Maximum number of children to support
+
+        Returns:
+            Dictionary with child field specifications
+        """
+        child_specs = {}
+
+        # Starting position for first child (after number_of_children field)
+        base_position = 364
+
+        for child_num in range(1, max_children + 1):
+            # Each child takes 62 positions (2+20+30+8+1+1)
+            child_base_pos = base_position + ((child_num - 1) * 62)
+
+            child_specs.update({
+                f'child_{child_num}_number': {'position': child_base_pos, 'length': 2},
+                f'child_{child_num}_first_name': {'position': child_base_pos + 2, 'length': 20},
+                f'child_{child_num}_last_name': {'position': child_base_pos + 22, 'length': 30},
+                f'child_{child_num}_birth_date': {'position': child_base_pos + 52, 'length': 8},
+                f'child_{child_num}_gender': {'position': child_base_pos + 60, 'length': 1},
+                f'child_{child_num}_dependent': {'position': child_base_pos + 61, 'length': 1},
+            })
+
+        return child_specs
+
+    def _fill_missing_child_data(self, df: pd.DataFrame, max_children: int = 100) -> pd.DataFrame:
+        """
+        Fill missing child data with default values for up to max_children.
+
+        For each child that doesn't exist in the data, fill with:
+        - child_X_number: 0
+        - child_X_first_name: ""
+        - child_X_last_name: ""
+        - child_X_birth_date: ""
+        - child_X_gender: 0
+        - child_X_dependent: 0
+
+        Args:
+            df: DataFrame with child data
+            max_children: Maximum number of children to support
+
+        Returns:
+            DataFrame with all child fields filled
+        """
+        df = df.copy()
+
+        # Define default values for missing child data
+        child_defaults = {
+            'number': 0,  # Numeric field
+            'first_name': "",
+            'last_name': "",
+            'birth_date': "",
+            'gender': 0,  # Numeric field (0 = not specified)
+            'dependent': 0  # Numeric field (0 = not dependent)
+        }
+
+        # Collect all missing columns and their default values
+        missing_columns = {}
+
+        # Check for missing child columns (1 to max_children)
+        for child_num in range(1, max_children + 1):
+            for field, default_value in child_defaults.items():
+                column_name = f"child_{child_num}_{field}"
+                if column_name not in df.columns:
+                    # Column doesn't exist, add to missing columns
+                    missing_columns[column_name] = [default_value] * len(df)
+                else:
+                    # Column exists but may have NaN values, fill them
+                    df[column_name] = df[column_name].fillna(default_value)
+
+        # Add all missing columns at once using pd.concat for better performance
+        if missing_columns:
+            missing_df = pd.DataFrame(missing_columns, index=df.index)
+            df = pd.concat([df, missing_df], axis=1)
+
+        return df
+
+    def import_civil_status_data(self, df: pd.DataFrame):
+        """
+        Import civil status data
+
+        Args:
+            df: DataFrame to import
+        """
+        # Add unique_code automatically - it's always "02" for Civil Status
+        df = df.copy()
+        df['unique_code'] = "02"
+
+        df = self._fill_missing_child_data(df, max_children=99)
+
+        valid_data = CivilStatusSchema(df)
+
+        rows = self.sage_100_france.prepare_formatted_rows(df=valid_data, schema=CivilStatusSchema)
+
+        self.sage_100_france.add_rows_to_buffer(rows)
+
+    def import_time_page_data(self, df: pd.DataFrame):
+        """
+        Import time page data
+
+        Args:
+            df: DataFrame to import
+        """
+        # Add unique_code automatically - it's always "GT" for Time Page
+        df = df.copy()
+        df['unique_code'] = "GT"
+
+        valid_data = PersonnelRecordTimePageSchema(df)
+
+        rows = self.sage_100_france.prepare_formatted_rows(df=valid_data, schema=PersonnelRecordTimePageSchema)
+
+        self.sage_100_france.add_rows_to_buffer(rows)
+
+    def import_dads_u_data(self, df: pd.DataFrame):
+        """
+        Import DADS-U (Données DADS-U) data
+
+        Args:
+            df: DataFrame to import
+        """
+        # Add unique_code automatically - it's always "DU" for DADS-U
+        df = df.copy()
+        df['unique_code'] = "DU"
+
+        valid_data = DadsUSchema(df)
+
+        rows = self.sage_100_france.prepare_formatted_rows(df=valid_data, schema=DadsUSchema)
+
+        self.sage_100_france.add_rows_to_buffer(rows)

brynq_sdk_sage_100_france/employee_insurance.py

@@ -0,0 +1,40 @@
+import pandas as pd
+from typing import Union, List, Dict, Any
+from .schemas.employee_insurance import EmployeeInsuranceSchema
+from brynq_sdk_functions import Functions
+
+class EmployeeInsurance:
+    """Class for interacting with Sage 100 France employee insurance affiliations"""
+
+    # Get column names from schema
+    COLUMN_NAMES = list(EmployeeInsuranceSchema.to_schema().columns.keys())
+
+    def __init__(self, employee):
+        """Initialize EmployeeInsurance class
+
+        Args:
+            sage_100_france: Parent Sage 100 France instance for authentication and configuration
+        """
+        self.employee = employee
+        self.db_table = "T_SALARIE_CONTRAT_SOCIAL"
+
+    def get(self):
+        """Get all employee insurance affiliation records
+
+        Returns:
+            pandas.DataFrame: DataFrame containing employee insurance data with schema validation
+
+        Raises:
+            ValueError: If there is an error processing the employee insurance data
+        """
+        employee_insurance = self.employee.sage_100_france.get(table_name=self.db_table, columns=self.COLUMN_NAMES)
+        try:
+            df = pd.DataFrame(employee_insurance)
+            if not df.empty:
+                df.columns = self.COLUMN_NAMES
+                valid_data, invalid_data = Functions.validate_data(df, EmployeeInsuranceSchema)
+                return valid_data, invalid_data
+            return df
+        except Exception as e:
+            raise ValueError(f"There was an error processing the Employee Insurance data: {e}")
+

brynq_sdk_sage_100_france/event.py

@@ -0,0 +1,30 @@
+import pandas as pd
+from .schemas.event import EventSchema
+
+class Event:
+    """Class for interacting with Sage 100 France event endpoints"""
+
+    def __init__(self, sage_100_france):
+        """Initialize Event class
+
+        Args:
+            sage_100_france: Parent Sage 100 France instance for authentication and configuration
+        """
+        self.sage_100_france = sage_100_france
+
+    def import_event_data(self, df: pd.DataFrame):
+        """
+        Import event data
+
+        Args:
+            df: DataFrame to import
+        """
+        # Add unique_code automatically - it's always "EV" for Event
+        df = df.copy()
+        df['unique_code'] = "EV"
+
+        valid_data = EventSchema(df)
+
+        rows = self.sage_100_france.prepare_formatted_rows(df=valid_data, schema=EventSchema)
+
+        self.sage_100_france.add_rows_to_buffer(rows)

brynq_sdk_sage_100_france/family.py

@@ -0,0 +1,38 @@
+import pandas as pd
+from .schemas.family import FamilySchema
+from brynq_sdk_functions import Functions
+
+class Family:
+    """Class for interacting with Sage 100 France family history endpoints"""
+
+    # Get column names from schema
+    COLUMN_NAMES = list(FamilySchema.to_schema().columns.keys())
+    
+    def __init__(self, sage_100_france):
+        """Initialize Family class
+        
+        Args:
+            sage_100_france: Parent Sage 100 France instance for authentication and configuration
+        """
+        self.sage_100_france = sage_100_france
+        self.db_table = "T_HST_FAMILLE"
+    
+    def get(self):
+        """Get all family history records
+        
+        Returns:
+            pandas.DataFrame: DataFrame containing family history data with schema validation
+            
+        Raises:
+            ValueError: If there is an error processing the family data
+        """
+        family = self.sage_100_france.get(table_name=self.db_table, columns=self.COLUMN_NAMES)
+        try:
+            df = pd.DataFrame(family)
+            if not df.empty:
+                df.columns = self.COLUMN_NAMES
+                valid_data, invalid_Data = Functions.validate_data(df, FamilySchema)
+                return valid_data, invalid_Data
+            return df
+        except Exception as e:
+            raise ValueError(f"There was an error processing the Family data: {e}")

brynq_sdk_sage_100_france/insurance.py

@@ -0,0 +1,39 @@
+import pandas as pd
+from typing import Union, List, Dict, Any
+from .schemas.insurance import InsuranceSchema
+from brynq_sdk_functions import Functions
+
+class Insurance:
+    """Class for interacting with Sage 100 France insurance endpoints"""
+
+    # Get column names from schema
+    COLUMN_NAMES = list(InsuranceSchema.to_schema().columns.keys())
+
+    def __init__(self, sage_100_france):
+        """Initialize Insurance class
+
+        Args:
+            sage_100_france: Parent Sage 100 France instance for authentication and configuration
+        """
+        self.sage_100_france = sage_100_france
+        self.db_table = "T_CONTRAT_SOCIAL"
+
+    def get(self):
+        """Get all insurance records
+
+        Returns:
+            pandas.DataFrame: DataFrame containing insurance data with schema validation
+
+        Raises:
+            ValueError: If there is an error processing the insurance data
+        """
+        insurance = self.sage_100_france.get(table_name=self.db_table, columns=self.COLUMN_NAMES)
+        try:
+            df = pd.DataFrame(insurance)
+            if not df.empty:
+                df.columns = self.COLUMN_NAMES
+                valid_data, invalid_data = Functions.validate_data(df, InsuranceSchema)
+                return valid_data, invalid_data
+            return df
+        except Exception as e:
+            raise ValueError(f"There was an error processing the Insrance data: {e}")

brynq_sdk_sage_100_france/leave.py

@@ -0,0 +1,35 @@
+import pandas as pd
+from .schemas.leave import LeaveSchema
+from brynq_sdk_functions import Functions
+
+class Leave:
+    """Class for interacting with Sage 100 France leave history endpoints"""
+
+    # Get column names from schema
+    COLUMN_NAMES = list(LeaveSchema.to_schema().columns.keys())
+    
+    def __init__(self, sage_100_france):
+        """Initialize Leave class
+        
+        Args:
+            sage_100_france: Parent Sage 100 France instance for authentication and configuration
+        """
+        self.sage_100_france = sage_100_france
+        self.db_table = "T_HST_CONGE"
+    
+    def get(self):
+        """Get all leave history records
+        
+        Returns:
+            pandas.DataFrame: DataFrame containing leave history data with schema validation
+        """
+        leave = self.sage_100_france.get(table_name=self.db_table, columns=self.COLUMN_NAMES)
+        try:
+            df = pd.DataFrame(leave)
+            if not df.empty:
+                df.columns = self.COLUMN_NAMES
+                valid_data, invalid_data = Functions.validate_data(df, LeaveSchema)
+                return valid_data, invalid_data
+            return df
+        except Exception as e:
+            raise ValueError(f"There was an error processing the Leave data: {e}")