semvec/pypi-packages huggingface dataset:
bravas 0.0.1a0
A unified interface for profiling and analyzing GPU applications on different platforms.
Requires Python: >=3.8

# BRAVAS
Bottleneck and Resource Analysis for Visualization and Acceleration of gpuS

![bravas](https://github.com/OkkeVanEck/bravas/assets/39912605/4a73d3ea-2213-43f7-acf1-07de9878b21c)
rdfox 7.1.1
 RDFox is a high performance knowledge graph and semantic reasoning engine.
Requires Python: ~=3.5

RDFox PyPI distribution
=======================

[RDFox][rdfox] is a knowledge graph and semantic reasoning engine from Oxford Semantic Technologies. This [rdfox-pypi][pypi] Python package is an unofficial redistribution of the RDFox binaries so they can be used as a dependency of Python projects.

[rdfox]: https://www.oxfordsemantic.tech/product
[pypi]: https://pypi.org/project/rdfox/

Usage
-----

To run RDFox from the command line, use:

```shell
python -m rdfox
```

To run RDFox from a Python program, use `sys.executable` to locate the Python binary to invoke. For example:

```python
import sys, subprocess

subprocess.call([sys.executable, "-m", "rdfox"])
```

License
-------

RDFox requires a licence from Oxford Semantic Technologies.
docker-snapshot 1.0.11
`ds` is a development utility for managing snapshots inside a docker container.
Requires Python: <4.0,>=3.9

# ds - docker snapshot

`ds` is a development utility for managing snapshots inside a docker container.

Personally I use it to quickly save the state of my development database, try out something that mutates the state - a data migration or user interaction - and return to the initial state. Often repeatedly, because trial and error is essential. You can probably use it on any sort of stored data, probably. 

Note: This repository is still a work in progress.

## Installing
```bash
# Note: executable will be called `ds`
pip install docker-snapshot
```

Shell completion:
```bash
# For Bash, add this to ~/.bashrc:
eval "$(_DS_COMPLETE=source_bash ds)"

# For Zsh, add this to ~/.zshrc:
eval "$(_DS_COMPLETE=source_zsh ds)"
```


## Usage

Create a snapshot
```bash
ds create name-goes-here
# or auto-generate a name
ds create 
```

Restore a snapshot
```bash
ds restore name-goes-here
# or restore the latest snapshot
ds restore
```

List snapshots
```bash
ds ls
```

Delete snapshots
```bash
ds delete name-goes-here
```

## Example project setup
In this example we use `ds` to create and restore database snapshots in our development environment. The projects `docker-compose.yml` file could look something like this:
```
version: "3.8"
services:
  db:
    container_name: db
    restart: always
    image: postgres:13
    env_file: .env
    ports:
      - 5432:5432
    volumes:
      - db-volume:/var/lib/postgresql/data
  ...
```

1) Browse to your project root
```bash
cd code/your-awesome-project
```

2) Create `ds.yaml` template file
```bash
ds init
```

3) Edit your `ds.yaml`
```yaml
# The target container
container_name: "db"

# The directory inside said container that you want to snapshot
directory: "/var/lib/postgresql/data"

# Identifier to separate projects, this allows you:
# - To have multiple projects with the same container name
# - To have multiple setups (ie. docker-compose / kind) for the same project
namespace: "your-awesome-project"
```
log2kusto 0.1.4
Logging handler module that writes the logs to Kusto database.

# Log2Kusto

log2kusto is a Python logging handler library for saving the generated log records to a Kusto database table.

## Installation

Use the package manager [pip](link will be updated) to install foobar.

```bash
pip install log2kusto
```

# Requirments
- Python logging library
- An MS internal library for providing credentials to authenticate to Kusto (working on making it open source.)

## Usage

```python
import logging
from log2kusto.kusto_handler import KustoHandler

class CustomFormatter(logging.Formatter):
    def __init__(self, fmt=None, datefmt=None, style='%', validate=True, attributes_list=[]):
        super().__init__(fmt, datefmt, style, validate)
        self.attributes = attributes_list

    def format(self, record):
        print("in format")
        for attr in self.attributes:
            print(attr)
            if not hasattr(record, attr):
                setattr(record, attr, '')
        return super().format(record)

#https://docs.python.org/3/library/logging.html#logrecord-attributes
logrecord_attributes_list = ['asctime', 'levelname', 'filename', 'funcName', 'module', 'message']
custom_attributes_list = ['env', 'domain']
all_attributes_list = logrecord_attributes_list + custom_attributes_list
formatter = CustomFormatter('%(' + ((')s' + " ; " + '%(').join(all_attributes_list)) + ')s', "%Y-%m-%d %H:%M:%S", \
                            attributes_list=all_attributes_list)

kusto_handler = KustoHandler(<kusto cluster name>, <kusto database>, <kusto table name>, all_attributes_list)
kusto_handler.setLevel(logging.INFO)
kusto_handler.setFormatter(formatter)

logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
logger.addHandler(kusto_handler)

d = {'env':'stage', 'domain':'xyz'}
while True:
    log = input("> ")
    if log.strip().lower() != "quit":
        logger.warn(log)
        logger.info(log, extra=d)
    else:
        break

## Contributing
Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

Please make sure to update tests as appropriate.

## License
[MIT](https://choosealicense.com/licenses/mit/)