semvec/pypi-packages huggingface dataset:
jikoku 0.0.1
Python utility to generate working timetables from general schedule data.
Requires Python: >=3.11,<4.0

# Jikoku  
  
Flexible and extendable Python utility for generating working timetables from general schedule data.  
  
## Basic Usage Example

```python
from jikoku.models import Stop, Service
from jikoku.scheduler import schedule
from datetime import time, timedelta

# Define a simple service and return service
starts = time(hour=8)
ends = time(hour=9, minute=30)

first = Service("a_service", starts, ends, [Stop("Teufort", starts), Stop("Badlands",ends)])
first_return = Service( "a_return_service",starts , ends, [Stop("Badlands", starts), Stop("Teufort", ends)])

# Copy those services throughout the day
all_services = [first + timedelta(hours=i) for i in range(4)] + ([first_return + timedelta(hours=i) for i in range(4)])

# Schedule the services
generated_schedule = schedule(all_services)
print(generated_schedule)
"""prints the following:

train-ZT4bwn
        09:00:00 - 10:30:00: Teufort => Badlands
        11:00:00 - 12:30:00: Badlands => Teufort
train-eP9nMb
        08:00:00 - 09:30:00: Badlands => Teufort
        10:00:00 - 11:30:00: Teufort => Badlands
train-hVGMEI
        08:00:00 - 09:30:00: Teufort => Badlands
        10:00:00 - 11:30:00: Badlands => Teufort
train-jzVbxj
        09:00:00 - 10:30:00: Badlands => Teufort
        11:00:00 - 12:30:00: Teufort => Badlands
"""
```

Have a look at [the documentation](/docs) for more examples, including real word schedules from JR & SNCF! 
  
## Installation  
  
Jikoku is available on PyPI. Install via using (preferably in a virtual environment) via:
```bash
pip install jikoku
```

## Contributing

Pull requests, feature requests or other ideas always welcome.
To get a local development environment setup, you will need [Poetry](https://github.com/python-poetry/poetry) installed. Then:
```bash
git clone https://github.com/TakeoIschiFan/Jikoku
cd Jikoku
poetry install
```
> Note: use `poetry install --with docs if you want to compile the documentation website

To get logging working, add a `.env` file in the root directory which contains the following variables
```txt
PYTHONPATH="jikoku:tests"
DEBUG="true"
```
servicenow-selenium 0.2
A simple selenium wrapper for ServiceNow
Requires Python: >=3.6

# ServiceNow Selenium Wrapper

A simple selenium wrapper designed for interaction with ServiceNow. This package simplifies logging in, managing alerts, and interacting with shadow elements within the ServiceNow environment.

## Installation

To install the package, use pip:

```bash
pip install servicenow-selenium
```

## Usage

Initialize the ServiceNowSelenium class by providing the URL, username, and password:

```python
from servicenow_selenium import ServiceNowSelenium

selenium_wrapper = ServiceNowSelenium(url="YOUR_SERVICENOW_URL", username="YOUR_USERNAME", password="YOUR_PASSWORD")
```

### Key Features:

1. **Login**:
   Easily log into ServiceNow:

   ```python
   selenium_wrapper.login()
   ```
2. **Logout**:
   Log out and quit the driver:

   ```python
   selenium_wrapper.logout(user_menu_path="JS_PATH_HERE", logout_path="JS_PATH_HERE")
   ```
3. **Interact with Shadow DOM Elements**:
   Click shadow elements using JS path:

   ```python
   selenium_wrapper.click_shadow_element(errorName="element name for error reference", js_path="JS_PATH_HERE")
   ```
   Note: The provided JS path must contain "return" to correctly fetch the element. For instance, `return document.querySelector(...)`
4. **Check for Element Presence**:
   Determine if an element is present using its JS path:

   ```python
   is_present = selenium_wrapper.is_element_present(js_path="JS_PATH_HERE")
   ```
modality 0.1.0
A python client library for the Modality API
Requires Python: >=3.7

# Python Client Library for Modality

This is a library for the python programming language used to interact with
Auxon's Modality suite of products.

It currently provides read access to data stored within the Modality database,
both as raw trace data and in-place statistical analyses.

The primary interface is in `modality.client`. The functions
`events_dataframe`, `event_value_distributions_dataframe`,
`experiment_overview`, and `workspace_segments` allow access to trace data
stored within modality. See the inline documentation for more information, eg.:

```python
from modality import client
help(client)
```

## Running tests

```python
pip3 install -U pytest
pip3 install -U appdirs
pytest
```
serverless-sdk 0.6.0
Serverless SDK for Python
Requires Python: >=3.7

# serverless-sdk

## [Serverless Console](https://www.serverless.com/console) SDK for Python

### Use case

Environment agnostic [Serverless Console](https://www.serverless.com/console) instrumentation functions for Python applications.

This library is safe to use without side-effects in any Python application. It becomes effective once (one of the listed below) environment specific SDK is loaded on top.

#### Environment extensions

- **AWS Lambda** - [serverless-aws-lambda-sdk](https://github.com/serverless/console/tree/main/python/packages/aws-lambda-sdk#readme)

### Installation

```shell
pip install serverless-sdk
```

### Usage

```python
from sls_sdk import serverlessSdk
print(serverlessSdk.name)
print(serverlessSdk.version)

serverlessSdk.capture_error(Exception("Unexpected"))
```

### Setup

#### 1. Register with [Serverless Console](https://console.serverless.com/)

#### 2. Initialize and setup SDK specific to your enviroment

See [Environment extensions](#environment-extensions)

##### 2.1 Configuration options

_Common options supported by all environments:_

###### `SLS_ORG_ID` (or `org_id`)

Required setting. Id of your organization in Serverless Console.

##### `SLS_DISABLE_HTTP_MONITORING` (or `disable_http_monitoring`)

Disable tracing of HTTP and HTTPS requests. See [HTTP instrumentation](docs/instrumentation/http.md)

##### `SLS_DISABLE_REQUEST_RESPONSE_MONITORING` (or `disable_request_response_monitoring`)

(Dev mode only) Disable monitoring requests and reponses (function, AWS SDK requests and HTTP(S) requests)

##### `SLS_DISABLE_FLASK_MONITORING` (or `disable_flask_monitoring`)

Disable automated flask monitoring. See [flask app instrumentation](docs/instrumentation/flask-app.md)

##### `SLS_DISABLE_CAPTURED_EVENTS_STDOUT` (or `disable_captured_events_stdout`)

Disable writing captured events registered via `.capture_error` and `.capture_warning` to stdout

### Instrumentation

This package comes with instrumentation for following areas.

_Note: instrumentation is enabled via environment specific SDK instance, relying just on `serverless-sdk` doesn't enable any instrumentation)_

- [HTTP(s) requests](docs/instrumentation/http.md)
- [flask app](docs/instrumentation/flask-app.md)
- [Python logging module](docs/instrumentation/python-logging.md)

### API

- [serverlessSdk](docs/sdk.md)