semvec/pypi-packages huggingface dataset:
wyckoff 0.3.2
A package for working with Wyckoff positions in crystallography
Requires Python: <3.13,>=3.10

# Wyckoff

A Python package for working with Wyckoff positions in crystallography.

## Installation

```bash
pip install wyckoff
```
OR
```bash
uv add wyckoff
```

## Usage

Simple Example:

```python
from wyckoff import WyckoffDatabase

wyckoff = WyckoffDatabase()
data = wyckoff.data

for items in data["2"].wyckoff_positions:
    print(items)

print("Spacegroup 3:") # which is 3-b varient
print(data["3"].wyckoff_positions)
```
for more complex example checkout the [example](https://github.com/anoopkcn/wyckoff/blob/main/examples/usage.py) file

## Info

**IMPORTANT: If variations are available for a spacegroup, and functions/dictionary are called/indexed without specifying the variation then first available variation will be returned.**

Following variation types are included in the database:

1. **Unique axis settings**: Suffixes like "-b" and "-c" typically indicate which crystallographic axis is chosen as the unique axis, especially in monoclinic and orthorhombic systems. For example:
   - "3-b" means space group 3 with b-axis as the unique axis
   - "3-c" means space group 3 with c-axis as the unique axis

Example:
```python
data["3-b"]  # Space group 3 with b-axis as the unique axis
```

2. **Origin choice**: Suffixes like "-1" and "-2" usually indicate different origin choices for the same space group:
   - "48-1" is space group 48 with origin choice 1
   - "48-2" is space group 48 with origin choice 2

Example:
```python
data["48-1"]  # Space group 48 with origin choice 1
```
3. **Cell choices**: Some suffixes may represent different conventional cell choices (hexagonal vs. rhombohedral settings in trigonal groups, for example).

Example:
```python
data["148-hexagonal"]  # Space group 148 with hexagonal cell
```

## Data Source

This implementation is inspierd by a utility fuction in [doped](https://github.com/SMTG-Bham/doped/tree/main) project. That version used a non-standard datafile for parsing the Wyckoff positions from [bilbao crystallographic server](https://www.cryst.ehu.es/). This implementation uses a standard JSON file for parsing the Wyckoff positions, add additional checks and validations to ensure data integrity, remove a bug that produces duplicate Wyckoff positions
and custom wyckoff dataclass, etc,.

## License

MIT
cisco-nso-restconf 1.0.5
A Python client library for interacting with the Cisco NSO RESTCONF API
Requires Python: <4.0,>=3.8.1

# cisco-nso-restconf

## Overview

This Python library provides an interface for interacting with the Cisco Network Services Orchestrator (NSO) RESTCONF API.

## Features

* **RESTCONF API Access:** Use the [NSORestconfClient](cisco_nso_restconf/client.py) class to make raw GET, POST, & DELETE requests to any RESTCONF ```/data``` resource.
* **Utility Classes:** Use pre-built helper classes, such as the [Devices](cisco_nso_restconf/devices.py) class, or [Query](cisco_nso_restconf/query.py) class, to simplify common operations, like fetching all device NED ID's.

## Requirements

* NSO RESTCONF Configuration
  * To use this library, RESTCONF must be enabled in NSO. Please refer to the documentation specific to the NSO version being used to determine how to enable RESTCONF in NSO.

## Installation

You can install the library using pip:

```bash
pip install cisco-nso-restconf
```

## Client Class

Use the [NSORestconfClient](cisco_nso_restconf/client.py) class to interact with the NSO RESTCONF API ```/data``` resource

### Methods Supported

* GET, POST, DELETE

## Utility Classes

To make the process easier, the library also provides utility classes for specific tasks. For example, the [Devices](cisco_nso_restconf/devices.py) class simplifies interaction with ```tailf-ncs:devices``` RESTCONF resources.

### Available Utility Classes

| Class   | Description                                            |
|---------|--------------------------------------------------------|
| Devices | Interact with the NSO ```tailf-ncs:devices``` resource |
| Query   | Interact with the NSO ```tailf-ncs:query``` resource   |

### Closing Sessions

When using the NSORestconfClient, it’s important to close the session when you’re done to free up resources. You can do this using the close() method, as shown in the examples above.

## Examples

There are a number of [examples](examples) provided for utilizing the Client classes and various Helper classes, such as the ```Devices``` class. The examples are intended to showcase basic use cases/workflows for achieving a specific function in NSO, such as retrieving NED ID's, device groups, life cycle of a VLAN resource, life cycle of a service, and so on.

### Running Examples

To run the examples, you'll need to install the development dependencies which include the `rich` library for enhanced terminal output. Use [UV](https://docs.astral.sh/uv/) to install these dependencies:

```shell
uv sync
```

This will install all required dependencies, including those needed for the examples. Without installing the development dependencies, the examples that use the `rich` library for output formatting will not work.

## Contributing

We welcome contributions! Feel free to open issues or submit pull requests. For development, we recommend using [UV](https://docs.astral.sh/uv/) to manage dependencies and packaging.

```shell
uv sync
```

## License

This project is licensed under the MIT License.
vereshchaginpy 0.1.4
Graph-based integration for structural mechanics using the Vereshchagin method
Requires Python: >=3.7

# VereshchaginPy

**VereshchaginPy** is a Python library for performing graph multiplication — particularly useful in structural mechanics when applying the flexibility method.

The integration is based on the principle that the integral from two graphs can be expressed as:

```
∫ Mi(x) * Mj(x) dx = A * y
```

Where:
- `A` is the area under the first moment diagram `Mi(x)`
- `y` is the corresponding ordinate (value) from the second moment diagram `Mj(x)` evaluated at the centroid of area `A`
- `Mi`, `Mj` are continuous functions (e.g., moments) over a shared length `L`

This library helps formalize that process by abstracting common shape-based moment diagrams (rectangles, triangles, trapezoids, parabolas) and automating their integration and visualization.

---

## Installation

Install the package via pip:

```bash
pip install vereshchaginpy
```

---

## Example Usage

```python
from vereshchaginpy import Rectangle, TriangleLeft, VereshchaginVisualiser

# Define two figures
r = Rectangle(5, 3)
t = TriangleLeft(5, 2)

# Visualize the interaction
viz = VereshchaginVisualiser()
viz.draw_situation(r, t)

# Compute the integral using the + operator
result = r + t

print(f"Result: {result}")
```

---

## Features

- Support for standard structural figure types:
  - `Rectangle`
  - `TriangleLeft`, `TriangleRight`
  - `Trapezoid`
  - `Parabola`
  - `ParabolicTrapezoid` (combining a parabola and trapezoid)
- Clean and extendable figure model
- Visualizer to plot and label diagrams
- Operator overloading for quick integration via `+`
- Strict input validation for type safety

---

## Project Links

- GitHub: https://github.com/Haudkozaur/VereshchaginPy
- PyPI: https://pypi.org/project/vereshchaginpy

---

## License

This project is licensed under the MIT License. See the `LICENSE` file for details.