semvec/pypi-packages huggingface dataset:
simplestructlogs 0.0.4
A simple wrapper around the standard logging library to support structured logging.
Requires Python: >=3.8
Keywords: logging,structured,structured-logging

# simplestructlogs

A simple wrapper around the python standard logging library that supports structured logs.

JSON logs are supported out of the box, but you can write your own log record classes to support other formats!

## Example Usage

```python
from simplestructlogs import StructuredLogger
import logging

def raise_err():
    raise Exception("BOOM")

if __name__ == "__main__":
    logger = StructuredLogger.get_default_logger("calvin", logging.DEBUG, {"parent-context": "This is cool!"})
    logger.debug("debug test")
    child_logger = logger.make_child_context_logger("calvin-child", {"child-context": "woo hoo!"})
    err = KeyError("uh oh")
    child_logger.info("an error", exc_info=err, stack_info=True, extra={"value1": 123, "value2": {"value3" :"456"}})
    try:
        raise_err()
    except Exception as e:
        logger.exception("testing exception logging")
        logger.warn("test with warning", exc_info=e)
        logger.warn("test with warning", is_exception_call=True)

```
PyTML5 1.0.0b0
This is PyTML5, a module for writing HTML using Python.
Requires Python: >=3.6

# __PyTML5__

**PyTML5** is a python module used to make static html webpages using python syntax

## Functions

### setup()

A function used to setup the first things at the webpage and they are the `Language` and the `Title`,and the user can't make the webpage without adding the setup code but he can just write it without adding something but it will set the title and the language to defult.

### setDescription()

A function used to add description to the html code, returns a string like that
```html
<meta name="description" content="{YourWebpage Description}">
```

### addLinking()

A function used to link a file with the html code, returns a string like that
```html
<link rel="{type of the linking}" herf="linkedFile">
```

### setCharset()

A function used to set the charset of the webpage like UTF-8,returns a string like that
```html
<meta charset="UTF-8">
```

### setViewport()

A function used to set the viewport of the webpage like `initial-scale`,`width` and `height`,returns a string like that
```html
<meta name="viewport" content="{your content}">
```

### addMeta()

A function used to add a custom meta (as name and content only),returns a string like that
```html
<meta name="{your meta name}" content="your meta content">
```

### addCustomMeta()

A function used to add a custom meta (as you want),returns like that
```html
<meta {your attributes}>
```

### addNewHeadElement()

A function used to make anew two sides element like `<element></element>`

### addNewBodyElement()

A function used to add an elementto the body,but with another module at PyTML named `Webgets`and can return with one side element or two sides element

### generateHTML()

This is the most important function,and its used to generate the html after adding elements and returns it as string
datadiff 2.2.0
DataDiff is a library to provide human-readable diffs of python data structures.
Keywords: data,diff

DataDiff
========

DataDiff is a library to provide human-readable diffs of python data structures.
It can handle sequence types (lists, tuples, etc), sets, and dictionaries.

Dictionaries and sequences will be diffed recursively, when applicable.

It has special-case handling for multi-line strings, showing them as a typical unified diff.

Drop-in replacements for some nose assertions are available.  If the assertion fails,
a nice data diff is shown, letting you easily pinpoint the root difference.

``datadiff`` works on Python 2.6 through Python 3.

DataDiff project homepage: http://sourceforge.net/projects/datadiff/

Example
-------

Here's an example::

    >>> from datadiff import diff
    >>> a = dict(foo=1, bar=2, baz=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
    >>> b = dict(foo=1, bar=4, baz=[0, 1, 2, 3, 4, 5, 6, 7, 8])
    >>> print diff(a, b)
    --- a
    +++ b
    {
    -'bar': 2,
    +'bar': 4,
     'baz': [
     @@ -5,11 +5,8 @@
      6,
      7,
      8,
     -9,
     -10,
     -11,
     ],
     'foo': 1,
    }
    >>>
    >>> from datadiff.tools import assert_equal
    >>> assert_equal([1, 2, 3], [1, 2, 5])
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
      File "datadiff/tools.py", line 29, in assert_equal
        raise AssertionError(msg)
    AssertionError:
    --- a
    +++ b
    [
    @@ -0,2 +0,2 @@
     1,
     2,
    -3,
    +5,
    ]

License
-------

Copyright Dave Brondsema

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

  http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
collect-framework-oleksandr 0.0.1
Program count unique letters in a word
Requires Python: >=3.10

# Collect Framework

Welcome to my project! This program will help you to count unique letters.

## Table of Contents

- [Introduction](#introduction)
- [Installation](#installation)
- [Usage](#usage)
- [License](#License)

## Introduction

This project helps you to count unique letters in any word

## Installation

To get started, follow these steps:

Clone the repository: `git clone https://git.foxminded.ua/foxstudent105474/task5.git`


## Usage

Run the application using the following command:
1. python -m task.collect_framework --string (your word)
2. python -m task.collect_framework --file (path to your file)
 
## License

This project is licensed under the [GNU GPLv3 License](LICENSE).