semvec/pypi-packages huggingface dataset:
hexlib 2.0.3
Basic tools to read, filter, format and display hex values
License: MIT

# Description

Basic tools to read, format, filter and display hex values

# Installation

`pip install hexlib`

# Usage

- The class `HexTwin` is a hexadecimal representation of a file
  - `HexTwin` reads a file in 16 byte chunks
  - Each of this chunks is saved as as tuple together with the following information:
    - tuple[0] = Offset 
    - tuple[1] = A bytearray containing the 16 bytes
    - tuple[2] = A boolean indicating if the bytes are all zero 
    - tuple[3] = A boolean indicating if the bytes are all non ASCII values
- The class `Hexdump` format and prints `HexTwin` instances

# Example

```python
from hexlib.HexTwin import HexTwin
from hexlib.Hexdump import Hexdump

# 1.) HexTwin instance
twin = HexTwin("path/to/file/test.txt")
dump = Hexdump()

# Activates filtering for zero rows
dump.filter(filterZeroRows=True) 
dump.printTwin("path/to/result.txt", twin)

# Activates filtering for non-ascii rows (Includes also zero rows)
dump.filter(filterNonAsciiRows=True) 
dump.printTwin("path/to/result.txt", twin)

# 2.) Create HexTwin from bytes (Filtering can also be used here)
f = open("path/to/file", "rb")
twinFromBytes = HexTwin.fromBytes(f.read(16))
dumpFromBytes = Hexdump()

dumpfromBytes.printTwin("path/to/bytes-result.txt", twinFromBytes)

# 3.) Create a HexTwin from a offset reading x bytes (Filtering can also be used here)
twinFromOffset = HexTwin.fromOffset("path/to/file.txt", offset=50, noOfBytes=10)
dumpFromOffset = Hexdump()

dumpFromOffset.printTwin("path/to/offset-result.txt", twinFromOffset)
```

# License

MIT
cthmm 0.0.3
Testing installation of Package
License: MIT

# cthmm

This is a python library for training and applying
[continuous-time markov hidden markov models](https://en.wikipedia.org/wiki/Continuous-time_Markov_chain) (CT-HMMs).
They are a simple, but exceptionally powerful tool for extracting
signal from a stream of noisy data.

It was developed by [Field Cady](http://www.fieldcady.com).


# Basic Usage

A Jupyter Notebook with usage usage is [here](https://github.com/field-cady/cthmm/blob/main/CTHMM%20Examples.ipynb).
The main functionalities are to:
* Create a CT-HMM with pre-defined parameters
* Fit a CT-HMM to data (i.e. one or more sequences of observations, along with their timestamps)
* Given a sequence of observations and timestamps, use a fitted CT-HMM to decode the underlying states
    at each timestamp

# TODO Items
* Support for GaussianCTHMM and ExponentialCTHMM by inheriting from BaseCTHMM class
* Allowing human-readable names for states
* Performance improvements, possibly by converting to C or Cython
* Unit testing
* Add in some fitting tolerances to reduce overfitting


# What is a continuous-time hidden markov model?

Say you take somebody's temperate and it's in the normal range.
In isolation that suggests they are healthy rather than sick.
But if they had elevated temperatures one hour before and after,
chances are that measurement was a fluke and they were actually sick the whole time.

Hidden markov models address this problem more generally.
There is some underlying state S of the world that varies over time
(or something like time - things just have to be sequential),
and you have some idea of how often S changes.
You don't know S for certain, but you have a sequence of
imperfect observations O at certain points in time.
You can use O(t) to guess at S(t), but you want to use the
other observations before/after t to improve on that guess.

In a traditional HMM time occurs in discrete steps:
t is an integer, S(t) is either the same or different from S(t-1),
and you have the accompanying observation O(t).
But in many real-world situations time flows continuously,
and S can change at any moment.
Observations come at irregular intervals,
and they may or may not be close to the times that S changes.
If you are trying to guess S(t), the surrounding observations
are more/less informative depending on how far they are from t.

In math terms a traditional HMM assumes that S is a
discrete-time [Markov Chain](https://en.wikipedia.org/wiki/Markov_chain),
while a CT-HMM assumes that S is a
[continuous-time markov model](https://en.wikipedia.org/wiki/Continuous-time_Markov_chain)
and makes no assumption about what observations get taken.
The nuts-and-bolts math of a CT-HMM ends up being a lot trickier
than for a normal HMM, and partly for that reason they are not
used as commonly.
But in many situations they are essential.
ICQBotPy 0.2.6b0
"An ICQ async bot framework"
License: MIT
Keywords: icq bot framework async python

# ICQBOT

An actually working ICQ bot framework

- [Purpose](#purpose)
- [Getting Started](#getting-started)
    - [Installation](#installation)
    - [Example](#example)
- [Current State](#current-state)
- [TODO](#todo)
- [NOTES](#notes)

## Purpose

I made this bot framework for personal use, since the original ICQ bot framework is a mess and
almost impossible to work with.

This bot allows for easy development and has a concise syntax based of Aiogram with a really simple
async impl.

## Getting started

### Installation

You can install this framework with the command `pip install ICQBot`.

### Example

[Checkout the wiki!](https://github.com/kamuridesu/ICQBotPy/wiki).

## Current state

The bot does not implements full control of the ICQ new api yet, I'll try to map the other
endpoints asap. The current implementations are:

- Self:
    - `/self/get`
- Chats:
    - `/chats/members/delete`
    - `POST /chats/avatar/set`
    - `/chats/sendActions`
    - `/chats/getInfo`
    - `/chats/getAdmins`
    - `/chats/getMembers`
    - `/chats/getBlockedUsers`
    - `/chats/getPendingUsers`
    - `/chats/blockUser`
    - `/chats/unblockUser`
    - `/chats/resolvePending`
    - `/chats/setTitle`
    - `/chats/setAbout`
    - `/chats/setRules`
    - `/chats/pinMessage`
    - `/chats/unpinMessage`
- Message:
    - `/messages/deleteMessages`
    - `/messages/sendText`
    - `/messages/editText`
    - `/messages/answerCallbackQuery`
    - `GET /messages/sendFile`
    - `POST /messages/sendFile`
    - `GET /messages/sendVoice`
    - `POST /messages/sendVoice`
- Files:
    - `/files/getInfo`
    - `/messages/sendFile`
- Events:
    - `/events/get`
        - `newMessage`
        - `callbackQuery`

## TODO

- Map all of the others endpoints
- Use matches with regex or string match to search for terms in messages

## Notes

There's a known bug on aiohttp on windows that closes the event loop. I'm trying to fix this rn.