brynq-sdk-bob 2.5.2.dev0__tar.gz → 2.6.2.dev0__tar.gz

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

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

brynq_sdk_bob-2.6.2.dev0/brynq_sdk_bob/__init__.py

@@ -0,0 +1,77 @@
+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)
+        if type(credentials) is list:
+            credentials = credentials[0]
+
+        print(credentials)
+        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.2.dev0 → brynq_sdk_bob-2.6.2.dev0}/brynq_sdk_bob/bank.py

@@ -2,6 +2,8 @@ import pandas as pd
 from brynq_sdk_functions import Functions
 from .schemas.bank import BankSchema
 
+import time
+from tqdm import tqdm
 
 class Bank:
     def __init__(self, bob):
@@ -10,7 +12,7 @@ class Bank:
 
     def get(self, person_ids: pd.Series, field_selection: list[str] = []) -> (pd.DataFrame, pd.DataFrame):
         data = []
-        for person_id in person_ids:
+        for person_id in tqdm(person_ids, desc="Fetching bank accounts"):
             resp = self.bob.session.get(url=f"{self.bob.base_url}people/{person_id}/bank-accounts", timeout=self.bob.timeout)
             resp.raise_for_status()
             temp_data = resp.json()['values']
@@ -19,6 +21,9 @@ class Bank:
                 account['employee_id'] = person_id
             data += temp_data
 
+            # rate limit is 50 per minute
+            time.sleep(1.3)
+
         df = pd.DataFrame(data)
 
         valid_banks, invalid_banks = Functions.validate_data(df=df, schema=BankSchema, debug=True)

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

@@ -3,15 +3,49 @@ from typing import Optional, List
 from brynq_sdk_functions import Functions
 from .schemas.payments import VariablePaymentSchema, ActualPaymentsSchema
 
+import time
+from tqdm import tqdm
+
 
 class Payments:
     def __init__(self, bob):
         self.bob = bob
         self.schema = VariablePaymentSchema
 
+    def _apply_named_list_mappings(self, df: pd.DataFrame) -> pd.DataFrame:
+        """Apply named list ID-to-value mappings to dataframe columns."""
+        if df.empty:
+            return df
+
+        # Fetch named lists from Bob API
+        resp_named_lists = self.bob.session.get(
+            url=f"{self.bob.base_url}company/named-lists",
+            timeout=self.bob.timeout,
+            headers=self.bob.headers
+        )
+        named_lists = resp_named_lists.json()
+
+        # Transform named_lists to create id-to-value mappings for each field
+        named_lists = {
+            key.split('.')[-1]: {item['id']: item['value'] for item in value['values']}
+            for key, value in named_lists.items()
+        }
+
+        for field in df.columns:
+            # Fields in the response and in the named-list have different building blocks
+            # but they both end with the same last block
+            field_df = field.split('.')[-1].split('work_')[-1]
+            if field_df in named_lists.keys() and field_df not in ['site']:
+                mapping = named_lists[field_df]
+                df[field] = df[field].apply(
+                    lambda v: [mapping.get(x, x) for x in v] if isinstance(v, list) else mapping.get(v, v)
+                )
+
+        return df
+
     def get(self, person_ids: List[str]) -> (pd.DataFrame, pd.DataFrame):
         df = pd.DataFrame()
-        for person_id in person_ids:
+        for person_id in tqdm(person_ids, desc="Fetching variable payments"):
             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()
@@ -20,7 +54,15 @@ class Payments:
                 record_path='values'
             )])
             df['employee_id'] = person_id
+
+            # Rate limit is 50 per minute
+            time.sleep(1.3)
+
         df = df.reset_index(drop=True)
+
+        # Apply named list mappings
+        df = self._apply_named_list_mappings(df)
+
         valid_payments, invalid_payments = Functions.validate_data(df=df, schema=self.schema, debug=True)
         return valid_payments, invalid_payments
 
@@ -107,6 +149,9 @@ class Payments:
 
         df = pd.json_normalize(all_results)
 
+        # Apply named list mappings
+        df = self._apply_named_list_mappings(df)
+
         valid_payments, invalid_payments = Functions.validate_data(
             df=df,
             schema=ActualPaymentsSchema,

brynq_sdk_bob-2.6.2.dev0/brynq_sdk_bob/people.py

@@ -0,0 +1,100 @@
+import pandas as pd
+from typing import Optional, List
+from brynq_sdk_functions import Functions
+from brynq_sdk_functions import BrynQPanderaDataFrameModel
+from .bank import Bank
+from .employment import Employment
+from .salaries import Salaries
+from .schemas.people import PeopleSchema
+from .work import Work
+from .custom_tables import CustomTables
+
+
+class People:
+    def __init__(self, bob):
+        self.bob = bob
+        self.salaries = Salaries(bob)
+        self.employment = Employment(bob)
+        self.bank = Bank(bob)
+        self.work = Work(bob)
+        self.custom_tables = CustomTables(bob)
+        self.schema = PeopleSchema
+
+
+        # Build API fields using column metadata if present (api_field), otherwise use the column (alias) name
+    def __build_api_fields(self, schema_model: BrynQPanderaDataFrameModel) -> list[str]:
+        schema = schema_model.to_schema()
+        return [
+            ((getattr(col, "metadata", None) or {}).get("api_field")) or col_name
+            for col_name, col in schema.columns.items()
+        ]
+
+    def get(self, schema_custom_fields: Optional[BrynQPanderaDataFrameModel] = None, employee_ids: Optional[List[str]] = None) -> pd.DataFrame:
+        core_fields = self.__build_api_fields(PeopleSchema)
+        custom_fields = self.__build_api_fields(schema_custom_fields) if schema_custom_fields is not None else []
+        fields = core_fields + custom_fields
+
+        # Build filters based on employee_ids if provided
+        filters = []
+        if employee_ids is not None:
+            filters = [
+                {
+                    "fieldPath": "root.id",
+                    "operator": "equals",
+                    "values": employee_ids
+                }
+            ]
+
+        resp = self.bob.session.post(url=f"{self.bob.base_url}people/search",
+                                      json={
+                                          "fields": fields,
+                                          "filters": filters
+                                          #"humanReadable": "REPLACE"
+                                      },
+                                      timeout=self.bob.timeout)
+        resp.raise_for_status()
+        df = pd.json_normalize(resp.json()['employees'])
+        df = df.loc[:, ~df.columns.str.contains('value')]
+
+        # Normalize separators in incoming data: convert '/' to '.' to match schema aliases
+        df.columns = df.columns.str.replace('/', '.', regex=False)
+
+        # A lot of fields from Bob are returned with only ID's. Those fields should be mapped to names. Therefore, we need to get the mapping from the named-lists endpoint.
+        resp_named_lists = self.bob.session.get(url=f"{self.bob.base_url}company/named-lists", timeout=self.bob.timeout, headers=self.bob.headers)
+        named_lists = resp_named_lists.json()
+        # save json to file
+        # import json
+        # with open('named_lists.json', 'w') as f:
+        #     json.dump(named_lists, f, indent=4)
+
+        # Transform named_lists to create id-to-value mappings for each field
+        named_lists = {key.split('.')[-1]: {item['id']: item['value'] for item in value['values']} for key, value in named_lists.items()}
+
+        deviating_named_list_cols_mapping = {
+            'payroll.employment.type': 'payrollEmploymentType',
+            'home.familyStatus': 'familystatus',
+            'personal.nationality': 'nationalities',
+        }
+
+        for field in df.columns:
+            # Fields in the response and in the named-list does have different building blocks (e.g. people.payroll.entitlement. or people.entitlement.). But they both end with the same last block
+            field_df = field.split('.')[-1].split('work_')[-1]
+
+            # Check if this field has a deviating mapping
+            named_list_key = deviating_named_list_cols_mapping.get(field, field_df)
+
+            if named_list_key in named_lists.keys() and named_list_key not in ['site']:
+                mapping = named_lists[named_list_key]
+                df[field] = df[field].apply(
+                    lambda v: [mapping.get(x, x) for x in v] if isinstance(v, list) else mapping.get(v, v)
+                )
+
+        if schema_custom_fields is not None:
+            valid_people, invalid_people_custom = Functions.validate_data(df=df, schema=schema_custom_fields, debug=True)
+        else:
+            valid_people = df
+            invalid_people_custom = pd.DataFrame()
+
+        valid_people, invalid_people = Functions.validate_data(df=valid_people, schema=PeopleSchema, debug=True)
+
+        return valid_people, pd.concat([invalid_people, invalid_people_custom])

{brynq_sdk_bob-2.5.2.dev0 → brynq_sdk_bob-2.6.2.dev0}/brynq_sdk_bob/salaries.py

@@ -1,5 +1,6 @@
 import pandas as pd
 import requests
+from typing import Optional, List
 from brynq_sdk_functions import Functions
 from .schemas.salary import SalarySchema, SalaryCreateSchema
 
@@ -9,10 +10,16 @@ class Salaries:
         self.bob = bob
         self.schema = SalarySchema
 
-    def get(self) -> tuple[pd.DataFrame, pd.DataFrame]:
+    def get(self, employee_ids: Optional[List[str]] = None) -> tuple[pd.DataFrame, pd.DataFrame]:
+        params = {"limit": 100}
+
+        # Add employeeIds filter if provided
+        if employee_ids is not None:
+            params["employeeIds"] = ",".join(employee_ids)
+
         request = requests.Request(method='GET',
                                    url=f"{self.bob.base_url}bulk/people/salaries",
-                                   params={"limit": 100})
+                                   params=params)
         data = self.bob.get_paginated_result(request)
         df = pd.json_normalize(
             data,

{brynq_sdk_bob-2.5.2.dev0 → brynq_sdk_bob-2.6.2.dev0}/brynq_sdk_bob/schemas/bank.py

@@ -1,4 +1,5 @@
 import pandera as pa
+from typing import Optional
 from pandera.typing import Series, String
 import pandas as pd
 from brynq_sdk_functions import BrynQPanderaDataFrameModel
@@ -6,19 +7,19 @@ from brynq_sdk_functions import BrynQPanderaDataFrameModel
 
 class BankSchema(BrynQPanderaDataFrameModel):
     id: Series[pd.Int64Dtype] = pa.Field(coerce=True, description="Bank ID", alias="id")
-    employee_id: Series[pd.Int64Dtype] = pa.Field(coerce=True, description="Employee ID", alias="employeeId")
-    amount: Series[pd.Int64Dtype] = pa.Field(coerce=True, description="Amount", alias="amount")
-    allocation: Series[String] = pa.Field(coerce=True, nullable=True, description="Allocation", alias="allocation")
-    branch_address: Series[String] = pa.Field(coerce=True, nullable=True, description="Branch Address", alias="branchAddress")
+    employee_id: Series[String] = pa.Field(coerce=True, description="Employee ID", alias="employee_id")
+    amount: Optional[Series[pd.Int64Dtype]] = pa.Field(coerce=True, description="Amount", alias="amount")
+    allocation: Optional[Series[String]] = pa.Field(coerce=True, nullable=True, description="Allocation", alias="allocation")
+    branch_address: Optional[Series[String]] = pa.Field(coerce=True, nullable=True, description="Branch Address", alias="branchAddress")
     bank_name: Series[String] = pa.Field(coerce=True, nullable=True, description="Bank Name", alias="bankName")
     account_number: Series[String] = pa.Field(coerce=True, nullable=True, description="Account Number", alias="accountNumber")
-    routing_number: Series[String] = pa.Field(coerce=True, nullable=True, description="Routing Number", alias="routingNumber")
+    routing_number: Optional[Series[String]] = pa.Field(coerce=True, nullable=True, description="Routing Number", alias="routingNumber")
     bank_account_type: Series[String] = pa.Field(coerce=True, nullable=True, description="Bank Account Type", alias="bankAccountType")
-    bic_or_swift: Series[String] = pa.Field(coerce=True, nullable=True, description="BIC or SWIFT", alias="bicOrSwift")
+    bic_or_swift: Optional[Series[String]] = pa.Field(coerce=True, nullable=True, description="BIC or SWIFT", alias="bicOrSwift")
     changed_by: Series[String] = pa.Field(coerce=True, nullable=True, description="Changed By", alias="changedBy")
     iban: Series[String] = pa.Field(coerce=True, description="IBAN", alias="iban")
     account_nickname: Series[String] = pa.Field(coerce=True, nullable=True, description="Account Nickname", alias="accountNickname")
-    use_for_bonus: Series[pd.BooleanDtype] = pa.Field(coerce=True, nullable=True, description="Use for Bonus", alias="useForBonus")
+    use_for_bonus: Optional[Series[pd.BooleanDtype]] = pa.Field(coerce=True, nullable=True, description="Use for Bonus", alias="useForBonus")
 
     class Config:
         coerce = True