brynq-sdk-bob 2.5.0__tar.gz → 2.5.2.dev0__tar.gz

{brynq_sdk_bob-2.5.0 → brynq_sdk_bob-2.5.2.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.0
 Name: brynq_sdk_bob
-Version: 2.5.0
+Version: 2.5.2.dev0
 Summary: Bob wrapper from BrynQ
 Home-page: UNKNOWN
 Author: BrynQ

brynq_sdk_bob-2.5.2.dev0/brynq_sdk_bob/__init__.py

@@ -0,0 +1,349 @@
+import base64
+import re
+import inspect
+from typing import Union, List, Optional, Literal
+import pandas as pd
+import requests
+import os
+from brynq_sdk_brynq import BrynQ
+from brynq_sdk_functions import Functions
+from .bank import Bank
+from .company import Company
+from .documents import CustomDocuments
+from .employment import Employment
+from .named_lists import NamedLists
+from .payments import Payments
+from .people import People
+from .salaries import Salaries
+from .timeoff import TimeOff
+from .work import Work
+from .custom_tables import CustomTables
+from .payroll_history import History
+
+class Bob(BrynQ):
+    def __init__(self, system_type: Optional[Literal['source', 'target']] = None, test_environment: bool = True, debug: bool = False, target_system: str = None):
+        super().__init__()
+        self.timeout = 3600
+        self.headers = self._get_request_headers(system_type)
+        if test_environment:
+            self.base_url = "https://api.sandbox.hibob.com/v1/"
+        else:
+            self.base_url = "https://api.hibob.com/v1/"
+        self.session = requests.Session()
+        self.session.headers.update(self.headers)
+        self.people = People(self)
+        self.salaries = Salaries(self)
+        self.work = Work(self)
+        self.bank = Bank(self)
+        self.employment = Employment(self)
+        self.payments = Payments(self)
+        self.time_off = TimeOff(self)
+        self.documents = CustomDocuments(self)
+        self.companies = Company(self)
+        self.named_lists = NamedLists(self)
+        self.custom_tables = CustomTables(self)
+        self.payroll_history = History(self)
+        self.data_interface_id = os.getenv("DATA_INTERFACE_ID")
+        self.debug = debug
+        self.bob_dir = "bob_data"  # Directory to save Bob data files
+        self.setup_schema_endpoint_mapping()
+
+    def _get_request_headers(self, system_type):
+        credentials = self.interfaces.credentials.get(system='bob', system_type=system_type)
+        auth_token = base64.b64encode(f"{credentials.get('data').get('User ID')}:{credentials.get('data').get('API Token')}".encode()).decode('utf-8')
+        headers = {
+            "accept": "application/json",
+            "Authorization": f"Basic {auth_token}",
+            "Partner-Token": "001Vg00000A6FY6IAN"
+        }
+
+        return headers
+
+    def get_paginated_result(self, request: requests.Request) -> List:
+        has_next_page = True
+        result_data = []
+        while has_next_page:
+            prepped = request.prepare()
+            prepped.headers.update(self.session.headers)
+            resp = self.session.send(prepped, timeout=self.timeout)
+            resp.raise_for_status()
+            response_data = resp.json()
+            result_data += response_data['results']
+            next_cursor = response_data.get('response_metadata').get('next_cursor')
+            # If there is no next page, set has_next_page to False, we could use the falsy value of None but this is more readable
+            has_next_page = next_cursor is not None
+            if has_next_page:
+                request.params.update({"cursor": next_cursor})
+
+        return result_data
+
+    #methods to be used in conjunction with teh scenario sdk. scenario sdks collects all schemas and correpodnign fields and passes it to the get_data_per_schema method, which needs this method to map the schema name to the corresponding endpoint.
+    def setup_schema_endpoint_mapping(self):
+        self.schema_endpoint_map = {
+            "PeopleSchema": self.people,
+            "SalarySchema": self.salaries,
+            "WorkSchema": self.work,
+            "BankSchema": self.bank,
+            "EmploymentSchema": self.employment,
+            "VariablePaymentSchema": self.payments,
+            "ActualPaymentsSchema": self.payments,
+            "TimeOffSchema": self.time_off,
+            "TimeOffBalanceSchema": self.time_off,
+            "PayrollHistorySchema": self.payroll_history,
+            "CustomTableSchema": self.custom_tables,
+            "CustomTableMetadataSchema": self.custom_tables,
+            "NamedListSchema": self.named_lists,
+            # Note: DocumentsSchema and CompanySchema don't have corresponding schema classes yet
+            # but keeping them for backward compatibility
+            "DocumentsSchema": self.documents,
+            "CompanySchema": self.companies,
+        }
+
+    def get_data_for_schemas(self, schemas: dict[str, set], save_dir = None) -> dict:
+        """
+        Get data for each schema using the schema-to-fields mapping from the scenario SDK.
+
+        This method integrates with the BrynQ scenario SDK to retrieve data based on schema
+        definitions. It automatically maps schema names to the appropriate Bob API endpoints
+        and retrieves only the fields specified in the schema-to-fields mapping.
+
+        NOTE:
+        "endpoint_obj" is just a variable that represents the specific Bob API client (or "endpoint") for a given type of data.
+        For example, if you want to get people data, endpoint_obj would be self.people.
+        If you want salary data, endpoint_obj would be self.salaries, and so on.
+        Each of these endpoint objects knows how to fetch data for its specific schema/table from Bob.
+        So, "endpoint_obj" is basically a shortcut to the right part of the Bob SDK that knows how to get the data you want.
+
+        Args:
+            schemas: Dictionary mapping schema names to sets of fields
+                    Example: {'PeopleSchema': {'firstName', 'lastName', 'email'},
+                             'WorkSchema': {'title', 'department', 'site'}}
+            save_dir: Optional directory path to save parquet files. Can be a string or path object
+                     (e.g., os.path.join(self.basedir, "data", "bob_to_zenegy")). If None, files are not saved to disk.
+
+        Returns:
+            Dictionary with results for each schema containing:
+            - 'dataframe': The retrieved data as pandas DataFrame
+            - 'filepath': Path where the data was saved as parquet file (None if save_dir is None)
+            - 'fields': List of fields that were requested
+            - 'status_message': Status message about field retrieval
+            - 'status_level': Status level (INFO/WARNING/ERROR)
+
+        Integration with Scenario SDK:
+            This method is designed to work seamlessly with the BrynQ scenario SDK:
+            1. Use scenarios.get_schema_field_mapping() to get schema-to-fields mapping
+            2. Pass the mapping to this method to retrieve data
+            3. The method automatically handles endpoint mapping and field selection
+            4. Field tracking shows exactly which requested fields were returned vs missing
+
+        Example usage:
+            # Initialize Bob SDK
+            bob = Bob(system_type='source')
+
+            # Get schema-to-fields mapping from scenarios
+            schema_fields = bob.interfaces.scenarios.get_schema_field_mapping()
+
+            # Get data for specific schemas
+            results = bob.get_data_for_schemas({
+                'PeopleSchema': schema_fields['PeopleSchema'],
+                'WorkSchema': schema_fields['WorkSchema']
+            }, save_dir=os.path.join('data', 'bob_to_zenegy'))
+
+            # Access results and status messages
+            for schema_name, result in results.items():
+                print(f"Schema: {schema_name}")
+                print(f"Status: {result['status_message']}")
+                print(f"Level: {result['status_level']}")
+                print(f"Data shape: {result['dataframe'].shape}")
+                print(f"Saved to: {result['filepath']}")
+
+            # Process the data
+            people_data = results['PeopleSchema']['dataframe']
+            work_data = results['WorkSchema']['dataframe']
+
+            # Example with path object
+            custom_path = os.path.join('data', 'bob_to_zenegy')
+            results_with_path = bob.get_data_for_schemas({
+                'PeopleSchema': schema_fields['PeopleSchema']
+            }, save_dir=custom_path)
+        """
+        results = {}
+
+        # Validate input
+        if not schemas:
+            print("Warning: No schemas provided")
+            return results
+
+        # Process each schema
+        for schema_name, fields in schemas.items():
+            # Validate schema name and fields
+            if not schema_name:
+                print("Warning: Empty schema name provided, skipping")
+                continue
+
+            if not fields:
+                print(f"Warning: No fields provided for schema '{schema_name}', skipping")
+                continue
+
+            # Get the endpoint/service for this schema
+            endpoint_obj = self.schema_endpoint_map.get(schema_name)
+
+            if endpoint_obj is None:
+                print(f"Warning: No endpoint found for schema '{schema_name}'. Available schemas: {list(self.schema_endpoint_map.keys())}")
+                continue
+
+            try:
+                # Get data using the service endpoint
+                df_bob, status_message, status_level = self._handle_endpoint(endpoint_obj, list(fields), schema_name)
+            except Exception as e:
+                print(f"Error processing schema '{schema_name}': {str(e)}")
+                results[schema_name] = {
+                    'dataframe': pd.DataFrame(),
+                    'filepath': None,
+                    'fields': list(fields),
+                    'status_message': f"Error processing schema '{schema_name}': {str(e)}",
+                    'status_level': 'ERROR'
+                }
+                continue
+
+            # Save the result
+            if save_dir:
+                filename = f"bob_{schema_name.replace(' ', '_')}.parquet"
+                output_dir = save_dir if save_dir is not None else self.bob_dir
+                os.makedirs(output_dir, exist_ok=True)
+                filepath = os.path.join(output_dir, filename)
+                df_bob.to_parquet(filepath)
+            else:
+                filepath = None
+
+            results[schema_name] = {
+                'dataframe': df_bob,
+                'filepath': filepath,
+                'fields': list(fields),
+                'status_message': status_message,
+                'status_level': status_level
+            }
+        return results
+
+    def _handle_endpoint(self, endpoint_obj, body_fields: List[str], schema_name: str) -> tuple[pd.DataFrame, str, str]:
+        """
+        Handle data retrieval for a given endpoint object (e.g., self.people, self.work, etc.).
+
+        Args:
+            endpoint_obj: The endpoint object responsible for fetching data for a specific schema.
+                For example, this could be self.people, self.work, self.salaries, etc.
+                (Think of these as "API clients" or "data access classes" for each schema/table.)
+            body_fields: List of fields to retrieve
+            schema_name: Name of the schema being processed
+
+        Returns:
+            tuple[pd.DataFrame, str, str]: Dataframe, status message, and status level
+        """
+        get_method = endpoint_obj.get
+
+        # Check if the method accepts field_selection parameter
+        sig = inspect.signature(get_method)
+        if 'field_selection' in sig.parameters and 'person_ids' not in sig.parameters:
+            bob_data_valid, _ = get_method(field_selection=body_fields)
+        # elif 'person_id' in sig.parameters:
+        #     bob_data_valid, _ = self._fetch_data_with_person_id(get_method)
+        # elif 'person_ids' in sig.parameters and 'field_selection' in sig.parameters:
+        #     bob_data_valid, _ = self._fetch_data_with_person_ids(get_method, body_fields)
+        else:
+            bob_data_valid, _ = get_method()
+        df_bob = pd.DataFrame(bob_data_valid)
+
+        # Track field retrieval success/failure and handle missing fields
+        status_message, status_level = self._log_field_retrieval_status(df_bob, body_fields, schema_name)
+
+        return df_bob, status_message, status_level
+
+    def _log_field_retrieval_status(self, df_bob: pd.DataFrame, body_fields: List[str], schema_name: str) -> tuple[str, str]:
+        """
+        Checks if the data returned from the Bob API actually contains all the fields you asked for.
+
+        This function counts how many fields you requested (body_fields)
+        and how many columns you actually got back in the DataFrame (df_bob).
+
+        - If the numbers are different, it means some fields you wanted are missing from the result.
+        - If the numbers match, you got everything you asked for.
+        - If the DataFrame is empty, then Bob API returned no data at all.
+
+        Args:
+            df_bob: The DataFrame you got back from the Bob API (could be empty or missing columns).
+            body_fields: The list of field names you told the API you wanted.
+            schema_name: The name of the schema/table you were trying to get.
+
+        Returns:
+            tuple[str, str]:
+                - A human-readable status message (for logs or debugging).
+                - A status level string: "DEBUG" (all good or minor mismatch), or "ERROR" (no data at all).
+        """
+        if not df_bob.empty:
+            requested_count = len(body_fields)
+            returned_count = len(df_bob.columns)
+
+            if requested_count != returned_count:
+                status_message = (f"Schema '{schema_name}' [INFO]:\n"
+                                f"Requested {requested_count} fields, got {returned_count} fields\n"
+                                f"Total records: {len(df_bob)}")
+                return status_message, "DEBUG"
+            else:
+                status_message = (f"Schema '{schema_name}': All {requested_count} requested fields "
+                                f"successfully retrieved from Bob API ({len(df_bob)} records)")
+                return status_message, "DEBUG"
+        else:
+            return f"Schema '{schema_name}' [ERROR]: No data returned from Bob API", "ERROR"
+
+    def initialize_person_id_mapping(self) -> pd.DataFrame:
+        """
+        Creates a mapping DataFrame between Bob's internal person ID (`root.id`) and the employee ID in the company
+        (`work.employeeIdInCompany`).
+
+        This is a utility function for situations where you need to join or map data between endpoints/scenarios that use different
+        identifiers for people. In scenarios maybe root.id is used as primary key, but in Bob, some API endpoints require you to use the employee ID.
+        This function helps you convert between them.
+
+        Note:
+            - This is NOT required for the Bob SDK to function, but is a convenience tool you can call from the interface
+              whenever you need to perform such a mapping.
+            - The mapping is especially useful when you have data from other sources (e.g., payroll, HRIS exports) that use
+              employee IDs, and you want to join or compare them with data from Bob, which often uses person IDs.
+
+        Returns:
+            pd.DataFrame: A DataFrame with two columns:
+                - 'person_id': The unique person identifier in Bob (formerly `root.id`)
+                - 'employee_id_in_company': The employee ID as used in your company (formerly `work.employeeIdInCompany`)
+
+            If no people are found, returns an empty DataFrame with these columns.
+
+        Example:
+            >>> df = sdk.initialize_person_id_mapping()
+            >>> # Now you can merge/join on 'person_id' or 'employee_id_in_company' as needed
+
+        """
+        # Only fetch the two fields needed for the mapping
+        field_selection = ['work.employeeIdInCompany', 'root.id']
+
+        # Use the Bob SDK to get the people data with just those fields
+        valid_people, _ = self.people.get(field_selection=field_selection)
+
+        # The SDK renames:
+        #   root.id -> id
+        #   work.employeeIdInCompany -> work_employee_id_in_company
+
+        if not valid_people.empty:
+            # Rename columns to standard names for mapping
+            valid_people = valid_people.rename(
+                columns={
+                    'id': 'person_id',
+                    'work_employee_id_in_company': 'employee_id_in_company'
+                }
+            )
+            self.person_id_to_employee_id_in_company = valid_people[['person_id', 'employee_id_in_company']].copy()
+        else:
+            # Return empty DataFrame with expected columns if no data
+            self.person_id_to_employee_id_in_company = pd.DataFrame(
+                columns=['person_id', 'employee_id_in_company']
+            )
+        return self.person_id_to_employee_id_in_company

{brynq_sdk_bob-2.5.0 → brynq_sdk_bob-2.5.2.dev0}/brynq_sdk_bob/payments.py

@@ -9,17 +9,19 @@ class Payments:
         self.bob = bob
         self.schema = VariablePaymentSchema
 
-    def get(self, person_id: str) -> (pd.DataFrame, pd.DataFrame):
-        resp = self.bob.session.get(url=f"{self.bob.base_url}people/{person_id}/variable", timeout=self.bob.timeout)
-        resp.raise_for_status()
-        data = resp.json()
-        df = pd.json_normalize(
-            data,
-            record_path='values'
-        )
-        df['employee_id'] = person_id
+    def get(self, person_ids: List[str]) -> (pd.DataFrame, pd.DataFrame):
+        df = pd.DataFrame()
+        for person_id in person_ids:
+            resp = self.bob.session.get(url=f"{self.bob.base_url}people/{person_id}/variable", timeout=self.bob.timeout)
+            resp.raise_for_status()
+            data = resp.json()
+            df = pd.concat([df, pd.json_normalize(
+                data,
+                record_path='values'
+            )])
+            df['employee_id'] = person_id
+        df = df.reset_index(drop=True)
         valid_payments, invalid_payments = Functions.validate_data(df=df, schema=self.schema, debug=True)
-
         return valid_payments, invalid_payments
 
     def get_actual_payments(

{brynq_sdk_bob-2.5.0 → brynq_sdk_bob-2.5.2.dev0}/brynq_sdk_bob/people.py

@@ -127,7 +127,7 @@ class People:
 
                 if isinstance(sample_value, dict):
                     # Flatten nested structure
-                    nested_df = pd.json_normalize(df_result[col].tolist())
+                    nested_df = pd.json_normalize(df_result[col].tolist(), max_level=10)
 
                     # Rename columns to include the original column name as prefix
                     nested_df.columns = [f"{col}.{subcol}" for subcol in nested_df.columns]
@@ -196,8 +196,7 @@ class People:
 
         Args:
             additional_fields (list[str]): Additional fields to get (not defined in the schema)
-            field_selection (list[str]): Fields to get (defined in the schema), if not provided, all fields are returned.
-                Can be either pythonic field names (e.g., 'work_start_date') or Bob API field names (e.g., 'work.startDate').
+            field_selection (list[str]): Fields to get (defined in the schema), if not provided, all fields are returned
             add_payroll_information (list[str]): List of payroll information types to include (valid options: 'entitlement', 'variable')
 
         Returns:
@@ -211,9 +210,6 @@ class People:
         response_fields = list(set(self.field_name_in_response + additional_fields))
 
         if field_selection:
-            # Convert pythonic field names to aliases (e.g., 'work_start_date' -> 'work.startDate')
-            field_selection = PeopleSchema.convert_pythonic_to_alias(field_selection)
-
             body_fields = [field for field in body_fields if field in field_selection]
             response_fields = [self.endpoint_to_response.get(field) for field in field_selection if field in self.endpoint_to_response]
 
@@ -232,7 +228,7 @@ class People:
                                                            "filters": []
                                                        },
                                                        timeout=self.bob.timeout)
-        df = pd.json_normalize(resp_additional_fields.json()['employees'])
+        df = pd.json_normalize(resp_additional_fields.json()['employees'], max_level=10)
 
         # Validate payroll types if requested
         valid_payroll_types = []
@@ -250,6 +246,9 @@ class People:
             # Keep if it's in response_fields
             if col in response_fields:
                 columns_to_keep.append(col)
+            # Or if it starts with any response_field followed by a dot (for nested fields)
+            elif any(col.startswith(field + '.') for field in response_fields):
+                columns_to_keep.append(col)
             # Or if it's a payroll column (original or flattened)
             elif valid_payroll_types:
                 for payroll_type in valid_payroll_types:
@@ -337,7 +336,7 @@ class People:
                                                            "filters": []
                                                        },
                                                        timeout=self.bob.timeout)
-        df = pd.json_normalize(resp_additional_fields.json()['employees'])
+        df = pd.json_normalize(resp_additional_fields.json()['employees'], max_level=10)
         df = df[[col for col in response_fields if col in df.columns]]
         # Get the valid column names from PeopleSchema
         valid_people, invalid_people = Functions.validate_data(df=df, schema=PeopleSchema, debug=True)

brynq_sdk_bob-2.5.2.dev0/brynq_sdk_bob/salaries.py

@@ -0,0 +1,38 @@
+import pandas as pd
+import requests
+from brynq_sdk_functions import Functions
+from .schemas.salary import SalarySchema, SalaryCreateSchema
+
+
+class Salaries:
+    def __init__(self, bob):
+        self.bob = bob
+        self.schema = SalarySchema
+
+    def get(self) -> tuple[pd.DataFrame, pd.DataFrame]:
+        request = requests.Request(method='GET',
+                                   url=f"{self.bob.base_url}bulk/people/salaries",
+                                   params={"limit": 100})
+        data = self.bob.get_paginated_result(request)
+        df = pd.json_normalize(
+            data,
+            record_path='values',
+            meta=['employeeId']
+        )
+        valid_salaries, invalid_salaries = Functions.validate_data(df=df, schema=SalarySchema, debug=True)
+
+        return valid_salaries, invalid_salaries
+
+    def create(self, salary_data: dict) -> requests.Response:
+        nested_data = self.nmbrs.flat_dict_to_nested_dict(salary_data, SalaryCreateSchema)
+        salary_data = SalaryCreateSchema(**nested_data)
+        payload = salary_data.model_dump(exclude_none=True, by_alias=True)
+
+        resp = self.bob.session.post(url=f"{self.bob.base_url}people/{salary_data.employee_id}/salaries", json=payload)
+        resp.raise_for_status()
+        return resp
+
+    def delete(self, employee_id: str, salary_id: str) -> requests.Response:
+        resp = self.bob.session.delete(url=f"{self.bob.base_url}people/{employee_id}/salaries/{salary_id}")
+        resp.raise_for_status()
+        return resp

{brynq_sdk_bob-2.5.0 → brynq_sdk_bob-2.5.2.dev0}/brynq_sdk_bob/schemas/employment.py

@@ -6,7 +6,7 @@ from brynq_sdk_functions import BrynQPanderaDataFrameModel
 
 class EmploymentSchema(BrynQPanderaDataFrameModel):
     id: Series[pd.Int64Dtype] = pa.Field(coerce=True, description="Employment ID", alias="id")
-    employee_id: Series[String] = pa.Field(coerce=True, description="Employee ID", alias="employeeId")
+    employee_id: Series[pd.Int64Dtype] = pa.Field(coerce=True, description="Employee ID", alias="employeeId")
     active_effective_date: Series[DateTime] = pa.Field(coerce=True, description="Active Effective Date", alias="activeEffectiveDate")
     contract: Series[String] = pa.Field(coerce=True, nullable=True, description="Contract", alias="contract") # has a list of possible values
     creation_date: Series[DateTime] = pa.Field(coerce=True, nullable=True, description="Creation Date", alias="creationDate")

{brynq_sdk_bob-2.5.0 → brynq_sdk_bob-2.5.2.dev0}/brynq_sdk_bob/schemas/payments.py

@@ -21,8 +21,9 @@ class VariablePaymentSchema(BrynQPanderaDataFrameModel):
     end_effective_date: Series[DateTime] = pa.Field(nullable=True, coerce=True, description="End Effective Date", alias="endEffectiveDate")
     payment_period: Series[String] = pa.Field(coerce=True, description="Payment Period", alias="paymentPeriod")
     effective_date: Series[DateTime] = pa.Field(coerce=True, description="Effective Date", alias="effectiveDate")
-    amount_value: Series[Float] = pa.Field(coerce=True, description="Amount Value", alias="amount.value")
-    amount_currency: Series[String] = pa.Field(coerce=True, description="Amount Currency", alias="amount.currency")
+    amount_value: Optional[Series[Float]] = pa.Field(coerce=True, description="Amount Value", alias="amount.value")
+    amount_alternative_value: Optional[Series[Float]] = pa.Field(coerce=True, description="Amount Value", alias="amount")
+    amount_currency: Optional[Series[String]] = pa.Field(coerce=True, description="Amount Currency", alias="amount.currency")
     change_reason: Series[String] = pa.Field(nullable=True, coerce=True, description="Change Reason", alias="change.reason")
     change_changed_by: Series[String] = pa.Field(nullable=True, coerce=True, description="Change Changed By", alias="change.changedBy")
     change_changed_by_id: Series[pd.Int64Dtype] = pa.Field(nullable=True, coerce=True, description="Change Changed By ID", alias="change.changedById")

{brynq_sdk_bob-2.5.0 → brynq_sdk_bob-2.5.2.dev0}/brynq_sdk_bob/schemas/people.py

@@ -1,5 +1,5 @@
 from datetime import datetime
-from typing import Optional, List, Dict
+from typing import Optional
 
 import pandas as pd
 import pandera as pa
@@ -23,7 +23,7 @@ class PeopleSchema(BrynQPanderaDataFrameModel):
     home_mobile_phone: Optional[Series[String]] = pa.Field(coerce=True, nullable=True, description="Personal Mobile Phone", alias="home.mobilePhone")
     surname: Optional[Series[String]] = pa.Field(coerce=True, description="Surname", alias="root.surname")
     first_name: Optional[Series[String]] = pa.Field(coerce=True, nullable=True, description="First Name", alias="root.firstName")
-    full_name: Optional[Series[String]] = pa.Field(coerce=True, nullable=True, description="Full Name", alias="fullName")
+    full_name: Optional[Series[String]] = pa.Field(coerce=True, nullable=True, description="Full Name", alias="root.fullName")
     personal_birth_date: Optional[Series[DateTime]] = pa.Field(coerce=True, nullable=True, description="Personal Birth Date", alias="personal.birthDate")
     personal_pronouns: Optional[Series[String]] = pa.Field(coerce=True, nullable=True, description="Personal Pronouns", alias="personal.pronouns")
     personal_honorific: Optional[Series[String]] = pa.Field(coerce=True, nullable=True, description="Personal Honorific", alias="personal.honorific")
@@ -98,39 +98,3 @@ class PeopleSchema(BrynQPanderaDataFrameModel):
 
     class Config:
         coerce = True
-
-    @classmethod
-    def convert_pythonic_to_alias(cls, pythonic_fields: List[str]) -> List[str]:
-        """
-        Convert pythonic field names to their Bob API aliases.
-
-        Args:
-            pythonic_fields: List of pythonic field names (e.g., ['work_start_date', 'first_name'])
-
-        Returns:
-            List of Bob API field aliases (e.g., ['work.startDate', 'root.firstName'])
-        """
-        # Get the alias mapping from the class (populated by BrynQPanderaDataFrameModel.__init_subclass__)
-        alias_map = getattr(cls, "_alias_map", {})
-
-        # Convert the provided pythonic fields to aliases
-        result = []
-        for field in pythonic_fields:
-            if field in alias_map:
-                result.append(alias_map[field])
-            else:
-                # If not found in schema, keep the field as-is (could be a custom field)
-                result.append(field)
-
-        return result
-
-    @classmethod
-    def get_pythonic_to_alias_mapping(cls) -> Dict[str, str]:
-        """
-        Get the complete mapping from pythonic field names to Bob API aliases.
-
-        Returns:
-            Dictionary mapping pythonic field names to aliases
-        """
-        # Get the alias mapping from the class (populated by BrynQPanderaDataFrameModel.__init_subclass__)
-        return getattr(cls, "_alias_map", {})

brynq_sdk_bob-2.5.2.dev0/brynq_sdk_bob/schemas/salary.py

@@ -0,0 +1,49 @@
+import pandas as pd
+import pandera as pa
+from pandera import Bool
+from pandera.typing import Series, String, Float, DateTime
+import pandera.extensions as extensions
+from brynq_sdk_functions import BrynQPanderaDataFrameModel
+from pydantic import BaseModel, Field
+from datetime import datetime, date
+from typing import Optional, Dict, Any
+
+
+class SalarySchema(BrynQPanderaDataFrameModel):
+    id: Series[pd.Int64Dtype] = pa.Field(coerce=True, description="Salary ID", alias="id")
+    employee_id: Series[pd.Int64Dtype] = pa.Field(coerce=True, description="Employee ID", alias="employeeId")
+    pay_frequency: Series[String] = pa.Field(coerce=True, nullable=True, description="Pay Frequency", alias="payFrequency") # has a list of possible values , isin=['Monthly']
+    creation_date: Series[DateTime] = pa.Field(coerce=True, nullable=True, description="Creation Date", alias="creationDate")
+    is_current: Series[Bool] = pa.Field(coerce=True, description="Is Current", alias="isCurrent")
+    modification_date: Series[DateTime] = pa.Field(coerce=True, nullable=True, description="Modification Date", alias="modificationDate")
+    effective_date: Series[DateTime] = pa.Field(coerce=True, description="Effective Date", alias="effectiveDate")
+    end_effective_date: Series[DateTime] = pa.Field(coerce=True, nullable=True, description="End Effective Date", alias="endEffectiveDate")
+    change_reason: Series[str] = pa.Field(coerce=True, nullable=True, description="Change Reason", alias="change.reason")
+    pay_period: Series[String] = pa.Field(coerce=True, nullable=True, description="Pay Period", alias="payPeriod")
+    base_value: Series[Float] = pa.Field(coerce=True, nullable=True, description="Base Value", alias="base.value") #needs to become base.value?
+    base_currency: Series[String] = pa.Field(coerce=True, nullable=True, description="Base Currency", alias="base.currency")
+    active_effective_date: Series[DateTime] = pa.Field(coerce=True, nullable=True, description="Active Effective Date", alias="activeEffectiveDate")
+
+
+class SalaryCreateSchema(BaseModel):
+    can_be_deleted: Optional[bool] = Field(None, description="internal flag", alias="canBeDeleted")
+    work_change_type: Optional[str] = Field(None, description="The type of the change that was performed for this work entry. This will contain the ID of the value from the Change Type list.", alias="workChangeType")
+    salary_change_reason: Optional[str] = Field(None, description="Reason for the change", alias="change.reason")
+    salary_change_changed_by: Optional[str] = Field(None, description="Name of the user who changed the entry", alias="change.changedBy")
+    salary_change_changed_by_id: Optional[str] = Field(None, description="ID of the user who changed the entry", alias="change.changedById")
+    pay_frequency: Optional[str] = Field(None, description="Represents the frequency the salary is paid. This can be one of: Monthly, Semi Monthly, Weekly, or Bi-Weekly.", alias="payFrequency")
+    creation_date: Optional[date] = Field(None, description="The date this entry was created.", alias="creationDate")
+    is_current: Optional[bool] = Field(None, description="Is 'true' when this is the effective entry which is currently active.", alias="isCurrent")
+    modification_date: Optional[date] = Field(None, description="The date this entry was modified.", alias="modificationDate")
+    id: Optional[int] = Field(None, description="The id of the entry.", alias="id")
+    end_effective_date: Optional[date] = Field(None, description="For entries that are not active - this it the date this entry became not effective.", alias="endEffectiveDate")
+    active_effective_date: Optional[date] = Field(None, description="The active effective date for this entry.", alias="activeEffectiveDate")
+    custom_columns: Optional[Dict[str, Any]] = Field(None, description="If the table has custom columns, they will appear here.", alias="customColumns")
+    base_value: float = Field(..., description="Base amount value", alias="base.value")
+    base_currency: str = Field(..., description="Three-letter currency code.", alias="base.currency")
+    pay_period: str = Field(..., description="Represents the period for this salary entry. This can be one of: Annual, Hourly, Daily, Weekly, Monthly.", alias="payPeriod")
+    effective_date: Optional[date] = Field(None, description="The date this entry becomes effective. This is a mandatory field for a work entry.", alias="effectiveDate")
+
+    class Config:
+        allow_population_by_field_name = True
+        coerce = True

{brynq_sdk_bob-2.5.0 → brynq_sdk_bob-2.5.2.dev0}/brynq_sdk_bob/schemas/timeoff.py

@@ -6,25 +6,25 @@ from brynq_sdk_functions import BrynQPanderaDataFrameModel
 
 class TimeOffSchema(BrynQPanderaDataFrameModel):
     change_type: Series[String] = pa.Field(coerce=True, description="Change Type", alias="changeType")
-    employee_id: Series[String] = pa.Field(coerce=True, description="Employee ID", alias="employeeId")
+    employee_id: Series[pd.Int64Dtype] = pa.Field(coerce=True, description="Employee ID", alias="employeeId")
     employee_display_name: Series[String] = pa.Field(coerce=True, description="Employee Display Name", alias="employeeDisplayName")
     employee_email: Series[String] = pa.Field(coerce=True, description="Employee Email", alias="employeeEmail")
     request_id: Series[pd.Int64Dtype] = pa.Field(coerce=True, description="Request ID", alias="requestId")
     policy_type_display_name: Series[String] = pa.Field(coerce=True, description="Policy Type Display Name", alias="policyTypeDisplayName")
     type: Series[String] = pa.Field(coerce=True, description="Type", alias="type")
-    start_date: Series[String] = pa.Field(coerce=True, description="Start Date", alias="startDate")
-    start_portion: Series[String] = pa.Field(coerce=True, description="Start Portion", alias="startPortion")
-    end_date: Series[String] = pa.Field(coerce=True, description="End Date", alias="endDate")
-    end_portion: Series[String] = pa.Field(coerce=True, description="End Portion", alias="endPortion")
-    day_portion: Optional[Series[String]] = pa.Field(coerce=True, description="Day Portion", alias="dayPortion")
-    date: Optional[Series[String]] = pa.Field(coerce=True, description="Date", alias="date")
-    hours_on_date: Optional[Series[Float]] = pa.Field(coerce=True, description="Hours on Date", alias="hoursOnDate")
-    daily_hours: Optional[Series[Float]] = pa.Field(coerce=True, description="Daily Hours", alias="dailyHours")
-    duration_unit: Optional[Series[String]] = pa.Field(coerce=True, description="Duration Unit", alias="durationUnit")
-    total_duration: Optional[Series[Float]] = pa.Field(coerce=True, description="Total Duration", alias="totalDuration")
-    total_cost: Optional[Series[Float]] = pa.Field(coerce=True, description="Total Cost", alias="totalCost")
+    start_date: Series[String] = pa.Field(coerce=True, nullable=True, description="Start Date", alias="startDate")
+    start_portion: Series[String] = pa.Field(coerce=True, nullable=True, description="Start Portion", alias="startPortion")
+    end_date: Series[String] = pa.Field(coerce=True, nullable=True, description="End Date", alias="endDate")
+    end_portion: Series[String] = pa.Field(coerce=True, nullable=True, description="End Portion", alias="endPortion")
+    day_portion: Optional[Series[String]] = pa.Field(coerce=True, nullable=True, description="Day Portion", alias="dayPortion")
+    date: Optional[Series[String]] = pa.Field(coerce=True, nullable=True, description="Date", alias="date")
+    hours_on_date: Optional[Series[Float]] = pa.Field(coerce=True, nullable=True, description="Hours on Date", alias="hoursOnDate")
+    daily_hours: Optional[Series[Float]] = pa.Field(coerce=True, nullable=True, description="Daily Hours", alias="dailyHours")
+    duration_unit: Optional[Series[String]] = pa.Field(coerce=True, nullable=True, description="Duration Unit", alias="durationUnit")
+    total_duration: Optional[Series[Float]] = pa.Field(coerce=True, nullable=True, description="Total Duration", alias="totalDuration")
+    total_cost: Optional[Series[Float]] = pa.Field(coerce=True, nullable=True, description="Total Cost", alias="totalCost")
     change_reason: Optional[Series[String]] = pa.Field(nullable=True, coerce=True, description="Change Reason", alias="changeReason")
-    visibility: Optional[Series[String]] = pa.Field(coerce=True, description="Visibility", alias="visibility")
+    visibility: Optional[Series[String]] = pa.Field(coerce=True, nullable=True, description="Visibility", alias="visibility")
 
     class Config:
         coerce = True

{brynq_sdk_bob-2.5.0 → brynq_sdk_bob-2.5.2.dev0}/brynq_sdk_bob/schemas/work.py

@@ -18,14 +18,14 @@ class WorkSchema(BrynQPanderaDataFrameModel):
     active_effective_date: Series[datetime] = pa.Field(coerce=True, nullable=True, description="Active Effective Date", alias="activeEffectiveDate")
     department: Series[str] = pa.Field(coerce=True, nullable=True, description="Department", alias="department")
     effective_date: Series[datetime] = pa.Field(coerce=True, nullable=True, description="Effective Date", alias="effectiveDate")
-    change_reason: Series[str] = pa.Field(coerce=True, nullable=True, description="Change Reason", alias="changeReason")
-    change_changed_by: Series[str] = pa.Field(coerce=True, nullable=True, description="Change Changed By", alias="changeChangedBy")
-    change_changed_by_id: Series[str] = pa.Field(coerce=True, nullable=True, description="Change Changed By ID", alias="changeChangedById")
-    reports_to_id: Series[str] = pa.Field(coerce=True, nullable=True, description="Reports To ID", alias="reportsToId")
-    reports_to_first_name: Series[str] = pa.Field(coerce=True, nullable=True, description="Reports To First Name", alias="reportsToFirstName")
-    reports_to_surname: Series[str] = pa.Field(coerce=True, nullable=True, description="Reports To Surname", alias="reportsToSurname")
-    reports_to_email: Series[str] = pa.Field(coerce=True, nullable=True, description="Reports To Email", alias="reportsToEmail")
-    reports_to_display_name: Series[str] = pa.Field(coerce=True, nullable=True, description="Reports To Display Name", alias="reportsToDisplayName")
+    change_reason: Series[str] = pa.Field(coerce=True, nullable=True, description="Change Reason", alias="change.reason")
+    change_changed_by: Series[str] = pa.Field(coerce=True, nullable=True, description="Change Changed By", alias="change.changedBy")
+    change_changed_by_id: Series[str] = pa.Field(coerce=True, nullable=True, description="Change Changed By ID", alias="change.changedById")
+    reports_to_id: Series[str] = pa.Field(coerce=True, nullable=True, description="Reports To ID", alias="reportsTo.id")
+    reports_to_first_name: Series[str] = pa.Field(coerce=True, nullable=True, description="Reports To First Name", alias="reportsTo.firstName")
+    reports_to_surname: Series[str] = pa.Field(coerce=True, nullable=True, description="Reports To Surname", alias="reportsTo.surname")
+    reports_to_email: Series[str] = pa.Field(coerce=True, nullable=True, description="Reports To Email", alias="reportsTo.email")
+    reports_to_display_name: Series[str] = pa.Field(coerce=True, nullable=True, description="Reports To Display Name", alias="reportsTo.displayName")
     reports_to: Series[pd.Int64Dtype] = pa.Field(coerce=True, nullable=True, description="Reports To", alias="reportsTo")
     employee_id: Series[pd.Int64Dtype] = pa.Field(coerce=True, description="Employee ID", alias="employeeId")
 

{brynq_sdk_bob-2.5.0 → brynq_sdk_bob-2.5.2.dev0}/brynq_sdk_bob.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.0
 Name: brynq-sdk-bob
-Version: 2.5.0
+Version: 2.5.2.dev0
 Summary: Bob wrapper from BrynQ
 Home-page: UNKNOWN
 Author: BrynQ

{brynq_sdk_bob-2.5.0 → brynq_sdk_bob-2.5.2.dev0}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_namespace_packages
 
 setup(
     name='brynq_sdk_bob',
-    version='2.5.0',
+    version='2.5.2-dev',
     description='Bob wrapper from BrynQ',
     long_description='Bob wrapper from BrynQ',
     author='BrynQ',

brynq_sdk_bob-2.5.0/brynq_sdk_bob/__init__.py

@@ -1,73 +0,0 @@
-import base64
-import re
-from typing import Union, List, Optional, Literal
-import pandas as pd
-import requests
-import os
-from brynq_sdk_brynq import BrynQ
-from brynq_sdk_functions import Functions
-from .bank import Bank
-from .company import Company
-from .documents import CustomDocuments
-from .employment import Employment
-from .named_lists import NamedLists
-from .payments import Payments
-from .people import People
-from .salaries import Salaries
-from .timeoff import TimeOff
-from .work import Work
-from .custom_tables import CustomTables
-
-class Bob(BrynQ):
-    def __init__(self, system_type: Optional[Literal['source', 'target']] = None, test_environment: bool = True, debug: bool = False, target_system: str = None):
-        super().__init__()
-        self.timeout = 3600
-        self.headers = self._get_request_headers(system_type)
-        if test_environment:
-            self.base_url = "https://api.sandbox.hibob.com/v1/"
-        else:
-            self.base_url = "https://api.hibob.com/v1/"
-        self.session = requests.Session()
-        self.session.headers.update(self.headers)
-        self.people = People(self)
-        self.salaries = Salaries(self)
-        self.work = Work(self)
-        self.bank = Bank(self)
-        self.employment = Employment(self)
-        self.payments = Payments(self)
-        self.time_off = TimeOff(self)
-        self.documents = CustomDocuments(self)
-        self.companies = Company(self)
-        self.named_lists = NamedLists(self)
-        self.custom_tables = CustomTables(self)
-        self.data_interface_id = os.getenv("DATA_INTERFACE_ID")
-        self.debug = debug
-
-    def _get_request_headers(self, system_type):
-        credentials = self.interfaces.credentials.get(system='bob', system_type=system_type)
-        auth_token = base64.b64encode(f"{credentials.get('data').get('User ID')}:{credentials.get('data').get('API Token')}".encode()).decode('utf-8')
-        headers = {
-            "accept": "application/json",
-            "Authorization": f"Basic {auth_token}",
-            "Partner-Token": "001Vg00000A6FY6IAN"
-        }
-
-        return headers
-
-    def get_paginated_result(self, request: requests.Request) -> List:
-        has_next_page = True
-        result_data = []
-        while has_next_page:
-            prepped = request.prepare()
-            prepped.headers.update(self.session.headers)
-            resp = self.session.send(prepped, timeout=self.timeout)
-            resp.raise_for_status()
-            response_data = resp.json()
-            result_data += response_data['results']
-            next_cursor = response_data.get('response_metadata').get('next_cursor')
-            # If there is no next page, set has_next_page to False, we could use the falsy value of None but this is more readable
-            has_next_page = next_cursor is not None
-            if has_next_page:
-                request.params.update({"cursor": next_cursor})
-
-        return result_data

brynq_sdk_bob-2.5.0/brynq_sdk_bob/salaries.py

@@ -1,24 +0,0 @@
-import pandas as pd
-import requests
-from brynq_sdk_functions import Functions
-from .schemas.salary import SalarySchema
-
-
-class Salaries:
-    def __init__(self, bob):
-        self.bob = bob
-        self.schema = SalarySchema
-
-    def get(self) -> (pd.DataFrame, pd.DataFrame):
-        request = requests.Request(method='GET',
-                                   url=f"{self.bob.base_url}bulk/people/salaries",
-                                   params={"limit": 100})
-        data = self.bob.get_paginated_result(request)
-        df = pd.json_normalize(
-            data,
-            record_path='values',
-            meta=['employeeId']
-        )
-        valid_salaries, invalid_salaries = Functions.validate_data(df=df, schema=SalarySchema, debug=True)
-
-        return valid_salaries, invalid_salaries

brynq_sdk_bob-2.5.0/brynq_sdk_bob/schemas/salary.py

@@ -1,25 +0,0 @@
-import pandas as pd
-import pandera as pa
-from pandera import Bool
-from pandera.typing import Series, String, Float, DateTime
-import pandera.extensions as extensions
-from brynq_sdk_functions import BrynQPanderaDataFrameModel
-
-
-class SalarySchema(BrynQPanderaDataFrameModel):
-    id: Series[String] = pa.Field(coerce=True, description="Salary ID", alias="id")
-    employee_id: Series[String] = pa.Field(coerce=True, description="Employee ID", alias="employeeId")
-    pay_frequency: Series[String] = pa.Field(coerce=True, nullable=True, description="Pay Frequency", alias="payFrequency") # has a list of possible values , isin=['Monthly']
-    creation_date: Series[DateTime] = pa.Field(coerce=True, nullable=True, description="Creation Date", alias="creationDate")
-    is_current: Series[Bool] = pa.Field(coerce=True, description="Is Current", alias="isCurrent")
-    modification_date: Series[DateTime] = pa.Field(coerce=True, nullable=True, description="Modification Date", alias="modificationDate")
-    effective_date: Series[DateTime] = pa.Field(coerce=True, description="Effective Date", alias="effectiveDate")
-    end_effective_date: Series[DateTime] = pa.Field(coerce=True, nullable=True, description="End Effective Date", alias="endEffectiveDate")
-    change_reason: Series[str] = pa.Field(coerce=True, nullable=True, description="Change Reason", alias="change.reason")
-    pay_period: Series[String] = pa.Field(coerce=True, nullable=True, description="Pay Period", alias="payPeriod")
-    base_value: Series[Float] = pa.Field(coerce=True, nullable=True, description="Base Value", alias="base.value") #needs to become base.value?
-    base_currency: Series[String] = pa.Field(coerce=True, nullable=True, description="Base Currency", alias="base.currency")
-    active_effective_date: Series[DateTime] = pa.Field(coerce=True, nullable=True, description="Active Effective Date", alias="activeEffectiveDate")
-
-    class Config:
-        coerce = True