brynq-sdk-bob 2.9.5__tar.gz → 2.10.1__tar.gz

{brynq_sdk_bob-2.9.5 → brynq_sdk_bob-2.10.1}/PKG-INFO

@@ -1,12 +1,15 @@
 Metadata-Version: 2.4
 Name: brynq_sdk_bob
-Version: 2.9.5
+Version: 2.10.1
 Summary: Bob wrapper from BrynQ
 Author: BrynQ
 Author-email: support@brynq.com
 License: BrynQ License
 Requires-Dist: brynq-sdk-brynq<5,>=4
+Requires-Dist: brynq-sdk-functions>=2.0.5
 Requires-Dist: pandas<3.0.0,>=2.2.0
+Requires-Dist: pydantic<3.0.0,>=2.5.0
+Requires-Dist: pandera<1.0.0,>=0.16.0
 Dynamic: author
 Dynamic: author-email
 Dynamic: description

{brynq_sdk_bob-2.9.5 → brynq_sdk_bob-2.10.1}/brynq_sdk_bob/__init__.py

@@ -1,16 +1,12 @@
 import base64
 import os
 from typing import List, Literal, Optional
-
 import requests
 from requests.adapters import HTTPAdapter
 from urllib3.util.retry import Retry
-
 from brynq_sdk_brynq import BrynQ
-
 from .bank import Bank
 from .company import Company
-from .custom_tables import CustomTables
 from .documents import CustomDocuments
 from .employment import Employment
 from .named_lists import NamedLists
@@ -21,6 +17,8 @@ from .reports import Reports
 from .salaries import Salaries
 from .timeoff import TimeOff
 from .work import Work
+from .custom_tables import CustomTables
+from .entitlements import Entitlements
 
 
 class Bob(BrynQ):
@@ -57,6 +55,7 @@ class Bob(BrynQ):
         self.custom_tables = CustomTables(self)
         self.payroll_history = History(self)
         self.reports = Reports(self)
+        self.entitlements = Entitlements(self)
         self.data_interface_id = os.getenv("DATA_INTERFACE_ID")
         self.debug = debug
 

{brynq_sdk_bob-2.9.5 → brynq_sdk_bob-2.10.1}/brynq_sdk_bob/bank.py

@@ -1,17 +1,17 @@
 import pandas as pd
 from brynq_sdk_functions import Functions
-from .schemas.bank import BankSchema
+from .schemas.bank import BankGet
 
 
 class Bank:
-    def __init__(self, bob):
-        self.bob = bob
-        self.schema = BankSchema
+    def __init__(self, client):
+        self.client = client
+        self.schema = BankGet
 
-    def get(self, person_ids: pd.Series, field_selection: list[str] = []) -> (pd.DataFrame, pd.DataFrame):
+    def get(self, person_ids: pd.Series, field_selection: list[str] = []) -> tuple[pd.DataFrame, pd.DataFrame]:
         data = []
         for person_id in person_ids:
-            resp = self.bob.session.get(url=f"{self.bob.base_url}people/{person_id}/bank-accounts", timeout=self.bob.timeout)
+            resp = self.client.session.get(url=f"{self.client.base_url}people/{person_id}/bank-accounts", timeout=self.client.timeout)
             resp.raise_for_status()
             temp_data = resp.json()['values']
             # when an employee has one or more bank accounts, the response is a list of dictionaries.
@@ -21,6 +21,6 @@ class Bank:
 
         df = pd.DataFrame(data)
 
-        valid_banks, invalid_banks = Functions.validate_data(df=df, schema=BankSchema, debug=True)
+        valid_banks, invalid_banks = Functions.validate_data(df=df, schema=BankGet, debug=True)
 
         return valid_banks, invalid_banks

{brynq_sdk_bob-2.9.5 → brynq_sdk_bob-2.10.1}/brynq_sdk_bob/company.py

@@ -2,19 +2,19 @@ import pandas as pd
 
 
 class Company:
-    def __init__(self, bob):
-        self.bob = bob
+    def __init__(self, client):
+        self.client = client
 
     def get_variable_values(self, list_name: str = None) -> dict:
         values = {}
 
         if list_name is not None:
-            resp = self.bob.session.get(url=f"{self.bob.base_url}company/named-lists/{list_name}", timeout=self.bob.timeout)
+            resp = self.client.session.get(url=f"{self.client.base_url}company/named-lists/{list_name}", timeout=self.client.timeout)
             resp.raise_for_status()
             data = resp.json()
             values.update({data["name"]: [value['id'] for value in data['values']]})
         else:
-            resp = self.bob.session.get(url=f"{self.bob.base_url}company/named-lists", timeout=self.bob.timeout)
+            resp = self.client.session.get(url=f"{self.client.base_url}company/named-lists", timeout=self.client.timeout)
             resp.raise_for_status()
             data = resp.json()
             for list_key, list_data in data.items():

{brynq_sdk_bob-2.9.5 → brynq_sdk_bob-2.10.1}/brynq_sdk_bob/custom_tables.py

@@ -4,13 +4,13 @@ import pandas as pd
 
 from brynq_sdk_functions import BrynQPanderaDataFrameModel, Functions
 
-from .schemas.custom_tables import CustomTableMetadataSchema, CustomTableSchema
+from .schemas.custom_tables import CustomTableMetadataGet, CustomTableGet
 
 
 class CustomTables:
-    def __init__(self, bob):
-        self.bob = bob
-        self.schema = CustomTableSchema
+    def __init__(self, client):
+        self.client = client
+        self.schema = CustomTableGet
 
     def get(self, employee_ids: List[str], custom_table_id: str, schema_custom_fields: Optional[BrynQPanderaDataFrameModel] = None) -> tuple[pd.DataFrame, pd.DataFrame]:
         """
@@ -26,7 +26,7 @@ class CustomTables:
         """
         df = pd.DataFrame()
         for employee_id in employee_ids:
-            resp = self.bob.session.get(url=f"{self.bob.base_url}people/custom-tables/{employee_id}/{custom_table_id}", timeout=self.bob.timeout)
+            resp = self.client.session.get(url=f"{self.client.base_url}people/custom-tables/{employee_id}/{custom_table_id}", timeout=self.client.timeout)
             resp.raise_for_status()
             data = resp.json()
 
@@ -53,8 +53,8 @@ class CustomTables:
         Returns:
             A tuple of (valid_data, invalid_data) as pandas DataFrames containing table and column metadata
         """
-        url = f"{self.bob.base_url}people/custom-tables/metadata"
-        resp = self.bob.session.get(url=url)
+        url = f"{self.client.base_url}people/custom-tables/metadata"
+        resp = self.client.session.get(url=url)
         resp.raise_for_status()
         data = resp.json()
 
@@ -82,6 +82,6 @@ class CustomTables:
         df = pd.DataFrame(rows)
 
         # Validate against the metadata schema
-        valid_data, invalid_data = Functions.validate_data(df=df, schema=CustomTableMetadataSchema, debug=True)
+        valid_data, invalid_data = Functions.validate_data(df=df, schema=CustomTableMetadataGet, debug=True)
 
         return valid_data, invalid_data

brynq_sdk_bob-2.10.1/brynq_sdk_bob/documents.py

@@ -0,0 +1,37 @@
+from datetime import datetime
+from io import BytesIO
+
+import pandas as pd
+from brynq_sdk_functions import Functions
+
+
+class CustomDocuments:
+    def __init__(self, client):
+        self.client = client
+
+    def get(self, person_id: datetime) -> pd.DataFrame:
+        resp = self.client.session.get(url=f"{self.client.base_url}docs/people/{person_id}", timeout=self.client.timeout)
+        resp.raise_for_status()
+        data = resp.json()['documents']
+        df = pd.DataFrame(data)
+        df = self.client.rename_camel_columns_to_snake_case(df)
+
+        return df
+
+    def get_folders(self) -> dict:
+        resp = self.client.session.get(url=f"{self.client.base_url}docs/folders/metadata", timeout=self.client.timeout)
+        resp.raise_for_status()
+        data = resp.json()
+
+        return data
+
+    def create(self,
+               person_id: datetime,
+               folder_id: str,
+               file_name: str,
+               file_object: BytesIO):
+        files = {"file": (file_name, file_object, "application/pdf")}
+        resp = self.client.session.post(url=f"{self.client.base_url}docs/people/{person_id}/folders/{folder_id}/upload",
+                                     files=files,
+                                     timeout=self.client.timeout)
+        resp.raise_for_status()

{brynq_sdk_bob-2.9.5 → brynq_sdk_bob-2.10.1}/brynq_sdk_bob/employment.py

@@ -1,18 +1,19 @@
 import pandas as pd
 import requests
-from .schemas.employment import EmploymentSchema
+from .schemas.employment import EmploymentGet
 from brynq_sdk_functions import Functions
 
 
 class Employment:
-    def __init__(self, bob):
-        self.bob = bob
-        self.schema = EmploymentSchema
+    def __init__(self, client):
+        self.client = client
+        self.schema = EmploymentGet
 
-    def get(self) -> (pd.DataFrame, pd.DataFrame):
+    def get(self) -> tuple[pd.DataFrame, pd.DataFrame]:
         request = requests.Request(method='GET',
-                                   url=f"{self.bob.base_url}bulk/people/employment")
-        data = self.bob.get_paginated_result(request)
+                                   url=f"{self.client.base_url}bulk/people/employment",
+                                   params={"includeArchived": "true"})
+        data = self.client.get_paginated_result(request)
         df = pd.json_normalize(
             data,
             record_path='values',

brynq_sdk_bob-2.10.1/brynq_sdk_bob/entitlements.py

@@ -0,0 +1,37 @@
+from typing import Tuple
+import pandas as pd
+from brynq_sdk_functions import Functions
+from brynq_sdk_bob.schemas.entitlements import EntitlementReportGet
+
+
+class Entitlements:
+    def __init__(self, client):
+        self.client = client
+
+    def get(self, report_id: str | None = None, debug: bool = False) -> tuple[pd.DataFrame, pd.DataFrame]:
+        """
+        Get entitlement history data from the Bob reports.
+
+        Args:
+            report_id: Optional report ID. If not provided, will search for 'Entitlement history' report.
+            debug: Whether to print debug information.
+
+        Returns:
+            Tuple of (valid_entitlements, invalid_entitlements) DataFrames
+        """
+        reports_df, _ = self.client.reports.get()
+        if report_id is None:
+            entitlement_report = reports_df[reports_df['name'] == 'Entitlement history']
+            if entitlement_report.empty:
+                raise ValueError("Report 'Entitlement history' not found.")
+            report_id = entitlement_report['id'].iloc[0]
+
+        report_data = self.client.reports.download(report_id=report_id)
+        df_raw = pd.json_normalize(report_data, record_path='employees')
+        valid_entitlements, invalid_entitlements = Functions.validate_data(
+            df=df_raw,
+            schema=EntitlementReportGet,
+            debug=debug,
+        )
+
+        return valid_entitlements, invalid_entitlements

{brynq_sdk_bob-2.9.5 → brynq_sdk_bob-2.10.1}/brynq_sdk_bob/named_lists.py

@@ -1,15 +1,15 @@
 from datetime import datetime
 import pandas as pd
 from brynq_sdk_functions import Functions
-from .schemas.named_lists import NamedListSchema
+from .schemas.named_lists import NamedListGet
 
 
 class NamedLists:
-    def __init__(self, bob):
-        self.bob = bob
-        self.schema = NamedListSchema
+    def __init__(self, client):
+        self.client = client
+        self.schema = NamedListGet
 
-    def get(self) -> (pd.DataFrame, pd.DataFrame):
+    def get(self) -> tuple[pd.DataFrame, pd.DataFrame]:
         """
         Get custom table data for an employee
 
@@ -19,8 +19,8 @@ class NamedLists:
         Returns:
             A tuple of (valid_data, invalid_data) as pandas DataFrames
         """
-        url = f"{self.bob.base_url}company/named-lists/"
-        resp = self.bob.session.get(url=url)
+        url = f"{self.client.base_url}company/named-lists/"
+        resp = self.client.session.get(url=url)
         resp.raise_for_status()
         data = resp.json()
 
@@ -31,7 +31,6 @@ class NamedLists:
         ])
 
         # Normalize the nested JSON response
-        # df = pd.DataFrame(data.get('values'))
-        valid_data, invalid_data = Functions.validate_data(df=df, schema=NamedListSchema, debug=True)
+        valid_data, invalid_data = Functions.validate_data(df=df, schema=NamedListGet, debug=True)
 
         return valid_data, invalid_data

{brynq_sdk_bob-2.9.5 → brynq_sdk_bob-2.10.1}/brynq_sdk_bob/payments.py

@@ -5,24 +5,25 @@ import pandas as pd
 
 from brynq_sdk_functions import Functions
 
-from .schemas.payments import ActualPaymentsSchema, VariablePaymentSchema
+from .schemas.payments import ActualPaymentsGet, VariablePaymentGet
 
 
 class Payments:
-    def __init__(self, bob):
-        self.bob = bob
-        self.schema = VariablePaymentSchema
+    def __init__(self, client):
+        self.client = client
+        self.schema = VariablePaymentGet
 
-    def get(self, person_ids: List[str]) -> (pd.DataFrame, pd.DataFrame):
+    def get(self, person_ids: List[str]) -> tuple[pd.DataFrame, pd.DataFrame]:
         records = []
 
         for person_id in person_ids:
             # Throttle requests to respect API rate limits
             time.sleep(0.2)
 
-            resp = self.bob.session.get(
-                url=f"{self.bob.base_url}people/{person_id}/variable",
-                timeout=self.bob.timeout
+            resp = self.client.session.get(
+                url=f"{self.client.base_url}people/{person_id}/variable",
+                timeout=self.client.timeout,
+                params={"includeArchived": "true"}
             )
             resp.raise_for_status()
 
@@ -46,7 +47,7 @@ class Payments:
         employee_ids: Optional[List[str]] = None,
         pay_date_from: Optional[str] = None,
         pay_date_to: Optional[str] = None
-    ) -> (pd.DataFrame, pd.DataFrame):
+    ) -> tuple[pd.DataFrame, pd.DataFrame]:
         """
         Search for actual payments with optional employee and pay date filters.
         This method auto-paginates until all results are fetched.
@@ -101,10 +102,10 @@ class Payments:
             if next_cursor:
                 payload["pagination"]["cursor"] = next_cursor
 
-            resp = self.bob.session.post(
-                url=f"{self.bob.base_url}people/actual-payments/search",
+            resp = self.client.session.post(
+                url=f"{self.client.base_url}people/actual-payments/search",
                 json=payload,
-                timeout=self.bob.timeout
+                timeout=self.client.timeout
             )
             resp.raise_for_status()
             data = resp.json()
@@ -125,7 +126,7 @@ class Payments:
 
         valid_payments, invalid_payments = Functions.validate_data(
             df=df,
-            schema=ActualPaymentsSchema,
+            schema=ActualPaymentsGet,
             debug=True
         )
 

{brynq_sdk_bob-2.9.5 → brynq_sdk_bob-2.10.1}/brynq_sdk_bob/payroll_history.py

@@ -1,11 +1,11 @@
 import pandas as pd
 from brynq_sdk_functions import Functions
-from .schemas.people import PeopleSchema
+from .schemas.people import PeopleGet
 
 class History:
-    def __init__(self, bob):
-        self.bob = bob
-        self.schema = PeopleSchema
+    def __init__(self, client):
+        self.client = client
+        self.schema = PeopleGet
         self.field_name_in_body, self.field_name_in_response, self.endpoint_to_response = self._init_fields()
 
     def get(self, additional_fields: list[str] = [], field_selection: list[str] = []) -> tuple[pd.DataFrame, pd.DataFrame]:
@@ -16,7 +16,6 @@ class History:
             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
         """
-        #resp = self.bob.session.get(url=f"{self.bob.base_url}profiles", timeout=self.bob.timeout)
         body_fields = list(set(self.field_name_in_body + additional_fields))
         response_fields = list(set(self.field_name_in_response + additional_fields))
 
@@ -25,25 +24,25 @@ class History:
             response_fields = [self.endpoint_to_response.get(field) for field in field_selection if field in self.endpoint_to_response]
 
         # Bob sucks with default fields so you need to do a search call to retrieve additional fields.
-        resp_additional_fields = self.bob.session.post(url=f"{self.bob.base_url}people/search",
+        resp_additional_fields = self.client.session.post(url=f"{self.client.base_url}people/search",
                                                        json={
                                                            "fields": body_fields,
                                                            "filters": []
                                                        },
-                                                       timeout=self.bob.timeout)
+                                                       timeout=self.client.timeout)
         json_response = resp_additional_fields.json()
         df = pd.json_normalize(resp_additional_fields.json()['employees'])
         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)
+        # Get the valid column names from PeopleGet
+        valid_people, invalid_people = Functions.validate_data(df=df, schema=PeopleGet, debug=True)
         return valid_people, invalid_people
 
 
     def _init_fields(self) -> tuple[list[str], list[str], dict[str, str]]:
-        resp_fields = self.bob.session.get(
-            url=f"{self.bob.base_url}company/people/fields",
-            timeout=self.bob.timeout,
-            headers=self.bob.headers
+        resp_fields = self.client.session.get(
+            url=f"{self.client.base_url}company/people/fields",
+            timeout=self.client.timeout,
+            headers=self.client.headers
         )
         fields = resp_fields.json()
         field_name_in_body = [field.get('id') for field in fields]
@@ -58,14 +57,14 @@ class History:
         body_fields = [employee_id_in_company, person_id]
         response_fields = [self.endpoint_to_response.get(field) for field in body_fields if field in self.endpoint_to_response]
 
-        resp_additional_fields = self.bob.session.post(url=f"{self.bob.base_url}people/search",
+        resp_additional_fields = self.client.session.post(url=f"{self.client.base_url}people/search",
                                                        json={
                                                            "fields": body_fields,
                                                            "filters": []
                                                        },
-                                                       timeout=self.bob.timeout)
+                                                       timeout=self.client.timeout)
         df = pd.json_normalize(resp_additional_fields.json()['employees'])
         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)
+        # Get the valid column names from PeopleGet
+        valid_people, invalid_people = Functions.validate_data(df=df, schema=PeopleGet, debug=True)
         return valid_people, invalid_people

{brynq_sdk_bob-2.9.5 → brynq_sdk_bob-2.10.1}/brynq_sdk_bob/people.py

@@ -9,19 +9,19 @@ from .bank import Bank
 from .custom_tables import CustomTables
 from .employment import Employment
 from .salaries import Salaries
-from .schemas.people import PeopleSchema
+from .schemas.people import PeopleGet
 from .work import Work
 
 
 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
+    def __init__(self, client):
+        self.client = client
+        self.salaries = Salaries(client)
+        self.employment = Employment(client)
+        self.bank = Bank(client)
+        self.work = Work(client)
+        self.custom_tables = CustomTables(client)
+        self.schema = PeopleGet
 
 
 
@@ -33,19 +33,18 @@ class People:
             for col_name, col in schema.columns.items()
         ]
 
-    def get(self, schema_custom_fields: Optional[BrynQPanderaDataFrameModel] = None) -> pd.DataFrame:
+    def get(self, schema_custom_fields: Optional[BrynQPanderaDataFrameModel] = None) -> tuple[pd.DataFrame, pd.DataFrame]:
 
-        core_fields = self.__build_api_fields(PeopleSchema)
+        core_fields = self.__build_api_fields(PeopleGet)
         custom_fields = self.__build_api_fields(schema_custom_fields) if schema_custom_fields is not None else []
         fields = core_fields + custom_fields
 
-        resp = self.bob.session.post(url=f"{self.bob.base_url}people/search",
+        resp = self.client.session.post(url=f"{self.client.base_url}people/search",
                                       json={
                                           "fields": fields,
                                           "filters": []
-                                          #"humanReadable": "REPLACE"
                                       },
-                                      timeout=self.bob.timeout)
+                                      timeout=self.client.timeout)
         resp.raise_for_status()
         df = pd.json_normalize(resp.json()['employees'])
 
@@ -72,7 +71,7 @@ class People:
 
 
         # 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)
+        resp_named_lists = self.client.session.get(url=f"{self.client.base_url}company/named-lists", timeout=self.client.timeout, headers=self.client.headers)
         named_lists = resp_named_lists.json()
 
         # Transform named_lists to create id-to-value mappings for each field
@@ -102,7 +101,7 @@ class People:
             invalid_people_custom = pd.DataFrame()
 
 
-        valid_people, invalid_people = Functions.validate_data(df=valid_people, schema=PeopleSchema, debug=True)
+        valid_people, invalid_people = Functions.validate_data(df=valid_people, schema=PeopleGet, debug=True)
 
         # For columns ending with .value.value, use fillna to fill the corresponding base column since that's not done automatically
         def _normalize_key(key: str) -> str:

brynq_sdk_bob-2.10.1/brynq_sdk_bob/reports.py

@@ -0,0 +1,41 @@
+from typing import Literal, TYPE_CHECKING
+
+import pandas as pd
+from brynq_sdk_functions import Functions
+from brynq_sdk_bob.schemas.reports import ReportGet
+if TYPE_CHECKING:
+    from brynq_sdk_bob import Bob
+
+
+class Reports:
+    def __init__(self, client):
+        self.client: Bob = client
+
+    def get(self) -> tuple[pd.DataFrame, pd.DataFrame]:
+        resp = self.client.session.get(url=f"{self.client.base_url}company/reports", timeout=self.client.timeout)
+        resp.raise_for_status()
+        data = resp.json()
+        df = pd.json_normalize(
+            data,
+            record_path='views'
+        )
+        valid_reports, invalid_reports = Functions.validate_data(df=df, schema=ReportGet, debug=True)
+
+        return valid_reports, invalid_reports
+
+    def download(self, report_id: int | str = None, report_format: Literal["json", "csv"] = "json") -> dict | bytes:
+        if report_id:
+            url = f"{self.client.base_url}company/reports/{report_id}/download"
+        else:
+            raise ValueError("Either report_id or report_name must be provided")
+
+        resp = self.client.session.get(url=url, timeout=self.client.timeout, params={"format": report_format})
+        resp.raise_for_status()
+        if report_format == "json":
+            data = resp.json()
+        elif report_format == "csv":
+            data = resp.content
+        else:
+            raise ValueError(f"Invalid report format: {report_format}")
+
+        return data

brynq_sdk_bob-2.10.1/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 SalaryGet, SalaryCreate
+
+
+class Salaries:
+    def __init__(self, client):
+        self.client = client
+        self.schema = SalaryGet
+
+    def get(self) -> tuple[pd.DataFrame, pd.DataFrame]:
+        request = requests.Request(method='GET',
+                                   url=f"{self.client.base_url}bulk/people/salaries",
+                                   params={"limit": 100, "includeArchived": "true"})
+        data = self.client.get_paginated_result(request)
+        df = pd.json_normalize(
+            data,
+            record_path='values',
+            meta=['employeeId']
+        )
+        valid_salaries, invalid_salaries = Functions.validate_data(df=df, schema=SalaryGet, debug=True)
+
+        return valid_salaries, invalid_salaries
+
+    def create(self, salary_data: dict) -> requests.Response:
+        nested_data = self.client.flat_dict_to_nested_dict(salary_data, SalaryCreate)
+        salary_data = SalaryCreate(**nested_data)
+        payload = salary_data.model_dump(exclude_none=True, by_alias=True)
+
+        resp = self.client.session.post(url=f"{self.client.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.client.session.delete(url=f"{self.client.base_url}people/{employee_id}/salaries/{salary_id}")
+        resp.raise_for_status()
+        return resp

{brynq_sdk_bob-2.9.5 → brynq_sdk_bob-2.10.1}/brynq_sdk_bob/schemas/bank.py

@@ -4,9 +4,9 @@ import pandas as pd
 from brynq_sdk_functions import BrynQPanderaDataFrameModel
 
 
-class BankSchema(BrynQPanderaDataFrameModel):
+class BankGet(BrynQPanderaDataFrameModel):
     id: Series[pd.Int64Dtype] = pa.Field(coerce=True, description="Bank ID", alias="id")
-    employee_id: Series[String] = pa.Field(coerce=True, description="Employee ID", alias="employeeId")
+    employee_id: Series[String] = pa.Field(coerce=True, description="Employee ID", alias="employee_id")
     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")

{brynq_sdk_bob-2.9.5 → brynq_sdk_bob-2.10.1}/brynq_sdk_bob/schemas/custom_tables.py

@@ -3,13 +3,13 @@ from pandera.typing import Series
 import pandas as pd
 from brynq_sdk_functions import BrynQPanderaDataFrameModel
 
-class CustomTableSchema(BrynQPanderaDataFrameModel):
+class CustomTableGet(BrynQPanderaDataFrameModel):
     id: Series[pd.Int64Dtype] = pa.Field(coerce=True, description="Custom Table ID", alias="id")
     employee_id: Series[str] = pa.Field(coerce=True, description="Employee ID", alias="employee_id")
 
     class Config:
         coerce = True
-class CustomTableMetadataSchema(BrynQPanderaDataFrameModel):
+class CustomTableMetadataGet(BrynQPanderaDataFrameModel):
     # Table information
     table_id: Series[str] = pa.Field(coerce=True, description="Table ID", alias="table_id")
     table_name: Series[str] = pa.Field(coerce=True, description="Table Name", alias="table_name")