oneCInteraction 1.0.0__tar.gz

onecinteraction-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 agcl-x
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

onecinteraction-1.0.0/PKG-INFO

@@ -0,0 +1,54 @@
+Metadata-Version: 2.4
+Name: oneCInteraction
+Version: 1.0.0
+Summary: A Python library for interacting with 1C:Enterprise databases via COM connection.
+Author: agcl
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: Microsoft :: Windows
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pytz
+Requires-Dist: pywin32; platform_system == "Windows"
+Dynamic: license-file
+
+# 1C Interaction Library (`onec_interaction`)
+
+A modular, clean Python library for interacting with 1C:Enterprise databases using Windows COM connection (`V83.COMConnector`).
+
+## Installation
+
+Install the package locally in editable mode:
+```bash
+pip install -e .
+```
+
+## Basic Usage
+
+```python
+from onec_interaction import Connection, Customer, Order, OrderItem
+
+# 1. Initialize the connection details
+c_conn = Connection(
+    s_oneCDatabasePathIn="C:\\Path\\To\\1C\\Database",
+    s_usernameIn="admin",
+    s_passwordIn="password"
+)
+
+# 2. Configure default parameters
+c_conn.s_warehouse_code = "WH001"
+c_conn.s_counteragent_code = "CA001"
+c_conn.s_organisation_code = "ORG001"
+
+# 3. Establish COM connection
+c_conn.initiate_connection()
+
+# 4. Use composition managers
+# Fetch product details
+c_product = c_conn.nomenclature.get(s_articleIn="ART001")
+print(f"Product: {c_product.s_name}, Price: {c_product.l_variety[0].n_price}")
+
+# Close connection when done
+c_conn.close_connection()
+```

onecinteraction-1.0.0/README.md

@@ -0,0 +1,39 @@
+# 1C Interaction Library (`onec_interaction`)
+
+A modular, clean Python library for interacting with 1C:Enterprise databases using Windows COM connection (`V83.COMConnector`).
+
+## Installation
+
+Install the package locally in editable mode:
+```bash
+pip install -e .
+```
+
+## Basic Usage
+
+```python
+from onec_interaction import Connection, Customer, Order, OrderItem
+
+# 1. Initialize the connection details
+c_conn = Connection(
+    s_oneCDatabasePathIn="C:\\Path\\To\\1C\\Database",
+    s_usernameIn="admin",
+    s_passwordIn="password"
+)
+
+# 2. Configure default parameters
+c_conn.s_warehouse_code = "WH001"
+c_conn.s_counteragent_code = "CA001"
+c_conn.s_organisation_code = "ORG001"
+
+# 3. Establish COM connection
+c_conn.initiate_connection()
+
+# 4. Use composition managers
+# Fetch product details
+c_product = c_conn.nomenclature.get(s_articleIn="ART001")
+print(f"Product: {c_product.s_name}, Price: {c_product.l_variety[0].n_price}")
+
+# Close connection when done
+c_conn.close_connection()
+```

onecinteraction-1.0.0/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["setuptools>=61.0.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "oneCInteraction"
+version = "1.0.0"
+description = "A Python library for interacting with 1C:Enterprise databases via COM connection."
+readme = "README.md"
+requires-python = ">=3.8"
+authors = [
+    { name = "agcl" }
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: Microsoft :: Windows",
+]
+dependencies = [
+    "pytz",
+    "pywin32; platform_system == 'Windows'"
+]

onecinteraction-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

onecinteraction-1.0.0/src/oneCInteraction/__init__.py

@@ -0,0 +1,21 @@
+from .connection import Connection
+from .structures import (
+    Nomenclature,
+    Variety,
+    Characteristic,
+    Group,
+    Customer,
+    OrderItem,
+    Order
+)
+
+__all__ = [
+    'Connection',
+    'Nomenclature',
+    'Variety',
+    'Characteristic',
+    'Group',
+    'Customer',
+    'OrderItem',
+    'Order'
+]

onecinteraction-1.0.0/src/oneCInteraction/characteristics.py

@@ -0,0 +1,109 @@
+from .log import log_sys
+from . import structures
+
+class CharacteristicsManager:
+    def __init__(self, c_connectionIn):
+        self.c_connection = c_connectionIn
+
+    @property
+    def c_v8(self):
+        return self.c_connection.c_v8
+
+    @staticmethod
+    def parse_name(s_charNameIn: str) -> list:
+        """Parses a characteristic name string into a list of Characteristic objects."""
+        if not s_charNameIn or s_charNameIn in ["NULL", "Без характеристики"]:
+            return []
+            
+        if " - " in s_charNameIn:
+            l_parts = s_charNameIn.split(" - ")
+            s_value = l_parts[1] if len(l_parts) > 1 else l_parts[0]
+            return [structures.Characteristic("Характеристика", s_value)]
+        elif ":" in s_charNameIn:
+            l_parts = s_charNameIn.split(":")
+            s_name = l_parts[0].strip()
+            s_value = l_parts[1].strip() if len(l_parts) > 1 else ""
+            return [structures.Characteristic(s_name, s_value)]
+        else:
+            return [structures.Characteristic("Характеристика", s_charNameIn)]
+
+    def get(self, c_charRefIn, s_charNameIn: str = "") -> list:
+        """Fetches characteristic properties from registry or parses description."""
+        l_characteristics = []
+        if c_charRefIn is not None and not c_charRefIn.IsEmpty():
+            try:
+                c_query = self.c_v8.NewObject("Query")
+                c_query.Text = """
+                    SELECT
+                        Properties.Свойство.Наименование AS PropName,
+                        Properties.Значение.Наименование AS ValName
+                    FROM
+                        РегистрСведений.ЗначенияСвойствОбъектов AS Properties
+                    WHERE
+                        Properties.Объект = &CharRef
+                """
+                c_query.SetParameter("CharRef", c_charRefIn)
+                c_res = c_query.Execute()
+                if c_res is not None and not c_res.IsEmpty():
+                    c_sel = c_res.Select()
+                    while c_sel.Next():
+                        l_characteristics.append(structures.Characteristic(c_sel.PropName, c_sel.ValName))
+            except Exception as e:
+                log_sys(f"Error fetching characteristics for {s_charNameIn}: {e}", 1)
+        
+        # Fallback to string parsing if properties were not found in registry
+        if not l_characteristics:
+            l_characteristics = self.parse_name(s_charNameIn)
+        
+        return l_characteristics
+
+    def get_variety(self, c_charRefIn, s_charNameIn: str, n_priceIn: float, n_priceOptIn: float, d_stocksIn: dict):
+        """Creates a Variety object with its characteristics and stock counts."""
+        l_characteristics = self.get(c_charRefIn, s_charNameIn)
+        return structures.Variety(
+            n_priceIn=n_priceIn,
+            n_priceOptIn=n_priceOptIn,
+            d_countIn=d_stocksIn,
+            l_characteristicsIn=l_characteristics
+        )
+
+    def fetch_batch(self, l_charRefsIn: list) -> dict:
+        """Batch fetches properties and values for a list of characteristics."""
+        if not self.c_v8 or not l_charRefsIn:
+            return {}
+
+        log_sys(f"Batch fetching properties for {len(l_charRefsIn)} characteristics...")
+        
+        c_charRefsV8 = self.c_v8.NewObject("ValueList")
+        for c_ref in l_charRefsIn:
+            if c_ref and not c_ref.IsEmpty():
+                c_charRefsV8.Add(c_ref)
+
+        d_charProps = {} # {char_uuid: [Characteristic]}
+
+        if c_charRefsV8.Count() > 0:
+            try:
+                c_propQuery = self.c_v8.NewObject("Query")
+                c_propQuery.Text = """
+                    SELECT
+                        Properties.Объект AS CharRef,
+                        Properties.Свойство.Наименование AS PropName,
+                        Properties.Значение.Наименование AS ValName
+                    FROM
+                        РегистрСведений.ЗначенияСвойствОбъектов AS Properties
+                    WHERE
+                        Properties.Объект В (&CharRefs)
+                """
+                c_propQuery.SetParameter("CharRefs", c_charRefsV8)
+                c_propRes = c_propQuery.Execute()
+                if c_propRes is not None and not c_propRes.IsEmpty():
+                    c_sel = c_propRes.Select()
+                    while c_sel.Next():
+                        s_uuid = self.c_v8.String(c_sel.CharRef.UUID())
+                        if s_uuid not in d_charProps:
+                            d_charProps[s_uuid] = []
+                        d_charProps[s_uuid].append(structures.Characteristic(c_sel.PropName, c_sel.ValName))
+            except Exception as e:
+                log_sys(f"Error batch fetching characteristics: {e}", 1)
+
+        return d_charProps

onecinteraction-1.0.0/src/oneCInteraction/connection.py

@@ -0,0 +1,98 @@
+import sys
+import pythoncom
+import pytz
+from .log import log_sys
+
+# Handle path for win32com on local environments
+PYWIN32_PATH = r'C:\Users\Администратор\AppData\Local\Programs\Python\Python314\Lib\site-packages\pywin32_system32'
+if PYWIN32_PATH not in sys.path:
+    sys.path.append(PYWIN32_PATH)
+
+import win32com.client
+
+from .nomenclature import NomenclatureManager
+from .groups import GroupsManager
+from .orders import OrdersManager
+from .characteristics import CharacteristicsManager
+
+class Connection:
+    """Manages the COM connection to 1C and hosts managers to interact with different modules."""
+    
+    tz_kiev = pytz.timezone('Europe/Kiev')
+
+    def __init__(
+        self,
+        s_oneCDatabasePathIn: str,
+        s_usernameIn: str,
+        s_passwordIn: str
+    ):
+        """Initializes connection details, saves required codes, and instantiates managers."""
+        self.s_connection_string = f"File='{s_oneCDatabasePathIn}';Usr='{s_usernameIn}';Pwd='{s_passwordIn}';"
+        self.c_v8 = None
+        self.d_price_types = {}
+        
+        # Save codes to self for order creation
+        self.s_warehouse_code = ""
+        self.s_counteragent_code = ""
+        self.s_organisation_code = ""
+        self.sl_price_types = ["Розничная", "Оптовая"]
+
+        # Managers (Composition)
+        self.nomenclature = NomenclatureManager(self)
+        self.groups = GroupsManager(self)
+        self.orders = OrdersManager(self)
+        self.characteristics = CharacteristicsManager(self)
+
+    def initiate_connection(self) -> None:
+        """Establishes COM connection to 1C and caches price type references."""
+        log_sys('Trying to initiate connection...')
+        try:
+            pythoncom.CoInitialize()
+            c_connector = win32com.client.Dispatch("V83.COMConnector")
+            self.c_v8 = c_connector.Connect(self.s_connection_string)
+            log_sys("Successfully connected to 1C.")
+            self._cache_price_types()
+        except Exception as e:
+            log_sys(f"Failed to connect to 1C: {e}")
+            self.c_v8 = None
+
+    def _cache_price_types(self) -> None:
+        """Caches references for retail and wholesale price types from 1C catalog."""
+        if not self.c_v8:
+            return
+        
+        log_sys("Caching price types...")
+        for s_ptName in self.sl_price_types:
+            self.get_price_type_ref(s_ptName)
+
+    def get_price_type_ref(self, s_nameIn: str):
+        """Returns the cached price type reference, or queries 1C if not yet cached."""
+        if s_nameIn in self.d_price_types:
+            return self.d_price_types[s_nameIn]
+        
+        if not self.c_v8:
+            return None
+
+        try:
+            c_query = self.c_v8.NewObject("Query")
+            c_query.Text = "SELECT Ссылка FROM Справочник.ТипыЦенНоменклатуры WHERE Наименование = &Name"
+            c_query.SetParameter("Name", s_nameIn)
+            c_ptExec = c_query.Execute()
+            if c_ptExec is not None and not c_ptExec.IsEmpty():
+                c_ptRes = c_ptExec.Select()
+                c_ptRes.Next()
+                self.d_price_types[s_nameIn] = c_ptRes.Ссылка
+                return c_ptRes.Ссылка
+            else:
+                log_sys(f"Cannot find price type '{s_nameIn}' in 1C constants/catalog", 1)
+                return self.c_v8.String("")
+        except Exception as e:
+            log_sys(f"Error fetching price type '{s_nameIn}': {e}", 1)
+            return self.c_v8.String("")
+
+    def close_connection(self) -> None:
+        """Closes the COM connection and uninitializes PythonCOM."""
+        log_sys("Closing 1C connection...")
+        self.c_v8 = None
+        pythoncom.CoUninitialize()
+        log_sys("1C connection closed successfully.")

onecinteraction-1.0.0/src/oneCInteraction/groups.py

@@ -0,0 +1,153 @@
+from .log import log_sys
+from . import structures
+
+class GroupsManager:
+    def __init__(self, c_connectionIn):
+        self.c_connection = c_connectionIn
+
+    @property
+    def c_v8(self):
+        return self.c_connection.c_v8
+
+    def get_tree(self, sl_ignoredCategoriesNamesIn: list) -> list:
+        """Retrieves and builds hierarchical group structure excluding ignored names."""
+        if not self.c_v8:
+            log_sys("Failed to get hierarchical groups: No connection to 1C.", 1)
+            return []
+
+        try:
+            c_ignoredVl = self.c_v8.NewObject("ValueList")
+            
+            if sl_ignoredCategoriesNamesIn:
+                log_sys(f"Finding references for ignored categories: {sl_ignoredCategoriesNamesIn}")
+                c_refQuery = self.c_v8.NewObject("Query")
+
+                l_whereClauses = []
+                for i in range(len(sl_ignoredCategoriesNamesIn)):
+                    l_whereClauses.append(f"Наименование = &Name{i}")
+                
+                c_refQuery.Text = f"SELECT Ссылка FROM Справочник.Номенклатура WHERE ({' OR '.join(l_whereClauses)}) AND ЭтоГруппа = ИСТИНА"
+                
+                for i, s_name in enumerate(sl_ignoredCategoriesNamesIn):
+                    c_refQuery.SetParameter(f"Name{i}", s_name)
+                    
+                c_refRes = c_refQuery.Execute()
+                if not c_refRes.IsEmpty():
+                    c_sel = c_refRes.Select()
+                    while c_sel.Next():
+                        c_ignoredVl.Add(c_sel.Ссылка)
+
+            log_sys("Fetching nomenclature groups (excluding ignored branches)...")
+            c_query = self.c_v8.NewObject("Query")
+            s_queryText = """
+                SELECT Ссылка AS Ref, 
+                       Наименование AS Name, 
+                       Код AS Code,
+                       Родитель AS Parent
+                FROM Справочник.Номенклатура
+                WHERE ЭтоГруппа = ИСТИНА AND ПометкаУдаления = ЛОЖЬ
+            """
+            
+            if c_ignoredVl.Count() > 0:
+                s_queryText += " AND NOT Ссылка В ИЕРАРХИИ(&IgnoredRefs)"
+                c_query.SetParameter("IgnoredRefs", c_ignoredVl)
+            
+            s_queryText += " ORDER BY Родитель, Наименование"
+            c_query.Text = s_queryText
+            
+            c_result = c_query.Execute()
+
+            d_groupsDict = {}
+            l_rootGroups = []
+
+            if not c_result.IsEmpty():
+                c_selection = c_result.Select()
+                while c_selection.Next():
+                    c_groupRef = c_selection.Ref
+                    s_groupName = c_selection.Name
+                    s_groupCode = self.c_v8.String(c_selection.Code)
+                    c_parentRef = c_selection.Parent
+
+                    s_refKey = self.c_v8.String(c_groupRef.UUID())
+                    c_groupObj = structures.Group(
+                        s_groupNameIn=s_groupName, 
+                        l_nomenclaturesIn=[], 
+                        c_refIn=c_groupRef, 
+                        s_codeIn=s_groupCode,
+                        s_uuidIn=s_refKey
+                    )
+                    
+                    s_parentKey = self.c_v8.String(c_parentRef.UUID()) if not c_parentRef.IsEmpty() else None
+
+                    d_groupsDict[s_refKey] = {
+                        'obj': c_groupObj,
+                        'parent': s_parentKey
+                    }
+
+                for s_ref, d_data in d_groupsDict.items():
+                    s_parentKey = d_data['parent']
+                    if s_parentKey and s_parentKey in d_groupsDict:
+                        d_groupsDict[s_parentKey]['obj'].l_subGroups.append(d_data['obj'])
+                    else:
+                        l_rootGroups.append(d_data['obj'])
+
+            log_sys(f"Successfully fetched and organized {len(d_groupsDict)} groups.")
+            return l_rootGroups
+
+        except Exception as e:
+            log_sys(f"Error in getHierarchicalGroups: {e}", 1)
+            return []
+
+    def get_by_name(self, s_nameIn: str):
+        """Finds a single category Group by its name."""
+        if not self.c_v8:
+            log_sys("Failed to get category: No connection to 1C. Returning None", 1)
+            return None
+
+        try:
+            log_sys(f"Trying to get category by name: {s_nameIn}...")
+            c_query = self.c_v8.NewObject("Query")
+            c_query.Text = """
+                SELECT TOP 1 Ссылка AS Ref, 
+                       Наименование AS Name,
+                       Код AS Code
+                FROM Справочник.Номенклатура
+                WHERE Наименование = &Name AND ЭтоГруппа = ИСТИНА AND ПометкаУдаления = ЛОЖЬ
+            """
+            c_query.SetParameter("Name", s_nameIn)
+
+            c_result = c_query.Execute()
+            if c_result.IsEmpty():
+                log_sys(f"Category '{s_nameIn}' not found. Returning None", 1)
+                return None
+
+            c_selection = c_result.Select()
+            c_selection.Next()
+
+            s_groupCode = self.c_v8.String(c_selection.Code)
+            log_sys(f"Category '{s_nameIn}' successfully found.")
+            return structures.Group(s_groupNameIn=c_selection.Name, l_nomenclaturesIn=[], c_refIn=c_selection.Ref, s_codeIn=s_groupCode)
+        except Exception as e:
+            log_sys(f"Error in getCategoryByName: {e}", 1)
+            return None
+
+    def get_full_path(self, c_groupRefIn) -> str:
+        """Returns the full hierarchical path of the group (e.g. 'Parent > Subgroup')."""
+        if c_groupRefIn is None or c_groupRefIn.IsEmpty():
+            return ""
+        
+        l_pathParts = []
+        c_currentRef = c_groupRefIn
+        
+        try:
+            while c_currentRef is not None and not c_currentRef.IsEmpty():
+                c_groupObj = c_currentRef.GetObject()
+                l_pathParts.insert(0, c_groupObj.Наименование)
+                c_currentRef = c_groupObj.Родитель
+            
+            s_fullPath = " > ".join(l_pathParts)
+            log_sys(f"Full group path built: '{s_fullPath}'")
+            return s_fullPath
+        except Exception as e:
+            log_sys(f"Error in getFullGroupPath: {e}", 1)
+            return ""

onecinteraction-1.0.0/src/oneCInteraction/log.py

@@ -0,0 +1,99 @@
+import inspect
+import os
+from datetime import datetime
+import json
+from pathlib import Path
+import shutil
+import sys
+
+# Load config from the shared data folder
+COMMON_DIR = os.path.dirname(os.path.abspath(__file__))
+CONFIG_PATH = os.path.abspath(os.path.join(COMMON_DIR, '..', 'data', 'config.json'))
+
+try:
+    with open(CONFIG_PATH, 'r', encoding='utf-8-sig') as f:
+        config = json.load(f)
+except Exception as e:
+    config = {}
+
+# LOGS_DIR is resolved dynamically inside the shared work/log/ directory
+WORK_DIR = os.path.abspath(os.path.join(COMMON_DIR, '..'))
+
+main_module = sys.modules.get('__main__')
+if main_module and hasattr(main_module, '__file__') and main_module.__file__:
+    main_dir = os.path.dirname(os.path.abspath(main_module.__file__))
+    project_name = os.path.basename(main_dir)
+else:
+    project_name = 'unknown'
+
+LOGS_DIR = os.path.join(WORK_DIR, 'log', project_name)
+
+def log_usr(message, errorflag = 0, user_id = None):
+    folder_path = os.path.join(LOGS_DIR, 'user')
+    if user_id is None:
+        user_id = "no_ID_user"
+    log_path = os.path.join(folder_path, f"{user_id}.log")
+
+    os.makedirs(folder_path, exist_ok=True)
+
+    log_text = f"[{datetime.now().strftime('%H:%M %d.%m.%Y')}]{'[ERROR]' if errorflag else '\t'} {message}\n"
+    log(log_path, log_text)
+
+def log_sys(message, errorFlag = 0, user_id = None):
+    folder_path = os.path.join(LOGS_DIR, 'system')
+
+    caller_frame = inspect.stack()[1]
+    caller_filename = os.path.basename(caller_frame.filename)
+
+    log_path = os.path.join(folder_path, f"{caller_filename.split('.')[0]}.log")
+
+    os.makedirs(folder_path, exist_ok=True)
+
+    log_text = f"[{datetime.now().strftime('%H:%M %d.%m.%Y')}]{'[ERROR]' if errorFlag else '\t'} {message}\n"
+    log(log_path, log_text)
+
+def log(file_path, log_text):
+    with open(file_path, "a", encoding="utf-8") as f:
+        f.write(log_text)
+
+def archiveLog():
+    format = "zip"
+    source_dir = LOGS_DIR
+
+    if not os.path.exists(source_dir):
+        log_sys(f"Source directory '{source_dir}' not found. Archiving aborted.", 1)
+        return 0
+
+    filename = datetime.now().strftime('%d-%m-%Y')
+    config_path = config.get("LogDumpsPath")
+
+    if config_path and os.access(config_path, os.W_OK):
+        log_sys("Dump folder path from config is valid")
+        base_dump_path = Path(config_path)
+    else:
+        log_sys("Dump folder path from config is not valid. Dump path set to default")
+        base_dump_path = (Path(LOGS_DIR).parent.parent / "logDumps").resolve()
+
+    base_dump_path.mkdir(parents=True, exist_ok=True)
+
+    full_archive_path = base_dump_path / filename
+
+    log_sys(f"Backup path generated: {full_archive_path}.{format}")
+
+    try:
+        shutil.make_archive(str(full_archive_path), format, source_dir)
+        log_sys(f"Log archive created successfully: {filename}.{format}")
+        return 1
+    except Exception as e:
+        log_sys(f"Error during archiving logs: {e}", 1)
+        return 0
+
+def clearLog():
+    log_path = LOGS_DIR
+    try:
+        shutil.rmtree(log_path)
+        log_sys(f"Logs cleared")
+        return 1
+    except Exception as e:
+        log_sys(f"Error during clearing logs: {e}", 1)
+        return 0