brynq-sdk-nmbrs 1.2.0__tar.gz → 1.3.1__tar.gz

{brynq_sdk_nmbrs-1.2.0 → brynq_sdk_nmbrs-1.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.0
 Name: brynq_sdk_nmbrs
-Version: 1.2.0
+Version: 1.3.1
 Summary: Nmbrs wrapper from BrynQ
 Home-page: UNKNOWN
 Author: BrynQ

{brynq_sdk_nmbrs-1.2.0 → brynq_sdk_nmbrs-1.3.1}/brynq_sdk_nmbrs/__init__.py

@@ -4,43 +4,81 @@ import re
 import pandas as pd
 import requests
 from brynq_sdk_brynq import BrynQ
+from .address import Address
+from .bank import Bank
 from zeep import Client, Settings
 from .children import Children
 from .companies import Companies
 from .debtors import Debtors
+from .contract import Contract
+from .costcenter import EmployeeCostcenter, Costcenter
+from .costunit import Costunit
+from .department import EmployeeDepartment
+from .document import Payslip
 from .employees import Employees
 from .salary_tables import SalaryTables, SalaryScales, SalarySteps
+from .employment import Employment
+from .function import EmployeeFunction
+from .hours import VariableHours, FixedHours
+from .salaries import Salaries
+from .schedules import Schedule
+from .wagecomponents import EmployeeFixedWageComponents, EmployeeVariableWageComponents
 
 
 class Nmbrs(BrynQ):
-    def __init__(self, label: Union[str, List], debug: bool = False):
-        super().__init__()
-        self.label = label
-        headers = self._get_request_headers(label=label)
-        self.base_url = "https://api.nmbrsapp.com/api/"
-        self.session = requests.Session()
-        self.session.headers.update(headers)
-        # self.session.headers.update({'Content-Type': 'application/json'})
-        # Initialize SOAP client
-        self.soap_settings = Settings(
-            strict=False,
-            xml_huge_tree=True,
-            force_https=True
-        )
-        self.soap_client = Client(
-            'https://api.nmbrs.nl/soap/v3/CompanyService.asmx?wsdl',
-            settings=self.soap_settings
-        )
+    def __init__(self, label: Union[str, List], debug: bool = False, mock_mode: bool = True):
+        """
+        Initialize the Nmbrs class.
+
+        Args:
+            label: The label of the system in BrynQ. legacy
+            debug: Whether to print debug information
+            mock_mode: If true, data will NOT be send to Nmbrs but only be tested for validity against Pydantic schemas
+        """
+        self.mock_mode = mock_mode
+        if mock_mode is False:
+            super().__init__()
+            self.label = label
+            headers = self._get_request_headers(label=label)
+            self.base_url = "https://api.nmbrsapp.com/api/"
+            self.session = requests.Session()
+            self.session.headers.update(headers)
+
+            # Initialize SOAP client
+            self.soap_settings = Settings(
+                strict=False,
+                xml_huge_tree=True,
+                force_https=True
+            )
+            self.soap_client = Client(
+                'https://api.nmbrs.nl/soap/v3/CompanyService.asmx?wsdl',
+                settings=self.soap_settings
+            )
+
+        self.address = Address(self)
+        self.bank = Bank(self)
+        self.children = Children(self)
         self.debtor = Debtors(self)
         self.companies = Companies(self)
+        self.contract = Contract(self)
+        self.department = EmployeeDepartment(self)
         self.company_ids = self.companies.get()['company_id']
         self.soap_company_ids = self.companies.get_soap_ids()
         self.employees = Employees(self)
+        self.employment = Employment(self)
+        self.function = EmployeeFunction(self)
+        self.fixed_hours = FixedHours(self)
+        self.variable_hours = VariableHours(self)
+        self.salaries = Salaries(self)
+        self.schedule = Schedule(self)
+        self.fixed_wagecomponents = EmployeeFixedWageComponents(self)
+        self.variable_wagecomponents = EmployeeVariableWageComponents(self)
         self.children = Children(self)
         self.salary_tables = SalaryTables(self)
         self.salary_scales = SalaryScales(self)
         self.salary_steps = SalarySteps(self)
         self.debug = debug
+        self.timeout = 3600
 
     def _get_request_headers(self, label):
         initial_credentials = self.get_system_credential(system='nmbrs', label=label)
@@ -82,7 +120,7 @@ class Nmbrs(BrynQ):
         while has_next_page:
             prepped = request.prepare()
             prepped.headers.update(self.session.headers)
-            resp = self.session.send(prepped)
+            resp = self.session.send(prepped, timeout=self.nmbrs.timeout)
             resp.raise_for_status()
             response_data = resp.json()
             result_data += response_data['data']
@@ -119,3 +157,4 @@ class Nmbrs(BrynQ):
         df.columns = map(camel_to_snake_case, df.columns)
 
         return df
+

brynq_sdk_nmbrs-1.3.1/brynq_sdk_nmbrs/address.py

@@ -0,0 +1,66 @@
+import pandas as pd
+import requests
+from typing import Dict, Any
+from .schemas.address import AddressCreate, AddressGet, Period
+from brynq_sdk_functions import Functions
+
+class Address:
+    def __init__(self, nmbrs):
+        self.nmbrs = nmbrs
+
+    def get(self,
+            created_from: str = None) -> pd.DataFrame:
+        addresses = pd.DataFrame()
+        for company in self.nmbrs.company_ids:
+            addresses = pd.concat([addresses, self._get(company, created_from)])
+
+        valid_addresses, invalid_addresses = Functions.validate_data(df=addresses, schema=AddressGet, debug=True)
+
+        return valid_addresses, invalid_addresses
+
+    def _get(self,
+            company_id: str,
+            created_from: str = None) -> pd.DataFrame:
+        params = {} if created_from is None else {'createdFrom': created_from}
+        request = requests.Request(method='GET',
+                                   url=f"{self.nmbrs.base_url}companies/{company_id}/employees/addresses",
+                                   params=params)
+
+        data = self.nmbrs.get_paginated_result(request)
+        df = pd.json_normalize(
+            data,
+            record_path='addresses',
+            meta=['employeeId']
+        )
+
+        return df
+
+    def create(self, employee_id: str, data: Dict[str, Any]):
+        """
+        Create a new address for an employee using Pydantic validation.
+
+        Args:
+            employee_id: The ID of the employee
+            data: Dictionary containing address data with fields matching
+                 the AddressCreate schema (using camelCase field names)
+
+        Returns:
+            Response from the API
+        """
+        # Validate with Pydantic model - this will raise an error if required fields are missing
+        address_model = AddressCreate(**data)
+
+        if self.nmbrs.mock_mode:
+            return address_model
+
+        # Convert validated model to dict for API payload
+        payload = address_model.dict(exclude_none=True)
+
+        # Send request
+        resp = self.nmbrs.session.post(
+            url=f"{self.nmbrs.base_url}employees/{employee_id}/address",
+            json=payload,
+            timeout=self.nmbrs.timeout
+        )
+        return resp
+

brynq_sdk_nmbrs-1.3.1/brynq_sdk_nmbrs/bank.py

@@ -0,0 +1,123 @@
+import math
+import pandas as pd
+import requests
+from brynq_sdk_functions import Functions
+from typing import Dict, Any
+from .schemas.bank import BankGet, BankCreate, BankUpdate, BankDelete
+
+
+class Bank:
+    def __init__(self, nmbrs):
+        self.nmbrs = nmbrs
+
+    def get(self,
+            created_from: str = None) -> tuple[pd.DataFrame, pd.DataFrame]:
+        banks = pd.DataFrame()
+        for company in self.nmbrs.company_ids:
+            banks = pd.concat([banks, self._get(company, created_from)])
+
+        valid_banks, invalid_banks = Functions.validate_data(df=banks, schema=BankGet, debug=True)
+
+        return valid_banks, invalid_banks
+
+    def _get(self,
+            company_id: str,
+            created_from: str = None) -> pd.DataFrame:
+        params = {}
+        if created_from:
+            params['createdFrom'] = created_from
+        try:
+            request = requests.Request(method='GET',
+                                       url=f"{self.nmbrs.base_url}companies/{company_id}/employees/bankaccounts",
+                                       params=params)
+
+            data = self.nmbrs.get_paginated_result(request)
+            df = pd.json_normalize(
+                data,
+                record_path='bankAccounts',
+                meta=['employeeId']
+            )
+        except requests.HTTPError as e:
+            df = pd.DataFrame()
+
+        return df
+
+    def create(self, employee_id: str, data: Dict[str, Any]):
+        """
+        Create a new bank account for an employee using Pydantic validation.
+
+        Args:
+            employee_id: The ID of the employee
+            data: Dictionary containing bank account data in the format matching BankCreate schema
+
+        Returns:
+            Response from the API
+        """
+        # Validate with Pydantic model - this will raise an error if required fields are missing
+        bank_model = BankCreate(**data)
+
+        if self.nmbrs.mock_mode:
+            return bank_model
+
+        # Convert validated model to dict for API payload
+        payload = bank_model.dict(exclude_none=True)
+
+        # Send request
+        resp = self.nmbrs.session.post(
+            url=f"{self.nmbrs.base_url}employees/{employee_id}/bankaccount",
+            json=payload,
+            timeout=self.nmbrs.timeout
+        )
+        return resp
+
+    def update(self, employee_id: str, data: Dict[str, Any]):
+        """
+        Update a bank account for an employee using Pydantic validation.
+
+        Args:
+            employee_id: The ID of the employee
+            data: Dictionary containing bank account data in the format matching BankUpdate schema
+
+        Returns:
+            Response from the API
+        """
+        # Validate with Pydantic model - this will raise an error if required fields are missing
+        bank_model = BankUpdate(**data)
+
+        if self.nmbrs.mock_mode:
+            return bank_model
+
+        # Convert validated model to dict for API payload
+        payload = bank_model.dict(exclude_none=True)
+
+        # Send request
+        resp = self.nmbrs.session.put(
+            url=f"{self.nmbrs.base_url}employees/{employee_id}/bankaccount",
+            json=payload,
+            timeout=self.nmbrs.timeout
+        )
+        return resp
+
+    def delete(self, employee_id: str, bank_account_id: str):
+        """
+        Delete a bank account for an employee.
+
+        Args:
+            employee_id: The ID of the employee
+            bank_account_id: The ID of the bank account to delete
+
+        Returns:
+            Response from the API
+        """
+        # Create and validate a BankDelete model
+        bank_model = BankDelete(bankAccountId=bank_account_id)
+
+        if self.nmbrs.mock_mode:
+            return bank_model
+
+        # Send request
+        resp = self.nmbrs.session.delete(
+            url=f"{self.nmbrs.base_url}employees/{employee_id}/bankaccounts/{bank_account_id}",
+            timeout=self.nmbrs.timeout
+        )
+        return resp

{brynq_sdk_nmbrs-1.2.0 → brynq_sdk_nmbrs-1.3.1}/brynq_sdk_nmbrs/children.py

@@ -37,7 +37,6 @@ class Children:
                 record_path='functions',
                 meta=['employeeId']
             )
-            df = self.nmbrs._rename_camel_columns_to_snake_case(df)
         except requests.HTTPError as e:
             df = pd.DataFrame()
 

{brynq_sdk_nmbrs-1.2.0 → brynq_sdk_nmbrs-1.3.1}/brynq_sdk_nmbrs/companies.py

@@ -1,7 +1,8 @@
 import pandas as pd
 import requests
 import logging
-from .costcenter import Costcenter, Costunit
+from .costcenter import Costcenter
+from .costunit import Costunit
 from .hours import Hours
 from .bank import Bank
 from .function import Functions
@@ -23,7 +24,7 @@ class Companies:
         request = requests.Request(method='GET',
                                    url=f"{self.nmbrs.base_url}companies")
         data = self.nmbrs.get_paginated_result(request)
-        df = self.nmbrs._rename_camel_columns_to_snake_case(pd.DataFrame(data))
+        df = pd.DataFrame(data)
 
         return df
 
@@ -51,10 +52,6 @@ class Companies:
                 # Convert to DataFrame
                 df = pd.DataFrame(serialized_response)
                 
-                # Rename columns to snake_case
-                if not df.empty:
-                    df = self.nmbrs._rename_camel_columns_to_snake_case(df)
-                
                 return df
             else:
                 return pd.DataFrame()

brynq_sdk_nmbrs-1.3.1/brynq_sdk_nmbrs/contract.py

@@ -0,0 +1,128 @@
+import math
+import pandas as pd
+import requests
+from typing import Dict, Any
+from .schemas.contracts import ContractGet, ContractCreate, ContractUpdate, ContractDelete
+from brynq_sdk_functions import Functions
+
+
+class Contract:
+    def __init__(self, nmbrs):
+        self.nmbrs = nmbrs
+
+    def get(self,
+            created_from: str = None,
+            employee_id: str = None) -> (pd.DataFrame, pd.DataFrame):
+        contracts = pd.DataFrame()
+        for company in self.nmbrs.company_ids:
+            contracts = pd.concat([contracts, self._get(company, created_from, employee_id)])
+
+        valid_contracts, invalid_contracts = Functions.validate_data(df=contracts, schema=ContractGet, debug=True)
+
+        return valid_contracts, invalid_contracts
+
+    def _get(self,
+            company_id: str,
+            created_from: str = None,
+            employee_id: str = None) -> pd.DataFrame:
+        params = {}
+        if created_from:
+            params['createdFrom'] = created_from
+        if employee_id:
+            params['employeeId'] = employee_id
+        request = requests.Request(method='GET',
+                                   url=f"{self.nmbrs.base_url}companies/{company_id}/employees/contracts",
+                                   params=params)
+
+        data = self.nmbrs.get_paginated_result(request)
+        df = pd.json_normalize(
+            data,
+            record_path='contracts',
+            meta=['employeeId']
+        )
+
+        df['company_id'] = company_id
+
+        return df
+
+    def create(self, employee_id: str, data: Dict[str, Any]):
+        """
+        Create a new contract for an employee using Pydantic validation.
+
+        Args:
+            employee_id: The ID of the employee
+            data: Dictionary containing contract data with fields matching
+                 the ContractCreate schema (using camelCase field names)
+
+        Returns:
+            Response from the API
+        """
+        # Validate with Pydantic model - this will raise an error if required fields are missing
+        contract_model = ContractCreate(**data)
+
+        if self.nmbrs.mock_mode:
+            return contract_model
+
+        # Convert validated model to dict for API payload
+        payload = contract_model.dict(exclude_none=True)
+
+        # Send request
+        resp = self.nmbrs.session.post(
+            url=f"{self.nmbrs.base_url}employees/{employee_id}/contract",
+            json=payload,
+            timeout=self.nmbrs.timeout
+        )
+        return resp
+
+    def update(self, employee_id: str, data: Dict[str, Any]):
+        """
+        Update a contract for an employee using Pydantic validation.
+
+        Args:
+            employee_id: The ID of the employee
+            data: Dictionary containing contract data with fields matching
+                 the ContractUpdate schema (using camelCase field names)
+
+        Returns:
+            Response from the API
+        """
+        # Validate with Pydantic model - this will raise an error if required fields are missing
+        contract_model = ContractUpdate(**data)
+
+        if self.nmbrs.mock_mode:
+            return contract_model
+
+        # Convert validated model to dict for API payload
+        payload = contract_model.dict(exclude_none=True)
+
+        # Send request
+        resp = self.nmbrs.session.put(
+            url=f"{self.nmbrs.base_url}employees/{employee_id}/contract",
+            json=payload,
+            timeout=self.nmbrs.timeout
+        )
+        return resp
+
+    def delete(self, employee_id: str, contract_id: str):
+        """
+        Delete a contract for an employee.
+
+        Args:
+            employee_id: The ID of the employee
+            contract_id: The ID of the contract to delete
+
+        Returns:
+            Response from the API
+        """
+        # Create and validate a ContractDelete model
+        contract_model = ContractDelete(contractId=contract_id)
+
+        if self.nmbrs.mock_mode:
+            return contract_model
+
+        # Send request
+        resp = self.nmbrs.session.delete(
+            url=f"{self.nmbrs.base_url}employees/{employee_id}/contracts/{contract_id}",
+            timeout=self.nmbrs.timeout
+        )
+        return resp