semvec/pypi-packages huggingface dataset:
ophyd-devices 0.29.2
Custom device implementations based on the ophyd hardware abstraction layer
Requires Python: >=3.10

# Ophyd Devices

ophyd-devices is an extension to [ophyd](https://github.com/bluesky/ophyd) and provides device support for devices not covered by the standard EPICS implementation in ophyd. 

## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install ophyd-devices.

```bash
pip install ophyd-devices
```

For development, clone the repository and install the package in editable mode:

```bash
git clone https://gitlab.psi.ch/bec/ophyd_devices.git
cd ophyd_devices
pip install -e .[dev]
```

## Documentation

The documentation for the usage with BEC can be found  [here](https://bec.readthedocs.io/en/latest/). More general documentation can be found [here](https://blueskyproject.io/ophyd/).

## Contributing

Merge requests are very welcome! For major changes, please open an issue first to discuss what you would like to change.
All commits should use the Angular commit scheme:

```
<type>(<scope>): <short summary>
  │       │             │
  │       │             └─⫸ Summary in present tense. Not capitalized. No period at the end.
  │       │
  │       └─⫸ Commit Scope: animations|bazel|benchpress|common|compiler|compiler-cli|core|
  │                          elements|forms|http|language-service|localize|platform-browser|
  │                          platform-browser-dynamic|platform-server|router|service-worker|
  │                          upgrade|zone.js|packaging|changelog|docs-infra|migrations|ngcc|ve|
  │                          devtools
  │
  └─⫸ Commit Type: build|ci|docs|feat|fix|perf|refactor|test
```

The `<type>` and `<summary>` fields are mandatory, the `(<scope>)` field is optional.
##### Type

Must be one of the following:

* **build**: Changes that affect the build system or external dependencies (example scopes: gulp, broccoli, npm)
* **ci**: Changes to our CI configuration files and scripts (examples: CircleCi, SauceLabs)
* **docs**: Documentation only changes
* **feat**: A new feature
* **fix**: A bug fix
* **perf**: A code change that improves performance
* **refactor**: A code change that neither fixes a bug nor adds a feature
* **test**: Adding missing tests or correcting existing tests


Please make sure to update tests as necessary.

## License

[BSD-3-Clause](https://choosealicense.com/licenses/bsd-3-clause/)
isne-recommendation 0.1.3
The recommendation system aims to suggest the best suitable courses for learners who have taken at least one course.
Requires Python: >=3.8

# Recommendation System

The recommendation system aims to suggest the best suitable courses for learners who have taken at least one course.

## Table of Contents

- [Installation](#installation)
- [Usage](#tutorial)
- [Contributing](#contributors)
- [License](#license)

## Installation

To install and set up the project, you can use the following command:

```[PowerShell]
pip install isne-recommendation
```

For detailed instructions on how to install the Study Focus Recommendation System, please navigate to our installation guide on [installation](https://docs.isne-recommendation.com/get-started/installation). Follow the step-by-step instructions to set up the system on your machine and start enhancing your study experience today.

## Tutorial

After installation is successful, you can now import these functions from an isne_recommendation package:

```[PowerShell]
from isne_recommendation import TfidfLinearKernel, FeatureRatingsKNN, Hybrid
```

Are you seeking to unravel the mysteries behind recommendation systems? Look no further! Dive into the comprehensive guide available at [tutorial](https://docs.isne-recommendation.com/get-started/tutorial).

## Contributors

Check out our [contribution guidelines](https://docs.isne-recommendation.com/contributors) to learn how you can get involved. Whether it's coding, documentation, testing, or providing feedback, every contribution makes a difference and helps us create a better tool for students worldwide.

## License

**License:** MIT

Please refer to the [LICENSE](https://docs.isne-recommendation.com/license) for more details.
R3XA 2024.4.8
Remember, Reuse and Replicate eXperiments and Analyses
Requires Python: <4.0.0,>=3.8.1

# R3XA
## Remember, Reuse and Replicate eXperiments and Analyses

### Specs
- overleaf: https://www.overleaf.com/project/660bc2619d82bd8e8e107397
- online: https://photomecanics.gitlab.io/r3xa/doc/
- json: https://gitlab.com/photomecanics/r3xa/-/raw/main/resources/schema.json
clirm 0.1
Command line-oriented ORM.
Requires Python: >=3.11
Keywords: database, cli, orm

# clirm

Command-Line ORM (clirm) is a library for creating simple ORMs that
can be used in command-line programs that allow users to manipulate
objects in an interactive context, and that also regularly run scripts
that iterate over the entire database.

Features include:

- Changes are always committed to the database immediately, so that
  there is no need to worry about a separate later "save" step.
- There is always only one object per database row, so that users
  do not need to worry about editing one copy and leaving another
  ORM object corresponding to the same row unchanged.
- All columns in a row are always fetched together, to simplify
  implementation of the above point.
- Tight integration with the type system. Fields can be declared
  as `Field[T]()`, where `T` is a normal Python type.

Clirm requires that every table has an `id` column containing
a unique identifier.

## Usage

As an example, we will create a simple database containing
animal taxa:

```python
import enum
import sqlite3
from typing import Self

from clirm import Clirm, Field, Model

class Status(enum.Enum):
    living = 1
    recently_extinct = 2
    fossil = 3

CLIRM = Clirm(sqlite3.connect("taxon.db"))

class Taxon(Model):
    clirm = CLIRM
    clirm_table_name = "taxon"

    name = Field[str]()  # string field
    status = Field[Status]()  # enum field
    common_name = Field[str | None]()  # nullable string field
    parent = Field[Self | None]()  # foreign key to self; can also write "Taxon | None"

if __name__ == "__main__":
    txn1 = Taxon.create(
        name="Mammalia", status=Status.living, common_name="Mammals"
    )
    txn2 = Taxon.create(
        name="Rodentia", status=Status.living, common_name="Rodents",
        parent=txn1
    )
    tnx3 = Taxon.create(
        name="Multituberculata", status=Status.fossil, parent=txn1
    )

    living_taxa = Taxon.select().filter(Taxon.status == Status.living)
    assert living_taxa.count() == 2
    assert {txn.common_name for txn in living_taxa} == {"Mammals", "Rodents"}
    for txn in living_taxa:
        txn.common_name = txn.common_name + "!"

    # Change is immediately visible
    assert txn1.common_name == "Mammals!"
```

## Supported types

The following field types are currently supported:

- Primitive types, e.g., `int`, `str`, `bool`, which are passed
  directly to the database
- Enums, which are converted to their value before being passed to
  the database
- Foreign keys to other clirm models, which are stored as their
  IDs
- Foreign keys to the current class, which can be expressed with `typing.Self`
- Nullable versions of any of the above, expressed by adding `| None`
  to the type

Additional types can be supported by subclassing `Field` and overriding
the `deserialize` and `serialize` methods.

## Backends

For now only SQLite is supported as a backend.

## Changelog

Version 0.1 (April 8, 2024)

- Initial release