brynq-sdk-nmbrs 2.3.4.dev0__tar.gz → 2.4.5__tar.gz

{brynq_sdk_nmbrs-2.3.4.dev0 → brynq_sdk_nmbrs-2.4.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: brynq_sdk_nmbrs
-Version: 2.3.4.dev0
+Version: 2.4.5
 Summary: Nmbrs wrapper from BrynQ
 Author: BrynQ
 Author-email: support@brynq.com

{brynq_sdk_nmbrs-2.3.4.dev0 → brynq_sdk_nmbrs-2.4.5}/brynq_sdk_nmbrs/__init__.py

@@ -17,14 +17,14 @@ from .children import Children
 from .companies import Companies
 from .contract import Contract
 from .costcenter import Costcenter, EmployeeCostcenter
-from .costunit import Costunit
 from .days import FixedDays, VariableDays
 from .debtors import Debtors
 from .department import Departments, EmployeeDepartment
-from .document import EmployeeDocument, Payslip
+from .document import Document
 from .employee_wage_tax_settings import EmployeeWageTaxSettings
 from .employees import Employees
 from .employment import Employment
+from .extra_fields import EmployeeExtraFields, ExtraFieldSettings
 from .function import EmployeeFunction, Functions
 from .hours import FixedHours, VariableHours
 from .leave import Leave, LeaveBalance, LeaveGroup
@@ -32,115 +32,119 @@ from .manager import EmployeeManager, Manager
 from .salaries import Salaries
 from .salary_tables import SalaryScales, SalarySteps, SalaryTables
 from .schedules import Schedule
-from .wage_tax import WageTax, WageTaxSettings
+from .svw_settings import CompanySVWSettings, EmployeeSVWSettings
+from .wage_tax import CompanyWageTax, WageTax
 from .wagecomponents import EmployeeFixedWageComponents, EmployeeVariableWageComponents
 
 
 class Nmbrs(BrynQ):
-    def __init__(self, system_type: Optional[Literal['source', 'target']] = None, debug: bool = False, mock_mode: bool = True):
+    def __init__(self, system_type: Optional[Literal['source', 'target']] = None, debug: bool = False):
         """
         Initialize the Nmbrs class.
 
         Args:
-            label: The label of the system in BrynQ. legacy
+            system_type: The type of system ('source' or 'target')
             debug: Whether to print debug information
-            mock_mode: If true, data will NOT be sent to Nmbrs but only be tested for validity against Pydantic schemas
         """
-        self.mock_mode = mock_mode
+        super().__init__()
+        self.mock_mode = False  # Always disabled, kept for backwards compatibility with existing code
         self.debug = debug
         self.timeout = 3600
         self.system_type = system_type
+        self.data_interface_id = os.getenv("DATA_INTERFACE_ID")
+
+        # Fetch and store credentials
+        credentials = self.interfaces.credentials.get(system="nmbrs", system_type=system_type)
+        if isinstance(credentials, list):
+            credentials = credentials[0] if credentials else {}
+        if not isinstance(credentials, dict):
+            credentials = {}
+        self._credentials = credentials.get("data", credentials) or {}
+        self._custom_config = (
+            credentials.get("custom_config")
+            or credentials.get("custom_data")
+            or {}
+        )
+
+        headers = self._get_request_headers()
+        self.base_url = "https://api.nmbrsapp.com/api/"
+        self.session = requests.Session()
+        self.session.headers.update(headers)
 
-        # Initialize classes that work in both mock and real mode
+        # Initialize SOAP client
+        self.soap_settings = Settings(
+            strict=False,
+            xml_huge_tree=True,
+            force_https=True
+        )
+        self.soap_client_companies = Client(
+            'https://api.nmbrs.nl/soap/v3/CompanyService.asmx?wsdl',
+            settings=self.soap_settings
+        )
+        self.soap_client_employees = Client(
+            'https://api.nmbrs.nl/soap/v3/EmployeeService.asmx?wsdl',
+            settings=self.soap_settings
+        )
+        self.soap_auth_header = self._get_soap_auth_header()
+        self.companies = Companies(self)
+        # Following methods can only be used if the SOAP authentication header is set (optional, this is not always in scope for all integrations)
+        if self.soap_auth_header is not None:
+            self.soap_company_ids = self.companies.get_soap_ids()
+            self.salary_tables = SalaryTables(self)
+            self.salary_scales = SalaryScales(self)
+            self.salary_steps = SalarySteps(self)
+            self.wage_tax = WageTax(self)
+            self.absence = Absence(self)
+            self.children = Children(self)
         self.address = Address(self)
         self.bank = Bank(self)
-        self.children = Children(self)
+        self.cost_center = Costcenter(self)
+        self.employee_cost_center = EmployeeCostcenter(self)
+        if self.soap_auth_header is None:
+            self.children = Children(self)
+        self.debtor = Debtors(self)
         self.contract = Contract(self)
+        self.employee_department = EmployeeDepartment(self)
+        self.department = Departments(self)
+        debtors, _ = self.debtor.get()
+        self.debtor_ids = debtors['debtor_id'].to_list()
+        self.company_ids = self.companies.get()['companyId'].to_list()
+        self.employees = Employees(self)
+        self.employment = Employment(self)
+        self.employee_function = EmployeeFunction(self)
+        self.function = Functions(self)
+        self.fixed_hours = FixedHours(self)
+        self.fixed_days = FixedDays(self)
+        self.variable_hours = VariableHours(self)
+        self.variable_days = VariableDays(self)
+        self.manager = Manager(self)
+        self.employee_manager = EmployeeManager(self)
+        self.salaries = Salaries(self)
+        self.schedule = Schedule(self)
+        self.fixed_wagecomponents = EmployeeFixedWageComponents(self)
+        self.variable_wagecomponents = EmployeeVariableWageComponents(self)
+        self.current_period = self.companies.get_current_period()
+
+        self.company_wage_tax = CompanyWageTax(self)
+        self.documents = Document(self)
+        self.company_svw_settings = CompanySVWSettings(self)
+        self.employee_svw_settings = EmployeeSVWSettings(self)
+        self.employee_wage_tax_settings = EmployeeWageTaxSettings(self)
+        self.extra_field_settings = ExtraFieldSettings(self)
+        self.employee_extra_fields = EmployeeExtraFields(self)
         self.leave = Leave(self)
-        self.leave_group = LeaveGroup(self)
-        self.function = EmployeeFunction(self)
-        self.functions = Functions(self)
-        self.employee_document = EmployeeDocument(self)
-        self.departments = Departments(self)
-        self.debtor = Debtors(self)
-        self.companies = Companies(self)
+        self.leave_balance = LeaveBalance(self)
+        self.leave_groups = LeaveGroup(self)
+
 
-        if mock_mode is False:
-            # Initialize BrynQ parent class for REST API credentials
-            super().__init__()
-            self.data_interface_id = os.getenv("DATA_INTERFACE_ID")
-
-            # Get credentials once and store
-            self._credentials = self.interfaces.credentials.get(system='nmbrs', system_type=self.system_type)
-            self._custom_config = self._credentials.get("custom_data", {})
-
-            headers = self._get_request_headers()
-            self.base_url = "https://api.nmbrsapp.com/api/"
-            self.session = requests.Session()
-            self.session.headers.update(headers)
-
-            # Initialize SOAP clients
-            self.soap_settings = Settings(
-                strict=False,
-                xml_huge_tree=True,
-                force_https=True
-            )
-            self.soap_client_companies = Client(
-                'https://api.nmbrs.nl/soap/v3/CompanyService.asmx?wsdl',
-                settings=self.soap_settings
-            )
-            self.soap_client_employees = Client(
-                'https://api.nmbrs.nl/soap/v3/EmployeeService.asmx?wsdl',
-                settings=self.soap_settings
-            )
-            self.soap_client_debtors = Client(
-                'https://api.nmbrs.nl/soap/v3/DebtorService.asmx?wsdl',
-                settings=self.soap_settings
-            )
-            # Create auth headers for each service (namespace must match)
-            self.soap_auth_header = self._create_soap_auth_header(self.soap_client_companies)
-            self.soap_auth_header_employees = self._create_soap_auth_header(self.soap_client_employees)
-            self.soap_auth_header_debtors = self._create_soap_auth_header(self.soap_client_debtors)
-
-            # REST API dependent classes
-            self.employee_department = EmployeeDepartment(self)
-
-            debtors, _ = self.debtor.get()
-            self.debtor_ids = debtors['debtor_id'].to_list()
-            self.company_ids = self.companies.get()['companyId'].to_list()
-
-            # SOAP dependent on REST - companies must be defined first
-            if self.soap_auth_header is not None:
-                self.employees = Employees(self)
-                self.soap_company_ids = self.companies.get_soap_ids()
-                self.soap_employee_ids = self.employees.get_soap_ids()
-                self.salary_tables = SalaryTables(self)
-                self.salary_scales = SalaryScales(self)
-                self.salary_steps = SalarySteps(self)
-                self.wage_tax = WageTax(self)
-                self.absence = Absence(self)
-
-            self.employees = Employees(self)
-            self.employment = Employment(self)
-            self.wage_tax_settings = WageTaxSettings(self)
-            self.fixed_hours = FixedHours(self)
-            self.fixed_days = FixedDays(self)
-            self.variable_hours = VariableHours(self)
-            self.variable_days = VariableDays(self)
-            self.manager = Manager(self)
-            self.employee_manager = EmployeeManager(self)
-            self.salaries = Salaries(self)
-            self.schedule = Schedule(self)
-            self.fixed_wagecomponents = EmployeeFixedWageComponents(self)
-            self.variable_wagecomponents = EmployeeVariableWageComponents(self)
-            self.current_period = self.companies.get_current_period()
-            self.cost_center = Costcenter(self)
-            self.employee_cost_center = EmployeeCostcenter(self)
-            self.cost_unit = Costunit(self)
-            self.employee_wage_tax_settings = EmployeeWageTaxSettings(self)
     def _get_request_headers(self):
-        access_token = self._credentials.get('data').get('access_token')
-        subscription_key = self._custom_config.get("subscription_key")
+        access_token = self._credentials.get('access_token')
+        subscription_key = (
+            self._custom_config.get("subscription_key")
+            or self._custom_config.get("subscriptionKey")
+            or self._credentials.get("subscription_key")
+            or self._credentials.get("subscriptionKey")
+        )
         headers = {
             "accept": "application/json",
             "Authorization": f"Bearer {access_token.strip() if access_token else ''}",

{brynq_sdk_nmbrs-2.3.4.dev0 → brynq_sdk_nmbrs-2.4.5}/brynq_sdk_nmbrs/absence.py

@@ -1,11 +1,8 @@
-from typing import Any, Dict, List, Union, Tuple
+from typing import Any, Dict, Tuple
 import pandas as pd
 from .schemas.absence import AbsenceCreate, AbsenceGet
 from zeep.exceptions import Fault
-from zeep.ns import WSDL, SOAP_ENV_11
-from zeep.xsd import ComplexType, Element, String
 from zeep.helpers import serialize_object
-# import logging
 from brynq_sdk_functions import Functions
 
 

brynq_sdk_nmbrs-2.4.5/brynq_sdk_nmbrs/address.py

@@ -0,0 +1,70 @@
+from typing import Any, Dict
+
+import pandas as pd
+import requests
+
+from brynq_sdk_functions import Functions
+
+from .schemas.address import AddressCreate, AddressGet
+
+
+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
+        nested_data = self.nmbrs.flat_dict_to_nested_dict(data, AddressCreate)
+        address_model = AddressCreate(**nested_data)
+
+        if self.nmbrs.mock_mode:
+            return address_model
+
+        # Convert validated model to dict for API payload
+        payload = address_model.model_dump(exclude_none=True, by_alias=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-2.3.4.dev0 → brynq_sdk_nmbrs-2.4.5}/brynq_sdk_nmbrs/bank.py

@@ -1,4 +1,3 @@
-import math
 from typing import Any, Dict
 
 import pandas as pd
@@ -40,7 +39,7 @@ class Bank:
                 record_path='bankAccounts',
                 meta=['employeeId']
             )
-        except requests.HTTPError as e:
+        except requests.HTTPError:
             df = pd.DataFrame()
 
         return df

brynq_sdk_nmbrs-2.4.5/brynq_sdk_nmbrs/companies.py

@@ -0,0 +1,228 @@
+import logging
+from typing import TYPE_CHECKING, Optional
+
+import pandas as pd
+import requests
+from zeep.exceptions import Fault
+from zeep.helpers import serialize_object
+
+from .bank import Bank
+from .costcenter import Costcenter
+from .costunit import Costunit
+from .hours import Hours
+from .leave import LeaveGroup
+
+if TYPE_CHECKING:
+    from brynq_sdk_nmbrs import Nmbrs
+
+
+class Companies:
+    def __init__(self, nmbrs):
+        self.nmbrs: Nmbrs = nmbrs
+        self.costcenters = Costcenter(nmbrs)
+        self.costunits = Costunit(nmbrs)
+        self.hours = Hours(nmbrs)
+        self.banks = Bank(nmbrs)
+        self.logger = logging.getLogger(__name__)
+        self.leave_groups = LeaveGroup(nmbrs)
+
+    @property
+    def soap_client_companies(self):
+        return self.nmbrs.soap_client_companies
+
+    def get(self) -> pd.DataFrame:
+        try:
+            request = requests.Request(method='GET',
+                                    url=f"{self.nmbrs.base_url}companies")
+            data = self.nmbrs.get_paginated_result(request)
+            df = pd.DataFrame(data)
+        except requests.HTTPError as e:
+            if e.response.status_code == 403 and e.response.json().get("title") == "ForbiddenMultiDebtor.":
+                df = pd.DataFrame()
+                for debtor_id in self.nmbrs.debtor_ids:
+                    request = requests.Request(method='GET',
+                                        url=f"{self.nmbrs.base_url}debtors/{debtor_id}/companies")
+                    data = self.nmbrs.get_paginated_result(request)
+                    df = pd.concat([df, pd.DataFrame(data)])
+            else:
+                raise e
+        # TODO: add validation
+
+        return df
+
+    def get_soap_ids(self) -> pd.DataFrame:
+        """
+        Get all companies using the SOAP API.
+
+        Returns:
+            pd.DataFrame: DataFrame containing all companies
+        """
+        try:
+            # Make SOAP request with the proper header structure
+            response = self.nmbrs.soap_client_companies.service.List_GetAll(
+                _soapheaders=[self.nmbrs.soap_auth_header]
+            )
+
+            # Convert response to DataFrame
+            if response:
+                # Convert Zeep objects to Python dictionaries
+                serialized_response = serialize_object(response)
+
+                # TODO: add validation here
+                # Convert to DataFrame
+                df = pd.DataFrame(serialized_response)
+                df = self.nmbrs._rename_camel_columns_to_snake_case(df)
+
+                return df
+            else:
+                return pd.DataFrame()
+
+        except Fault as e:
+            raise Exception(f"SOAP request failed: {str(e)}")
+        except Exception as e:
+            self.logger.exception("Exception occurred:")
+            raise Exception(f"Failed to get companies: {str(e)}")
+
+    def get_current_period(self) -> int:
+        try:
+            df = pd.DataFrame()
+            for company_id in self.nmbrs.company_ids:
+                request = requests.Request(method='GET',
+                                    url=f"{self.nmbrs.base_url}companies/{company_id}/period")
+                data = self.nmbrs.get_paginated_result(request)
+                df_temp = pd.json_normalize(data)
+                df_temp['company_id'] = company_id
+                df = pd.concat([df, df_temp])
+
+            return df
+        except Exception as e:
+            self.logger.exception("Exception occurred:")
+            raise Exception(f"Failed to get current period: {str(e)}")
+
+    def get_wage_models(self,
+                        company_id: Optional[str] = None,
+                        period: Optional[int] = None,
+                        year: Optional[int] = None) -> pd.DataFrame:
+        """
+        Get company wage models per period.
+
+        Returns the available wage codes for employees of this company in the
+        period consulted. If no period is used it returns the current period information.
+
+        Args:
+            company_id: Optional company ID. If not provided, fetches for all companies.
+            period: Optional period filter
+            year: Optional year filter
+
+        Returns:
+            DataFrame containing wage models
+        """
+        if company_id:
+            return self._get_wage_models(company_id, period, year)
+
+        df = pd.DataFrame()
+        for company in self.nmbrs.company_ids:
+            df = pd.concat([df, self._get_wage_models(company, period, year)])
+
+        return df
+
+    def _get_wage_models(self,
+                         company_id: str,
+                         period: Optional[int] = None,
+                         year: Optional[int] = None) -> pd.DataFrame:
+        """
+        Internal method to get wage models for a single company.
+        """
+        params = {}
+        if period is not None:
+            params['period'] = period
+        if year is not None:
+            params['year'] = year
+
+        request = requests.Request(
+            method='GET',
+            url=f"{self.nmbrs.base_url}companies/{company_id}/wagemodels",
+            params=params
+        )
+
+        data = self.nmbrs.get_paginated_result(request)
+        df = pd.DataFrame(data)
+
+        if not df.empty:
+            df['companyId'] = company_id
+
+        return df
+
+    def get_addresses(self, company_id: Optional[str] = None) -> pd.DataFrame:
+        """
+        Get addresses history for a company.
+
+        Args:
+            company_id: Optional company ID. If not provided, fetches for all companies.
+
+        Returns:
+            DataFrame containing company addresses
+        """
+        if company_id:
+            return self._get_addresses(company_id)
+
+        df = pd.DataFrame()
+        for company in self.nmbrs.company_ids:
+            df = pd.concat([df, self._get_addresses(company)])
+
+        return df
+
+    def _get_addresses(self, company_id: str) -> pd.DataFrame:
+        """
+        Internal method to get addresses for a single company.
+        """
+        request = requests.Request(
+            method='GET',
+            url=f"{self.nmbrs.base_url}companies/{company_id}/addresses"
+        )
+
+        data = self.nmbrs.get_paginated_result(request)
+        df = pd.DataFrame(data)
+
+        if not df.empty:
+            df['companyId'] = company_id
+
+        return df
+
+    def get_contact_persons(self, company_id: Optional[str] = None) -> pd.DataFrame:
+        """
+        Get contact persons for a company.
+
+        There's no history on these values.
+
+        Args:
+            company_id: Optional company ID. If not provided, fetches for all companies.
+
+        Returns:
+            DataFrame containing contact persons
+        """
+        if company_id:
+            return self._get_contact_persons(company_id)
+
+        df = pd.DataFrame()
+        for company in self.nmbrs.company_ids:
+            df = pd.concat([df, self._get_contact_persons(company)])
+
+        return df
+
+    def _get_contact_persons(self, company_id: str) -> pd.DataFrame:
+        """
+        Internal method to get contact persons for a single company.
+        """
+        request = requests.Request(
+            method='GET',
+            url=f"{self.nmbrs.base_url}companies/{company_id}/contactpersons"
+        )
+
+        data = self.nmbrs.get_paginated_result(request)
+        df = pd.DataFrame(data)
+
+        if not df.empty:
+            df['companyId'] = company_id
+
+        return df

{brynq_sdk_nmbrs-2.3.4.dev0 → brynq_sdk_nmbrs-2.4.5}/brynq_sdk_nmbrs/contract.py

@@ -1,4 +1,3 @@
-import math
 import pandas as pd
 import requests
 from typing import Dict, Any

{brynq_sdk_nmbrs-2.3.4.dev0 → brynq_sdk_nmbrs-2.4.5}/brynq_sdk_nmbrs/days.py

@@ -2,7 +2,7 @@ import pandas as pd
 import requests
 from typing import Dict, Any
 from .schemas.days import (
-    VariableDaysGet, VariableDaysCreate, FixedDaysCreate, FixedDaysGet
+    VariableDaysGet, VariableDaysCreate, FixedDaysCreate
 )
 from brynq_sdk_functions import Functions
 

brynq_sdk_nmbrs-2.4.5/brynq_sdk_nmbrs/debtors.py

@@ -0,0 +1,87 @@
+
+import pandas as pd
+import requests
+
+from brynq_sdk_functions import Functions
+
+from .department import Departments
+from .function import Functions as NmbrsFunctions
+from .schemas.debtor import DebtorsGet
+
+
+class Debtors:
+    """
+    Class for handling debtor information.
+
+    Endpoints:
+        - GET /api/debtors
+        - GET /api/debtors/info
+        - GET /api/debtors/endcontractreasons/{Year}
+    """
+
+    def __init__(self, nmbrs):
+        self.nmbrs = nmbrs
+        self.departments = Departments(nmbrs)
+        self.functions = NmbrsFunctions(nmbrs)
+
+    def get(self) -> tuple:
+        """
+        Get a list of all debtors for the authenticated user.
+
+        Returns:
+            Tuple of (valid_data, invalid_data) DataFrames
+        """
+        request = requests.Request(method='GET',
+                                   url=f"{self.nmbrs.base_url}debtors")
+        data = self.nmbrs.get_paginated_result(request)
+
+        df = pd.DataFrame(data)
+
+        valid_debtors, invalid_debtors = Functions.validate_data(df=df, schema=DebtorsGet, debug=True)
+
+        return valid_debtors, invalid_debtors
+
+    def get_info(self) -> pd.DataFrame:
+        """
+        Get information about the authenticated debtor.
+
+        Returns info about the debtor that the API keys belong to,
+        including current settings and subscription details.
+
+        Returns:
+            DataFrame containing debtor info
+        """
+        resp = self.nmbrs.session.get(
+            url=f"{self.nmbrs.base_url}debtors/info",
+            timeout=self.nmbrs.timeout
+        )
+        resp.raise_for_status()
+        data = resp.json()
+
+        # Normalize the response if it's a dict
+        if isinstance(data, dict):
+            df = pd.json_normalize(data)
+        else:
+            df = pd.DataFrame(data)
+
+        return df
+
+    def get_end_contract_reasons(self, year: int) -> pd.DataFrame:
+        """
+        Get the available end contract reasons for a specific year.
+
+        Args:
+            year: The year to get end contract reasons for
+
+        Returns:
+            DataFrame containing end contract reasons
+        """
+        request = requests.Request(
+            method='GET',
+            url=f"{self.nmbrs.base_url}debtors/endcontractreasons/{year}"
+        )
+
+        data = self.nmbrs.get_paginated_result(request)
+        df = pd.DataFrame(data)
+
+        return df