semvec/pypi-packages huggingface dataset:
rxnSMILES4AtomEco 2025.6.1
Calculate atom economy for chemical reactions using reaction SMILES
Requires Python: >=3.8


# rxnSMILES4AtomEco:

This package provides functions to calculate the atom economy of chemical reactions using reaction SMILES.
It utilizes the RDKit library to handle molecular structures and properties.

### Features:
- Calculation of atom economy for reactions
- Handling of multiple reactions in a single calculation
- Support for different types of reaction SMILES
- Programmatic output of atom economy numerical value: verbose- and numberic output.
    
### Usage:
To use the package, simply import the relevant functions and provide reaction SMILES as input.
    
### Example verbose output:

```python
from rxnSMILES4AtomEco import atom_economy
reactions_smiles = "C.O>catalyst>{3}[HH]"
atom_economy(reactions_smiles)

 Atom Economy Calculation:
 
--------------------------------------------------
                      REACTANTS
..................................................
 SMILES:             C
 Molecular Formula:  CH4
 Molecular Weight:   16.04 g/mol
 Coefficient:        1.0
..................................................
 SMILES:             O
 Molecular Formula:  H2O
 Molecular Weight:   18.02 g/mol
 Coefficient:        1.0
--------------------------------------------------
--------------------------------------------------
                     PRODUCTS
..................................................
 SMILES:             [HH]
 Molecular Formula:  H2
 Molecular Weight:   2.02 g/mol
 Coefficient:        3.0
--------------------------------------------------

 Atom Economy:       17.8%
```

### Example Numeric Output:

```python  
from rxnSMILES4AtomEco import get_atom_economy
reactions_smiles = "C.O>catalyst>{3}[HH]"
value = get_atom_economy(reactions_smiles)
print(value)

17.8
```



### More info...
For more information, please refer to the documentation at https://pypi.org/project/rxnSMILES4AtomEco/
yassin-matrix 0.1.1
A simple Python library for multiplying two matrices of any size
Requires Python: >=3.6

# yassin-matrix

A lightweight Python library to multiply two matrices of any compatible size.

## Example

```python
from yassin_matrix import martices_multiplication

a = [[3, 2, 3], [7, 5, 6]]
b = [[79, 8], [0, 10], [1, 14]]

result = martices_multiplication(a, b)
print(result)
mkxcli 1.0.1
Simple CLI tools for make, encode, decode
Requires Python: >=3.6


# Make

This CLI (command line interface) is designed to make any file with custom contents.


## Documentation

This makes any file with any extension easily

eg. ```make hello.txt``` or ```make hello.bat```

There are parameters, those being
 ```-c``` eg. ```make hello.txt -c hi```

```-c``` = the contents of the file

```-encode``` eg. ```encode hi.txt```

```-decode``` does the opposite

Also the file is always made in the desktop folder


## Deployment

To deploy this project run

```pip install mkxcli```
conndoc 0.2.2
Diagnose connectivity and infrastructure issues from the CLI
Requires Python: >=3.9

# Conndoc

Over the years, troubleshooting the root cause of connection problems has always given me headaches. It often required using multiple different tools and manually interpreting their results.

`conndoc` is a simple yet extensive command-line tool that aims to make connectivity diagnosis easier. It supports checks for ping, DNS, SSL, HTTP, and TCP, and provides a handy summary view.

---

## 🚀 Installation

### 📦 pip
```bash
pip install conndoc
```

### 🍺 Homebrew (macOS)
```bash
brew tap hmerac/conndoc
brew install conndoc
```

---

## 🆘 Help
To see all available commands and options:
```bash
conndoc --help
```

You can provide either a domain name or a valid IP address as input to most commands.

---

## 🔍 Commands

### `summary`
Run all applicable checks and show a live summary table.
```bash
conndoc summary google.com
```

### `ping`
Ping a host.
```bash
conndoc ping google.com
```

### `checkdns`
Resolve a domain's DNS to IP addresses.
```bash
conndoc checkdns google.com
```

### `checkssl`
Inspect SSL certificate details (only for domains).
```bash
conndoc checkssl google.com
```

### `checkhttp`
Send an HTTP GET request and show basic diagnostics.
```bash
conndoc checkhttp https://google.com
```

### `checktcp`
Check if a TCP port is open.
```bash
conndoc checktcp google.com 443
```

For IPs, DNS and SSL will be skipped automatically.

---

## 📦 Project Info
- Python 3.9+
- Dependencies: `typer`, `rich`, `httpx`

---

## 🗺 Roadmap

Here are some planned and upcoming features for `conndoc`:

- **ICMP latency graph**  
  Show ping latencies over time as simple terminal plots.

- **Traceroute support**  
  Trace the path packets take through the network and measure latency at each hop.

- **Port scan (safe mode)**  
  Scan a set of common TCP ports to identify open services safely and quickly.

- **Save and export results**  
  Export diagnostics in JSON or Markdown format for easier sharing or CI integration.

- **Cross-platform packaging**  
  Add better support for Windows installers and Linux `.deb` / `.rpm` distributions.

- **Plugin support**  
  Let users extend Conndoc with custom checks that integrate into the summary view.

---

## 🤝 Contributing

Contributions are very welcome! Whether it's fixing a bug, improving the documentation, or suggesting a new feature — every bit helps.

If you're unsure where to start, feel free to open an issue or check out the roadmap for ideas.  

By contributing, you agree that your code will be licensed under the [Apache License 2.0](LICENSE).

### Quick Start
- Fork the repository
- Create a new branch (`git checkout -b my-feature`)
- Make your changes
- Commit and push (`git commit -am 'Add feature' && git push`)
- Open a Pull Request 🚀

If you're adding a new feature, try to include a short demo or usage example.

Looking forward to seeing what you build!

---

## 📄 License
Apache License 2.0
logoo 1.6.0
Openobserve log ingestion made simple.
Requires Python: >=3.10

## Logoo
#### A log ingestion engine for [openobserve](https://github.com/openobserve/openobserve)

*Pronounced log-ew*

`pip install logoo`

### Examples

Primary file. One instance of `PrimaryLogger` is required per program.
```python
import asyncio

from logoo import PrimaryLogger


async def main():
    logger: PrimaryLogger = PrimaryLogger(
        __name__,
        base_url="",
        org="",
        stream="",
        username="",
        password="",
        poll_time=5,
    )
    await logger.start_consumer()

    logger.info("Hello world!")
    logger.critical("Something went wrong!")
    await asyncio.sleep(10)


asyncio.run(main())
```

Any other file:
```python
from logoo import Logger

logger = Logger(__name__)
logger.info("This comes from another file.")
```

Note that this supports argument interpolation and can be a fairly good drop in logging replacement:
```python
from logging import Logger as built_in_logger
from logoo import Logger

log = built_in_logger(__name__)
logger = Logger(__name__)

log.info("%s", "Test")
logger.info("%s", "test")
```

Documentation is as follows and remarkably simple:
```text
Parameters
----------
name: str
    The name of the logger
base_url: str
    Your base openobserve URL.

    E.g. `base_url="https://logs.example.com"`
org: str
    The org to make logs under
stream: str
    The stream for these logs to be ingested under
username: str
    The username to use for auth
password: str
    The password to use for auth
logs_per_call: int
    How many logs to send per request to your instance.
    Useful to set, so you don't hit things like WAF request
    limits in high throughput environments.
    
    Note logoo makes as many requests as required
    to exhaust the queue every `poll_time`.

    Defaults to `100`.
poll_time: datetime.timedelta | float
    How often to send all logs to your instance.

    Defaults to every `30` seconds.
extra_metadata: dict
    Extra metadata to add to all logs made by this class
global_metadata: dict
    Extra metadata to add to every log sent to your instance
```

---

### Support

Want realtime help? Join the discord [here](https://discord.gg/BqPNSH2jPg).

---

### License
This project is licensed under the MIT license
vikinglotto 0.0.6
Generate lottery numbers for Vikinglotto and Eurojackpot
Requires Python: >=3.6

# vikinglotto-generator

This program can generate a set of randomly picked lottery numbers 
for [Vikinglotto](https://en.wikipedia.org/wiki/Vikinglotto)
and [Eurojackpot](https://en.wikipedia.org/wiki/Eurojackpot).

The program's output supports showing the result using `cowsay` for added fun.
The generated numbers are stored in a log file and can be reviewed if necessary. 

![Demo](./img/demo.png)

[中文说明](./README_CN.md)

## Requirements

If you need the program to display the results as `cowsay`, you need to have `cowsay` installed on your system.

Take Debian & Ubuntu as an example:

```bash
sudo apt update
sudo apt install cowsay -y
```

## Installation

Use `pip`:

```
python3 -m pip install vikinglotto
```

## Usage

Run the program in `cowsay` mode:

```bash
vikinglotto
```

Without using `cowsay`, print the result directly:

```bash
vikinglotto --plain
```

Generate numbers for Eurojackpot:

```bash
vikinglotto --euro
```