brynq-sdk-factorial 2.3.0__py3-none-any.whl

brynq_sdk_factorial/__init__.py

@@ -0,0 +1,60 @@
+import requests
+from typing import List, Union, Optional, Literal
+from brynq_sdk_brynq import BrynQ
+from .compensations import Compensations
+from .employees import Employees
+from .companies import Companies
+from .contracts import Contracts
+from .files import Files
+from .costcenter import Costcenter
+from .locations import Locations
+from .payroll import Payroll
+from .teams import Teams
+from .workschedules import Workschedules
+from .family_situation import FamilySituation
+
+# Set the base class for Factorial. This class will be used to set the credentials and those will be used in all other classes.
+class Factorial(BrynQ):
+    def __init__(self, system_type: Optional[Literal['source', 'target']] = None, debug: bool = False, demo: bool = False):
+        """"
+        For the documentation of Factorial, see: https://apidoc.factorialhr.com/docs/authentication-1
+        """
+        super().__init__()
+        self.timeout = 3600
+        if demo:
+            self.base_url = 'https://api.demo.factorial.dev/api/2025-07-01/'
+            self.base_url_v1 = 'https://api.demo.factorial.dev/api/v1/'
+        else:
+            self.base_url = 'https://api.factorialhr.com/api/2025-07-01/'
+            self.base_url_v1 = 'https://api.factorialhr.com/api/v1/'
+        headers = self._get_credentials(system_type)
+        self.session = requests.Session()
+        self.session.headers.update(headers)
+        self.employees = Employees(self)
+        self.contracts = Contracts(self)
+        self.companies = Companies(self)
+        self.costcenter = Costcenter(self)
+        self.compensations = Compensations(self)
+        self.team = Teams(self)
+        self.locations = Locations(self)
+        self.payroll = Payroll(self)
+        self.workschedules = Workschedules(self)
+        self.files = Files(self)
+        self.family_situation = FamilySituation(self)
+        self.debug = debug
+
+    def _get_credentials(self, system_type):
+        """
+        Sets the credentials for the SuccessFactors API.
+        :param label (str): The label for the system credentials.
+        :returns: headers (dict): The headers for the API request, including the access token.
+        """
+        credentials = self.interfaces.credentials.get(system="factorial", system_type=system_type)
+        credentials = credentials.get('data')
+
+        headers = {
+            'Authorization': f"Bearer {credentials['access_token']}",
+            'Content-Type': 'application/json'
+        }
+
+        return headers

brynq_sdk_factorial/companies.py

@@ -0,0 +1,76 @@
+import requests
+import pandas as pd
+
+
+class Companies:
+    def __init__(self, factorial):
+        self.factorial = factorial
+        self.base_endpoint = '/resources/companies/legal_entities'
+
+    def get(self,
+            ids: list = None,
+            employees_ids: list[int] = None,
+            companies_ids: list[int] = None,
+            country_ids: list[int] = None) -> pd.DataFrame:
+
+        # Use locals() to get all function parameters as a dictionary. Do not move this down since it will include all variables in function scope
+        func_params = list(locals().items())
+        params = {}
+        for param, value in func_params:
+            if param != 'self' and value is not None:
+                params[param] = value
+
+        has_next_page = True
+        result_data = pd.DataFrame()
+        while has_next_page:
+            response = self.factorial.session.get(url=f'{self.factorial.base_url}{self.base_endpoint}',
+                                                  params=params,
+                                                  timeout=self.factorial.timeout)
+            response.raise_for_status()
+            response_data = response.json()
+            result_data = pd.concat([result_data, pd.DataFrame(response_data['data'])])
+            has_next_page = response_data['meta']['has_next_page']
+            if has_next_page:
+                params['after_id'] = response_data['meta']['end_cursor']
+
+        return result_data
+
+    def get_types(self,
+                  ids: list = None,
+                  legal_entity_ids: list[int] = None) -> pd.DataFrame:
+
+        # Use locals() to get all function parameters as a dictionary. Do not move this down since it will include all variables in function scope
+        func_params = locals().items()
+        params = {}
+        for param, value in func_params:
+            if param != 'self' and value is not None:
+                params[param] = value
+
+        has_next_page = True
+        result_data = pd.DataFrame()
+        while has_next_page:
+            response = self.factorial.session.get(url=f'{self.factorial.base_url}{self.base_endpoint}',
+                                                  params=params,
+                                                  timeout=self.factorial.timeout)
+            response.raise_for_status()
+            response_data = response.json()
+            result_data = pd.concat([result_data, pd.DataFrame(response_data['data'])])
+            has_next_page = response_data['meta']['has_next_page']
+            params['after_id'] = response_data['meta']['end_cursor']
+
+        return result_data
+
+    def update(self, company_id: str, data: dict) -> requests.Response:
+        response = self.factorial.session.put(url=f'{self.factorial.base_url}{self.base_endpoint}/{company_id}',
+                                              json=data,
+                                              timeout=self.factorial.timeout)
+        response.raise_for_status()
+        return response
+
+    def delete(self, company_id: str) -> requests.Response:
+        response = self.factorial.session.delete(url=f'{self.factorial.base_url}{self.base_endpoint}/{company_id}', timeout=self.factorial.timeout)
+        response.raise_for_status()
+        return response
+
+    def create(self, data: dict) -> requests.Response:
+        raise NotImplementedError

brynq_sdk_factorial/compensations.py

@@ -0,0 +1,80 @@
+import requests
+import pandas as pd
+
+
+class Compensations:
+    def __init__(self, factorial):
+        self.factorial = factorial
+        self.base_endpoint = '/resources/contracts/'
+
+    def get(self,
+            ids: list = None,
+            contract_version_id: list[int] = None) -> pd.DataFrame:
+
+        # Use locals() to get all function parameters as a dictionary. Do not move this down since it will include all variables in function scope
+        func_params = list(locals().items())
+        params = {}
+        for param, value in func_params:
+            if param != 'self' and value is not None:
+                params[param] = value
+
+        has_next_page = True
+        result_data = pd.DataFrame()
+        while has_next_page:
+            response = self.factorial.session.get(url=f'{self.factorial.base_url}{self.base_endpoint}compensations',
+                                                  params=params,
+                                                  timeout=self.factorial.timeout)
+            response.raise_for_status()
+            response_data = response.json()
+            result_data = pd.concat([result_data, pd.DataFrame(response_data['data'])])
+            has_next_page = response_data['meta']['has_next_page']
+            if has_next_page:
+                params['after_id'] = response_data['meta']['end_cursor']
+
+        taxonomies = self.get_types()
+        if not result_data.empty:
+            result_data = pd.merge(result_data, taxonomies, left_on='contracts_taxonomy_id', right_on='id', suffixes=('', '_taxonomy'))
+
+        return result_data
+
+    def get_types(self,
+                  ids: list = None,
+                  legal_entity_ids: list[int] = None,
+                  legal_entity_id: int = None) -> pd.DataFrame:
+
+        # Use locals() to get all function parameters as a dictionary. Do not move this down since it will include all variables in function scope
+        func_params = list(locals().items())
+        params = {}
+        for param, value in func_params:
+            if param != 'self' and value is not None:
+                params[param] = value
+
+        has_next_page = True
+        result_data = pd.DataFrame()
+        while has_next_page:
+            response = self.factorial.session.get(url=f'{self.factorial.base_url}{self.base_endpoint}taxonomies',
+                                                  params=params,
+                                                  timeout=self.factorial.timeout)
+            response.raise_for_status()
+            response_data = response.json()
+            result_data = pd.concat([result_data, pd.DataFrame(response_data['data'])])
+            has_next_page = response_data['meta']['has_next_page']
+            if has_next_page:
+                params['after_id'] = response_data['meta']['end_cursor']
+
+        return result_data
+
+    def update(self, compensation_id: str, data: dict) -> requests.Response:
+        response = self.factorial.session.put(url=f'{self.factorial.base_url}{self.base_endpoint}/{compensation_id}',
+                                              json=data,
+                                              timeout=self.factorial.timeout)
+        response.raise_for_status()
+        return response
+
+    def delete(self, compensation_id: str) -> requests.Response:
+        response = self.factorial.session.delete(url=f'{self.factorial.base_url}{self.base_endpoint}/{compensation_id}', timeout=self.factorial.timeout)
+        response.raise_for_status()
+        return response
+
+    def create(self, data: dict) -> requests.Response:
+        raise NotImplementedError

brynq_sdk_factorial/contracts.py

@@ -0,0 +1,50 @@
+import requests
+import pandas as pd
+
+
+class Contracts:
+    def __init__(self, factorial):
+        self.factorial = factorial
+        self.base_endpoint = '/resources/contracts/contract_versions'
+
+    def get(self,
+            ids: list = None,
+            employee_ids: list[int] = None,
+            date: str = None) -> pd.DataFrame:
+
+        # Use locals() to get all function parameters as a dictionary. Do not move this down since it will include all variables in function scope
+        func_params = list(locals().items())
+        params = {}
+        for param, value in func_params:
+            if param != 'self' and value is not None:
+                params[param] = value
+
+        has_next_page = True
+        result_data = pd.DataFrame()
+        while has_next_page:
+            response = self.factorial.session.get(url=f'{self.factorial.base_url}{self.base_endpoint}',
+                                                  params=params,
+                                                  timeout=self.factorial.timeout)
+            response.raise_for_status()
+            response_data = response.json()
+            result_data = pd.concat([result_data, pd.DataFrame(response_data['data'])])
+            has_next_page = response_data['meta']['has_next_page']
+            if has_next_page:
+                params['after_id'] = response_data['meta']['end_cursor']
+
+        return result_data
+
+    def update(self, contract_id: str, data: dict) -> requests.Response:
+        response = self.factorial.session.put(url=f'{self.factorial.base_url}{self.base_endpoint}/{contract_id}',
+                                              json=data,
+                                              timeout=self.factorial.timeout)
+        response.raise_for_status()
+        return response
+
+    def delete(self, contract_id: str) -> requests.Response:
+        response = self.factorial.session.delete(url=f'{self.factorial.base_url}{self.base_endpoint}/{contract_id}', timeout=self.factorial.timeout)
+        response.raise_for_status()
+        return response
+
+    def create(self, data: dict) -> requests.Response:
+        raise NotImplementedError

brynq_sdk_factorial/costcenter.py

@@ -0,0 +1,80 @@
+import requests
+import pandas as pd
+
+
+class Costcenter:
+    def __init__(self, factorial):
+        self.factorial = factorial
+        self.base_endpoint = '/resources/finance/cost_centers'
+
+    def get(self,
+            ids: list = None,
+            company_id: int = None,
+            legal_entity_ids: list = None,
+            include_actives_on_date: str = None,
+            search: str = None) -> pd.DataFrame:
+
+        # Use locals() to get all function parameters as a dictionary. Do not move this down since it will include all variables in function scope
+        func_params = locals().items()
+        params = {}
+        for param, value in func_params:
+            if param != 'self' and value is not None:
+                params[param] = value
+
+        has_next_page = True
+        result_data = pd.DataFrame()
+        while has_next_page:
+            response = self.factorial.session.get(url=f'{self.factorial.base_url}{self.base_endpoint}',
+                                                  params=params,
+                                                  timeout=self.factorial.timeout)
+            response.raise_for_status()
+            response_data = response.json()
+            result_data = pd.concat([result_data, pd.DataFrame(response_data['data'])])
+            has_next_page = response_data['meta']['has_next_page']
+            if has_next_page:
+                params['after_id'] = response_data['meta']['end_cursor']
+
+        return result_data
+
+    def get_membership(self,
+                       cost_center_id: int = None,
+                       employee_id: int = None,
+                       active_on: str = None,
+                       company_id: int = None) -> pd.DataFrame:
+
+        # Use locals() to get all function parameters as a dictionary. Do not move this down since it will include all variables in function scope
+        func_params = list(locals().items())
+        params = {}
+        for param, value in func_params:
+            if param != 'self' and value is not None:
+                params[param] = value
+
+        has_next_page = True
+        result_data = pd.DataFrame()
+        while has_next_page:
+            response = self.factorial.session.get(url=f'{self.factorial.base_url}/resources/finance/cost_center_memberships',
+                                                  params=params,
+                                                  timeout=self.factorial.timeout)
+            response.raise_for_status()
+            response_data = response.json()
+            result_data = pd.concat([result_data, pd.DataFrame(response_data['data'])])
+            has_next_page = response_data['meta']['has_next_page']
+            if has_next_page:
+                params['after_id'] = response_data['meta']['end_cursor']
+
+        return result_data
+
+    def update(self, costcenter_id: str, data: dict) -> requests.Response:
+        response = self.factorial.session.put(url=f'{self.factorial.base_url}{self.base_endpoint}/{costcenter_id}',
+                                              json=data,
+                                              timeout=self.factorial.timeout)
+        response.raise_for_status()
+        return response
+
+    def delete(self, costcenter_id: str) -> requests.Response:
+        response = self.factorial.session.delete(url=f'{self.factorial.base_url}{self.base_endpoint}/{costcenter_id}', timeout=self.factorial.timeout)
+        response.raise_for_status()
+        return response
+
+    def create(self, data: dict) -> requests.Response:
+        raise NotImplementedError

brynq_sdk_factorial/custom_fields.py

@@ -0,0 +1,76 @@
+from typing import Literal, List
+
+import requests
+import pandas as pd
+
+
+class CustomFields:
+    def __init__(self, factorial):
+        self.factorial = factorial
+        self.base_endpoint = '/resources/custom_fields/fields'
+
+    def get(self,
+            ids: list = None,
+            field_type: str = None,
+            label: str = None,
+            slug: str = None,
+            company_id: int = None
+            ) -> pd.DataFrame:
+
+        # Use locals() to get all function parameters as a dictionary. Do not move this down since it will include all variables in function scope
+        func_params = locals().items()
+        params = {}
+        for param, value in func_params:
+            if param != 'self' and value is not None:
+                params[param] = value
+
+        has_next_page = True
+        result_data = pd.DataFrame()
+        while has_next_page:
+            response = self.factorial.session.get(url=f'{self.factorial.base_url}{self.base_endpoint}',
+                                                  params=params,
+                                                  timeout=self.factorial.timeout)
+            response.raise_for_status()
+            response_data = response.json()
+            result_data = pd.concat([result_data, pd.DataFrame(response_data['data'])])
+            has_next_page = response_data['meta']['has_next_page']
+            params['after_id'] = response_data['meta']['end_cursor']
+
+        return result_data
+
+    def update(self, contract_id: str, data: dict) -> requests.Response:
+        response = self.factorial.session.put(url=f'{self.factorial.base_url}{self.base_endpoint}/{self.base_endpoint}',
+                                              json=data,
+                                              timeout=self.factorial.timeout)
+        response.raise_for_status()
+        return response
+
+    def delete(self, contract_id: str) -> requests.Response:
+        response = self.factorial.session.delete(url=f'{self.factorial.base_url}{self.base_endpoint}/{self.base_endpoint}', timeout=self.factorial.timeout)
+        response.raise_for_status()
+        return response
+
+    def create(self,
+               company_id: int,
+               editable: Literal['owned', 'reportees', 'teamleader',  'everybody'] = None,
+               visible: Literal['owned', 'reportees', 'teamleader',  'everybody'] = None,
+               label: str = None,
+               field_type: Literal['text', 'long_text', 'date', 'rating', 'checkbox', 'single_choice', 'multiple_choice', 'money', 'cents'] = None,
+               min_value: int = None,
+               max_value: int = None,
+               required: bool = None,
+               options: List[str] = None,
+               position: int = None
+               ) -> requests.Response:
+        # Use locals() to get all function parameters as a dictionary. Do not move this down since it will include all variables in function scope
+        func_params = list(locals().items())
+        data = {}
+        for param, value in func_params:
+            if param != 'self' and value is not None:
+                data[param] = value
+
+        response = self.factorial.session.post(url=f'{self.factorial.base_url}{self.base_endpoint}/{self.base_endpoint}',
+                                               data=data,
+                                               timeout=self.factorial.timeout)
+        response.raise_for_status()
+        return response 

brynq_sdk_factorial/employees.py

@@ -0,0 +1,57 @@
+import requests
+import pandas as pd
+
+
+class Employees:
+    def __init__(self, factorial):
+        self.factorial = factorial
+        self.base_endpoint = '/resources/employees/employees'
+
+    def get(self,
+            only_active: bool = False,
+            only_managers: bool = False,
+            ids: list = None,
+            access_ids: list[int] = None,
+            emails: list[str] = None,
+            full_text_name: str = None,
+            name_starts_with: str = None,
+            legal_entity_ids: list[int] = None,
+            team_ids: list[int] = None,
+            location_ids: list[int] = None) -> pd.DataFrame:
+
+        # Use locals() to get all function parameters as a dictionary. Do not move this down since it will include all variables in function scope
+        func_params = list(locals().items())
+        params = {}
+        for param, value in func_params:
+            if param != 'self' and value is not None:
+                params[param] = value
+
+        has_next_page = True
+        result_data = pd.DataFrame()
+        while has_next_page:
+            response = self.factorial.session.get(url=f'{self.factorial.base_url}{self.base_endpoint}',
+                                                  params=params,
+                                                  timeout=self.factorial.timeout)
+            response.raise_for_status()
+            response_data = response.json()
+            result_data = pd.concat([result_data, pd.DataFrame(response_data['data'])])
+            has_next_page = response_data['meta']['has_next_page']
+            if has_next_page:
+                params['after_id'] = response_data['meta']['end_cursor']
+
+        return result_data
+
+    def update(self, employee_id: str, data: dict) -> requests.Response:
+        response = self.factorial.session.put(url=f'{self.factorial.base_url}{self.base_endpoint}/{employee_id}',
+                                              json=data,
+                                              timeout=self.factorial.timeout)
+        response.raise_for_status()
+        return response
+
+    def delete(self, employee_id: str) -> requests.Response:
+        response = self.factorial.session.delete(url=f'{self.factorial.base_url}{self.base_endpoint}/{employee_id}', timeout=self.factorial.timeout)
+        response.raise_for_status()
+        return response
+
+    def create(self, data: dict) -> requests.Response:
+        raise NotImplementedError

brynq_sdk_factorial/family_situation.py

@@ -0,0 +1,50 @@
+import requests
+import pandas as pd
+
+
+class FamilySituation:
+    def __init__(self, factorial):
+        self.factorial = factorial
+        self.base_endpoint = '/resources/payroll/family_situations'
+
+    def get(self,
+            employee_ids: list[int] = None) -> pd.DataFrame:
+
+        # Use locals() to get all function parameters as a dictionary. Do not move this down since it will include all variables in function scope
+        func_params = list(locals().items())
+        params = {}
+        for param, value in func_params:
+            if param != 'self' and value is not None:
+                params[param] = value
+
+        has_next_page = True
+        result_data = pd.DataFrame()
+        while has_next_page:
+            response = self.factorial.session.get(url=f'{self.factorial.base_url}{self.base_endpoint}',
+                                                  params=params,
+                                                  timeout=self.factorial.timeout)
+            response.raise_for_status()
+            response_data = response.json()
+            result_data = pd.concat([result_data, pd.DataFrame(response_data['data'])])
+            has_next_page = response_data['meta']['has_next_page']
+            if has_next_page:
+                params['after_id'] = response_data['meta']['end_cursor']
+
+        return result_data
+
+    def create(self, data: dict) -> requests.Response:
+        response = self.factorial.session.post(url=f'{self.factorial.base_url}{self.base_endpoint}',
+                                               json=data,
+                                               timeout=self.factorial.timeout)
+        response.raise_for_status()
+        return response
+
+    def update(self, family_situation_id: str, data: dict) -> requests.Response:
+        response = self.factorial.session.put(url=f'{self.factorial.base_url}{self.base_endpoint}/{family_situation_id}',
+                                              json=data,
+                                              timeout=self.factorial.timeout)
+        response.raise_for_status()
+        return response
+
+    def delete(self, family_situation_id: str) -> requests.Response:
+        raise NotImplementedError

brynq_sdk_factorial/files.py

@@ -0,0 +1,22 @@
+import requests
+import pandas as pd
+
+
+class Files:
+
+    def __init__(self, core):
+        self.core = core
+        self.base_endpoint = '/core/employees'
+
+    def get(self) -> pd.DataFrame:
+        response = requests.get(f'{self.core.factorial.base_url_v1}{self.base_endpoint}', timeout=self.factorial.timeout)
+        response.raise_for_status()
+        return pd.DataFrame(response.json())
+
+    def update(self, employee_id: str, data: dict) -> requests.Response:
+        response = requests.put(f'{self.core.factorial.base_url_v1}{self.base_endpoint}/{employee_id}', json=data, timeout=self.factorial.timeout)
+        response.raise_for_status()
+        return response
+
+    def create(self, data: dict) -> requests.Response:
+        raise NotImplementedError

brynq_sdk_factorial/locations.py

@@ -0,0 +1,49 @@
+import requests
+import pandas as pd
+
+
+class Locations:
+    def __init__(self, factorial):
+        self.factorial = factorial
+        self.base_endpoint = '/resources/locations/locations'
+
+    def get(self,
+            ids: list = None,
+            employee_ids: list[int] = None) -> pd.DataFrame:
+
+        # Use locals() to get all function parameters as a dictionary. Do not move this down since it will include all variables in function scope
+        func_params = list(locals().items())
+        params = {}
+        for param, value in func_params:
+            if param != 'self' and value is not None:
+                params[param] = value
+
+        has_next_page = True
+        result_data = pd.DataFrame()
+        while has_next_page:
+            response = self.factorial.session.get(url=f'{self.factorial.base_url}{self.base_endpoint}',
+                                                  params=params,
+                                                  timeout=self.factorial.timeout)
+            response.raise_for_status()
+            response_data = response.json()
+            result_data = pd.concat([result_data, pd.DataFrame(response_data['data'])])
+            has_next_page = response_data['meta']['has_next_page']
+            if has_next_page:
+                params['after_id'] = response_data['meta']['end_cursor']
+
+        return result_data
+
+    def update(self, location_id: str, data: dict) -> requests.Response:
+        response = self.factorial.session.put(url=f'{self.factorial.base_url}{self.base_endpoint}/{location_id}',
+                                              json=data,
+                                              timeout=self.factorial.timeout)
+        response.raise_for_status()
+        return response
+
+    def delete(self, location_id: str) -> requests.Response:
+        response = self.factorial.session.delete(url=f'{self.factorial.base_url}{self.base_endpoint}/{location_id}', timeout=self.factorial.timeout)
+        response.raise_for_status()
+        return response
+
+    def create(self, data: dict) -> requests.Response:
+        raise NotImplementedError

brynq_sdk_factorial/payroll.py

@@ -0,0 +1,54 @@
+import requests
+import pandas as pd
+
+
+class Payroll:
+    def __init__(self, factorial):
+        self.factorial = factorial
+        self.base_endpoint = '/resources/payroll/supplements'
+
+    def get(self,
+            to_date: str = None, # YYYY-MM-DD
+            from_date: str = None, # YYYY-MM-DD
+            legal_entity_ids: list = None,
+            policy_period_ids: list = None,
+            compensation_id: int = None,
+            ids: list = None,
+            employee_ids: list[int] = None) -> pd.DataFrame:
+
+        # Use locals() to get all function parameters as a dictionary. Do not move this down since it will include all variables in function scope
+        func_params = list(locals().items())
+        params = {}
+        for param, value in func_params:
+            if param != 'self' and value is not None:
+                params[param] = value
+
+        has_next_page = True
+        result_data = pd.DataFrame()
+        while has_next_page:
+            response = self.factorial.session.get(url=f'{self.factorial.base_url}{self.base_endpoint}',
+                                                  params=params,
+                                                  timeout=self.factorial.timeout)
+            response.raise_for_status()
+            response_data = response.json()
+            result_data = pd.concat([result_data, pd.DataFrame(response_data['data'])])
+            has_next_page = response_data['meta']['has_next_page']
+            if has_next_page:
+                params['after_id'] = response_data['meta']['end_cursor']
+
+        return result_data
+
+    def update(self, supplement_id: str, data: dict) -> requests.Response:
+        response = self.factorial.session.put(url=f'{self.factorial.base_url}{self.base_endpoint}/{supplement_id}',
+                                              json=data,
+                                              timeout=self.factorial.timeout)
+        response.raise_for_status()
+        return response
+
+    def delete(self, supplement_id: str) -> requests.Response:
+        response = self.factorial.session.delete(url=f'{self.factorial.base_url}{self.base_endpoint}/{supplement_id}', timeout=self.factorial.timeout)
+        response.raise_for_status()
+        return response
+
+    def create(self, data: dict) -> requests.Response:
+        raise NotImplementedError