semvec/pypi-packages huggingface dataset:
eoq3pyecoremdb 3.1.0
pyecore-based MDB for EOQ3
Requires Python: >=3.10

# eoq3pyecoremdb - pyecore-based MDB for EOQ3

This is a model database (MDB) for EOQ3 based on the [pyecore](https://github.com/pyecore/pyecore) framework, but with full compatibility to EOQ3's CRUD interface and Concepts. 
		
## Usage

    from eoq3pyecoremdb import PyEcoreMdb #requres pyecoremdb to be installed
    
	mdb = PyEcoreMdb()
	domain = DomainWithMdb(mdb)

Access to CRUD interface. This is normally not recomended, because it bypasses the domain.

    mdb.Create(classId, createArgs, target, recoveryArgs)
	mdb.Read(target, featureName, context)
    mdb.Update(target, featureName, value, position)
    mdb.Delete(self, target)
	
## Implementation

Large parts of the wrapper between pyecore an EOQ3 are generated from the concepts generation. To regenerate use:

    gen/generatepyecoremdb.py

## Documentation

For more information see EOQ3 documentation: https://eoq.gitlab.io/doc/eoq3/

## Author

2024 Bjoern Annighoefer
eoq3pyecoreutils 3.1.0
A collection of pyecore to EOQ3 bridging tools.
Requires Python: >=3.10

# eoq3pyecoreutils - pyecore-eoq3 bridge

An auxilary package for using eoq3 with pyecore, e.g. value type and model conversion as well as operation conversion and Concepts wrappers.

### Usage

Imports:

    from eoq3pyecoreutils.ecorefiletoeoqfile import EcoreFileToEoqFile
    from eoq3pyecoreutils.eoqfiletoecorefile import EoqFileToEcoreFile
	
Uploading ecore files:
    
    m2EcoreFile = "testdata/Workspace/Meta/oaam.ecore"
    m1EcoreFile = "testdata/Workspace/MinimalFlightControl.oaam"
    
    LoadEcoreFile(m2EcoreFile,domain,options=resource.options,config=resource.config)
    LoadEcoreFile(m1EcoreFile,domain,metafile=m2EcoreFile,options=resource.options,config=resource.config)
	
Saving ecore files:

	SaveEcoreFile(m2EcoreFileSaved, rootObj, domain, options=resource.options)
	SaveEcoreFile(m1EcoreFileSaved, rootObj, domain, metafile=m2EcoreFile, options=resource.options)
	SaveEcoreFile(m1EcoreFileSaved, rootObj, domain, metafile=m2EcoreFileSaved, saveMetamodelInAddition=True, options=resource.options)

## Documentation

For more information see EOQ3 documentation: https://eoq.gitlab.io/doc/eoq3/

## Author

2024 Bjoern Annighoefer
eoq3pyactions 3.1.0
action handler and python actions for EOQ3
Requires Python: >=3.10

# eoq3pyecoremdb - action handler and python actions for EOQ3

Actions are scripts to be applied on elements of a domain. 
The application is triggered throug the domain and script execution can be remote.
Actions might be parameterized to configure their targets and/or execution.

This comprises action handler and action manager. Per domain one action manager and several action handlers can be instantiated.

* action manager: extends the domain by an action model as well as commands to call and abort actions.
* action handler: registers local python scripts as actions in the actions manager and listens to execution requests.
		
## Usage

### API

Imports:

    from eoq3pyactions.actionhandler import ActionHandler
    from eoq3pyactions.actionmanager import ActionManager
    from eoq3pyactions.util import *

Create and connect an action manager:

    amaSessionId = GenerateSessionId() #action manager
    domain.Do(Hel('actionmanager','xxx'),amaSessionId)
    ama = ActionManager(config)
    ama.Connect(domain, amaSessionId)
	
Create and connect an action handler:

	ahaSessionId = GenerateSessionId() #action handler
    domain.Do(Hel('actionhandler','xxx'),ahaSessionId) 
    aha = ActionHandler(basedir=ACTIONS_DIR)
    aha.Connect(domain,ahaSessionId)
	
Call an action and retrieve the results (for the action itself, see example action below):

    res = domain.Do( Cus('CAL',['Misc/helloworld',[1]]) ,asDict=True)
    job = res['job']
    #wait for action to finish
    sleep(1.0) #make sure action has finished
    #check result 
	res = domain.Do( Get( Qry(job).Pth('results*').Idx(0) ) )
	# res should be STR("I printed 1 times Hello world!")
	
Alternative ways to call actions:

	#action call by util funciton and wait seperate
	res = CallAction(domain,sessionId,'helloworld',[1])
    job = res['job']
	jobStatus = res['statusInstance']
	WaitForAction(domain,sessionId,job,jobStatus,10.0)
	#call and wait with one helper
	CallActionAndWait(domain,sessionId,'helloworld',[],10.0)
	
See also Test/Eoq3/test_eoq3pyactions.py.
	
### Example action

This must reside as in ACTIONS_DIR:

    __tags__ = ['misc','test'] #classification tags to be used in clients #tags are optional
    
    def helloworld(domain : 'Domain', times : 'I64=2')->'STR':
        t = times.GetVal()
        for i in range(t):
            print("Hello world!",end='')
        return "I printed %d times Hello world!"%(t)
	
## Implementation

Large parts of the wrapper between pyecore an EOQ3 are generated from the concepts generation. To regenerate use:

    gen/generatepyecoremdb.py

## Documentation

For more information see EOQ3 documentation: https://eoq.gitlab.io/doc/eoq3/

## Author

2024 Bjoern Annighoefer
eoq3 3.1.0
Core implementation of EOQ3 for python
Requires Python: >=3.10

# eoq3 - EOQ3 core implementation for python

This implements EOQ3 domains, values, queries and commands in python. 
It is the central module of the EOQ3 implementation for python. 
It contains a ready-to-use domainwithmdb for programmatic model interactions.

## Getting started example 

This example implements the ["Why EOQ?"](https://eoq.gitlab.io/doc/eoq3/10_eoq.html#why-eoq-an-application-example) example and some additional prints of model information.

```python
from eoq3.domainwithmdb import DomainWithMdb
from eoq3.command import Crt, Get,Set #commands
from eoq3.query import Cls,Pth #queries
from eoq3.concepts import * #import constants as CONCEPTS, ....
from eoq3.examples.warehouse import CreateWarehouseM1Model, CreateWarehouseM2Model #creation of example models
# currently PyecoreMdb is the only local domain. eoq3pyecoremdb must be installed.
from eoq3pyecoremdb import PyEcoreMdb #requres pyecoremdb to be installed

# Initialize a local domain
mdb = PyEcoreMdb()
domain = DomainWithMdb(mdb)
# Init warehouse meta and user model
CreateWarehouseM2Model(domain) #open function to see model creation commands
CreateWarehouseM1Model(domain) #open function to see model creation commands
# Would you like to get a list of articles?
articles = domain.Do( Get( Cls('Article') ) )
print("Articles: %s"%(articles))
# Would you like to know which one is sold less than 3-times?
badArticles = domain.Do( Get( Cls('Article').Sel(Pth('sells').Les(3)) ) )
print("Bad articles: %s"%(badArticles))
# You might want to reduce their price by 10%?
nameAndPrice = domain.Do( Get( Cls('Article').Zip([Pth('name'),Pth('price')])))
print("Article prices: %s"%(nameAndPrice))
domain.Do( Set( 
	Cls('Article').Sel(Pth('sells').Les(3)),
	'price',
	Cls('Article').Sel(Pth('sells').Les(3)).Pth('price').Mul(0.9) 
) )
nameAndPrice = domain.Do( Get( Cls('Article').Zip([Pth('name'),Pth('price')])))
print("Article prices: %s"%(nameAndPrice))
# Would you like to see a list of the names of the categories of the badly selling articles sorted by ascendingly?
badCategories = domain.Do( Get( Cls('Article').Sel(Pth('sells').Les(3)).Met('PARENT').Pth('name').Uni([]).Idx('SORTASC') ) )
print(badCategories)
```

This example is available as  https://gitlab.com/eoq/py/pyeoq/Examples/Eoq3/WhyWarehouseExample.py

## Documentation

For more information see EOQ3 documentation: https://eoq.gitlab.io/doc/eoq3/

## pyeoq repository

Pyeoq module's source can be found here: https://gitlab.com/eoq/py/pyeoq

## Author

2024 Bjoern Annighoefer
eoq3conceptsgen 3.0.0
Scripts for generating code out of the formal definition of concepts using mako templates.
Requires Python: >=3.10

# eoq3conceptsgen - Code generator for EOQ3 concepts

Scripts for generating code out of the formal definition of concepts using mako templates.

## Command-line Interface (CLI)

### Usage

    python -m eoq3conceptsgen.generatefromconceptscli --help
    usage: generatefromconcepts [-h] [-c CONCEPTSDEFFILE] [-i INFILE] [-o OUTFILE] [-d DATAFILE]
    
    Generates mako templates from the content of concepts.xlsx
    
    options:
      -h, --help            show this help message and exit
      -c CONCEPTSDEFFILE, --conceptsDefFile CONCEPTSDEFFILE
                            the concept definition file
      -i INFILE, --inFile INFILE
                            The input template
      -o OUTFILE, --outFile OUTFILE
                            The generated file
      -d DATAFILE, --dataFile DATAFILE
                            Optional json data file, whose content is available as "data" in the template
							
### Examples

Generate concepts.py from sample.mako (included in package):

    python -m eoq3conceptsgen.generatefromconceptscli -o concepts.py
	
## API Interface

    from .generatefromconcepts import GenerateFromConcepts
	...
	GenerateFromConcepts(inFile,conceptsDefFile,outFile,dataFile)

## Documentation

For more information see EOQ3 documentation: https://eoq.gitlab.io/doc/eoq3/

## Author

2024 Bjoern Annighoefer
intersperse 0.1.0a0
A simple Python generator that yields elements from an iterable, inserting a separator value between each element.
Requires Python: >=2

# intersperse

A simple Python generator that yields elements from an iterable, inserting a separator value between each element.

## Installation

```bash
pip install intersperse
```

## Usage

```python
# coding=utf-8
from intersperse import intersperse

# Intersperse zeros between numbers
print(list(intersperse([1, 2, 3], 0)))
# Output: [1, 0, 2, 0, 3]

# Works with any iterable
print(list(intersperse('abc', '-')))
# Output: ['a', '-', 'b', '-', 'c']

# Edge cases
print(list(intersperse([], 0)))
# Output: []

print(list(intersperse([1], 0)))
# Output: [1]
```

## License

MIT
packagekit 0.1.0
Toolkit for day-to-day package development
Requires Python: <4.0,>=3.12

# PackageKit

Toolkit for day-to-day package development

Facilitates the following:

- **Normalization**: Advanced mechanism to normalize objects with user-defined source/destination types and mapping logic
- **YAML models**: Load/store models (pydantic, dataclass) from/to a YAML file
- **Logging**: Setup rich output and logging to timestamped file
- **Development workflow**:
    - `doit` task factory for formatting, test coverage, etc
    - Process test coverage and generate badges
liquidnn 1.1.2
A PyTorch based module for Liquid Networks

#🧠 liquidnn

A PyTorch implementation of Liquid Neural Networks (LNNs) and their hybrids (LTC, CNN, RNN, LSTM variants).
This library brings continuous-time dynamics into deep learning architectures using learnable time constants.

##✨ Features

🔹 LiquidNeuralNetwork – stacked liquid neurons

🔹 LTCLayer – Liquid Time-Constant layer

🔹 LiquidCNN – CNN + Liquid update

🔹 LiquidRNN – RNN + Liquid update

🔹 LiquidLSTM – LSTM + Liquid update (with bidirectional support)

🔹 HDNN - Height Dimensioned Neural Networks

🔹 Per-neuron learnable τ (time constants) with stability clamping

##📦 Installation
From PyPI (after publishing):

```bash
pip install liquidnn
```
```bash
##🚀 Quick Start (all models in one script)

Copy-paste this script to test every model in liquidnn:

import torch
from liquidnn import (
    LiquidNeuralNetwork,
    LTCLayer,
    LiquidCNN,
    LiquidRNN,
    LiquidLSTM,
    HDNN
)

# 1. LiquidNeuralNetwork
x = torch.randn(4, 10, 8)  # batch=4, seq_len=10, input_size=8  

model = LiquidNeuralNetwork(input_size=8, hidden_size=16,num_layers=2)  
out = model(x)   
print("LiquidNeuralNetwork output:", out.shape)  # [4, 16]   

# 2. LTCLayer    
x = torch.randn(5, 20, 10)  # batch=5, seq_len=20, input_size=10    
ltc = LTCLayer(input_size=10, hidden_size=32, num_layers=2)    
out = ltc(x)    
print("LTCLayer output:", out.shape)  # [5, 32]    

# 3. LiquidCNN    
x = torch.randn(8, 1, 28, 28)  # MNIST-like input    
model = LiquidCNN(input_channels=1, hidden_size=64, num_layers_liq=2, num_layers_conv=2)    
out = model(x)    
print("LiquidCNN output:", out.shape)  # [8, 64]    

# 4. LiquidRNN    
x = torch.randn(15, 4, 12)  # seq_len=15, batch=4, input_size=12    
model = LiquidRNN(input_size=12, hidden_size=32, num_layers_liq=2, num_layers_rnn=1)    
out = model(x)    
print("LiquidRNN output:", out.shape)  # [4, 32]    

# 5. LiquidLSTM    
x = torch.randn(3, 12, 10)  # batch=3, seq_len=12, input_size=10    
model = LiquidLSTM(input_size=10, hidden_size=32,    
                   num_layers_liq=2, num_layers_lstm=1,    
                   batch_first=True, bidirectional=False)    
out = model(x)    
print("LiquidLSTM output:", out.shape)  # [3, 32]   


#HDNN
model = HDNN(input_dim=10, hidden_dim=32, output_dim=2, height=3, depth=2)
x = torch.randn(5, 10)
out = model(x)
print("HDNN output:", out.shape )      #[5,2]


```

##📚 Architectures

LiquidNeuralNetwork: Stacked liquid neurons

LTCLayer: Continuous-time RNN update rule

LiquidCNN: Convolutional backbone + LTC dynamics

LiquidRNN: RNN + Liquid refinement

LiquidLSTM: LSTM + Liquid refinement

Install dependencies:

pip install torch


##🌟 Contribute

PRs and issues are welcome! If you try new liquidized architectures, feel free to share 🚀