semvec/pypi-packages huggingface dataset:
MyCommonLib 0.8.12
Common library
Requires Python: <4.0,>=3.10
Keywords: SETUP LIBS

# myCommonLib
![Version 0.8.12](https://img.shields.io/badge/version-0.8.10-blue?style=plastic)
![Language Python 3.14.2](https://img.shields.io/badge/python-3.14.2-orange?style=plastic&logo=python)

Common library used in several project

## Installation

To install you can run the command

```console
python3 -m pip install MyCommonLib
```
or clone the project and install using the command 

```python
python3 -m pip install .
```

If you use the *pyprojext.toml* file you need to add the line 

```toml
"MyCommonLib",
```
in the *dependencies* array.

## Usage

```python
from MyCommonLib import Configure, Vers
```

## Contents

### Vers Class

Class for the manipulation of objects version following the [Semantic Versioning](https://semver.org/)


### Setup the logger Name
sherlock-mcp 0.1.6
Shelock Domains MCP server to buy & manage domains
Requires Python: >=3.10

# sherlock-mcp MCP server

Shelock Domains MCP server to buy & manage domains

## Components

### Resources

The server implements a simple note storage system with:
- Custom note:// URI scheme for accessing individual notes
- Each note resource has a name, description and text/plain mimetype

### Prompts

The server provides a single prompt:
- summarize-notes: Creates summaries of all stored notes
  - Optional "style" argument to control detail level (brief/detailed)
  - Generates prompt combining all current notes with style preference

### Tools

The server implements one tool:
- add-note: Adds a new note to the server
  - Takes "name" and "content" as required string arguments
  - Updates server state and notifies clients of resource changes

## Configuration

[TODO: Add configuration details specific to your implementation]

## Quickstart

### Install

#### Claude Desktop

On MacOS: `~/Library/Application\ Support/Claude/claude_desktop_config.json`
On Windows: `%APPDATA%/Claude/claude_desktop_config.json`

<details>
  <summary>Development/Unpublished Servers Configuration</summary>
  ```
  "mcpServers": {
    "sherlock-mcp": {
      "command": "uv",
      "args": [
        "--directory",
        "/Users/pengren/go/github.com/Fewsats/sherlock-mcp",
        "run",
        "sherlock-mcp"
      ]
    }
  }
  ```
</details>

<details>
  <summary>Published Servers Configuration</summary>
  ```
  "mcpServers": {
    "sherlock-mcp": {
      "command": "uvx",
      "args": [
        "sherlock-mcp"
      ]
    }
  }
  ```
</details>

## Development

### Building and Publishing

To prepare the package for distribution:

1. Sync dependencies and update lockfile:
```bash
uv sync
```

2. Build package distributions:
```bash
uv build
```

This will create source and wheel distributions in the `dist/` directory.

3. Publish to PyPI:
```bash
uv publish
```

Note: You'll need to set PyPI credentials via environment variables or command flags:
- Token: `--token` or `UV_PUBLISH_TOKEN`
- Or username/password: `--username`/`UV_PUBLISH_USERNAME` and `--password`/`UV_PUBLISH_PASSWORD`

### Debugging

Since MCP servers run over stdio, debugging can be challenging. For the best debugging
experience, we strongly recommend using the [MCP Inspector](https://github.com/modelcontextprotocol/inspector).


You can launch the MCP Inspector via [`npm`](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm) with this command:

```bash
npx @modelcontextprotocol/inspector uv --directory /Users/pengren/go/github.com/Fewsats/sherlock-mcp run sherlock-mcp
```


Upon launching, the Inspector will display a URL that you can access in your browser to begin debugging.
tinysexpr 1.7.0
A very simple S-expression parser that tries to make as little fuss as possible.
Requires Python: >=3.10

# S-Expression Parser

A very simple [S-expression](https://en.m.wikipedia.org/wiki/S-expression) parser that tries to make as little fuss as possible.

## Example

This module provides a single iterator
```
def read(file_like, coords=(1, 1), delims=DEFAULT_DELIMS, comment_char=';', atom_handler=lambda x: x)
```
that reads all S-expressions in the `file_like`.
Reading
```
(a b c (123 e f () x))
```
returns a `Sequence` object that corresponds to this nesting:
```
['a', 'b', 'c', ['123', 'e', 'f', [], 'x']]
```

The sequence object has a field `range` that is a pair of row/col pairs that give the coordinates of the S-expression in the input.
Furthermore, it has a tuple `item_ranges` that gives the coordinates of the `i`-th item of the S-expression.

## Atoms

`a`, `b`, `c` in the above example are called **atoms**.
Atoms are parsed using two different rules:
1. Every sequence that does not contain a whitespace, opening of closing parenthesis or the comment character is an atom.
2. Every sequence that starts and ends with a **delimiter** is an atom.
   The default delimiters are `"` for strings with the usual escape characters (`\n`, `\t`, `\"`, `\\`, ...) and `|` without escape characters.
   Using the `delims` parameter, you can customize the delimiters and their escape sequences.

## Details

The parameters of `read` are:
1. `file_like`: An object that is [file like](https://docs.python.org/3/glossary.html#term-file-object) i.e. provides a `read` method.
2. `delims`: A map of delimiters used to surround atoms that contain spaces.
   Commonly these are double-quotes to represent strings as in `"Hello"` or
   vertical bars to allow for symbols that contain spaces as in `|some symbol|`.
   The map `DEFAULT_DELIMS` specifies delimiters for strings and symbols.
3. `comment_char`: The character that starts a single line comment.
   The default value is `;`.
4. `atom_handler`: A function that is called when an atom is parsed.
   This function is passed a string that consists of the text of the parsed
   atom. The function can convert this string into something else and the
   returned value is used to construct the S-expression.
   For example, this allows for converting digit sequences into ints.

## Testing

To run the tests, execute `uv run pytest`.