ApiLogicServer 15.0.47__py3-none-any.whl → 15.0.54__py3-none-any.whl

api_logic_server_cli/prototypes/base/.devcontainer-option/.copilot-instructions.md

@@ -1,178 +0,0 @@
-# GitHub Copilot Instructions for GenAI-Logic (aka API Logic Server) Projects
-
-## Project Type: Auto-Generated Microservice
-
-This is a **GenAI-Logic (aka API Logic Server) project** - a complete, working microservice - auto-generated from a database schema.
-
-## ⚠️ IMPORTANT: What's Already Built
-
-**DO NOT recreate these - they're already working:**
-
-1. **Admin Web Application** - Live at `http://localhost:5656`
-2. **REST API Endpoints** - All database tables exposed at `/api/*`
-3. **Database Models** - Complete SQLAlchemy ORM in `database/models.py`
-4. **Authentication System** - JWT-based auth framework
-5. **Business Logic Engine** - Declarative rules system
-
-## 🎯 Common Tasks
-
-If the user asks "what do I do now?", these subsections are good suggestions.
-
-List these as choices, do not just do all of them at once - that would be overwhelming.
-
-### 🚀 To Run This Project
-
-Use F5 (pre-configured run configuration - supports debugger for server logic), or (when focused on client apps):
-
-```bash
-python api_logic_server_run.py
-# Then open: http://localhost:5656
-```
-
-### Adding Business Logic
-Use `docs/training` to accept Natural Language logic, and translate it into rules like:
-
-```python
-# Edit: logic/declare_logic.py
-Rule.sum(derive=Customer.Balance, as_sum_of=Order.AmountTotal)
-Rule.constraint(validate=Customer, as_condition=lambda row: row.Balance <= row.CreditLimit)
-```
-
-Generally CoPilot solicits Natural Language logic for translation (see logic/logic_discovery/readme_logic_discovery.md), 
-but you can also offer to suggest rules.
-
-### Adding MCP
-
-The API is automatically MCP-enabled.
-
-To add MCP Client (requires OpenAI key):
-
-```bash
-# Add MCP Client
-genai-logic genai-add-mcp-client
-```
-
-### Configuring Admin UI
-
-This is built when project is created - no need to add it.
-Customize by editing the underlying yaml.
-
-```yaml
-# Edit: ui/admin/admin.yaml
-resources:
-  Customer:
-    attributes:
-      - name: CompanyName
-        search: true
-        sort: true
-```
-
-### Create and Customize React Apps
-
-Complete customization is provided by generating a React Application (requires OpenAI key, Node):
-
-```bash
-# Create: ui/admin/my-app-name
-genai-logic genai-add-app --app-name=my-app-name --vibe
-```
-
-Then, `npm install` and `npm start`
-
-Temporary restriction: security must be disabled.
-
-Customize using CoPilot chat, with `docs/training`.
-
-### Security - Role-Based Access Control
-
-Configure:
-```
-als add-auth --provider-type=sql --db-url=
-als add-auth --provider-type=sql --db_url=postgresql://postgres:p@localhost/authdb
-
-als add-auth --provider-type=keycloak --db-url=localhost
-als add-auth --provider-type=keycloak --db-url=hardened
-
-als add-auth --provider-type=None # to disable
-``` 
-
-Keycloak quick start [(more information here:)](https://apilogicserver.github.io/Docs/Security-Keycloak/)
-```bash
-cd devops/keycloak
-docker compose up
-als add-auth --provider-type=keycloak --db-url=localhost
-```
-
-For more on KeyCloak: https://apilogicserver.github.io/Docs/Security-Keycloak/
-
-Declaration:
-```python
-# Edit: security/declare_security.py
-Grant(on_entity=Customer, to_role=sales, filter=lambda: Customer.SalesRep == current_user())
-```
-
-### Adding Custom API Endpoints
-```python
-# Edit: api/customize_api.py
-@app.route('/api/custom-endpoint')
-def my_endpoint():
-    return {"message": "Custom endpoint"}
-```
-
-### Customize Models - Add Derived attributes
-
-Here is a sample derived attribute, `proper_salary`:
-
-```python
-
-# add derived attribute: https://github.com/thomaxxl/safrs/blob/master/examples/demo_pythonanywhere_com.py
-@add_method(models.Employee)
-@jsonapi_attr
-def __proper_salary__(self):  # type: ignore [no-redef]
-    import database.models as models
-    import decimal
-    if isinstance(self, models.Employee):
-        rtn_value = self.Salary
-        if rtn_value is None:
-          rtn_value = decimal.Decimal('0')
-        rtn_value = decimal.Decimal('1.25') * rtn_value
-        self._proper_salary = int(rtn_value)
-        return self._proper_salary
-    else:
-        rtn_value = decimal.Decimal('0')
-        self._proper_salary = int(rtn_value)
-        return self._proper_salary
-
-@add_method(models.Employee)
-@__proper_salary__.setter
-def _proper_salary(self, value):  # type: ignore [no-redef]
-    self._proper_salary = value
-    print(f'_proper_salary={self._proper_salary}')
-    pass
-
-models.Employee.ProperSalary = __proper_salary__
-
-```
-
-When customizing SQLAlchemy models:
-
-Don't use direct comparisons with database fields in computed properties
-Convert to Python values first using float(), int(), str()
-Use property() function instead of @jsonapi_attr for computed properties
-Always add error handling for type conversions
-
-## 📁 Key Directories
-
-- `logic/` - Business rules (declarative)
-- `api/` - REST API customization
-- `security/` - Authentication/authorization
-- `database/` - Data models and schemas
-- `ui/admin/` - Admin interface configuration
-- `ui/app/` - Alternative Angular admin app
-
-## 💡 Helpful Context
-
-- This uses Flask + SQLAlchemy + SAFRS for JSON:API
-- Admin UI is React-based with automatic CRUD generation
-- Business logic uses LogicBank (declarative rule engine)
-- Everything is auto-generated from database introspection
-- Focus on CUSTOMIZATION, not re-creation

api_logic_server_cli/prototypes/base/database/alembic/readme.md

@@ -1,18 +0,0 @@
-The diagram below illustrates a simple path for enacting changes to the data model, and using [Alembic](https://alembic.sqlalchemy.org/en/latest/index.html) to automate the database changes:
-
-1. Update `database/models.py` (e.g., add columns, tables)
-2. Use alembic to compute the revisions
-```bash
-cd database
-alembic revision --autogenerate -m "Added Tables and Columns"
-```
-3. Edit the revision file to signify your understanding (see below)
-4. Activate the change
-```bash
-alembic upgrade head 
-```
-
-![alembic example](https://github.com/ApiLogicServer/Docs/blob/main/docs/images/database/alembic/alembic-overview.png?raw=true)
-
-
-Then, run `rebuild-from-model`.  For more information, see [Database Design Changes](https://apilogicserver.github.io/Docs/Database-Changes/).

api_logic_server_cli/prototypes/base/database/system/SAFRSBaseX.pyZ

@@ -1,73 +0,0 @@
-from sqlalchemy.ext.declarative import declarative_base
-from sqlalchemy import Column, DECIMAL, Date, ForeignKey, Integer, String
-from safrs import SAFRSBase
-from flask_login import UserMixin
-import safrs, flask_sqlalchemy
-from safrs import jsonapi_attr
-from flask_sqlalchemy import SQLAlchemy
-from datetime import datetime
-
-Base = declarative_base()  # type: flask_sqlalchemy.model.DefaultMeta
-#vh new x
-@classmethod
-def jsonapi_filter(cls):
-    """
-    Use this to override SAFRS JSON:API filtering
-
-    Returns:
-        _type_: SQLAlchemy query filter
-    """
-    from sqlalchemy import text, or_, and_
-    from flask import request
-    expressions = []
-    sqlWhere = ""
-    query = cls._s_query
-    if args := request.args:
-        from api.system.expression_parser import advancedFilter
-        expressions, sqlWhere = advancedFilter(cls, args)
-    if sqlWhere != "":    
-        return query.filter(text(sqlWhere))
-    else:
-        return query.filter(or_(*expressions))   
-
-class SAFRSBaseX(SAFRSBase, safrs.DB.Model):
-    __abstract__ = True
-    if do_enable_ont_advanced_filters := False:
-        jsonapi_filter = jsonapi_filter
-        
-    def _s_parse_attr_value(self, attr_name: str, attr_val: any):
-        """
-        Parse the given jsonapi attribute value so it can be stored in the db
-        :param attr_name: attribute name
-        :param attr_val: attribute value
-        :return: parsed value
-        """
-        attr = self.__class__._s_jsonapi_attrs.get(attr_name, None)
-        if hasattr(attr, "type"):  # pragma: no cover
-            
-            if str(attr.type) in ["DATE", "DATETIME"] and attr_val:
-                try:
-                    attr_val = attr_val.replace("T", " ")
-                    datetime.strptime(attr_val, '%Y-%m-%d %H:%M')
-                    attr_val += ":00"
-                except ValueError:
-                    pass
-                except Exception as exc:
-                    safrs.log.warning(exc)
-        
-        
-        return super()._s_parse_attr_value(attr_name, attr_val)
-
-class TestBase(Base):
-    __abstract__ = True
-    def __init__(self, *args, **kwargs):
-        for name, val in kwargs.items():
-            col = getattr(self.__class__, name)
-            if 'amount_total' == name:
-                debug_stop = 'stop'
-            if val is not None:
-                if str(col.type) in ["DATE", "DATETIME"]:
-                    pass
-                else:
-                    kwargs[name] = col.type.python_type(val)
-        return super().__init__(*args, **kwargs)

api_logic_server_cli/prototypes/basic_demo/customizations/database/system/SAFRSBaseX.py

@@ -1,139 +0,0 @@
-import json
-from sqlalchemy.ext.declarative import declarative_base
-from sqlalchemy import Column, DECIMAL, Date, ForeignKey, Integer, String
-from safrs import SAFRSBase, ValidationError
-from flask_login import UserMixin
-import safrs, flask_sqlalchemy
-from safrs import jsonapi_attr
-from flask_sqlalchemy import SQLAlchemy
-from datetime import datetime
-import operator
-import json
-
-
-Base = declarative_base()  # type: flask_sqlalchemy.model.DefaultMeta
-#vh new x
-@classmethod
-def jsonapi_filter(cls):
-    """
-    Use this to override SAFRS JSON:API filtering
-
-    Returns:
-        _type_: SQLAlchemy query filter
-    """
-    from sqlalchemy import text, or_, and_
-    from flask import request
-    expressions = []
-    sqlWhere = ""
-    query = cls._s_query
-    if args := request.args:
-        from api.system.expression_parser import advancedFilter
-        expressions, sqlWhere = advancedFilter(cls, args)
-    if sqlWhere != "":    
-        return query.filter(text(sqlWhere))
-    else:
-        return query.filter(and_(*expressions))   
-
-class SAFRSBaseX(SAFRSBase, safrs.DB.Model):
-    __abstract__ = True
-    if do_enable_ont_advanced_filters := False:
-        jsonapi_filter = jsonapi_filter
-        
-    def _s_parse_attr_value(self, attr_name: str, attr_val: any):
-        """
-        Parse the given jsonapi attribute value so it can be stored in the db
-        :param attr_name: attribute name
-        :param attr_val: attribute value
-        :return: parsed value
-        """
-        attr = self.__class__._s_jsonapi_attrs.get(attr_name, None)
-        if hasattr(attr, "type"):  # pragma: no cover
-            
-            if str(attr.type) in ["DATE", "DATETIME"] and attr_val:
-                try:
-                    attr_val = attr_val.replace("T", " ")
-                    datetime.strptime(attr_val, '%Y-%m-%d %H:%M')
-                    attr_val += ":00"
-                except ValueError:
-                    pass
-                except Exception as exc:
-                    safrs.log.warning(exc)
-        
-        
-        return super()._s_parse_attr_value(attr_name, attr_val)
-
-
-    @classmethod
-    def _s_filter(cls, *filter_args, **filter_kwargs):
-        """
-        Apply a filter to this model
-        :param filter_args: A list of filters information to apply, passed as a request URL parameter.
-        Each filter object has the following fields:
-        - name: The name of the field you want to filter on.
-        - op: The operation you want to use (all sqlalchemy operations are available). The valid values are:
-            - like: Invoke SQL like (or "ilike", "match", "notilike")
-            - eq: check if field is equal to something
-            - ge: check if field is greater than or equal to something
-            - gt: check if field is greater than to something
-            - ne: check if field is not equal to something
-            - is_: check if field is a value
-            - is_not: check if field is not a value
-            - le: check if field is less than or equal to something
-            - lt: check if field is less than to something
-        - val: The value that you want to compare.
-        :return: sqla query object
-        """
-        try:
-            filters = json.loads(filter_args[0])
-        except json.decoder.JSONDecodeError:
-            raise ValidationError("Invalid filter format (see https://github.com/thomaxxl/safrs/wiki)")
-
-        if not isinstance(filters, list):
-            filters = [filters]
-
-        expressions = []
-        query = cls._s_query
-
-        for filt in filters:
-            if not isinstance(filt, dict):
-                safrs.log.warning(f"Invalid filter '{filt}'")
-                continue
-            attr_name = filt.get("name")
-            attr_val = filt.get("val")
-            if attr_name != "id" and attr_name not in cls._s_jsonapi_attrs:
-                raise ValidationError(f'Invalid filter "{filt}", unknown attribute "{attr_name}"')
-
-            op_name = filt.get("op", "").strip("_")
-            attr = cls._s_jsonapi_attrs[attr_name] if attr_name != "id" else cls.id
-            if op_name in ["in", "notin"]:
-                op = getattr(attr, op_name + "_")
-                query = query.filter(op(attr_val))
-            elif op_name in ["like", "ilike", "match", "notilike"] and hasattr(attr, "like"):
-                # => attr is Column or InstrumentedAttribute
-                like = getattr(attr, op_name)
-                expressions.append(like(attr_val))
-            elif not hasattr(operator, op_name):
-                raise ValidationError(f'Invalid filter "{filt}", unknown operator "{op_name}"')
-            else:
-                op = getattr(operator, op_name)
-                expressions.append(op(attr, attr_val))
-
-        if len(filters) > 1:
-            return query.filter(operator.and_(*expressions))
-        else:
-            return query.filter(*expressions)
-
-
-class TestBase(Base):
-    __abstract__ = True
-    def __init__(self, *args, **kwargs):
-        for name, val in kwargs.items():
-            col = getattr(self.__class__, name)
-            if 'amount_total' == name:
-                debug_stop = 'stop'
-            if val is not None:
-                if str(col.type) in ["DATE", "DATETIME"]:
-                    pass
-                else:
-                    kwargs[name] = col.type.python_type(val)
-        return super().__init__(*args, **kwargs)

api_logic_server_cli/prototypes/manager/run_web_genai.sh

@@ -1,6 +0,0 @@
-# Run WebGenAI from docker container
-
-# cd genai-logic-main
-# sh run_web_genai.sh
-
-docker compose -f webgenai/docker-compose-webg.yml up