semvec/pypi-packages huggingface dataset:
binarycookies 2.3.0
Python Binary Cookies (de)serializer
Requires Python: <4.0,>=3.8

[![Github Actions Status](https://github.com/dan1elt0m/binary-cookies-reader/workflows/test/badge.svg)](https://github.com/dan1elt0m/binary-cookies-reader/actions/workflows/test.yml)
<h1>
  <img src="docs/bincook.png" width="30" style="vertical-align: middle; margin-right: 10px;">
  Binary Cookies
</h1>

CLI tool and Python library for reading and writing Binary Cookies.

### Documentation
For detailed documentation, please visit the [Binary Cookies Documentation](https://dan1elt0m.github.io/binarycookies/)

### Requirements

- Python >= 3.9

### Installation
```bash 
pip install binarycookies
```

### CLI example:
```sh
bcparser path/to/cookies.binarycookies
```

Output:
```json
[
  {
    "name": "session_id",
    "value": "abc123",
    "url": "https://example.com",
    "path": "/",
    "create_datetime": "2023-10-01T12:34:56+00:00",
    "expiry_datetime": "2023-12-31T23:59:59+00:00",
    "flag": "Secure"
  },
  {
    "name": "user_token",
    "value": "xyz789",
    "url": "https://example.com",
    "path": "/account",
    "create_datetime": "2023-10-01T12:34:56+00:00",
    "expiry_datetime": "2023-12-31T23:59:59+00:00",
    "flag": "HttpOnly"
  }
]
```
#### Output formats
The CLI supports multiple output formats using the --output flag.
- `json` (default): Outputs cookies in JSON format.
- `ascii`: Outputs cookies in a human-readable ASCII format with each cookie property on a separate line.
- `netscape`: Outputs cookies in the Netscape cookie file format.

### Basic Usage Python

#### Deserialization

```python
import binarycookies 

with open("path/to/cookies.binarycookies", "rb") as f:
    cookies = binarycookies.load(f)
```

#### Serialization

```python
import binarycookies 

cookie = {
    "name": "session_id",
    "value": "abc123",
    "url": "https://example.com",
    "path": "/",
    "create_datetime": "2023-10-01T12:34:56+00:00",
    "expiry_datetime": "2023-12-31T23:59:59+00:00",
    "flag": "Secure"
}

with open("path/to/cookies.binarycookies", "wb") as f:
    binarycookies.dump(cookie, f)
```

### Ethical Use & Responsible Handling
This project is intended for lawful, ethical use only. Typical, appropriate uses include:
- Inspecting Binary Cookies from your own devices or data you are authorized to access
- DFIR, QA, and security testing performed with explicit, written permission
- Educational/research work on datasets that are owned by you, anonymized, or publicly released for that purpose

You must not use this tool to:
- Access, extract, modify, or distribute cookies from systems or accounts you do not own or have permission to analyze
- Bypass authentication, session management, DRM, or other technical controls
- Enable tracking, stalking, doxxing, fraud, or other privacy-invasive or harmful activities


### License
This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.

### Contributing
Contributions are welcome! If you find a bug or have a feature request, please open an issue on GitHub. Pull requests are also welcome.
complexity-estimator-dimple 0.1.2
Estimate time and space complexity of Python functions using static analysis and runtime profiling.
Requires Python: >=3.10
Keywords: complexity, time complexity, space complexity, Big-O, profiling, static analysis

# complexity-estimator

Estimate (not prove) Big-O time & space complexity of Python functions.

## Features
- Static hints (loops, recursion)
- Runtime profiling (time + peak memory via `tracemalloc`)
- Model fit to {O(1), O(log n), O(n), O(n log n), O(n^2), O(n^3)}
- Decorator `@analyze` and CLI `complexity-analyze`

## Quick Start
```bash
pip install complexity-estimator
scapy-gptp 0.3.0
scapy layer definition and tools for GPTP (IEEE 802.1as)
Requires Python: >=3.10
Keywords: 802.1as, PTP, gPTP, scapy

# scapy-gptp - scapy layer definition and tools for GPTP (IEEE 802.1as)

![PyPI - Version](https://img.shields.io/pypi/v/scapy-gptp)
![PyPI - License](https://img.shields.io/pypi/l/scapy-gptp)
![PyPI - Python Version](https://img.shields.io/pypi/pyversions/scapy-gptp)


This python module contains the layer definition for PTPv2 (GPTP) which includes custom
definitions for `Timestamp` and `ClockIdentity` fields. It further provide some handy utils when
analyzing PTPv2 traces.

## Usage

The `PTPv2` layer is automatically bound to the Ethernet layer based on its `type` field (`0x88F7`).
Just import the `PTPv2` layer definition to make scapy aware of this bond and for example read a
pcap file to dissect

```python
from gptp.layers import PTPv2
from scapy.utils import rdpcap

pcap = rdpcap("traces.pcap")

for p in pcap:
    if p.haslayer('PTPv2'):
        p.show()
```

which yields something like

```
###[ Ethernet ]###
  dst       = 01:83:b0:02:21:fe
  src       = 7a:1b:31:80:11:06
  type      = 0x88f7
###[ PTPv2 ]###
     transportSpecific= 1
     messageType= Sync
     reserved0 = 0x0
     versionPTP= 2
     messageLength= 44
     domainNumber= 0
     reserved1 = 0x0
     flags     = TIMESCALE+TWO_STEP
     correctionField= 0
     reserved2 = 0x0
     sourcePortIdentity= 7a:1b:31:80:11:06/1
     sequenceId= 2081
     control   = 0x0
     logMessageInterval= -3
     reserved3 = None
###[ Padding ]###
        load      = '\x00\x00\x00\x00\x00\x00'
```

A handy addition when analyzing PTP traces is the `MatchedList` from `utils` module. You can add PTP
packets to it and it will automatically find matching `(Sync, FollowUp)` message pairs as well as
`(PdelayReq, PdelayResp, PdelayRespFollowUp)` message triplets, providing them as lists for easy
processing and analysis.

```python
from gptp.utils import MatchedList

pcap = rdpcap("traces.pcap")
matched_list = MatchedList([p for p in pcap if p.haslayer('PTPv2')])

(sync, fup) = matched_list.sync[0]
assert sync.sequenceId == fup.sequenceId
print(fup.preciseOriginTimestamp)  # prints 1602135835.0758622
```
json-hyperscan 0.1.0
Library for matching large numbers of JSONPath expressions simultaniously
Requires Python: >=3.10

JSON Hyperscan
================

A small, fast library that builds a simple "hyperscan" automaton to match many JSONPath (RFC9535-style) expressions against JSON documents. The project provides a compact in-process matcher that aims for parity with `jsonpath_rfc9535`.

Key features
------------
- Add many JSONPath selectors and build a matching automaton
- Query JSON documents for matches efficiently
- Support for field, child, descendant, index, slice and filter selectors
- Small, well-tested core implementation located at `src/json_hyperscan/json_hyperscan.py`

Quick start
-----------

Install (developer/test environment)

This project uses modern Python tooling. Create a virtual environment and install dev dependencies listed in `pyproject.toml`.

```bash
python -m venv .venv
source .venv/bin/activate
pip install -U pip

# Recommended (fast, reproducible): install uv and use it to manage deps
pip install uv
# Create a venv and install project + dev deps using uv's pip frontend
uv pip install -e .[dev]
```

Note about the compliance test-suite
----------------------------------

The project includes the JSONPath compliance tests as a git submodule at `tests/jsonpath-compliance-test-suite`.
CI checks out submodules automatically, but if you're running tests locally you may need to initialize it first:

```bash
git submodule update --init --recursive
```

Or, if you only need runtime installation (no dev extras):

```bash
pip install -e .
```

Basic usage
-----------

A minimal example using the public API in `JSONHyperscan`:

```python
from json_hyperscan import JSONHyperscan

hs = JSONHyperscan()
hs.add_pattern('$.store.book[*].author')
hs.add_pattern('$..title')

doc = {
	"store": {
		"book": [
			{"author": "Nigel Rees", "title": "Sayings of the Century"},
			{"author": "Evelyn Waugh", "title": "Sword of Honour"}
		]
	}
}

matches = list(hs.iter_matches(doc))
for m in matches:
	print(m)
```

License
-------
See the `LICENSE` file in the repository.

Acknowledgements
----------------
This project uses `jsonpath_rfc9535` for parsing and some tests compare output to other JSONPath implementations. See `pyproject.toml` for the dependency list used in development and testing.
pyphishtanklookup 1.5.1
Python CLI and module for PhishtankLookup
Requires Python: >=3.10

# PyPhishtank Lookup

This is the client API for [Phishtank Lookup](https://github.com/Lookyloo/phishtank-lookup),
not the official phishtank API.

## Installation

```bash
pip install pyphishtanklookup
```

## Usage

### Command line

You can use the `phishtank-lookup` command to search in the database:

```bash
usage: phishtank-lookup [-h] [--url URL] (--info | --url_query url | --urls_by_cc cc | --urls_by_ip ip | --urls_by_asn asn)

Search a URL in Phishtank Lookup.

optional arguments:
  -h, --help         show this help message and exit
  --url URL          URL of the instance (defaults to https://phishtankapi.circl.lu/).
  --info             Info avout the instance.
  --url_query url    URL to search.
  --urls_by_cc cc    Country Code to search.
  --urls_by_ip ip    IP address to search.
  --urls_by_asn asn  ASN to search.
```

### Library

See [API Reference](https://pyphishtanklookup.readthedocs.io/en/latest/)
sittagger 1.1.2
Image viewer with user-labels tag database
Requires Python: >=3.4
Keywords: browser, database, image, label, labelling, photo, python, tag, tagging, viewer

# SIT-Tagger

SIT-Tagger is an app for browsing tagged files.

For now, it consists in an image browser app, that allows to set custom
text tags on any image file, and then list image files matching checked
tags. The tags are saved in a local SQLite database.

Other apps reusing the same database will be added, and support for
video files will be added.

![sit-tagger window with a directory tree pane and the list of files (with thumbnails) from the selected dir](https://gitlab.com/hydrargyrum/sit-tagger/-/raw/master/docs/shot-dirview.jpg)

![sit-tagger window with a tags list pane (with a checkbox for each tag) and the list of files (with thumbnails) matching the checked tags](https://gitlab.com/hydrargyrum/sit-tagger/-/raw/master/docs/shot-tagview.jpg)

It also comes with a command-line tool to manipulate the tag database.

## Captions

SIT-Tagger lets you write text captions for files. In addition, any `#hashtags` you write in the caption are transformed into actual file tags. This makes tagging files easier while letting you comment your files.

![sit-tagger window with the list of files (with thumbnails) and a caption editor pane (showing a user-entered caption with #hashtags in it)](https://gitlab.com/hydrargyrum/sit-tagger/-/raw/master/docs/shot-caption.jpg)

## Command-line tool

SIT-Tagger comes with a command-line tool to manipulate the tag
database.

These 2 commands set tag foo and unset tag bar on some/file.jpg:

    sit-tagger-cli set +foo some/file.jpg
    sit-tagger-cli set -bar some/file.jpg

Combined in a single command:

    sit-tagger-cli set +foo -bar some/file.jpg

It\'s possible to query the list files tagged foo:

    % sit-tagger-cli query foo
    /tmp/some/file.jpg

Or show the tags of a file:

    % sit-tagger-cli show some/file.jpg
    /tmp/some/file.jpg = [foo]

List all tags:

    % sit-tagger-cli list-tags
    foo

Rename a tag:

    sit-tagger-cli rename-tag foo foonew

List all files:

    % sit-tagger-cli list-files
    /tmp/some/file.jpg

Remove all tags from a file:

    sit-tagger-cli untrack-files some/file.jpg

## Install

Install with [`pipx install sittagger`](https://pypi.org/project/sittagger/).