semvec/pypi-packages huggingface dataset:
hopeit.dataframes 0.29.0
Hopeit Engine Dataframes for Polars

# hopeit.engine dataframes plugin


This library is part of hopeit.engine:

> check: https://github.com/hopeit-git/hopeit.engine


### Install using extras when installing hopeit.engine:

```
pip install hopeit.engine[dataframes]
```

### hopeit.dataframes

This plugin introduces dataclasses annotations to work with `polars` dataframes
as other dataobjects:

`@dataframe` annotation allows a dataclass to become the schema and container for a dataframe
`@dataframeobject` annotation, acts as @dataobject with support to have dataframe annotated fields
`DataFrames` class, provides an api to create, serialize, and access polars dataframe

Features:
-Type coercion for @dataframe fields
-Transparent access to series in @dataframe objects using dot notation
-Serialization for @dataframe and @dataframeobjects allowing them to be transferred through streams (using file system storage to store the actual data, and transferring only metadata for deserialization in the stream)
-Support to handle @dataframeobject as payload for web requests
hopeit.apps-client 0.29.0
Hopeit Apps Client Plugin

# hopeit.engine apps-client plugin


This library is part of hopeit.engine:

> check: https://github.com/hopeit-git/hopeit.engine


### Install using hopeit.engine extras [apps-client]:

```
pip install hopeit.engine[apps-client]
```

### Config app_connection section in your app to use this client implementation:

Configre a connection in `app_connections` section and specify which events to invoke
inside `event.connections` section:

```
    ...
    "app_connections": {
        "target-app-conn": {
            "name": "target-app",
            "version": "1.0",
            "client": "hopeit.apps_client.AppsClient"
        }
    },
    ...

    "events": {
        "my-event": {
            ...
            "connections": [
                {
                    "app_connection": "target-app-conn",
                    "event": "target-event",
                    "type": "GET"
                }
            ],
            ...
        }
    }
```

To configure `apps-client` add a settings section like this to app config file:
```
    ...

    "settings": {
        "simple_example_conn": {
            "connection_str": "http://host1,http://host2"
        }
    }

```

The only required setting is `connection_str` but many other values can be configured:

```
    ...

    "settings": {
        "simple_example_conn": {
            "connection_str": "${HOPEIT_SIMPLE_EXAMPLE_HOSTS}",
            "circuit_breaker_open_failures": 10,
            "circuit_breaker_failure_reset_seconds": 90.0,
            "circuit_breaker_open_seconds": 60.0,
            "retries": 2,
            "retry_backoff_ms": 10,
            "ssl": true,
            "max_connections": 100,
            "max_connections_per_host": 0,
            "dns_cache_ttl": 10,
            "routes_override": {
                "__list-somethings": "simple-example/${HOPEIT_APPS_ROUTE_VERSION}/list-somethings"
            }
        }
    }
```

### Usage

Invoking target-app target-event from your application code:

```
    from hopeit.app.client import app_call

    ...

    def my_event(payload: ..., context: EventContext) -> ...:
        response = await app_call(
            "target-app-conn", event="target-event",
            datatype=ResposeDataType, payload=..., context=context
        )
    ...

```
hopeit.apps-visualizer 0.29.0
Hopeit Engine Apps Visualizer Plugin

# hopeit.engine apps-visualizer plugin


This library is part of hopeit.engine:

> check: https://github.com/hopeit-git/hopeit.engine


### Install using hopeit.engine extras [apps-visualizer]:

```
pip install hopeit.engine[apps-visualizer]
```

### Include config-manager plugin config file when running `hopeit_server` in addition to your existing config files for each process/server that needs to be monitored.

```
hopeit_server --port=8020 --config-files=server-config.json,plugins/ops/config-manager/config/plugin-config.json,my-app-config.json
```

### Export list of hosts to connect to, and run a new hopeit_server instance with apps-visualizer plugin

```
export HOPEIT_APPS_VISUALIZER_HOSTS="http://host:8020,in-process"

hopeit_server --port=8098 --config-files=server-config.json,plugins/ops/apps-visualizer/config/plugin-config.json --api-file=plugins/ops/apps-visualizer/api/openapi.json
```

> The first host in the list, specifies to monitor apps running in `http://host:8020` by connecting in intervals to the server through config-manager plugin endpoints.

> Using `in-process` as host name local process running apps-visualizer can be monitored also without network load.

> Instead of using an environment variable, list of hosts can be directly added to a customized version of plugin-config.json


### Visualize App events diagram using url:

```
http://host:8098/ops/apps-visualizer
```

### To enable Live! events activity visualization, configure and start an instance of `log-streamer`:
 
#### Copy `config/plugin-config.json` and customize parameters to match your runtime environment. 


#### Run a `hopeit_server` instance with log_streamer, in each node where you run your applications:
```
hopeit_server --port=8099 --start-streams --config-files=server-config.json,customized-plugin-config.json
```

> Now when you can switch from `Static` to `Live` view clicking on the label at the top right of the Apps Visualizer page

If you want also to monitor log-streamer app, you can set:

```
export HOPEIT_APPS_VISUALIZER_HOSTS=$HOPEIT_APPS_VISUALIZER_HOSTS,http://host:8099
```

and re-run apps-visualizer using `hopeit_server` command above.
gekim 0.7.9
Generalized Kinetic Modeler: A Python package for modeling arbitrary kinetic schemes.
Requires Python: >=3.9

# GeKiM (Generalized Kinetic Modeler)

## Description

GeKiM (Generalized Kinetic Modeler) is a Python package designed for creating, interpreting, and modeling arbitrary kinetic schemes. Schemes are defined by the user in a dictionary of species and transitions, which is used to initialize an instance of the System class. Choose (or make) and initialize a simulator for the instance and run it. Field-specific practices are found in gekim/fields.

## Installation

With pip:

```bash
pip install gekim
```

Or directly from the source code:

```bash
git clone https://github.com/kghaby/GeKiM.git
cd GeKiM
pip install --editable . 
```

## Usage

Here is a basic example of how to use GeKiM to create and simulate a kinetic system:

```python
import gekim as gk
from gekim.fields.bio.enzyme.inhib import irrev as ii 

# Define your kinetic scheme in a configuration dictionary
concI0,concE0 = 100,1
scheme = {
    'species': {
        "I": {"y0": concI0, "label": "I"},
        "E": {"y0": concE0, "label": "E"},
        "EI": {"y0": 0, "label": "EI"},
        "E-I": {"y0": 0, "label": "E-I"},
    },    
    'transitions': {
        "kon": {"k": 0.01, "source": ["E","2I"], "target": ["EI"]},
        "koff": {"k": 0.1, "source": ["EI"], "target": ["E","2I"]},
        "kinact": {"k": 0.01, "source": ["EI"], "target": ["E-I"]}, # irreversible step
    }
}

# Initialize a system with your schematic dictionary
system = gk.System(scheme, quiet=False)

# Choose a simulator and go
#   In this example we're doing a deterministic 
#   simulation of the concentrations of each species over time.
sim = system.set_simulator(gk.simulators.ODESolver)
sim.simulate() # Note the lack of time-scale input. It's predicted!

# Fit the data to experimental models to extract mock-experimental measurements
t = system.simout["t"]
final_state = system.species["E-I"].simout["y"]
all_bound = system.sum_species_simout(blacklist=["E","I"])

fit_output = ii.kobs_uplim_fit_to_occ_final_wrt_t(
    t, final_state, 
    nondefault_params={"Etot":{"value":concE0, "vary":False}})

```

For more detailed examples, please refer to the examples directory.

## Documentation

Documentation pages are pending, but the functions have docstrings. 

Example Jupyter Notebooks where GeKiM has been applied to model and analyze irreversible enzyme inhibition:

1. [Covalent kinetics with rapid intermediates (2025)](https://github.com/RouxLab/covalent-kinetics-with-rapid-intermediates-2025)
2. [Covalent kinase activity probes (2025)](https://github.com/RouxLab/covalent-kinase-activity-probes-2025)

## Contributing

If you have suggestions or want to contribute code, please feel free to open an issue or a pull request.

## License

GeKiM is licensed under MIT.

## Contact

<kyleghaby@gmail.com>

## Citation

If you use this software, please cite:

Ghaby, K.; Roux, B. Kinetic Modeling of Covalent Inhibition: Effects of Rapidly Fluctuating Intermediate States. *J. Chem. Inf. Model.* **2025**. https://doi.org/10.1021/acs.jcim.5c00952
hopeit.log-streamer 0.29.0
Hopeit Engine Log Streamer Plugin

# hopeit.engine log-streamer plugin


This library is part of hopeit.engine:

> check: https://github.com/hopeit-git/hopeit.engine


### Install using hopeit.engine extras [log-streamer]:

```
pip install hopeit.engine[log-streamer]
```

### Copy `config/plugin-config.json` and customize parameters to match your runtime environment. 


### Run a `hopeit_server` instance, in each node where you run your appplications:

```
hopeit_server --port=8099 --start-streams --config-files=server-config.json,customized-plugin-config.json
```

> This way log_streamer plugin process will run separately from your main application, read logs locally on each node and publish data to a stream.
hopeit.config-manager 0.29.0
Hopeit Engine Config Manager Plugin

# hopeit.engine config-manager plugin


This library is part of hopeit.engine:

> check: https://github.com/hopeit-git/hopeit.engine


### Install using hopeit.engine extras [config-manager]:

```
pip install hopeit.engine[config-manager]
```

### Include plugin configuration file when running `hopeit_server` in addition to your existing config files. 

```
hopeit_server ... --config-files=...,plugins/ops/config-manager/config/plugin-config.json,...
```

> Remember also to include the plugin config file, when using `hopeit_openapi` command line tool to create or update Open API spec file for your server

### Check added endpoints under Config Manager session:

```
http://host:port/api/docs
```
hopeit.engine 0.29.0
Hopeit Engine: Microservices with Streams

## hopeit.engine

Docs: https://hopeitengine.readthedocs.io/en/latest/


### Engine development README

#### Install locally for apps or plugins development:
- Install [uv](https://docs.astral.sh/uv/getting-started/installation/)
- Run from hopeit.engine project root
```
    make dev
```
- Now everything you need is installed in .venv/
- Then you can create your apps or plugins and run the server

#### Install from Python Package Index
Install core hopeit.engine lib:
```
pip install "hopeit.engine"
```

#### Configure
- Create server configuration json file
    - See [configuration examples](./config/)
- Create apps configuration and python files
    - See [apps examples](../apps/examples/)
- Optionally you can develop plugins, similar to apps but can be shared
    - See available [plugins](../plugins/)

#### Start http server
- Example starting a single app/microservice
```
    python -m hopeit.server.web --config-files=server-config.json,app-folder/config/app-config.json
```

- Additional options:
```
    --config-files: comma-separated file of config files to load, starting with server config, then plugins, then apps
    --api-file: path to openapi complaint json specification
    --host: server host address or name, default is --host=0.0.0.0
    --port: indicates to listen on another port number, default is --port=8020
    --path: indicates to listen in a unix socket path, default is disabled    
    --start-streams: indicates to automatically start events of type STREAM when starting server
    
```

- Example starting a single app that depends on plugins:
```
    python engine/server/web.py --config-files=server-config.json,plugin-folder/config/plugin-config.json,app-folder/config/app-config.json
```

### Tools for Engine Development

- To install development dependencies, from engine folder run:
```
    make dev
```

- To run tests
```
    make test
```

- To fromat code
```
    make format
```

- To run static code checks (types, style)
```
    make lint
```

- To create distribution library (hopeit.engine)
```
    make dist
```